Changeset 12493


Ignore:
Timestamp:
02/21/10 13:53:44 (12 years ago)
Author:
vvoutilainen
Message:

1) do the param checking for all functions
2) with the consolidated param checking, clean up string/nstring-upcase/downcase/capitalize

File:
1 edited

Legend:

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

    r12490 r12493  
    3939public final class StringFunctions {
    4040    private final static class StringIndicesAndChars {
    41        
     41        AbstractString string1;
    4242        public char[] array1;
    4343        public char[] array2;
    4444        public int start1 = 0;
    45         public int end1;
     45        public int end1 = 0;
    4646        public int start2 = 0;
    47         public int end2;
    48     };
     47        public int end2 = 0;
     48    };
     49    private final static void
     50        checkParams(StringIndicesAndChars indicesAndChars) {
     51        if (indicesAndChars.start1 < 0
     52            || indicesAndChars.start1 > indicesAndChars.array1.length)
     53            error(new TypeError("Invalid start position "
     54                                + indicesAndChars.start1 + "."));
     55        if (indicesAndChars.end1 < 0
     56            || indicesAndChars.end1 > indicesAndChars.array1.length)
     57            error(new TypeError("Invalid end position "
     58                                + indicesAndChars.end1 + "."));
     59       
     60        if (indicesAndChars.start1 > indicesAndChars.end1)
     61            error(new TypeError("Start ("
     62                                + indicesAndChars.start1
     63                                + ") is greater than end ("
     64                                + indicesAndChars.end1 + ")."));
     65        if (indicesAndChars.array2 != null) {
     66            if (indicesAndChars.start2 < 0
     67                || indicesAndChars.start2 > indicesAndChars.array2.length)
     68                error(new TypeError("Invalid start2 position "
     69                                    + indicesAndChars.start2 + "."));
     70            if (indicesAndChars.end2 < 0
     71                || indicesAndChars.end2 > indicesAndChars.array2.length)
     72                error(new TypeError("Invalid end2 position "
     73                                    + indicesAndChars.end2 + "."));
     74            if (indicesAndChars.start2 > indicesAndChars.end2)
     75                error(new TypeError("Start2 ("
     76                                    + indicesAndChars.start2
     77                                    + ") is greater than end2 ("
     78                                    + indicesAndChars.end2 + ")."));
     79        }
     80
     81    }
     82
    4983    private final static StringIndicesAndChars
    5084        stringIndicesAndChars(LispObject... params) {
    5185        StringIndicesAndChars retVal = new StringIndicesAndChars();
    52         retVal.array1 = params[0].STRING().getStringChars();
    53         retVal.array2 = params[1].STRING().getStringChars();
     86        retVal.string1 = checkString(params[0].STRING());
     87        retVal.array1 = retVal.string1.getStringChars();
    5488        retVal.end1 = retVal.array1.length;
    55         retVal.end2 = retVal.array2.length;
    56         if (params.length > 2) {
     89        if (params.length == 3) {
     90            if (params[1] != NIL) {
     91                retVal.start1 = Fixnum.getValue(params[1]);
     92            }
    5793            if (params[2] != NIL) {
    58                 retVal.start1 = Fixnum.getValue(params[2]);
    59             }
    60             if (params[3] != NIL) {
    61                 retVal.end1 = Fixnum.getValue(params[3]);
    62             }
    63             if (params[4] != NIL) {
    64                 retVal.start2 = Fixnum.getValue(params[4]);
    65             }
    66             if (params[5] != NIL) {
    67                 retVal.end2 = Fixnum.getValue(params[5]);
    68             }
    69         }
     94                retVal.end1 = Fixnum.getValue(params[2]);
     95            }
     96        } else {
     97            retVal.array2 = params[1].STRING().getStringChars();
     98            retVal.end2 = retVal.array2.length;
     99            if (params.length > 2) {
     100                if (params[2] != NIL) {
     101                    retVal.start1 = Fixnum.getValue(params[2]);
     102                }
     103                if (params[3] != NIL) {
     104                    retVal.end1 = Fixnum.getValue(params[3]);
     105                }
     106                if (params[4] != NIL) {
     107                    retVal.start2 = Fixnum.getValue(params[4]);
     108                }
     109                if (params[5] != NIL) {
     110                    retVal.end2 = Fixnum.getValue(params[5]);
     111                }
     112            }
     113        }
     114        checkParams(retVal);
    70115        return retVal;
     116    }
     117
     118    // ### %%string=
     119    // Case sensitive.
     120    private static final Primitive __STRING_EQUAL = new pf___string_equal();
     121    private static final class pf___string_equal extends Primitive {
     122        pf___string_equal() {
     123            super("%%string=", PACKAGE_SYS, false);
     124        }
     125
     126        @Override
     127        public LispObject execute(LispObject first, LispObject second)
     128
     129        {
     130            StringIndicesAndChars chars = stringIndicesAndChars(first, second);
     131            return Arrays.equals(chars.array1, chars.array2) ?
     132                T : NIL;
     133        };
    71134    }
    72135
     
    92155    };
    93156
    94     // ### %%string=
    95     // Case sensitive.
    96     private static final Primitive __STRING_EQUAL = new pf___string_equal();
    97     private static final class pf___string_equal extends Primitive {
    98         pf___string_equal() {
    99             super("%%string=", PACKAGE_SYS, false);
    100         }
    101 
    102         @Override
    103         public LispObject execute(LispObject first, LispObject second)
    104 
    105         {
    106             StringIndicesAndChars chars = stringIndicesAndChars(first, second);
    107             return Arrays.equals(chars.array1, chars.array2) ?
    108                 T : NIL;
    109         };
    110     }
    111157
    112158    // ### %string/=
     
    508554
    509555        {
    510             LispObject s = first.STRING();
    511             final int length = s.length();
    512             int start = (int) Fixnum.getValue(second);
    513             if (start < 0 || start > length)
    514                 return error(new TypeError("Invalid start position " + start + "."));
    515             int end;
    516             if (third == NIL)
    517                 end = length;
    518             else
    519                 end = (int) Fixnum.getValue(third);
    520             if (end < 0 || end > length)
    521                 return error(new TypeError("Invalid end position " + start + "."));
    522             if (start > end)
    523                 return error(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
    524             StringBuilder sb = new StringBuilder(length);
    525             char[] array = s.getStringChars();
     556            StringIndicesAndChars indicesAndChars =
     557                stringIndicesAndChars(first, second, third);
     558            StringBuilder sb = new StringBuilder(indicesAndChars.array1.length);
    526559            int i;
    527             for (i = 0; i < start; i++)
    528                 sb.append(array[i]);
    529             for (i = start; i < end; i++)
    530                 sb.append(LispCharacter.toUpperCase(array[i]));
    531             for (i = end; i < length; i++)
    532                 sb.append(array[i]);
     560            for (i = 0; i < indicesAndChars.start1; i++)
     561                sb.append(indicesAndChars.array1[i]);
     562            for (i = indicesAndChars.start1; i < indicesAndChars.end1; i++)
     563                sb.append(LispCharacter.toUpperCase(indicesAndChars.array1[i]));
     564            for (i = indicesAndChars.end1;
     565                 i < indicesAndChars.array1.length; i++)
     566                sb.append(indicesAndChars.array1[i]);
    533567            return new SimpleString(sb);
    534568        }
     
    545579        public LispObject execute(LispObject first, LispObject second,
    546580                                  LispObject third) {
    547             LispObject s = first.STRING();
    548             final int length = s.length();
    549             int start = (int) Fixnum.getValue(second);
    550             if (start < 0 || start > length)
    551                 return error(new TypeError("Invalid start position " + start + "."));
    552             int end;
    553             if (third == NIL)
    554                 end = length;
    555             else
    556                 end = (int) Fixnum.getValue(third);
    557             if (end < 0 || end > length)
    558                 return error(new TypeError("Invalid end position " + start + "."));
    559             if (start > end)
    560                 return error(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
    561             StringBuilder sb = new StringBuilder(length);
    562             char[] array = s.getStringChars();
     581            StringIndicesAndChars indicesAndChars =
     582                stringIndicesAndChars(first, second, third);
     583            StringBuilder sb = new StringBuilder(indicesAndChars.array1.length);
    563584            int i;
    564             for (i = 0; i < start; i++)
    565                 sb.append(array[i]);
    566             for (i = start; i < end; i++)
    567                 sb.append(LispCharacter.toLowerCase(array[i]));
    568             for (i = end; i < length; i++)
    569                 sb.append(array[i]);
     585            for (i = 0; i < indicesAndChars.start1; i++)
     586                sb.append(indicesAndChars.array1[i]);
     587            for (i = indicesAndChars.start1; i < indicesAndChars.end1; i++)
     588                sb.append(LispCharacter.toLowerCase(indicesAndChars.array1[i]));
     589            for (i = indicesAndChars.end1;
     590                 i < indicesAndChars.array1.length; i++)
     591                sb.append(indicesAndChars.array1[i]);
    570592            return new SimpleString(sb);
    571593        }
     
    584606
    585607        {
    586             LispObject s = first.STRING();
    587             final int length = s.length();
    588             int start = (int) Fixnum.getValue(second);
    589             if (start < 0 || start > length)
    590                 return error(new TypeError("Invalid start position " + start + "."));
    591             int end;
    592             if (third == NIL)
    593                 end = length;
    594             else
    595                 end = (int) Fixnum.getValue(third);
    596             if (end < 0 || end > length)
    597                 return error(new TypeError("Invalid end position " + start + "."));
    598             if (start > end)
    599                 return error(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
    600             StringBuilder sb = new StringBuilder(length);
    601             char[] array = s.getStringChars();
     608            StringIndicesAndChars indicesAndChars =
     609                stringIndicesAndChars(first, second, third);
     610            StringBuilder sb = new StringBuilder(indicesAndChars.array1.length);
    602611            boolean lastCharWasAlphanumeric = false;
    603612            int i;
    604             for (i = 0; i < start; i++)
    605                 sb.append(array[i]);
    606             for (i = start; i < end; i++) {
    607                 char c = array[i];
     613            for (i = 0; i < indicesAndChars.start1; i++)
     614                sb.append(indicesAndChars.array1[i]);
     615            for (i = indicesAndChars.start1; i < indicesAndChars.end1; i++) {
     616                char c = indicesAndChars.array1[i];
    608617                if (Character.isLowerCase(c)) {
    609618                    sb.append(lastCharWasAlphanumeric ? c : LispCharacter.toUpperCase(c));
     
    617626                }
    618627            }
    619             for (i = end; i < length; i++)
    620                 sb.append(array[i]);
     628            for (i = indicesAndChars.end1;
     629                 i < indicesAndChars.array1.length; i++)
     630                sb.append(indicesAndChars.array1[i]);
    621631            return new SimpleString(sb);
    622632        }
     
    635645
    636646        {
    637             final AbstractString string = checkString(first);
    638             final int length = string.length();
    639             int start = (int) Fixnum.getValue(second);
    640             if (start < 0 || start > length)
    641                 return error(new TypeError("Invalid start position " + start + "."));
    642             int end;
    643             if (third == NIL)
    644                 end = length;
    645             else
    646                 end = (int) Fixnum.getValue(third);
    647             if (end < 0 || end > length)
    648                 return error(new TypeError("Invalid end position " + start + "."));
    649             if (start > end)
    650                 return error(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
    651             for (int i = start; i < end; i++)
    652                 string.setCharAt(i, LispCharacter.toUpperCase(string.charAt(i)));
     647            StringIndicesAndChars indicesAndChars =
     648                stringIndicesAndChars(first, second, third);
     649            AbstractString string = indicesAndChars.string1;
     650            for (int i = indicesAndChars.start1; i < indicesAndChars.end1; i++)
     651                string.setCharAt(i,
     652                                 LispCharacter.toUpperCase(string.charAt(i)));
    653653            return string;
    654654        }
     
    667667
    668668        {
    669             final AbstractString string = checkString(first);
    670             final int length = string.length();
    671             int start = (int) Fixnum.getValue(second);
    672             if (start < 0 || start > length)
    673                 return error(new TypeError("Invalid start position " + start + "."));
    674             int end;
    675             if (third == NIL)
    676                 end = length;
    677             else
    678                 end = (int) Fixnum.getValue(third);
    679             if (end < 0 || end > length)
    680                 return error(new TypeError("Invalid end position " + start + "."));
    681             if (start > end)
    682                 return error(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
    683             for (int i = start; i < end; i++)
    684                 string.setCharAt(i, LispCharacter.toLowerCase(string.charAt(i)));
     669            StringIndicesAndChars indicesAndChars =
     670                stringIndicesAndChars(first, second, third);
     671            AbstractString string = indicesAndChars.string1;
     672            for (int i = indicesAndChars.start1; i < indicesAndChars.end1; i++)
     673                string.setCharAt(i,
     674                                 LispCharacter.toLowerCase(string.charAt(i)));
    685675            return string;
    686676        }
     
    699689
    700690        {
    701             AbstractString string = checkString(first);
    702             final int length = string.length();
    703             int start = (int) Fixnum.getValue(second);
    704             if (start < 0 || start > length)
    705                 return error(new TypeError("Invalid start position " + start + "."));
    706             int end;
    707             if (third == NIL)
    708                 end = length;
    709             else
    710                 end = (int) Fixnum.getValue(third);
    711             if (end < 0 || end > length)
    712                 return error(new TypeError("Invalid end position " + start + "."));
    713             if (start > end)
    714                 return error(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
     691            StringIndicesAndChars indicesAndChars =
     692                stringIndicesAndChars(first, second, third);
    715693            boolean lastCharWasAlphanumeric = false;
    716             for (int i = start; i < end; i++) {
     694            AbstractString string = indicesAndChars.string1;
     695            for (int i = indicesAndChars.start1;
     696                 i < indicesAndChars.end1; i++) {
    717697                char c = string.charAt(i);
    718698                if (Character.isLowerCase(c)) {
    719699                    if (!lastCharWasAlphanumeric)
    720                         string.setCharAt(i, LispCharacter.toUpperCase(c));
     700                        string.setCharAt(i,
     701                                         LispCharacter.toUpperCase(c));
    721702                    lastCharWasAlphanumeric = true;
    722703                } else if (Character.isUpperCase(c)) {
    723704                    if (lastCharWasAlphanumeric)
    724                         string.setCharAt(i, LispCharacter.toLowerCase(c));
     705                        string.setCharAt(i,
     706                                         LispCharacter.toLowerCase(c));
    725707                    lastCharWasAlphanumeric = true;
    726708                } else
Note: See TracChangeset for help on using the changeset viewer.