Changeset 12497

Timestamp:

02/21/10 17:46:10 (14 years ago)

Author:

vvoutilainen

Message:

Consolidate string equality comparisons.

File:

• trunk/abcl/src/org/armedbear/lisp/StringFunctions.java (modified) (3 diffs)

trunk/abcl/src/org/armedbear/lisp/StringFunctions.java

@@ -163 +163 @@
 
 
-    // ### %string/=
-    // Case sensitive.
-    private static final Primitive _STRING_NOT_EQUAL = new pf__string_not_equal();
-    private static final class pf__string_not_equal extends Primitive {
-        pf__string_not_equal() {
-            super("%string/=", PACKAGE_SYS, true);
-        }
-
-        @Override
-        public LispObject execute(LispObject string1, LispObject string2,
-                                  LispObject start1, LispObject end1,
-                                  LispObject start2, LispObject end2) {
-            StringIndicesAndChars indicesAndChars = 
-                stringIndicesAndChars(string1, string2, start1, end1,
-                                      start2, end2);
-            int i = indicesAndChars.start1;
-            int j = indicesAndChars.start2;
-            while (true) {
-                if (i == indicesAndChars.end1) {
-                    // Reached end of string1.
-                    if (j == indicesAndChars.end2)
-                        return NIL; // Strings are identical.
-                    return Fixnum.getInstance(i);
-                }
-                if (j == indicesAndChars.end2) {
-                    // Reached end of string2 before end of string1.
-                    return Fixnum.getInstance(i);
-                }
-                if (indicesAndChars.array1[i] != indicesAndChars.array2[j])
-                    return Fixnum.getInstance(i);
-                ++i;
-                ++j;
-            }
-        }
-    };
-
-    // ### %string-equal
-    // Case insensitive.
-    private static final Primitive _STRING_EQUAL_IGNORE_CASE = new pf__string_equal_ignore_case();
-    private static final class pf__string_equal_ignore_case extends Primitive {
-        pf__string_equal_ignore_case() {
-            super("%string-equal", PACKAGE_SYS, true);
-        }
-
-        @Override
-        public LispObject execute(LispObject string1, LispObject string2,
-                                  LispObject start1, LispObject end1,
-                                  LispObject start2, LispObject end2)
-
-        {
-            return (_STRING_NOT_EQUAL_IGNORE_CASE.execute(string1, string2, 
-                                                          start1, end1, 
-                                                          start2, end2) 
-                    == NIL) ? T : NIL;
-        }
-    };
-
-    // ### %string-not-equal
-    // Case insensitive.
-    private static final Primitive _STRING_NOT_EQUAL_IGNORE_CASE = new pf__string_not_equal_ignore_case();
-    private static final class pf__string_not_equal_ignore_case extends Primitive {
-        pf__string_not_equal_ignore_case() {
-            super("%string-not-equal", PACKAGE_SYS, true);
-        }
-
-        @Override
-        public LispObject execute(LispObject string1, LispObject string2,
-                                  LispObject start1, LispObject end1,
-                                  LispObject start2, LispObject end2) {
-            StringIndicesAndChars indicesAndChars = 
-                stringIndicesAndChars(string1, string2, start1, end1,
-                                      start2, end2);
-            int i = indicesAndChars.start1;
-            int j = indicesAndChars.start2;
-            while (true) {
-                if (i == indicesAndChars.end1) {
-                    // Reached end of string1.
-                    if (j == indicesAndChars.end2)
-                        return NIL; // Strings are identical.
-                    return Fixnum.getInstance(i);
-                }
-                if (j == indicesAndChars.end2) {
-                    // Reached end of string2.
-                    return Fixnum.getInstance(i);
-                }
-                char c1 = indicesAndChars.array1[i];
-                char c2 = indicesAndChars.array2[j];
-                if (c1 == c2 ||
-                        LispCharacter.toUpperCase(c1) == LispCharacter.toUpperCase(c2) ||
-                        LispCharacter.toLowerCase(c1) == LispCharacter.toLowerCase(c2)) {
-                    ++i;
-                    ++j;
-                    continue;
-                }
-                return Fixnum.getInstance(i);
-            }
-        }
-    };
-
-    private static int lessThan(StringIndicesAndChars indicesAndChars) {
+    private static final int notEqual(StringIndicesAndChars indicesAndChars) {
         int i = indicesAndChars.start1;
         int j = indicesAndChars.start2;
@@ -273 +174 @@
             }
             if (j == indicesAndChars.end2) {
+                // Reached end of string2 before end of string1.
+                return i;
+            }
+            if (upcaseIfNeeded(indicesAndChars.array1[i],
+                               indicesAndChars.convertCase)
+                != upcaseIfNeeded(indicesAndChars.array2[j],
+                                  indicesAndChars.convertCase))
+                return i;
+            ++i;
+            ++j;
+        }
+    }
+    // ### %string/=
+    // Case sensitive.
+    private static final Primitive _STRING_NOT_EQUAL = new pf__string_not_equal();
+    private static final class pf__string_not_equal extends Primitive {
+        pf__string_not_equal() {
+            super("%string/=", PACKAGE_SYS, true);
+        }
+
+        @Override
+        public LispObject execute(LispObject string1, LispObject string2,
+                                  LispObject start1, LispObject end1,
+                                  LispObject start2, LispObject end2) {
+            StringIndicesAndChars indicesAndChars = 
+                stringIndicesAndChars(string1, string2, start1, end1,
+                                      start2, end2);
+            int tmp = notEqual(indicesAndChars);
+            return (tmp >= 0) ? Fixnum.getInstance(tmp) : NIL;
+        }
+    };
+
+    // ### %string-equal
+    // Case insensitive.
+    private static final Primitive _STRING_EQUAL_IGNORE_CASE = new pf__string_equal_ignore_case();
+    private static final class pf__string_equal_ignore_case extends Primitive {
+        pf__string_equal_ignore_case() {
+            super("%string-equal", PACKAGE_SYS, true);
+        }
+
+        @Override
+        public LispObject execute(LispObject string1, LispObject string2,
+                                  LispObject start1, LispObject end1,
+                                  LispObject start2, LispObject end2)
+
+        {
+            return (_STRING_NOT_EQUAL_IGNORE_CASE.execute(string1, string2, 
+                                                          start1, end1, 
+                                                          start2, end2) 
+                    == NIL) ? T : NIL;
+        }
+    };
+
+    // ### %string-not-equal
+    // Case insensitive.
+    private static final Primitive _STRING_NOT_EQUAL_IGNORE_CASE = new pf__string_not_equal_ignore_case();
+    private static final class pf__string_not_equal_ignore_case extends Primitive {
+        pf__string_not_equal_ignore_case() {
+            super("%string-not-equal", PACKAGE_SYS, true);
+        }
+
+        @Override
+        public LispObject execute(LispObject string1, LispObject string2,
+                                  LispObject start1, LispObject end1,
+                                  LispObject start2, LispObject end2) {
+            StringIndicesAndChars indicesAndChars = 
+                stringIndicesAndChars(string1, string2, start1, end1,
+                                      start2, end2);
+            indicesAndChars.convertCase = true;
+            int tmp = notEqual(indicesAndChars);
+            return (tmp >= 0) ? Fixnum.getInstance(tmp) : NIL;
+        }
+    };
+
+    private static final int lessThan(StringIndicesAndChars indicesAndChars) {
+        int i = indicesAndChars.start1;
+        int j = indicesAndChars.start2;
+        while (true) {
+            if (i == indicesAndChars.end1) {
+                // Reached end of string1.
+                if (j == indicesAndChars.end2)
+                    return -1; // Strings are identical.
+                return i;
+            }
+            if (j == indicesAndChars.end2) {
                 // Reached end of string2.
                 return -1;
@@ -345 +331 @@
     };
 
-    private static int lessThanOrEqual(StringIndicesAndChars indicesAndChars) {
+    private static final int lessThanOrEqual(StringIndicesAndChars indicesAndChars) {
         int i = indicesAndChars.start1;
         int j = indicesAndChars.start2;