Changeset 5908


Ignore:
Timestamp:
02/23/04 19:56:58 (17 years ago)
Author:
piso
Message:

Work in progress.

Location:
trunk/j/src/org/armedbear/lisp
Files:
14 edited

Legend:

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

    r5873 r5908  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: AbstractArray.java,v 1.14 2004-02-19 01:33:48 piso Exp $
     5 * $Id: AbstractArray.java,v 1.15 2004-02-23 19:56:55 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2424public abstract class AbstractArray extends LispObject
    2525{
     26    protected boolean isDisplaced;
     27
    2628    public LispObject typep(LispObject type) throws ConditionThrowable
    2729    {
     
    5052        }
    5153        return false;
     54    }
     55
     56    public final boolean isDisplaced()
     57    {
     58        return isDisplaced;
     59    }
     60
     61    public LispObject arrayDisplacement()
     62    {
     63        return LispThread.currentThread().setValues(NIL, Fixnum.ZERO);
     64    }
     65
     66    public boolean isAdjustable()
     67    {
     68        return true;
    5269    }
    5370
  • trunk/j/src/org/armedbear/lisp/AbstractString.java

    r5907 r5908  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: AbstractString.java,v 1.2 2004-02-23 15:55:26 piso Exp $
     5 * $Id: AbstractString.java,v 1.3 2004-02-23 19:56:55 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4747    }
    4848
    49     public final LispObject getElementType()
     49    public LispObject getElementType()
    5050    {
    5151        return Symbol.CHARACTER;
     
    9393    }
    9494
    95     public final String toString()
     95    public String toString()
    9696    {
    9797        try {
  • trunk/j/src/org/armedbear/lisp/AbstractVector.java

    r5873 r5908  
    8888    public abstract int capacity();
    8989
    90     public abstract void ensureCapacity(int minCapacity);
     90    public abstract void ensureCapacity(int minCapacity) throws ConditionThrowable;
    9191
    9292    public abstract LispObject get(int index) throws ConditionThrowable;
  • trunk/j/src/org/armedbear/lisp/ComplexString.java

    r5907 r5908  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexString.java,v 1.2 2004-02-23 15:55:14 piso Exp $
     5 * $Id: ComplexString.java,v 1.3 2004-02-23 19:56:55 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2424public final class ComplexString extends AbstractString
    2525{
     26    private int capacity;
     27
     28    // For non-displaced arrays.
    2629    private char[] chars;
    2730
    28     public ComplexString(int length)
    29     {
    30         chars = new char[length];
    31     }
    32 
    33     public char[] chars()
    34     {
     31    // For displaced arrays.
     32    private AbstractArray array;
     33    private int displacement;
     34
     35    public ComplexString(int capacity)
     36    {
     37        this.capacity = capacity;
     38        chars = new char[capacity];
     39        isDisplaced = false;
     40    }
     41
     42    public ComplexString(int capacity, AbstractArray array, int displacement)
     43    {
     44        this.capacity = capacity;
     45        this.array = array;
     46        this.displacement = displacement;
     47        isDisplaced = true;
     48    }
     49
     50    public LispObject typeOf()
     51    {
     52        return list2(Symbol.STRING, number(capacity()));
     53    }
     54
     55    public LispClass classOf()
     56    {
     57        return BuiltInClass.STRING;
     58    }
     59
     60    public LispObject arrayDisplacement()
     61    {
     62        if (array != null)
     63            return LispThread.currentThread().setValues(array, new Fixnum(displacement));
     64        return super.arrayDisplacement();
     65    }
     66
     67    public char[] chars() throws ConditionThrowable
     68    {
     69        if (chars != null)
     70            return chars;
     71        Debug.assertTrue(array != null);
     72        char[] chars = new char[capacity];
     73        System.arraycopy(array.chars(), displacement, chars, 0, capacity);
    3574        return chars;
    36     }
    37 
    38     public LispObject typeOf()
    39     {
    40         return list2(Symbol.STRING, number(capacity()));
    41     }
    42 
    43     public LispClass classOf()
    44     {
    45         return BuiltInClass.STRING;
    4675    }
    4776
     
    164193    public char getChar(int index) throws ConditionThrowable
    165194    {
    166         try {
    167             return chars[index];
    168         }
    169         catch (ArrayIndexOutOfBoundsException e) {
    170             badIndex(index, chars.length);
    171             return 0; // Not reached.
    172         }
     195        if (chars != null) {
     196            try {
     197                return chars[index];
     198            }
     199            catch (ArrayIndexOutOfBoundsException e) {
     200                badIndex(index, chars.length);
     201                return 0; // Not reached.
     202            }
     203        } else
     204            return LispCharacter.getValue(array.getRowMajor(index + displacement));
    173205    }
    174206
    175207    public void setChar(int index, char c) throws ConditionThrowable
    176208    {
    177         try {
    178             chars[index] = c;
    179         }
    180         catch (ArrayIndexOutOfBoundsException e) {
    181             badIndex(index, chars.length);
    182         }
    183     }
    184 
    185     public String getStringValue()
     209        if (chars != null) {
     210            try {
     211                chars[index] = c;
     212            }
     213            catch (ArrayIndexOutOfBoundsException e) {
     214                badIndex(index, chars.length);
     215            }
     216        } else
     217            array.setRowMajor(index + displacement, LispCharacter.getInstance(c));
     218    }
     219
     220    public String getStringValue() throws ConditionThrowable
    186221    {
    187222        if (fillPointer >= 0)
    188             return new String(chars, 0, fillPointer);
     223            return new String(chars(), 0, fillPointer);
    189224        else
    190             return new String(chars);
    191     }
    192 
    193     public Object javaInstance()
    194     {
    195         return new String(chars);
    196     }
    197 
    198     public Object javaInstance(Class c)
     225            return new String(chars());
     226    }
     227
     228    public Object javaInstance() throws ConditionThrowable
     229    {
     230        return new String(chars());
     231    }
     232
     233    public Object javaInstance(Class c) throws ConditionThrowable
    199234    {
    200235        return javaInstance();
     
    203238    public final int capacity()
    204239    {
    205         return chars.length;
    206     }
    207 
    208     public final void ensureCapacity(int minCapacity)
    209     {
    210         if (chars.length < minCapacity) {
    211             char[] newArray = new char[minCapacity];
    212             System.arraycopy(chars, 0, newArray, 0, chars.length);
    213             chars = newArray;
    214         }
    215     }
    216 
    217     public ComplexString adjustArray(int size, LispObject initialElement,
    218                                   LispObject initialContents)
     240        return capacity;
     241    }
     242
     243    public final void ensureCapacity(int minCapacity) throws ConditionThrowable
     244    {
     245        if (chars != null) {
     246            if (chars.length < minCapacity) {
     247                char[] newArray = new char[minCapacity];
     248                System.arraycopy(chars, 0, newArray, 0, chars.length);
     249                chars = newArray;
     250                capacity = minCapacity;
     251            }
     252        } else {
     253            Debug.assertTrue(array != null);
     254            if (array.length() - displacement < minCapacity) {
     255                // Copy array.
     256                char[] chars = new char[minCapacity];
     257                System.arraycopy(array.chars(), displacement, chars, 0,
     258                                 array.length() - displacement);
     259                capacity = minCapacity;
     260                array = null;
     261                displacement = 0;
     262                isDisplaced = false;
     263            }
     264        }
     265    }
     266
     267    public AbstractArray adjustArray(int size, LispObject initialElement,
     268                                     LispObject initialContents)
    219269        throws ConditionThrowable
    220270    {
     271        if (chars == null) {
     272            // Copy array.
     273            chars = new char[capacity];
     274            System.arraycopy(array.chars(), displacement, chars, 0, capacity);
     275            array = null;
     276            displacement = 0;
     277            isDisplaced = false;
     278        }
    221279        if (chars.length != size) {
    222280            char[] newArray = new char[size];
     
    247305            }
    248306            chars = newArray;
     307            capacity = chars.length;
    249308        }
    250309        return this;
    251310    }
    252311
     312    public AbstractArray adjustArray(int size, AbstractArray displacedTo,
     313                                     int displacement)
     314        throws ConditionThrowable
     315    {
     316        capacity = size;
     317        array = displacedTo;
     318        this.displacement = displacement;
     319        chars = null;
     320        isDisplaced = true;
     321        return this;
     322    }
     323
    253324    public final int length()
    254325    {
    255         return fillPointer >= 0 ? fillPointer : chars.length;
     326        return fillPointer >= 0 ? fillPointer : capacity;
    256327    }
    257328
    258329    public LispObject elt(int index) throws ConditionThrowable
    259330    {
    260         int limit = fillPointer >= 0 ? fillPointer : chars.length;
     331        final int limit = length();
    261332        if (index < 0 || index >= limit)
    262333            badIndex(index, limit);
  • trunk/j/src/org/armedbear/lisp/DisplacedArray.java

    r5897 r5908  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: DisplacedArray.java,v 1.24 2004-02-23 14:24:46 piso Exp $
     5 * $Id: DisplacedArray.java,v 1.25 2004-02-23 19:56:55 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8787    {
    8888        return stringp;
     89    }
     90
     91    public LispObject arrayDisplacement()
     92    {
     93        return LispThread.currentThread().setValues(array, new Fixnum(offset));
    8994    }
    9095
     
    245250        public LispObject execute(LispObject arg) throws ConditionThrowable
    246251        {
    247             AbstractArray array = checkArray(arg);
    248             final LispObject value1, value2;
    249             if (array instanceof DisplacedArray) {
    250                 DisplacedArray da = (DisplacedArray) array;
    251                 value1 = da.array;
    252                 value2 = new Fixnum(da.offset);
    253             } else {
    254                 value1 = NIL;
    255                 value2 = Fixnum.ZERO;
    256             }
    257             return LispThread.currentThread().setValues(value1, value2);
     252            return checkArray(arg).arrayDisplacement();
    258253        }
    259254    };
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r5901 r5908  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Lisp.java,v 1.209 2004-02-23 14:55:42 piso Exp $
     5 * $Id: Lisp.java,v 1.210 2004-02-23 19:56:55 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    322322            }
    323323            catch (Throwable t) {
     324                Debug.trace(t);
    324325                if (debug)
    325326                    thread.saveBacktrace();
  • trunk/j/src/org/armedbear/lisp/NilVector.java

    r5897 r5908  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: NilVector.java,v 1.5 2004-02-23 14:24:47 piso Exp $
     5 * $Id: NilVector.java,v 1.6 2004-02-23 19:56:55 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public final class NilVector extends AbstractVector
     24public final class NilVector extends AbstractString
    2525{
    2626    private int capacity;
     
    7272        }
    7373        return super.typep(type);
    74     }
    75 
    76     public LispObject STRINGP()
    77     {
    78         return T;
    79     }
    80 
    81     public boolean stringp()
    82     {
    83         return true;
    8474    }
    8575
     
    162152    }
    163153
     154    public char getChar(int index) throws ConditionThrowable
     155    {
     156        accessError();
     157        // Not reached.
     158        return 0;
     159    }
     160
     161    public void setChar(int index, char c) throws ConditionThrowable
     162    {
     163        storeError(LispCharacter.getInstance(c));
     164    }
     165
    164166    public LispObject subseq(int start, int end) throws ConditionThrowable
    165167    {
     
    172174    {
    173175        storeError(obj);
     176    }
     177
     178    public void fill(char c) throws ConditionThrowable
     179    {
     180        storeError(LispCharacter.getInstance(c));
    174181    }
    175182
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r5897 r5908  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Primitives.java,v 1.575 2004-02-23 14:24:47 piso Exp $
     5 * $Id: Primitives.java,v 1.576 2004-02-23 19:56:55 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    17071707        public LispObject execute(LispObject arg) throws ConditionThrowable
    17081708        {
    1709             if (arg instanceof AbstractArray)
    1710                 return T;
    1711             return signal(new TypeError(arg, Symbol.ARRAY));
     1709            try {
     1710                return ((AbstractArray)arg).isAdjustable() ? T : NIL;
     1711            }
     1712            catch (ClassCastException e) {
     1713                return signal(new TypeError(arg, Symbol.ARRAY));
     1714            }
    17121715        }
    17131716    };
  • trunk/j/src/org/armedbear/lisp/SimpleString.java

    r5903 r5908  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: SimpleString.java,v 1.2 2004-02-23 15:04:36 piso Exp $
     5 * $Id: SimpleString.java,v 1.3 2004-02-23 19:56:58 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2424public final class SimpleString extends AbstractString
    2525{
     26    private int capacity;
    2627    private char[] chars;
    27     private int length;
    2828
    2929    public SimpleString(LispCharacter c)
     
    3131        chars = new char[1];
    3232        chars[0] = c.getValue();
    33         length = 1;
     33        capacity = 1;
    3434    }
    3535
     
    3838        chars = new char[1];
    3939        chars[0] = c;
    40         length = 1;
    41     }
    42 
    43     public SimpleString(int length)
    44     {
    45         chars = new char[length];
    46         this.length = length;
     40        capacity = 1;
     41    }
     42
     43    public SimpleString(int capacity)
     44    {
     45        this.capacity = capacity;
     46        chars = new char[capacity];
    4747    }
    4848
     
    5050    {
    5151        chars = s.toCharArray();
    52         length = s.length();
     52        capacity = s.length();
    5353    }
    5454
     
    6666    public LispObject typeOf()
    6767    {
    68         return list2(Symbol.SIMPLE_STRING, number(chars.length));
     68        return list2(Symbol.SIMPLE_STRING, number(capacity));
    6969    }
    7070
     
    9292    }
    9393
     94    public boolean isAdjustable()
     95    {
     96        return false;
     97    }
     98
    9499    public boolean equal(LispObject obj) throws ConditionThrowable
    95100    {
     
    98103        if (obj instanceof SimpleString) {
    99104            SimpleString string = (SimpleString) obj;
    100             if (string.length() != length())
     105            if (string.capacity != capacity)
    101106                return false;
    102             for (int i = length(); i-- > 0;)
     107            for (int i = capacity; i-- > 0;)
    103108                if (string.chars[i] != chars[i])
    104109                    return false;
     
    107112        if (obj instanceof AbstractString) {
    108113            AbstractString string = (AbstractString) obj;
    109             if (string.length() != length())
     114            if (string.length() != capacity)
    110115                return false;
    111116            for (int i = length(); i-- > 0;)
     
    125130        if (obj instanceof SimpleString) {
    126131            SimpleString string = (SimpleString) obj;
    127             if (string.length() != length())
     132            if (string.capacity != capacity)
    128133                return false;
    129             for (int i = length(); i-- > 0;) {
     134            for (int i = capacity; i-- > 0;) {
    130135                if (string.chars[i] != chars[i]) {
    131136                    if (Utilities.toLowerCase(string.chars[i]) != Utilities.toLowerCase(chars[i]))
     
    137142        if (obj instanceof AbstractString) {
    138143            AbstractString string = (AbstractString) obj;
    139             if (string.length() != length())
     144            if (string.length() != capacity)
    140145                return false;
    141146            for (int i = length(); i-- > 0;) {
     
    173178    public void fill(char c)
    174179    {
    175         for (int i = length; i-- > 0;)
     180        for (int i = capacity; i-- > 0;)
    176181            chars[i] = c;
    177182    }
     
    179184    public void shrink(int n) throws ConditionThrowable
    180185    {
    181         if (n < length) {
     186        if (n < capacity) {
    182187            char[] newArray = new char[n];
    183188            System.arraycopy(chars, 0, newArray, 0, n);
    184189            chars = newArray;
    185             length = n;
     190            capacity = n;
    186191            return;
    187192        }
    188         if (n == length)
     193        if (n == capacity)
    189194            return;
    190195        signal(new LispError());
     
    193198    public LispObject reverse() throws ConditionThrowable
    194199    {
    195         SimpleString result = new SimpleString(length);
     200        SimpleString result = new SimpleString(capacity);
    196201        int i, j;
    197         for (i = 0, j = length - 1; i < length; i++, j--)
     202        for (i = 0, j = capacity - 1; i < capacity; i++, j--)
    198203            result.chars[i] = chars[j];
    199204        return result;
     
    203208    {
    204209        int i = 0;
    205         int j = length - 1;
     210        int j = capacity - 1;
    206211        while (i < j) {
    207212            char temp = chars[i];
     
    220225        }
    221226        catch (ArrayIndexOutOfBoundsException e) {
    222             badIndex(index, length);
     227            badIndex(index, capacity);
    223228            return NIL; // Not reached.
    224229        }
     
    231236        }
    232237        catch (ArrayIndexOutOfBoundsException e) {
    233             badIndex(index, length);
     238            badIndex(index, capacity);
    234239        }
    235240    }
     
    241246        }
    242247        catch (ArrayIndexOutOfBoundsException e) {
    243             badIndex(index, length);
     248            badIndex(index, capacity);
    244249            return NIL; // Not reached.
    245250        }
     
    252257        }
    253258        catch (ArrayIndexOutOfBoundsException e) {
    254             badIndex(index, length);
     259            badIndex(index, capacity);
    255260        }
    256261    }
     
    262267        }
    263268        catch (ArrayIndexOutOfBoundsException e) {
    264             badIndex(index, length);
     269            badIndex(index, capacity);
    265270            return 0; // Not reached.
    266271        }
     
    273278        }
    274279        catch (ArrayIndexOutOfBoundsException e) {
    275             badIndex(index, length);
    276         }
    277     }
    278 
    279 //     public final String getValue()
    280 //     {
    281 //         return new String(chars);
    282 //     }
     280            badIndex(index, capacity);
     281        }
     282    }
    283283
    284284    public String getStringValue()
     
    299299    public final int capacity()
    300300    {
    301         return length;
     301        return capacity;
    302302    }
    303303
     
    309309    }
    310310
     311    public AbstractArray adjustArray(int size, LispObject initialElement,
     312                                     LispObject initialContents)
     313        throws ConditionThrowable
     314    {
     315        SimpleString s = new SimpleString(size);
     316        if (initialContents != NIL) {
     317            if (initialContents.listp()) {
     318                LispObject list = initialContents;
     319                for (int i = 0; i < size; i++) {
     320                    s.chars[i] = LispCharacter.getValue(list.car());
     321                    list = list.cdr();
     322                }
     323            } else if (initialContents.vectorp()) {
     324                for (int i = 0; i < size; i++)
     325                    s.chars[i] = LispCharacter.getValue(initialContents.elt(i));
     326            } else
     327                signal(new TypeError(initialContents, Symbol.SEQUENCE));
     328        } else if (initialElement != NIL) {
     329            System.arraycopy(chars, 0, s.chars, 0, Math.min(size, capacity));
     330            if (size > capacity) {
     331                char c = LispCharacter.getValue(initialElement);
     332                for (int i = size; i-- > capacity;)
     333                    s.chars[i] = c;
     334            }
     335        } else
     336            System.arraycopy(chars, 0, s.chars, 0, Math.min(size, capacity));
     337        return s;
     338    }
     339
     340    public AbstractArray adjustArray(int size, AbstractArray displacedTo,
     341                                     int displacement)
     342        throws ConditionThrowable
     343    {
     344        return new ComplexString(size, displacedTo, displacement);
     345    }
     346
    311347    public final int length()
    312348    {
    313         return length;
     349        return capacity;
    314350    }
    315351
     
    320356        }
    321357        catch (ArrayIndexOutOfBoundsException e) {
    322             badIndex(index, length);
     358            badIndex(index, capacity);
    323359            return NIL; // Not reached.
    324360        }
     
    335371        }
    336372        catch (ArrayIndexOutOfBoundsException e) {
    337             badIndex(Fixnum.getValue(index), chars.length);
     373            badIndex(((Fixnum)index).value, capacity);
    338374            return NIL; // Not reached.
    339375        }
     
    347383            return cachedHashCode;
    348384        int hashCode = 0;
    349         for (int i = 0; i < length; i++)
     385        for (int i = 0; i < capacity; i++)
    350386            hashCode = hashCode * 31 + chars[i];
    351387        return cachedHashCode = hashCode;
  • trunk/j/src/org/armedbear/lisp/StringFunctions.java

    r5899 r5908  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: StringFunctions.java,v 1.19 2004-02-23 14:53:42 piso Exp $
     5 * $Id: StringFunctions.java,v 1.20 2004-02-23 19:56:58 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    623623            LispObject third) throws ConditionThrowable
    624624        {
    625             if (!first.stringp())
    626                 signal(new TypeError(first, Symbol.STRING));
    627             final int length = first.length();
     625            AbstractString string;
     626            try {
     627                string = (AbstractString) first;
     628            }
     629            catch (ClassCastException e) {
     630                return signal(new TypeError(first, Symbol.STRING));
     631            }
     632            final int length = string.length();
    628633            int start = (int) Fixnum.getValue(second);
    629634            if (start < 0 || start > length)
     
    638643            if (start > end)
    639644                return signal(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
    640             if (first instanceof DisplacedArray) {
    641                 DisplacedArray array = (DisplacedArray) first;
    642                 for (int i = start; i < end; i++) {
    643                     char c = LispCharacter.getValue(array.getRowMajor(i));
    644                     c = Utilities.toUpperCase(c);
    645                     array.setRowMajor(i, LispCharacter.getInstance(c));
    646                 }
    647             } else {
    648                 char[] chars = first.chars();
    649                 for (int i = start; i < end; i++)
    650                     chars[i] = Utilities.toUpperCase(chars[i]);
    651             }
    652             return first;
     645            for (int i = start; i < end; i++)
     646                string.setChar(i, Utilities.toUpperCase(string.getChar(i)));
     647            return string;
    653648        }
    654649    };
     
    661656            LispObject third) throws ConditionThrowable
    662657        {
    663             if (!first.stringp())
    664                 signal(new TypeError(first, Symbol.STRING));
    665             final int length = first.length();
     658            AbstractString string;
     659            try {
     660                string = (AbstractString) first;
     661            }
     662            catch (ClassCastException e) {
     663                return signal(new TypeError(first, Symbol.STRING));
     664            }
     665            final int length = string.length();
    666666            int start = (int) Fixnum.getValue(second);
    667667            if (start < 0 || start > length)
     
    676676            if (start > end)
    677677                return signal(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
    678             if (first instanceof DisplacedArray) {
    679                 DisplacedArray array = (DisplacedArray) first;
    680                 for (int i = start; i < end; i++) {
    681                     char c = LispCharacter.getValue(array.getRowMajor(i));
    682                     c = Utilities.toLowerCase(c);
    683                     array.setRowMajor(i, LispCharacter.getInstance(c));
    684                 }
    685             } else {
    686                 char[] chars = first.chars();
    687                 for (int i = start; i < end; i++)
    688                     chars[i] = Utilities.toLowerCase(chars[i]);
    689             }
    690             return first;
     678            for (int i = start; i < end; i++)
     679                string.setChar(i, Utilities.toLowerCase(string.getChar(i)));
     680            return string;
    691681        }
    692682    };
     
    699689            LispObject third) throws ConditionThrowable
    700690        {
    701             if (!first.stringp())
    702                 signal(new TypeError(first, Symbol.STRING));
    703             final int length = first.length();
     691            AbstractString string;
     692            try {
     693                string = (AbstractString) first;
     694            }
     695            catch (ClassCastException e) {
     696                return signal(new TypeError(first, Symbol.STRING));
     697            }
     698            final int length = string.length();
    704699            int start = (int) Fixnum.getValue(second);
    705700            if (start < 0 || start > length)
     
    714709            if (start > end)
    715710                return signal(new TypeError("Start (" + start + ") is greater than end (" + end + ")."));
    716             if (first instanceof DisplacedArray) {
    717                 DisplacedArray array = (DisplacedArray) first;
    718                 boolean lastCharWasAlphanumeric = false;
    719                 for (int i = start; i < end; i++) {
    720                     char c = LispCharacter.getValue(array.getRowMajor(i));
    721                     if (Character.isLowerCase(c)) {
    722                         if (!lastCharWasAlphanumeric) {
    723                             c = Utilities.toUpperCase(c);
    724                             array.setRowMajor(i, LispCharacter.getInstance(c));
    725                         }
    726                         lastCharWasAlphanumeric = true;
    727                     } else if (Character.isUpperCase(c)) {
    728                         if (lastCharWasAlphanumeric) {
    729                             c = Utilities.toLowerCase(c);
    730                             array.setRowMajor(i, LispCharacter.getInstance(c));
    731                         }
    732                         lastCharWasAlphanumeric = true;
    733                     } else
    734                         lastCharWasAlphanumeric = Character.isDigit(c);
    735                 }
    736             } else {
    737                 char[] chars = first.chars();
    738                 boolean lastCharWasAlphanumeric = false;
    739                 for (int i = start; i < end; i++) {
    740                     char c = chars[i];
    741                     if (Character.isLowerCase(c)) {
    742                         if (!lastCharWasAlphanumeric)
    743                             chars[i] = Utilities.toUpperCase(c);
    744                         lastCharWasAlphanumeric = true;
    745                     } else if (Character.isUpperCase(c)) {
    746                         if (lastCharWasAlphanumeric)
    747                             chars[i] = Utilities.toLowerCase(c);
    748                         lastCharWasAlphanumeric = true;
    749                     } else
    750                         lastCharWasAlphanumeric = Character.isDigit(c);
    751                 }
    752             }
    753             return first;
     711            boolean lastCharWasAlphanumeric = false;
     712            for (int i = start; i < end; i++) {
     713                char c = string.getChar(i);
     714                if (Character.isLowerCase(c)) {
     715                    if (!lastCharWasAlphanumeric)
     716                        string.setChar(i, Utilities.toUpperCase(c));
     717                    lastCharWasAlphanumeric = true;
     718                } else if (Character.isUpperCase(c)) {
     719                    if (lastCharWasAlphanumeric)
     720                        string.setChar(i, Utilities.toLowerCase(c));
     721                    lastCharWasAlphanumeric = true;
     722                } else
     723                    lastCharWasAlphanumeric = Character.isDigit(c);
     724            }
     725            return string;
    754726        }
    755727    };
     
    760732        public LispObject execute(LispObject arg) throws ConditionThrowable
    761733        {
    762             // Displaced arrays might be strings.
    763734            return arg.STRINGP();
    764735        }
  • trunk/j/src/org/armedbear/lisp/Vector.java

    r5847 r5908  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Vector.java,v 1.32 2004-02-16 01:25:22 piso Exp $
     5 * $Id: Vector.java,v 1.33 2004-02-23 19:56:58 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8282    }
    8383
    84     public Vector adjustArray(int size, LispObject initialElement,
    85                               LispObject initialContents)
     84    public AbstractArray adjustArray(int size, LispObject initialElement,
     85                                     LispObject initialContents)
    8686        throws ConditionThrowable
    8787    {
  • trunk/j/src/org/armedbear/lisp/adjust_array.java

    r5906 r5908  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: adjust_array.java,v 1.5 2004-02-23 15:12:17 piso Exp $
     5 * $Id: adjust_array.java,v 1.6 2004-02-23 19:56:58 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5353            return signal(new LispError("ADJUST-ARRAY: incompatible element type."));
    5454        }
     55        final int displacement;
     56        if (displacedIndexOffset == NIL)
     57            displacement = 0;
     58        else
     59            displacement = Fixnum.getValue(displacedIndexOffset);
    5560        if (array instanceof Vector) {
    5661            Vector v = (Vector) array;
     
    6974            }
    7075        }
     76        if (array instanceof SimpleString) {
     77            SimpleString s = (SimpleString) array;
     78            LispObject newSize = null;
     79            if (dimensions instanceof Cons) {
     80                if (dimensions.length() == 1)
     81                    newSize = dimensions.car();
     82            } else
     83                newSize = dimensions;
     84            if (newSize != null) {
     85                AbstractString s2;
     86                if (displacedTo != NIL)
     87                    s2 = (AbstractString) s.adjustArray(Fixnum.getValue(newSize),
     88                                                        checkArray(displacedTo),
     89                                                        displacement);
     90                else
     91                    s2 = (AbstractString) s.adjustArray(Fixnum.getValue(newSize),
     92                                                        initialElement,
     93                                                        initialContents);
     94                if (fillPointer != NIL)
     95                    s2.setFillPointer(fillPointer);
     96                return s2;
     97            }
     98        }
    7199        if (array instanceof ComplexString) {
    72100            ComplexString s = (ComplexString) array;
     
    78106                newSize = dimensions;
    79107            if (newSize != null) {
    80                 s.adjustArray(Fixnum.getValue(newSize), initialElement,
    81                               initialContents);
     108                if (displacedTo != NIL)
     109                    s.adjustArray(Fixnum.getValue(newSize),
     110                                  checkArray(displacedTo),
     111                                  displacement);
     112                else
     113                    s.adjustArray(Fixnum.getValue(newSize), initialElement,
     114                                  initialContents);
    82115                if (fillPointer != NIL)
    83116                    s.setFillPointer(fillPointer);
  • trunk/j/src/org/armedbear/lisp/ash.java

    r5114 r5908  
    22 * ash.java
    33 *
    4  * Copyright (C) 2003 Peter Graves
    5  * $Id: ash.java,v 1.4 2003-12-13 00:58:51 piso Exp $
     4 * Copyright (C) 2003-2004 Peter Graves
     5 * $Id: ash.java,v 1.5 2004-02-23 19:56:58 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3030    private ash()
    3131    {
    32         super("ash","integer count");
     32        super("ash", "integer count");
    3333    }
    3434
     
    3737    {
    3838        if (first instanceof Fixnum && second instanceof Fixnum) {
    39             int count = ((Fixnum)second).getValue();
     39            int count = ((Fixnum)second).value;
    4040            if (count == 0)
    4141                return first;
    42             long n = ((Fixnum)first).getValue();
     42            long n = ((Fixnum)first).value;
    4343            if (n == 0)
    4444                return first;
     
    5252        BigInteger n;
    5353        if (first instanceof Fixnum)
    54             n = BigInteger.valueOf(((Fixnum)first).getValue());
     54            n = BigInteger.valueOf(((Fixnum)first).value);
    5555        else if (first instanceof Bignum)
    5656            n = ((Bignum)first).getValue();
     
    5858            return signal(new TypeError(first, "integer"));
    5959        if (second instanceof Fixnum) {
    60             int count = Fixnum.getInt(second);
     60            int count = ((Fixnum)second).value;
    6161            if (count == 0)
    6262                return first;
  • trunk/j/src/org/armedbear/lisp/make_array.java

    r5906 r5908  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: make_array.java,v 1.12 2004-02-23 15:12:04 piso Exp $
     5 * $Id: make_array.java,v 1.13 2004-02-23 19:56:58 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6161        if (displacedTo != NIL) {
    6262            final AbstractArray array = checkArray(displacedTo);
    63             final int offset;
    64             if (displacedIndexOffset != NIL)
    65                 offset = Fixnum.getValue(displacedIndexOffset);
    66             else
    67                 offset = 0;
    6863            if (initialElementProvided != NIL)
    6964                return signal(new LispError(":INITIAL-ELEMENT must not be specified with :DISPLACED-TO"));
    7065            if (initialContents != NIL)
    7166                return signal(new LispError(":INITIAL-CONTENTS must not be specified with :DISPLACED-TO"));
    72             DisplacedArray displacedArray = new DisplacedArray(dimv, array, offset);
     67            final int displacement;
     68            if (displacedIndexOffset != NIL)
     69                displacement = Fixnum.getValue(displacedIndexOffset);
     70            else
     71                displacement = 0;
     72            if (rank == 1 && array.stringp()) {
     73                ComplexString string = new ComplexString(dimv[0], array, displacement);
     74                if (fillPointer != NIL)
     75                    string.setFillPointer(fillPointer);
     76                return string;
     77            }
     78            DisplacedArray displacedArray = new DisplacedArray(dimv, array, displacement);
    7379            if (rank == 1 && fillPointer != NIL)
    7480                displacedArray.setFillPointer(fillPointer);
Note: See TracChangeset for help on using the changeset viewer.