split upcase/downcase/swapcase/capitalize arities and optimize String…

…#casecmp?
jruby · Apr 13, 2018 · dac6261 · dac6261
1 parent bb8e0ad
commit dac6261
Showing 6 changed files with 257 additions and 147 deletions.
diff --git a/core/pom.xml b/core/pom.xml
@@ -1,10 +1,10 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-
-DO NOT MODIFIY - GENERATED CODE
-
-
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+
+DO NOT MODIFIY - GENERATED CODE
+
+
 -->
 <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

diff --git a/core/src/main/java/org/jruby/RubyString.java b/core/src/main/java/org/jruby/RubyString.java
@@ -1608,20 +1608,14 @@ public IRubyObject casecmp(ThreadContext context, IRubyObject other) {
         if (enc == null) return context.nil;
 
         if (singleByteOptimizable() && otherStr.singleByteOptimizable()) {
-            return RubyFixnum.newFixnum(context.runtime, value.caseInsensitiveCmp(otherStr.value));
+            return RubyFixnum.newFixnum(runtime, value.caseInsensitiveCmp(otherStr.value));
         }
 
         final int ret = StringSupport.multiByteCasecmp(enc, value, otherStr.value);
 
-        if (ret < 0) {
-            return RubyFixnum.minus_one(context.runtime);
-        }
-
-        if (ret > 0) {
-            return RubyFixnum.one(context.runtime);
-        }
-
-        return RubyFixnum.zero(context.runtime);
+        if (ret < 0) return RubyFixnum.minus_one(runtime);
+        if (ret > 0) return RubyFixnum.one(runtime);
+        return RubyFixnum.zero(runtime);
     }
 
     @JRubyMethod(name = "casecmp?")
@@ -1635,10 +1629,12 @@ public IRubyObject casecmp_p(ThreadContext context, IRubyObject other) {
         Encoding enc = StringSupport.areCompatible(this, otherStr);
         if (enc == null) return context.nil;
 
-        IRubyObject[] args = new IRubyObject[] {runtime.newSymbol("fold")};
-        RubyString downcasedString = this.downcase(context, args);
-        RubyString otherDowncasedString = otherStr.downcase(context, args);
-        return downcasedString.equals(otherDowncasedString) ? context.tru : context.fals;
+        int flags = Config.CASE_FOLD;
+        RubyString down = this.strDup(runtime);
+        down.downcase_bang(context, flags);
+        RubyString otherDown = otherStr.strDup(runtime);
+        otherDown.downcase_bang(context, flags);
+        return down.equals(otherDown) ? context.tru : context.fals;
     }
 
     /** rb_str_match
@@ -1773,52 +1769,70 @@ public IRubyObject str_eql_p19(ThreadContext context, IRubyObject other) {
         return runtime.getFalse();
     }
 
+    private int caseMap(Ruby runtime, int flags, Encoding enc) {
+        IntHolder flagsP = new IntHolder();
+        flagsP.value = flags;
+        if ((flags & Config.CASE_ASCII_ONLY) != 0) {
+            StringSupport.asciiOnlyCaseMap(runtime, value, flagsP, enc);
+        } else {
+            value = StringSupport.caseMap(runtime, value, flagsP, enc);
+        }
+        return flagsP.value;
+    }
+
     /** rb_str_upcase / rb_str_upcase_bang
      *
      */
     @Deprecated
