Changeset 12495


Ignore:
Timestamp:
02/21/10 15:22:39 (12 years ago)
Author:
vvoutilainen
Message:

Use sane names for parameters.

File:
1 edited

Legend:

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

    r12494 r12495  
    125125
    126126        @Override
    127         public LispObject execute(LispObject first, LispObject second)
    128 
    129         {
    130             StringIndicesAndChars chars = stringIndicesAndChars(first, second);
     127        public LispObject execute(LispObject string1, LispObject string2)
     128
     129        {
     130            StringIndicesAndChars chars =
     131                stringIndicesAndChars(string1, string2);
    131132            return Arrays.equals(chars.array1, chars.array2) ?
    132133                T : NIL;
     
    143144
    144145        @Override
    145         public LispObject execute(LispObject first, LispObject second,
    146                                   LispObject third, LispObject fourth,
    147                                   LispObject fifth, LispObject sixth)
     146        public LispObject execute(LispObject string1, LispObject string2,
     147                                  LispObject start1, LispObject end1,
     148                                  LispObject start2, LispObject end2)
    148149
    149150        {
    150151            return
    151                 (_STRING_NOT_EQUAL.execute(first, second, third,
    152                                            fourth, fifth, sixth)
     152                (_STRING_NOT_EQUAL.execute(string1, string2,
     153                                           start1, end1,
     154                                           start2, end2)
    153155                 == NIL) ? T : NIL;
    154156        }
     
    165167
    166168        @Override
    167         public LispObject execute(LispObject first, LispObject second,
    168                                   LispObject third, LispObject fourth,
    169                                   LispObject fifth, LispObject sixth) {
    170             StringIndicesAndChars indicesAndChars =
    171                 stringIndicesAndChars(first, second, third, fourth,
    172                                       fifth, sixth);
     169        public LispObject execute(LispObject string1, LispObject string2,
     170                                  LispObject start1, LispObject end1,
     171                                  LispObject start2, LispObject end2) {
     172            StringIndicesAndChars indicesAndChars =
     173                stringIndicesAndChars(string1, string2, start1, end1,
     174                                      start2, end2);
    173175            int i = indicesAndChars.start1;
    174176            int j = indicesAndChars.start2;
     
    201203
    202204        @Override
    203         public LispObject execute(LispObject first, LispObject second,
    204                                   LispObject third, LispObject fourth,
    205                                   LispObject fifth, LispObject sixth)
    206 
    207         {
    208             return (_STRING_NOT_EQUAL_IGNORE_CASE.execute(first, second, third,
    209                                                           fourth, fifth, sixth)
     205        public LispObject execute(LispObject string1, LispObject string2,
     206                                  LispObject start1, LispObject end1,
     207                                  LispObject start2, LispObject end2)
     208
     209        {
     210            return (_STRING_NOT_EQUAL_IGNORE_CASE.execute(string1, string2,
     211                                                          start1, end1,
     212                                                          start2, end2)
    210213                    == NIL) ? T : NIL;
    211214        }
     
    221224
    222225        @Override
    223         public LispObject execute(LispObject first, LispObject second,
    224                                   LispObject third, LispObject fourth,
    225                                   LispObject fifth, LispObject sixth) {
    226             StringIndicesAndChars indicesAndChars =
    227                 stringIndicesAndChars(first, second, third, fourth,
    228                                       fifth, sixth);
     226        public LispObject execute(LispObject string1, LispObject string2,
     227                                  LispObject start1, LispObject end1,
     228                                  LispObject start2, LispObject end2) {
     229            StringIndicesAndChars indicesAndChars =
     230                stringIndicesAndChars(string1, string2, start1, end1,
     231                                      start2, end2);
    229232            int i = indicesAndChars.start1;
    230233            int j = indicesAndChars.start2;
     
    291294
    292295        @Override
    293         public LispObject execute(LispObject first, LispObject second,
    294                                   LispObject third, LispObject fourth,
    295                                   LispObject fifth, LispObject sixth) {
    296             StringIndicesAndChars indicesAndChars =
    297                 stringIndicesAndChars(first, second, third,
    298                                       fourth, fifth, sixth);
     296        public LispObject execute(LispObject string1, LispObject string2,
     297                                  LispObject start1, LispObject end1,
     298                                  LispObject start2, LispObject end2) {
     299            StringIndicesAndChars indicesAndChars =
     300                stringIndicesAndChars(string1, string2,
     301                                      start1, end1, start2, end2);
    299302            int retVal = lessThan(indicesAndChars);
    300303            return (retVal >= 0) ? Fixnum.getInstance(retVal) : NIL;
     
    322325
    323326        @Override
    324         public LispObject execute(LispObject first, LispObject second,
    325                                   LispObject third, LispObject fourth,
    326                                   LispObject fifth, LispObject sixth) {
     327        public LispObject execute(LispObject string1, LispObject string2,
     328                                  LispObject start1, LispObject end1,
     329                                  LispObject start2, LispObject end2) {
    327330            // note the swap of the strings and lengths here..
    328331            StringIndicesAndChars indicesAndChars =
    329                 stringIndicesAndChars(second, first,
    330                                       fifth, sixth,
    331                                       third, fourth);
     332                stringIndicesAndChars(string2, string1,
     333                                      start2, end2,
     334                                      start1, end1);
    332335            int tmp = lessThan(indicesAndChars);
    333336            return swapReturnValue(tmp, indicesAndChars);
     
    369372
    370373        @Override
    371         public LispObject execute(LispObject first, LispObject second,
    372                                   LispObject third, LispObject fourth,
    373                                   LispObject fifth, LispObject sixth) {
    374 
    375             StringIndicesAndChars indicesAndChars =
    376                 stringIndicesAndChars(first, second, third,
    377                                       fourth, fifth, sixth);
     374        public LispObject execute(LispObject string1, LispObject string2,
     375                                  LispObject start1, LispObject end1,
     376                                  LispObject start2, LispObject end2) {
     377
     378            StringIndicesAndChars indicesAndChars =
     379                stringIndicesAndChars(string1, string2,
     380                                      start1, end1, start2, end2);
    378381            int retVal = lessThanOrEqual(indicesAndChars);
    379382            return (retVal >= 0) ? Fixnum.getInstance(retVal) : NIL;
     
    390393
    391394        @Override
    392         public LispObject execute(LispObject first, LispObject second,
    393                                   LispObject third, LispObject fourth,
    394                                   LispObject fifth, LispObject sixth) {
     395        public LispObject execute(LispObject string1, LispObject string2,
     396                                  LispObject start1, LispObject end1,
     397                                  LispObject start2, LispObject end2) {
    395398            // note the swap of the strings and lengths here..
    396399            StringIndicesAndChars indicesAndChars =
    397                 stringIndicesAndChars(second, first,
    398                                       fifth, sixth,
    399                                       third, fourth);
     400                stringIndicesAndChars(string2, string1,
     401                                      start2, end2,
     402                                      start1, end1);
    400403            int tmp = lessThanOrEqual(indicesAndChars);
    401404            return swapReturnValue(tmp, indicesAndChars);
     
    439442
    440443        @Override
    441         public LispObject execute(LispObject first, LispObject second,
    442                                   LispObject third, LispObject fourth,
    443                                   LispObject fifth, LispObject sixth) {
    444             StringIndicesAndChars indicesAndChars =
    445                 stringIndicesAndChars(first, second, third,
    446                                       fourth, fifth, sixth);
     444        public LispObject execute(LispObject string1, LispObject string2,
     445                                  LispObject start1, LispObject end1,
     446                                  LispObject start2, LispObject end2) {
     447            StringIndicesAndChars indicesAndChars =
     448                stringIndicesAndChars(string1, string2,
     449                                      start1, end1, start2, end2);
    447450            int retVal = stringLessp(indicesAndChars);
    448451            return (retVal >= 0) ? Fixnum.getInstance(retVal) : NIL;
     
    459462
    460463        @Override
    461         public LispObject execute(LispObject first, LispObject second,
    462                                   LispObject third, LispObject fourth,
    463                                   LispObject fifth, LispObject sixth) {
     464        public LispObject execute(LispObject string1, LispObject string2,
     465                                  LispObject start1, LispObject end1,
     466                                  LispObject start2, LispObject end2) {
    464467            // note the swap of the strings and lengths here..
    465468            StringIndicesAndChars indicesAndChars =
    466                 stringIndicesAndChars(second, first,
    467                                       fifth, sixth,
    468                                       third, fourth);
     469                stringIndicesAndChars(string2, string1,
     470                                      start2, end2,
     471                                      start1, end1);
    469472            int tmp = stringLessp(indicesAndChars);
    470473            return swapReturnValue(tmp, indicesAndChars);
     
    509512
    510513        @Override
    511         public LispObject execute(LispObject first, LispObject second,
    512                                   LispObject third, LispObject fourth,
    513                                   LispObject fifth, LispObject sixth) {
    514             StringIndicesAndChars indicesAndChars =
    515                 stringIndicesAndChars(first, second, third,
    516                                       fourth, fifth, sixth);
     514        public LispObject execute(LispObject string1, LispObject string2,
     515                                  LispObject start1, LispObject end1,
     516                                  LispObject start2, LispObject end2) {
     517            StringIndicesAndChars indicesAndChars =
     518                stringIndicesAndChars(string1, string2,
     519                                      start1, end1, start2, end2);
    517520            int retVal = stringNotLessp(indicesAndChars);
    518521            return (retVal >= 0) ? Fixnum.getInstance(retVal) : NIL;
     
    529532
    530533        @Override
    531         public LispObject execute(LispObject first, LispObject second,
    532                                   LispObject third, LispObject fourth,
    533                                   LispObject fifth, LispObject sixth) {
     534        public LispObject execute(LispObject string1, LispObject string2,
     535                                  LispObject start1, LispObject end1,
     536                                  LispObject start2, LispObject end2) {
    534537            // note the swap of the strings and lengths here..
    535538            StringIndicesAndChars indicesAndChars =
    536                 stringIndicesAndChars(second, first,
    537                                       fifth, sixth,
    538                                       third, fourth);
     539                stringIndicesAndChars(string2, string1,
     540                                      start2, end2,
     541                                      start1, end1);
    539542            int tmp = stringNotLessp(indicesAndChars);
    540543            return swapReturnValue(tmp, indicesAndChars);
     
    550553
    551554        @Override
    552         public LispObject execute(LispObject first, LispObject second,
    553                                   LispObject third)
    554 
    555         {
    556             StringIndicesAndChars indicesAndChars =
    557                 stringIndicesAndChars(first, second, third);
     555        public LispObject execute(LispObject string, LispObject start,
     556                                  LispObject end)
     557
     558        {
     559            StringIndicesAndChars indicesAndChars =
     560                stringIndicesAndChars(string, start, end);
    558561            char[] array = new char[indicesAndChars.array1.length];
    559562            System.arraycopy(indicesAndChars.array1, 0,
     
    578581
    579582        @Override
    580         public LispObject execute(LispObject first, LispObject second,
    581                                   LispObject third) {
    582             StringIndicesAndChars indicesAndChars =
    583                 stringIndicesAndChars(first, second, third);
     583        public LispObject execute(LispObject string, LispObject start,
     584                                  LispObject end) {
     585            StringIndicesAndChars indicesAndChars =
     586                stringIndicesAndChars(string, start, end);
    584587            char[] array = new char[indicesAndChars.array1.length];
    585588            System.arraycopy(indicesAndChars.array1, 0,
     
    604607
    605608        @Override
    606         public LispObject execute(LispObject first, LispObject second,
    607                                   LispObject third)
    608 
    609         {
    610             StringIndicesAndChars indicesAndChars =
    611                 stringIndicesAndChars(first, second, third);
     609        public LispObject execute(LispObject string, LispObject start,
     610                                  LispObject end)
     611
     612        {
     613            StringIndicesAndChars indicesAndChars =
     614                stringIndicesAndChars(string, start, end);
    612615            char[] array = new char[indicesAndChars.array1.length];
    613616            boolean lastCharWasAlphanumeric = false;
     
    647650
    648651        @Override
    649         public LispObject execute(LispObject first, LispObject second,
    650                                   LispObject third)
    651 
    652         {
    653             StringIndicesAndChars indicesAndChars =
    654                 stringIndicesAndChars(first, second, third);
    655             AbstractString string = indicesAndChars.string1;
     652        public LispObject execute(LispObject string, LispObject start,
     653                                  LispObject end)
     654
     655        {
     656            StringIndicesAndChars indicesAndChars =
     657                stringIndicesAndChars(string, start, end);
     658            AbstractString retString = indicesAndChars.string1;
    656659            for (int i = indicesAndChars.start1; i < indicesAndChars.end1; i++)
    657                 string.setCharAt(i,
    658                                  LispCharacter.toUpperCase(string.charAt(i)));
    659             return string;
     660                retString.setCharAt(i,
     661                                    LispCharacter.
     662                                    toUpperCase(
     663                                                retString.charAt(i)));
     664            return retString;
    660665        }
    661666    };
     
    669674
    670675        @Override
    671         public LispObject execute(LispObject first, LispObject second,
    672                                   LispObject third)
    673 
    674         {
    675             StringIndicesAndChars indicesAndChars =
    676                 stringIndicesAndChars(first, second, third);
    677             AbstractString string = indicesAndChars.string1;
     676        public LispObject execute(LispObject string, LispObject start,
     677                                  LispObject end)
     678
     679        {
     680            StringIndicesAndChars indicesAndChars =
     681                stringIndicesAndChars(string, start, end);
     682            AbstractString retString = indicesAndChars.string1;
    678683            for (int i = indicesAndChars.start1; i < indicesAndChars.end1; i++)
    679                 string.setCharAt(i,
    680                                  LispCharacter.toLowerCase(string.charAt(i)));
    681             return string;
     684                retString.setCharAt(i,
     685                                    LispCharacter.
     686                                    toLowerCase(retString.charAt(i)));
     687            return retString;
    682688        }
    683689    };
     
    691697
    692698        @Override
    693         public LispObject execute(LispObject first, LispObject second,
    694                                   LispObject third)
    695 
    696         {
    697             StringIndicesAndChars indicesAndChars =
    698                 stringIndicesAndChars(first, second, third);
     699        public LispObject execute(LispObject string, LispObject start,
     700                                  LispObject end)
     701
     702        {
     703            StringIndicesAndChars indicesAndChars =
     704                stringIndicesAndChars(string, start, end);
    699705            boolean lastCharWasAlphanumeric = false;
    700             AbstractString string = indicesAndChars.string1;
     706            AbstractString retString = indicesAndChars.string1;
    701707            for (int i = indicesAndChars.start1;
    702708                 i < indicesAndChars.end1; i++) {
    703                 char c = string.charAt(i);
     709                char c = retString.charAt(i);
    704710                if (Character.isLowerCase(c)) {
    705711                    if (!lastCharWasAlphanumeric)
    706                         string.setCharAt(i,
    707                                          LispCharacter.toUpperCase(c));
     712                        retString.setCharAt(i,
     713                                            LispCharacter.toUpperCase(c));
    708714                    lastCharWasAlphanumeric = true;
    709715                } else if (Character.isUpperCase(c)) {
    710716                    if (lastCharWasAlphanumeric)
    711                         string.setCharAt(i,
    712                                          LispCharacter.toLowerCase(c));
     717                        retString.setCharAt(i,
     718                                            LispCharacter.toLowerCase(c));
    713719                    lastCharWasAlphanumeric = true;
    714720                } else
    715721                    lastCharWasAlphanumeric = Character.isDigit(c);
    716722            }
    717             return string;
     723            return retString;
    718724        }
    719725    };
Note: See TracChangeset for help on using the changeset viewer.