Changeset 4271


Ignore:
Timestamp:
10/10/03 00:49:55 (19 years ago)
Author:
piso
Message:

String comparison functions now pass all tests.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/StringFunctions.java

    r4270 r4271  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: StringFunctions.java,v 1.10 2003-10-09 18:00:30 piso Exp $
     5 * $Id: StringFunctions.java,v 1.11 2003-10-10 00:49:55 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727    // Case sensitive.
    2828    private static final Primitive _STRING_EQUAL =
    29         new Primitive("%string=", PACKAGE_SYS, true) {
     29        new Primitive("%string=", PACKAGE_SYS, true)
     30    {
    3031        public LispObject execute(LispObject[] args) throws ConditionThrowable
    3132        {
     
    5657    // Case sensitive.
    5758    private static final Primitive _STRING_NOT_EQUAL =
    58         new Primitive("%string/=", PACKAGE_SYS, true) {
    59         public LispObject execute(LispObject[] args) throws ConditionThrowable
    60         {
    61             if (args.length != 6)
    62                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    63             char[] array1 = string(args[0]).chars();
    64             char[] array2 = string(args[1]).chars();
    65             int start1 = Fixnum.getInt(args[2]);
    66             int end1 = Fixnum.getInt(args[3]);
    67             int start2 = Fixnum.getInt(args[4]);
    68             int end2 = Fixnum.getInt(args[5]);
    69             int i, j;
    70             for (i = start1, j = start2; i < end1 && j < end2; i++, j++) {
     59        new Primitive("%string/=", PACKAGE_SYS, true)
     60    {
     61        public LispObject execute(LispObject[] args) throws ConditionThrowable
     62        {
     63            if (args.length != 6)
     64                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     65            char[] array1 = string(args[0]).chars();
     66            char[] array2 = string(args[1]).chars();
     67            int start1 = Fixnum.getInt(args[2]);
     68            int end1 = Fixnum.getInt(args[3]);
     69            int start2 = Fixnum.getInt(args[4]);
     70            int end2 = Fixnum.getInt(args[5]);
     71            int i = start1;
     72            int j = start2;
     73            while (true) {
     74                if (i == end1) {
     75                    // Reached end of string1.
     76                    if (j == end2)
     77                        return NIL; // Strings are identical.
     78                    return new Fixnum(i);
     79                }
     80                if (j == end2) {
     81                    // Reached end of string2 before end of string1.
     82                    return new Fixnum(i);
     83                }
    7184                if (array1[i] != array2[j])
    7285                    return new Fixnum(i);
    73             }
    74             return NIL;
     86                ++i;
     87                ++j;
     88            }
    7589        }
    7690    };
     
    7993    // Case insensitive.
    8094    private static final Primitive _STRING_EQUAL_IGNORE_CASE =
    81         new Primitive("%string-equal", PACKAGE_SYS, true) {
     95        new Primitive("%string-equal", PACKAGE_SYS, true)
     96    {
    8297        public LispObject execute(LispObject[] args) throws ConditionThrowable
    8398        {
     
    111126    // Case sensitive.
    112127    private static final Primitive _STRING_NOT_EQUAL_IGNORE_CASE =
    113         new Primitive("%string-not-equal", PACKAGE_SYS, true) {
    114         public LispObject execute(LispObject[] args) throws ConditionThrowable
    115         {
    116             if (args.length != 6)
    117                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    118             char[] array1 = string(args[0]).chars();
    119             char[] array2 = string(args[1]).chars();
    120             int start1 = Fixnum.getInt(args[2]);
    121             int end1 = Fixnum.getInt(args[3]);
    122             int start2 = Fixnum.getInt(args[4]);
    123             int end2 = Fixnum.getInt(args[5]);
    124             int i, j;
    125             for (i = start1, j = start2; i < end1 && j < end2; i++, j++) {
     128        new Primitive("%string-not-equal", PACKAGE_SYS, true)
     129    {
     130        public LispObject execute(LispObject[] args) throws ConditionThrowable
     131        {
     132            if (args.length != 6)
     133                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     134            char[] array1 = string(args[0]).chars();
     135            char[] array2 = string(args[1]).chars();
     136            int start1 = Fixnum.getInt(args[2]);
     137            int end1 = Fixnum.getInt(args[3]);
     138            int start2 = Fixnum.getInt(args[4]);
     139            int end2 = Fixnum.getInt(args[5]);
     140            int i = start1;
     141            int j = start2;
     142            while (true) {
     143                if (i == end1) {
     144                    // Reached end of string1.
     145                    if (j == end2)
     146                        return NIL; // Strings are identical.
     147                    return new Fixnum(i);
     148                }
     149                if (j == end2) {
     150                    // Reached end of string2.
     151                    return new Fixnum(i);
     152                }
    126153                char c1 = array1[i];
    127154                char c2 = array2[j];
    128                 if (c1 == c2)
    129                     continue;
    130                 if (Utilities.toUpperCase(c1) == Utilities.toUpperCase(c2))
    131                     continue;
    132                 if (Utilities.toLowerCase(c1) == Utilities.toLowerCase(c2))
    133                     continue;
     155                if (c1 == c2 ||
     156                    Utilities.toUpperCase(c1) == Utilities.toUpperCase(c2) ||
     157                    Utilities.toLowerCase(c1) == Utilities.toLowerCase(c2))
     158                {
     159                    ++i;
     160                    ++j;
     161                    continue;
     162                }
    134163                return new Fixnum(i);
    135164            }
    136             return NIL;
    137165        }
    138166    };
     
    141169    // Case sensitive.
    142170    private static final Primitive _STRING_LESS_THAN =
    143         new Primitive("%string<", PACKAGE_SYS, true) {
    144         public LispObject execute(LispObject[] args) throws ConditionThrowable
    145         {
    146             if (args.length != 6)
    147                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    148             char[] array1 = string(args[0]).chars();
    149             char[] array2 = string(args[1]).chars();
    150             int start1 = Fixnum.getInt(args[2]);
    151             int end1 = Fixnum.getInt(args[3]);
    152             int start2 = Fixnum.getInt(args[4]);
    153             int end2 = Fixnum.getInt(args[5]);
    154             int i, j;
    155             for (i = start1, j = start2; i < end1 && j < end2; i++, j++) {
     171        new Primitive("%string<", PACKAGE_SYS, true)
     172    {
     173        public LispObject execute(LispObject[] args) throws ConditionThrowable
     174        {
     175            if (args.length != 6)
     176                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     177            char[] array1 = string(args[0]).chars();
     178            char[] array2 = string(args[1]).chars();
     179            int start1 = Fixnum.getInt(args[2]);
     180            int end1 = Fixnum.getInt(args[3]);
     181            int start2 = Fixnum.getInt(args[4]);
     182            int end2 = Fixnum.getInt(args[5]);
     183            int i = start1;
     184            int j = start2;
     185            while (true) {
     186                if (i == end1) {
     187                    // Reached end of string1.
     188                    if (j == end2)
     189                        return NIL; // Strings are identical.
     190                    return new Fixnum(i);
     191                }
     192                if (j == end2) {
     193                    // Reached end of string2.
     194                    return NIL;
     195                }
    156196                char c1 = array1[i];
    157197                char c2 = array2[j];
    158                 if (c1 == c2)
    159                     continue;
    160                 if (c1 > c2)
    161                     return NIL;
     198                if (c1 == c2) {
     199                    ++i;
     200                    ++j;
     201                    continue;
     202                }
    162203                if (c1 < c2)
    163204                    return new Fixnum(i);
    164             }
    165             // Strings are equal.
    166             return NIL;
     205                // c1 > c2
     206                return NIL;
     207            }
    167208        }
    168209    };
     
    171212    // Case sensitive.
    172213    private static final Primitive _STRING_GREATER_THAN =
    173         new Primitive("%string>", PACKAGE_SYS, true) {
    174         public LispObject execute(LispObject[] args) throws ConditionThrowable
    175         {
    176             if (args.length != 6)
    177                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    178             char[] array1 = string(args[0]).chars();
    179             char[] array2 = string(args[1]).chars();
    180             int start1 = Fixnum.getInt(args[2]);
    181             int end1 = Fixnum.getInt(args[3]);
    182             int start2 = Fixnum.getInt(args[4]);
    183             int end2 = Fixnum.getInt(args[5]);
    184             int i, j;
    185             for (i = start1, j = start2; i < end1 && j < end2; i++, j++) {
     214        new Primitive("%string>", PACKAGE_SYS, true)
     215    {
     216        public LispObject execute(LispObject[] args) throws ConditionThrowable
     217        {
     218            if (args.length != 6)
     219                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     220            char[] array1 = string(args[0]).chars();
     221            char[] array2 = string(args[1]).chars();
     222            int start1 = Fixnum.getInt(args[2]);
     223            int end1 = Fixnum.getInt(args[3]);
     224            int start2 = Fixnum.getInt(args[4]);
     225            int end2 = Fixnum.getInt(args[5]);
     226            int i = start1;
     227            int j = start2;
     228            while (true) {
     229                if (i == end1) {
     230                    // Reached end of string1.
     231                    return NIL;
     232                }
     233                if (j == end2) {
     234                    // Reached end of string2.
     235                    return new Fixnum(i);
     236                }
    186237                char c1 = array1[i];
    187238                char c2 = array2[j];
    188                 if (c1 == c2)
    189                     continue;
     239                if (c1 == c2) {
     240                    ++i;
     241                    ++j;
     242                    continue;
     243                }
    190244                if (c1 < c2)
    191245                    return NIL;
    192                 if (c1 > c2)
    193                     return new Fixnum(i);
    194             }
    195             // Strings are equal.
    196             return NIL;
     246                // c1 > c2
     247                return new Fixnum(i);
     248            }
    197249        }
    198250    };
     
    201253    // Case sensitive.
    202254    private static final Primitive _STRING_LE =
    203         new Primitive("%string<=", PACKAGE_SYS, true) {
    204         public LispObject execute(LispObject[] args) throws ConditionThrowable
    205         {
    206             if (args.length != 6)
    207                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    208             char[] array1 = string(args[0]).chars();
    209             char[] array2 = string(args[1]).chars();
    210             int start1 = Fixnum.getInt(args[2]);
    211             int end1 = Fixnum.getInt(args[3]);
    212             int start2 = Fixnum.getInt(args[4]);
    213             int end2 = Fixnum.getInt(args[5]);
    214             int i, j;
    215             for (i = start1, j = start2; i < end1 && j < end2; i++, j++) {
     255        new Primitive("%string<=", PACKAGE_SYS, true)
     256    {
     257        public LispObject execute(LispObject[] args) throws ConditionThrowable
     258        {
     259            if (args.length != 6)
     260                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     261            char[] array1 = string(args[0]).chars();
     262            char[] array2 = string(args[1]).chars();
     263            int start1 = Fixnum.getInt(args[2]);
     264            int end1 = Fixnum.getInt(args[3]);
     265            int start2 = Fixnum.getInt(args[4]);
     266            int end2 = Fixnum.getInt(args[5]);
     267            int i = start1;
     268            int j = start2;
     269            while (true) {
     270                if (i == end1) {
     271                    // Reached end of string1.
     272                    return new Fixnum(i);
     273                }
     274                if (j == end2) {
     275                    // Reached end of string2.
     276                    return NIL;
     277                }
    216278                char c1 = array1[i];
    217279                char c2 = array2[j];
    218                 if (c1 == c2)
    219                     continue;
     280                if (c1 == c2) {
     281                    ++i;
     282                    ++j;
     283                    continue;
     284                }
    220285                if (c1 > c2)
    221286                    return NIL;
    222                 if (c1 < c2)
    223                     return new Fixnum(i);
    224             }
    225             return new Fixnum(i);
     287                // c1 < c2
     288                return new Fixnum(i);
     289            }
    226290        }
    227291    };
     
    230294    // Case sensitive.
    231295    private static final Primitive _STRING_GE =
    232         new Primitive("%string>=", PACKAGE_SYS, true) {
    233         public LispObject execute(LispObject[] args) throws ConditionThrowable
    234         {
    235             if (args.length != 6)
    236                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    237             char[] array1 = string(args[0]).chars();
    238             char[] array2 = string(args[1]).chars();
    239             int start1 = Fixnum.getInt(args[2]);
    240             int end1 = Fixnum.getInt(args[3]);
    241             int start2 = Fixnum.getInt(args[4]);
    242             int end2 = Fixnum.getInt(args[5]);
    243             int i, j;
    244             for (i = start1, j = start2; i < end1 && j < end2; i++, j++) {
     296        new Primitive("%string>=", PACKAGE_SYS, true)
     297    {
     298        public LispObject execute(LispObject[] args) throws ConditionThrowable
     299        {
     300            if (args.length != 6)
     301                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     302            char[] array1 = string(args[0]).chars();
     303            char[] array2 = string(args[1]).chars();
     304            int start1 = Fixnum.getInt(args[2]);
     305            int end1 = Fixnum.getInt(args[3]);
     306            int start2 = Fixnum.getInt(args[4]);
     307            int end2 = Fixnum.getInt(args[5]);
     308            int i = start1;
     309            int j = start2;
     310            while (true) {
     311                if (i == end1) {
     312                    // Reached end of string1.
     313                    if (j == end2)
     314                        return new Fixnum(i); // Strings are identical.
     315                    return NIL;
     316                }
     317                if (j == end2) {
     318                    // Reached end of string2.
     319                    return new Fixnum(i);
     320                }
    245321                char c1 = array1[i];
    246322                char c2 = array2[j];
    247                 if (c1 == c2)
    248                     continue;
     323                if (c1 == c2) {
     324                    ++i;
     325                    ++j;
     326                    continue;
     327                }
    249328                if (c1 < c2)
    250329                    return NIL;
    251                 if (c1 > c2)
    252                     return new Fixnum(i);
    253             }
    254             return new Fixnum(i);
    255             //             return LispString.equals(string(args[0]), string(args[1]),
    256             //                 start1, end1, start2, end2);
     330                // c1 > c2
     331                return new Fixnum(i);
     332            }
    257333        }
    258334    };
     
    261337    // Case insensitive.
    262338    private static final Primitive _STRING_LESSP =
    263         new Primitive("%string-lessp", PACKAGE_SYS, true) {
     339        new Primitive("%string-lessp", PACKAGE_SYS, true)
     340    {
    264341        public LispObject execute(LispObject[] args) throws ConditionThrowable
    265342        {
     
    294371                if (c1 > c2)
    295372                    return NIL;
    296                 if (c1 < c2)
    297                     return new Fixnum(i);
     373                // c1 < c2
     374                return new Fixnum(i);
    298375            }
    299376        }
     
    303380    // Case insensitive.
    304381    private static final Primitive _STRING_GREATERP =
    305         new Primitive("%string-greaterp", PACKAGE_SYS, true) {
     382        new Primitive("%string-greaterp", PACKAGE_SYS, true)
     383    {
    306384        public LispObject execute(LispObject[] args) throws ConditionThrowable
    307385        {
     
    334412                if (c1 < c2)
    335413                    return NIL;
    336                 if (c1 > c2)
    337                     return new Fixnum(i);
     414                // c1 > c2
     415                return new Fixnum(i);
    338416            }
    339417        }
     
    343421    // Case insensitive.
    344422    private static final Primitive _STRING_NOT_LESSP =
    345         new Primitive("%string-not-lessp", PACKAGE_SYS, true) {
     423        new Primitive("%string-not-lessp", PACKAGE_SYS, true)
     424    {
    346425        public LispObject execute(LispObject[] args) throws ConditionThrowable
    347426        {
     
    376455                if (c1 > c2)
    377456                    return new Fixnum(i);
    378                 if (c1 < c2)
    379                     return NIL;
     457                // c1 < c2
     458                return NIL;
    380459            }
    381460        }
     
    385464    // Case insensitive.
    386465    private static final Primitive _STRING_NOT_GREATERP =
    387         new Primitive("%string-not-greaterp", PACKAGE_SYS, true) {
     466        new Primitive("%string-not-greaterp", PACKAGE_SYS, true)
     467    {
    388468        public LispObject execute(LispObject[] args) throws ConditionThrowable
    389469        {
     
    416496                if (c1 > c2)
    417497                    return NIL;
    418                 if (c1 < c2)
    419                     return new Fixnum(i);
     498                // c1 < c2
     499                return new Fixnum(i);
    420500            }
    421501        }
     
    424504    // ### %string-upcase
    425505    private static final Primitive3 _STRING_UPCASE =
    426         new Primitive3("%string-upcase", PACKAGE_SYS, true) {
     506        new Primitive3("%string-upcase", PACKAGE_SYS, true)
     507    {
    427508        public LispObject execute(LispObject first, LispObject second,
    428509            LispObject third) throws ConditionThrowable
     
    457538    // ### %string-downcase
    458539    private static final Primitive3 _STRING_DOWNCASE =
    459         new Primitive3("%string-downcase", PACKAGE_SYS, true) {
     540        new Primitive3("%string-downcase", PACKAGE_SYS, true)
     541    {
    460542        public LispObject execute(LispObject first, LispObject second,
    461543            LispObject third) throws ConditionThrowable
     
    490572    // ### %string-capitalize
    491573    private static final Primitive3 _STRING_CAPITALIZE=
    492         new Primitive3("%string-capitalize", PACKAGE_SYS, true) {
     574        new Primitive3("%string-capitalize", PACKAGE_SYS, true)
     575    {
    493576        public LispObject execute(LispObject first, LispObject second,
    494577            LispObject third) throws ConditionThrowable
     
    535618    // ### %nstring-upcase
    536619    private static final Primitive3 _NSTRING_UPCASE =
    537         new Primitive3("%nstring-upcase", PACKAGE_SYS, true) {
     620        new Primitive3("%nstring-upcase", PACKAGE_SYS, true)
     621    {
    538622        public LispObject execute(LispObject first, LispObject second,
    539623            LispObject third) throws ConditionThrowable
     
    562646    // ### %nstring-downcase
    563647    private static final Primitive3 _NSTRING_DOWNCASE =
    564         new Primitive3("%nstring-downcase", PACKAGE_SYS, true) {
     648        new Primitive3("%nstring-downcase", PACKAGE_SYS, true)
     649    {
    565650        public LispObject execute(LispObject first, LispObject second,
    566651            LispObject third) throws ConditionThrowable
     
    589674    // ### %nstring-capitalize
    590675    private static final Primitive3 _NSTRING_CAPITALIZE =
    591         new Primitive3("%nstring-capitalize", PACKAGE_SYS, true) {
     676        new Primitive3("%nstring-capitalize", PACKAGE_SYS, true)
     677    {
    592678        public LispObject execute(LispObject first, LispObject second,
    593679            LispObject third) throws ConditionThrowable
Note: See TracChangeset for help on using the changeset viewer.