-    public RubyString upcase(ThreadContext context) {
-        return upcase19(context, RubyObject.NULL_ARRAY);
+    public RubyString upcase19(ThreadContext context) {
+        return upcase(context);
     }
 
     @Deprecated
-    public IRubyObject upcase_bang(ThreadContext context) {
-        return upcase_bang19(context, RubyObject.NULL_ARRAY);
-    }
-
-    public RubyString upcase19(ThreadContext context) {
-        return upcase19(context, RubyObject.NULL_ARRAY);
+    public IRubyObject upcase_bang19(ThreadContext context) {
+        return upcase_bang(context);
     }
 
-    public IRubyObject upcase_bang19(ThreadContext context) {
-        return upcase_bang19(context, RubyObject.NULL_ARRAY);
+    @JRubyMethod(name = "upcase")
+    public RubyString upcase(ThreadContext context) {
+        RubyString str = strDup(context.runtime);
+        str.upcase_bang(context);
+        return str;
     }
 
-    private int caseMap(Ruby runtime, int flags, Encoding enc) {
-        IntHolder flagsP = new IntHolder();
-        flagsP.value = flags;
-        if ((flags & Config.CASE_ASCII_ONLY) != 0) {
-            StringSupport.asciiOnlyCaseMap(runtime, value, flagsP, enc);
-        } else {
-            value = StringSupport.caseMap(runtime, value, flagsP, enc);
-        }
-        return flagsP.value;
+    @JRubyMethod(name = "upcase")
+    public RubyString upcase(ThreadContext context, IRubyObject arg) {
+        RubyString str = strDup(context.runtime);
+        str.upcase_bang(context, arg);
+        return str;
     }
 
-    @JRubyMethod(name = "upcase", rest = true)
-    public RubyString upcase19(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod(name = "upcase")
+    public RubyString upcase(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
         RubyString str = strDup(context.runtime);
-        str.upcase_bang19(context, args);
+        str.upcase_bang(context, arg0, arg1);
         return str;
     }
 
-    @JRubyMethod(name = "upcase!", rest = true)
-    public IRubyObject upcase_bang19(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod(name = "upcase!")
+    public IRubyObject upcase_bang(ThreadContext context) {
+        return upcase_bang(context, Config.CASE_UPCASE);
+    }
+
+    @JRubyMethod(name = "upcase!")
+    public IRubyObject upcase_bang(ThreadContext context, IRubyObject arg) {
+        return upcase_bang(context, StringSupport.checkCaseMapOptions(context.runtime, arg, Config.CASE_UPCASE));
+    }
+
+    @JRubyMethod(name = "upcase!")
+    public IRubyObject upcase_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
+        return upcase_bang(context, StringSupport.checkCaseMapOptions(context.runtime, arg0, arg1, Config.CASE_UPCASE));
+    }
+
+    private IRubyObject upcase_bang(ThreadContext context, int flags) {
         Ruby runtime = context.runtime;
-        int flags = StringSupport.checkCaseMapOptions(runtime, args, Config.CASE_UPCASE);
         modifyAndKeepCodeRange();
         Encoding enc = checkDummyEncoding();
-
         if (((flags & Config.CASE_ASCII_ONLY) != 0 && (enc.isUTF8() || enc.maxLength() == 1)) ||
                 (flags & Config.CASE_FOLD_TURKISH_AZERI) == 0 && getCodeRange() == CR_7BIT) {
             int s = value.getBegin();
@@ -1839,42 +1853,60 @@ public IRubyObject upcase_bang19(ThreadContext context, IRubyObject[] args) {
         return ((flags & Config.CASE_MODIFIED) != 0) ? this : context.nil;
     }
 
+    /** rb_str_downcase / rb_str_downcase_bang
+    *
+    */
+
     @Deprecated
     public RubyString downcase19(ThreadContext context) {
-        return downcase(context, RubyObject.NULL_ARRAY);
+        return downcase(context);
     }
 
     @Deprecated
     public IRubyObject downcase_bang19(ThreadContext context) {
-        return downcase_bang(context, RubyObject.NULL_ARRAY);
+        return downcase_bang(context);
     }
 
+    @JRubyMethod(name = "downcase")
     public RubyString downcase(ThreadContext context) {
-        return downcase(context, RubyObject.NULL_ARRAY);
+        RubyString str = strDup(context.runtime);
+        str.downcase_bang(context);
+        return str;
     }
 
-    public IRubyObject downcase_bang(ThreadContext context) {
-        return downcase_bang(context, RubyObject.NULL_ARRAY);
+    @JRubyMethod(name = "downcase")
+    public RubyString downcase(ThreadContext context, IRubyObject arg) {
+        RubyString str = strDup(context.runtime);
+        str.downcase_bang(context, arg);
+        return str;
     }
 
-    /** rb_str_downcase / rb_str_downcase_bang
-     *
-     */
-
-    @JRubyMethod(name = "downcase", rest = true)
-    public RubyString downcase(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod(name = "downcase")
+    public RubyString downcase(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
         RubyString str = strDup(context.runtime);
-        str.downcase_bang(context, args);
+        str.downcase_bang(context, arg0, arg1);
         return str;
     }
 
-    @JRubyMethod(name = "downcase!", rest = true)
-    public IRubyObject downcase_bang(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod(name = "downcase!")
+    public IRubyObject downcase_bang(ThreadContext context) {
+        return downcase_bang(context, Config.CASE_DOWNCASE);
+    }
+
+    @JRubyMethod(name = "downcase!")
+    public IRubyObject downcase_bang(ThreadContext context, IRubyObject arg) {
+        return upcase_bang(context, StringSupport.checkCaseMapOptions(context.runtime, arg, Config.CASE_DOWNCASE));
+    }
+
+    @JRubyMethod(name = "downcase!")
+    public IRubyObject downcase_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
+        return upcase_bang(context, StringSupport.checkCaseMapOptions(context.runtime, arg0, arg1, Config.CASE_DOWNCASE));
+    }
+
+    private IRubyObject downcase_bang(ThreadContext context, int flags) {
         Ruby runtime = context.runtime;
-        int flags = StringSupport.checkCaseMapOptions(runtime, args, Config.CASE_DOWNCASE);
         modifyAndKeepCodeRange();
         Encoding enc = checkDummyEncoding();
-
         if (((flags & Config.CASE_ASCII_ONLY) != 0 && (enc.isUTF8() || enc.maxLength() == 1)) ||
                 (flags & Config.CASE_FOLD_TURKISH_AZERI) == 0 && getCodeRange() == CR_7BIT) {
             int s = value.getBegin();
@@ -1898,79 +1930,119 @@ public IRubyObject downcase_bang(ThreadContext context, IRubyObject[] args) {
     /** rb_str_swapcase / rb_str_swapcase_bang
      *
      */
-    public RubyString swapcase(ThreadContext context) {
-        return swapcase19(context, RubyObject.NULL_ARRAY);
+    @Deprecated
+    public RubyString swapcase19(ThreadContext context) {
+        return swapcase(context);
     }
 
-    public IRubyObject swapcase_bang(ThreadContext context) {
-        return swapcase_bang19(context, RubyObject.NULL_ARRAY);
+    @Deprecated
+    public IRubyObject swapcase_bang19(ThreadContext context) {
+        return swapcase_bang(context);
     }
 
-    public RubyString swapcase19(ThreadContext context) {
-        return swapcase19(context, RubyObject.NULL_ARRAY);
+    @JRubyMethod(name = "swapcase")
+    public RubyString swapcase(ThreadContext context) {
+        RubyString str = strDup(context.runtime);
+        str.swapcase_bang(context);
+        return str;
     }
 
-    public IRubyObject swapcase_bang19(ThreadContext context) {
-        return swapcase_bang19(context, RubyObject.NULL_ARRAY);
+    @JRubyMethod(name = "swapcase")
+    public RubyString swapcase(ThreadContext context, IRubyObject arg) {
+        RubyString str = strDup(context.runtime);
+        str.swapcase_bang(context, arg);
+        return str;
     }
 
-    @JRubyMethod(name = "swapcase", rest = true)
-    public RubyString swapcase19(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod(name = "swapcase")
+    public RubyString swapcase(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
         RubyString str = strDup(context.runtime);
-        str.swapcase_bang19(context, args);
+        str.swapcase_bang(context, arg0, arg1);
         return str;
     }
 
-    @JRubyMethod(name = "swapcase!", rest = true)
-    public IRubyObject swapcase_bang19(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod(name = "swapcase!")
+    public IRubyObject swapcase_bang(ThreadContext context) {
+        return swapcase_bang(context, Config.CASE_UPCASE | Config.CASE_DOWNCASE);
+    }
+
+    @JRubyMethod(name = "swapcase!")
+    public IRubyObject swapcase_bang(ThreadContext context, IRubyObject arg) {
+        return swapcase_bang(context, StringSupport.checkCaseMapOptions(context.runtime, arg, Config.CASE_UPCASE | Config.CASE_DOWNCASE));
+    }
+
+    @JRubyMethod(name = "swapcase!")
+    public IRubyObject swapcase_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
+        return swapcase_bang(context, StringSupport.checkCaseMapOptions(context.runtime, arg0, arg1, Config.CASE_UPCASE | Config.CASE_DOWNCASE));
+    }
+
+    private IRubyObject swapcase_bang(ThreadContext context, int flags) {
         Ruby runtime = context.runtime;
-        int flags = StringSupport.checkCaseMapOptions(runtime, args, Config.CASE_UPCASE | Config.CASE_DOWNCASE);
         modifyAndKeepCodeRange();
         Encoding enc = checkDummyEncoding();
-
         flags = caseMap(runtime, flags, enc);
         return ((flags & Config.CASE_MODIFIED) != 0) ? this : context.nil;
     }
 
     /** rb_str_capitalize / rb_str_capitalize_bang
     *
     */
-    public IRubyObject capitalize(ThreadContext context) {
-        return capitalize19(context, RubyObject.NULL_ARRAY);
+    @Deprecated
+    public IRubyObject capitalize19(ThreadContext context) {
+        return capitalize(context);
     }
 
-    public IRubyObject capitalize_bang(ThreadContext context) {
-        return capitalize_bang19(context, RubyObject.NULL_ARRAY);
+    @Deprecated
+    public IRubyObject capitalize_bang19(ThreadContext context) {
+        return capitalize_bang(context);
     }
 
-    public IRubyObject capitalize19(ThreadContext context) {
-        return capitalize19(context, RubyObject.NULL_ARRAY);
+    @JRubyMethod(name = "capitalize")
+    public RubyString capitalize(ThreadContext context) {
+        RubyString str = strDup(context.runtime);
+        str.capitalize_bang(context);
+        return str;
     }
 
-    public IRubyObject capitalize_bang19(ThreadContext context) {
-        return capitalize_bang19(context, RubyObject.NULL_ARRAY);
+    @JRubyMethod(name = "capitalize")
+    public RubyString capitalize(ThreadContext context, IRubyObject arg) {
+        RubyString str = strDup(context.runtime);
+        str.capitalize_bang(context, arg);
+        return str;
     }
 
-    @JRubyMethod(name = "capitalize", rest = true)
-    public IRubyObject capitalize19(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod(name = "capitalize")
+    public RubyString capitalize(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
         RubyString str = strDup(context.runtime);
-        str.capitalize_bang19(context, args);
+        str.capitalize_bang(context, arg0, arg1);
         return str;
     }
 
-    @JRubyMethod(name = "capitalize!", rest = true)
-    public IRubyObject capitalize_bang19(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod(name = "capitalize!")
+    public IRubyObject capitalize_bang(ThreadContext context) {
+        return capitalize_bang(context, Config.CASE_UPCASE | Config.CASE_TITLECASE);
+    }
+
+    @JRubyMethod(name = "capitalize!")
+    public IRubyObject capitalize_bang(ThreadContext context, IRubyObject arg) {
+        return capitalize_bang(context, StringSupport.checkCaseMapOptions(context.runtime, arg, Config.CASE_UPCASE | Config.CASE_TITLECASE));
+    }
+
+    @JRubyMethod(name = "capitalize!")
+    public IRubyObject capitalize_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
+        return capitalize_bang(context, StringSupport.checkCaseMapOptions(context.runtime, arg0, arg1, Config.CASE_UPCASE | Config.CASE_TITLECASE));
+    }
+
+    private IRubyObject capitalize_bang(ThreadContext context, int flags) {
         Ruby runtime = context.runtime;
-        int flags = StringSupport.checkCaseMapOptions(runtime, args, Config.CASE_UPCASE | Config.CASE_TITLECASE);
+        modifyAndKeepCodeRange();
         Encoding enc = checkDummyEncoding();
 
         if (value.getRealSize() == 0) {
             modifyCheck();
             return runtime.getNil();
         }
 
-        modifyAndKeepCodeRange();
-
         flags = caseMap(runtime, flags, enc);
         return ((flags & Config.CASE_MODIFIED) != 0) ? this : context.nil;
     }

diff --git a/core/src/main/java/org/jruby/RubySymbol.java b/core/src/main/java/org/jruby/RubySymbol.java
@@ -457,44 +457,76 @@ public IRubyObject empty_p(ThreadContext context) {
         return newShared(context.runtime).empty_p(context);
     }
 
+    @JRubyMethod
     public IRubyObject upcase(ThreadContext context) {
-        return upcase(context, RubyObject.NULL_ARRAY);
+        Ruby runtime = context.runtime;
+        return newSymbol(runtime, newShared(runtime).upcase(context).getByteList());
     }
 
-    @JRubyMethod(rest = true)
-    public IRubyObject upcase(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod
+    public IRubyObject upcase(ThreadContext context, IRubyObject arg) {
         Ruby runtime = context.runtime;
-        return newSymbol(runtime, newShared(runtime).upcase19(context, args).getByteList());
+        return newSymbol(runtime, newShared(runtime).upcase(context, arg).getByteList());
     }
 
-    public IRubyObject downcase(ThreadContext context) {
-        return downcase(context, RubyObject.NULL_ARRAY);
+    @JRubyMethod
+    public IRubyObject upcase(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
+        Ruby runtime = context.runtime;
+        return newSymbol(runtime, newShared(runtime).upcase(context, arg0, arg1).getByteList());
     }
 
-    @JRubyMethod(rest = true)
-    public IRubyObject downcase(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod
+    public IRubyObject downcase(ThreadContext context) {
         Ruby runtime = context.runtime;
-        return newSymbol(runtime, newShared(runtime).downcase(context, args).getByteList());
+        return newSymbol(runtime, newShared(runtime).downcase(context).getByteList());
     }
 
-    public IRubyObject capitalize(ThreadContext context) {
-        return capitalize(context, RubyObject.NULL_ARRAY);
+    @JRubyMethod
+    public IRubyObject downcase(ThreadContext context, IRubyObject arg) {
+        Ruby runtime = context.runtime;
+        return newSymbol(runtime, newShared(runtime).downcase(context, arg).getByteList());
     }
 
-    @JRubyMethod(rest = true)
-    public IRubyObject capitalize(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod
+    public IRubyObject downcase(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
         Ruby runtime = context.runtime;
-        return newSymbol(runtime, ((RubyString) newShared(runtime).capitalize19(context, args)).getByteList());
+        return newSymbol(runtime, newShared(runtime).downcase(context, arg0, arg1).getByteList());
     }
 
+    @JRubyMethod
     public IRubyObject swapcase(ThreadContext context) {
-        return swapcase(context, RubyObject.NULL_ARRAY);
+        Ruby runtime = context.runtime;
+        return newSymbol(runtime, newShared(runtime).swapcase(context).getByteList());
+    }
+
+    @JRubyMethod
+    public IRubyObject swapcase(ThreadContext context, IRubyObject arg) {
+        Ruby runtime = context.runtime;
+        return newSymbol(runtime, newShared(runtime).swapcase(context, arg).getByteList());
+    }
+
+    @JRubyMethod
+    public IRubyObject swapcase(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
+        Ruby runtime = context.runtime;
+        return newSymbol(runtime, newShared(runtime).swapcase(context, arg0, arg1).getByteList());
+    }
+
+    @JRubyMethod
+    public IRubyObject capitalize(ThreadContext context) {
+        Ruby runtime = context.runtime;
+        return newSymbol(runtime, newShared(runtime).capitalize(context).getByteList());
+    }
+
+    @JRubyMethod
+    public IRubyObject capitalize(ThreadContext context, IRubyObject arg) {
+        Ruby runtime = context.runtime;
+        return newSymbol(runtime, newShared(runtime).capitalize(context, arg).getByteList());
     }
 
-    @JRubyMethod(rest = true)
-    public IRubyObject swapcase(ThreadContext context, IRubyObject[] args) {
+    @JRubyMethod
+    public IRubyObject capitalize(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
         Ruby runtime = context.runtime;
-        return newSymbol(runtime, newShared(runtime).swapcase19(context, args).getByteList());
+        return newSymbol(runtime, newShared(runtime).capitalize(context, arg0, arg1).getByteList());
     }
 
     @JRubyMethod

diff --git a/core/src/main/java/org/jruby/util/StringSupport.java b/core/src/main/java/org/jruby/util/StringSupport.java
@@ -46,6 +46,7 @@
 import org.jruby.RubyEncoding;
 import org.jruby.RubyIO;
 import org.jruby.RubyString;
+import org.jruby.RubySymbol;
 import org.jruby.ast.util.ArgsUtil;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.Helpers;
@@ -2409,38 +2410,43 @@ private static int rb_memsearch_qs_utf8(byte[] xsBytes, int xs, int m, byte[] ys
         return -1;
     }
 
-    public static int checkCaseMapOptions(Ruby runtime, IRubyObject[]args, int flags) {
-        if (args.length == 0) return flags;
-        if (args.length > 2) throw runtime.newArgumentError("too many options");
+    public static int checkCaseMapOptions(Ruby runtime, IRubyObject arg0, IRubyObject arg1, int flags) {
+        RubySymbol turkic = runtime.newSymbol("turkic");
+        RubySymbol lithuanian = runtime.newSymbol("lithuanian");
 
-        if (args[0] == runtime.newSymbol("turkic")) {
+        if (arg0.equals(turkic)) {
             flags |= Config.CASE_FOLD_TURKISH_AZERI;
-            if (args.length == 2) {
-                if (args[1] == runtime.newSymbol("lithuanian")) {
-                    flags |= Config.CASE_FOLD_LITHUANIAN;
-                } else {
-                    throw runtime.newArgumentError("invalid second option");
-                }
+            if (arg1.equals(lithuanian)) {
+                flags |= Config.CASE_FOLD_LITHUANIAN;
+            } else {
+                throw runtime.newArgumentError("invalid second option");
             }
-        } else if (args[0] == runtime.newSymbol("lithuanian")) {
+        } else if (arg0.equals(lithuanian)) {
             flags |= Config.CASE_FOLD_LITHUANIAN;
-            if (args.length == 2) {
-                if (args[1] == runtime.newSymbol("turkic")) {
-                    flags |= Config.CASE_FOLD_TURKISH_AZERI;
-                } else {
-                    throw runtime.newArgumentError("invalid second option");
-                }
+            if (arg1.equals(turkic)) {
+                flags |= Config.CASE_FOLD_TURKISH_AZERI;
+            } else {
+                throw runtime.newArgumentError("invalid second option");
             }
-        } else if (args.length > 1) {
-            throw runtime.newArgumentError("too many options");
-        } else if (args[0] == runtime.newSymbol("ascii")) {
+        } else {
+            throw runtime.newArgumentError("invalid option");
+        }
+        return flags;
+    }
+
+    public static int checkCaseMapOptions(Ruby runtime, IRubyObject arg0, int flags) {
+        if (arg0.equals(runtime.newSymbol("ascii"))) {
             flags |= Config.CASE_ASCII_ONLY;
-        } else if (args[0] == runtime.newSymbol("fold")) {
+        } else if (arg0.equals(runtime.newSymbol("fold"))) {
             if ((flags & (Config.CASE_UPCASE | Config.CASE_DOWNCASE)) == Config.CASE_DOWNCASE) {
                 flags ^= Config.CASE_FOLD | Config.CASE_DOWNCASE;
             } else {
                 throw runtime.newArgumentError("option :fold only allowed for downcasing");
             }
+        } else if (arg0.equals(runtime.newSymbol("turkic"))) {
+            flags |= Config.CASE_FOLD_TURKISH_AZERI;
+        } else if (arg0.equals(runtime.newSymbol("lithuanian"))) {
+            flags |= Config.CASE_FOLD_LITHUANIAN;
         } else {
             throw runtime.newArgumentError("invalid option");
         }

diff --git a/lib/pom.xml b/lib/pom.xml
@@ -1,10 +1,10 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-
-DO NOT MODIFIY - GENERATED CODE
-
-
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+
+DO NOT MODIFIY - GENERATED CODE
+
+
 -->
 <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

diff --git a/pom.xml b/pom.xml
@@ -1,10 +1,10 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-
-DO NOT MODIFIY - GENERATED CODE
-
-
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+
+DO NOT MODIFIY - GENERATED CODE
+
+
 -->
 <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">