Skip to content

Commit

Permalink
split upcase/downcase/swapcase/capitalize arities and optimize String…
Browse files Browse the repository at this point in the history 
…#casecmp?
  • Loading branch information
@lopex
lopex committed Apr 13, 2018
1 parent bb8e0ad commit dac6261
Show file tree
Hide file tree
Showing 6 changed files with 257 additions and 147 deletions.
14 changes: 7 additions & 7 deletions core/pom.xml
View file
@@ -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">
Expand Down
246 changes: 159 additions & 87 deletions core/src/main/java/org/jruby/RubyString.java
View file
Expand Up @@ -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?")
Expand All @@ -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
Expand Down Expand Up @@ -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();
Expand All @@ -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();
Expand All @@ -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;
}
Expand Down

0 comments on commit dac6261

Please sign in to comment.