Changeset 5819


Ignore:
Timestamp:
02/14/04 15:31:39 (17 years ago)
Author:
piso
Message:

array => chars

File:
1 edited

Legend:

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

    r5797 r5819  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: LispString.java,v 1.77 2004-02-13 00:24:41 piso Exp $
     5 * $Id: LispString.java,v 1.78 2004-02-14 15:31:39 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2424public final class LispString extends AbstractVector
    2525{
    26     private char[] array;
     26    private char[] chars;
    2727
    2828    public LispString(LispCharacter c)
    2929    {
    30         array = new char[1];
    31         array[0] = c.getValue();
     30        chars = new char[1];
     31        chars[0] = c.getValue();
    3232    }
    3333
    3434    public LispString(char c)
    3535    {
    36         array = new char[1];
    37         array[0] = c;
     36        chars = new char[1];
     37        chars[0] = c;
    3838    }
    3939
    4040    public LispString(int length)
    4141    {
    42         array = new char[length];
     42        chars = new char[length];
    4343    }
    4444
    4545    public LispString(String s)
    4646    {
    47         array = s.toCharArray();
     47        chars = s.toCharArray();
    4848    }
    4949
    5050    public char[] chars()
    5151    {
    52         return array;
     52        return chars;
    5353    }
    5454
     
    6262    {
    6363        return list2(fillPointer < 0 ? Symbol.SIMPLE_STRING : Symbol.STRING,
    64                      number(array.length));
     64                     number(chars.length));
    6565    }
    6666
     
    120120                return false;
    121121            for (int i = length(); i-- > 0;)
    122                 if (string.array[i] != array[i])
     122                if (string.chars[i] != chars[i])
    123123                    return false;
    124124            return true;
     
    138138                return false;
    139139            for (int i = length(); i-- > 0;) {
    140                 if (string.array[i] != array[i]) {
    141                     if (Utilities.toLowerCase(string.array[i]) != Utilities.toLowerCase(array[i]))
     140                if (string.chars[i] != chars[i]) {
     141                    if (Utilities.toLowerCase(string.chars[i]) != Utilities.toLowerCase(chars[i]))
    142142                        return false;
    143143                }
     
    156156        try {
    157157            while (i < end)
    158                 s.array[j++] = array[i++];
     158                s.chars[j++] = chars[i++];
    159159            return s;
    160160        }
     
    171171    public void fill(char c)
    172172    {
    173         final int limit = fillPointer >= 0 ? fillPointer : array.length;
     173        final int limit = fillPointer >= 0 ? fillPointer : chars.length;
    174174        for (int i = limit; i-- > 0;)
    175             array[i] = c;
     175            chars[i] = c;
    176176    }
    177177
    178178    public void shrink(int n) throws ConditionThrowable
    179179    {
    180         if (n < array.length) {
     180        if (n < chars.length) {
    181181            char[] newArray = new char[n];
    182             System.arraycopy(array, 0, newArray, 0, n);
    183             array = newArray;
     182            System.arraycopy(chars, 0, newArray, 0, n);
     183            chars = newArray;
    184184            return;
    185185        }
    186         if (n == array.length)
     186        if (n == chars.length)
    187187            return;
    188188        signal(new LispError());
     
    195195        int i, j;
    196196        for (i = 0, j = length - 1; i < length; i++, j--)
    197             result.array[i] = array[j];
     197            result.chars[i] = chars[j];
    198198        return result;
    199199    }
     
    204204        int j = length() - 1;
    205205        while (i < j) {
    206             char temp = array[i];
    207             array[i] = array[j];
    208             array[j] = temp;
     206            char temp = chars[i];
     207            chars[i] = chars[j];
     208            chars[j] = temp;
    209209            ++i;
    210210            --j;
     
    216216    {
    217217        try {
    218             return LispCharacter.getInstance(array[index]);
     218            return LispCharacter.getInstance(chars[index]);
    219219        }
    220220        catch (ArrayIndexOutOfBoundsException e) {
    221             badIndex(index, array.length);
     221            badIndex(index, chars.length);
    222222            return NIL; // Not reached.
    223223        }
     
    227227    {
    228228        try {
    229             array[index] = LispCharacter.getValue(newValue);
     229            chars[index] = LispCharacter.getValue(newValue);
    230230        }
    231231        catch (ArrayIndexOutOfBoundsException e) {
    232             badIndex(index, array.length);
     232            badIndex(index, chars.length);
    233233        }
    234234    }
     
    237237    {
    238238        try {
    239             return LispCharacter.getInstance(array[index]);
     239            return LispCharacter.getInstance(chars[index]);
    240240        }
    241241        catch (ArrayIndexOutOfBoundsException e) {
    242             badIndex(index, array.length);
     242            badIndex(index, chars.length);
    243243            return NIL; // Not reached.
    244244        }
     
    248248    {
    249249        try {
    250             array[index] = LispCharacter.getValue(newValue);
     250            chars[index] = LispCharacter.getValue(newValue);
    251251        }
    252252        catch (ArrayIndexOutOfBoundsException e) {
    253             badIndex(index, array.length);
     253            badIndex(index, chars.length);
    254254        }
    255255    }
     
    257257    public void set(int index, char c)
    258258    {
    259         array[index] = c;
     259        chars[index] = c;
    260260    }
    261261
     
    275275    {
    276276        if (fillPointer >= 0)
    277             return new String(array, 0, fillPointer);
     277            return new String(chars, 0, fillPointer);
    278278        else
    279             return new String(array);
     279            return new String(chars);
    280280    }
    281281
    282282    public Object javaInstance()
    283283    {
    284         return new String(array);
     284        return new String(chars);
    285285    }
    286286
     
    292292    public final int capacity()
    293293    {
    294         return array.length;
     294        return chars.length;
    295295    }
    296296
    297297    public final void ensureCapacity(int minCapacity)
    298298    {
    299         if (array.length < minCapacity) {
     299        if (chars.length < minCapacity) {
    300300            char[] newArray = new char[minCapacity];
    301             System.arraycopy(array, 0, newArray, 0, array.length);
    302             array = newArray;
     301            System.arraycopy(chars, 0, newArray, 0, chars.length);
     302            chars = newArray;
    303303        }
    304304    }
     
    306306    public LispString adjustArray(int size)
    307307    {
    308         if (array.length != size) {
     308        if (chars.length != size) {
    309309            char[] newArray = new char[size];
    310             System.arraycopy(array, 0, newArray, 0,
    311                              Math.min(array.length, size));
    312             array = newArray;
     310            System.arraycopy(chars, 0, newArray, 0,
     311                             Math.min(chars.length, size));
     312            chars = newArray;
    313313        }
    314314        return this;
     
    317317    public final int length()
    318318    {
    319         return fillPointer >= 0 ? fillPointer : array.length;
     319        return fillPointer >= 0 ? fillPointer : chars.length;
    320320    }
    321321
    322322    public LispObject elt(int index) throws ConditionThrowable
    323323    {
    324         int limit = fillPointer >= 0 ? fillPointer : array.length;
     324        int limit = fillPointer >= 0 ? fillPointer : chars.length;
    325325        if (index < 0 || index >= limit)
    326326            badIndex(index, limit);
    327         return LispCharacter.getInstance(array[index]);
     327        return LispCharacter.getInstance(chars[index]);
    328328    }
    329329
     
    332332    {
    333333        try {
    334             return LispCharacter.getInstance(array[Fixnum.getValue(index)]);
     334            return LispCharacter.getInstance(chars[Fixnum.getValue(index)]);
    335335        }
    336336        catch (ArrayIndexOutOfBoundsException e) {
    337             badIndex(Fixnum.getValue(index), array.length);
     337            badIndex(Fixnum.getValue(index), chars.length);
    338338            return NIL; // Not reached.
    339339        }
     
    354354        final int limit = length();
    355355        for (int i = 0; i < limit; i++)
    356             hashCode = hashCode * 31 + array[i];
     356            hashCode = hashCode * 31 + chars[i];
    357357        return cachedHashCode = hashCode;
    358358    }
     
    362362        if (beginIndex < 0)
    363363            beginIndex = 0;
    364         final int limit = fillPointer >= 0 ? fillPointer : array.length;
     364        final int limit = fillPointer >= 0 ? fillPointer : chars.length;
    365365        if (endIndex > limit)
    366366            endIndex = limit;
     
    369369            sb.append('"');
    370370            for (int i = beginIndex; i < endIndex; i++) {
    371                 char c = array[i];
     371                char c = chars[i];
    372372                if (c == '\"' || c == '\\')
    373373                    sb.append('\\');
     
    382382    public final String toString()
    383383    {
    384         return toString(0, array.length);
     384        return toString(0, chars.length);
    385385    }
    386386
Note: See TracChangeset for help on using the changeset viewer.