Changeset 5957


Ignore:
Timestamp:
02/25/04 13:50:54 (17 years ago)
Author:
piso
Message:

Work in progress.

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

Legend:

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

    r5933 r5957  
    163163    }
    164164
     165    public abstract AbstractVector adjustVector(int size,
     166                                                LispObject initialElement,
     167                                                LispObject initialContents)
     168        throws ConditionThrowable;
     169
     170    public abstract AbstractVector adjustVector(int size,
     171                                                AbstractArray displacedTo,
     172                                                int displacement)
     173        throws ConditionThrowable;
     174
    165175    public LispObject vectorPushExtend(LispObject element)
    166176        throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/ComplexBitVector.java

    r5955 r5957  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: ComplexBitVector.java,v 1.2 2004-02-25 03:08:42 piso Exp $
     5 * $Id: ComplexBitVector.java,v 1.3 2004-02-25 13:50:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    296296                    ++size;
    297297                bits = new long[size];
    298                 for (int i = 0; i < capacity; i++)
    299                     bits[i] = Fixnum.getValue(array.getRowMajor(displacement + i));
     298                for (int i = 0; i < capacity; i++) {
     299                    int n = Fixnum.getValue(array.getRowMajor(displacement + i));
     300                    if (n == 1)
     301                        setBit(i);
     302                    else
     303                        clearBit(i);
     304                }
    300305                capacity = minCapacity;
    301306                array = null;
     
    305310        }
    306311    }
     312
     313    public AbstractVector adjustVector(int newCapacity,
     314                                       LispObject initialElement,
     315                                       LispObject initialContents)
     316        throws ConditionThrowable
     317    {
     318        if (bits == null) {
     319            // Copy array.
     320            int size = capacity >>> 6;
     321            if ((capacity & LONG_MASK) != 0)
     322                ++size;
     323            bits = new long[size];
     324            for (int i = 0; i < capacity; i++) {
     325                int n = Fixnum.getValue(array.getRowMajor(displacement + i));
     326                if (n == 1)
     327                    setBit(i);
     328                else
     329                    clearBit(i);
     330            }
     331            array = null;
     332            displacement = 0;
     333            isDisplaced = false;
     334        }
     335        if (capacity != newCapacity) {
     336            int size = newCapacity >>> 6;
     337            if ((newCapacity & LONG_MASK) != 0)
     338                ++size;
     339            if (initialContents != NIL) {
     340                bits = new long[size];
     341                if (initialContents.listp()) {
     342                    LispObject list = initialContents;
     343                    for (int i = 0; i < newCapacity; i++) {
     344                        set(i, list.car());
     345                        list = list.cdr();
     346                    }
     347                } else if (initialContents.vectorp()) {
     348                    for (int i = 0; i < newCapacity; i++)
     349                        set(i, initialContents.elt(i));
     350                } else
     351                    signal(new TypeError(initialContents, Symbol.SEQUENCE));
     352            } else {
     353                long[] newBits = new long[size];
     354                System.arraycopy(bits, 0, newBits, 0,
     355                                 Math.min(bits.length, newBits.length));
     356                bits = newBits;
     357                if (newCapacity > capacity) {
     358                    int n = Fixnum.getValue(initialElement);
     359                    if (n == 1)
     360                        for (int i = capacity; i < newCapacity; i++)
     361                            setBit(i);
     362                    else
     363                        for (int i = capacity; i < newCapacity; i++)
     364                            clearBit(i);
     365                }
     366            }
     367            capacity = newCapacity;
     368        }
     369        return this;
     370    }
     371
     372    public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     373                                       int displacement)
     374        throws ConditionThrowable
     375    {
     376        capacity = size;
     377        array = displacedTo;
     378        this.displacement = displacement;
     379        bits = null;
     380        isDisplaced = true;
     381        return this;
     382    }
    307383}
  • trunk/j/src/org/armedbear/lisp/ComplexString.java

    r5938 r5957  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexString.java,v 1.7 2004-02-24 21:00:28 piso Exp $
     5 * $Id: ComplexString.java,v 1.8 2004-02-25 13:50:54 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    289289    }
    290290
    291     public AbstractArray adjustArray(int size, LispObject initialElement,
    292                                      LispObject initialContents)
     291    public AbstractVector adjustVector(int size, LispObject initialElement,
     292                                       LispObject initialContents)
    293293        throws ConditionThrowable
    294294    {
     
    345345    }
    346346
    347     public AbstractArray adjustArray(int size, AbstractArray displacedTo,
    348                                      int displacement)
     347    public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     348                                       int displacement)
    349349        throws ConditionThrowable
    350350    {
  • trunk/j/src/org/armedbear/lisp/ComplexVector.java

    r5954 r5957  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexVector.java,v 1.6 2004-02-25 03:06:52 piso Exp $
     5 * $Id: ComplexVector.java,v 1.7 2004-02-25 13:50:54 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    128128    }
    129129
    130     public AbstractArray adjustArray(int size, LispObject initialElement,
    131                                      LispObject initialContents)
     130    public AbstractVector adjustVector(int size, LispObject initialElement,
     131                                       LispObject initialContents)
    132132        throws ConditionThrowable
    133133    {
     
    169169    }
    170170
    171     public AbstractArray adjustArray(int size, AbstractArray displacedTo,
    172                                      int displacement)
     171    public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     172                                       int displacement)
    173173        throws ConditionThrowable
    174174    {
  • trunk/j/src/org/armedbear/lisp/NilVector.java

    r5936 r5957  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: NilVector.java,v 1.7 2004-02-24 16:33:33 piso Exp $
     5 * $Id: NilVector.java,v 1.8 2004-02-25 13:50:54 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    209209        return null;
    210210    }
     211
     212    public AbstractVector adjustVector(int newCapacity,
     213                                       LispObject initialElement,
     214                                       LispObject initialContents)
     215        throws ConditionThrowable
     216    {
     217        accessError();
     218        // Not reached.
     219        return null;
     220    }
     221
     222    public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     223                                       int displacement)
     224        throws ConditionThrowable
     225    {
     226        accessError();
     227        // Not reached.
     228        return null;
     229    }
    211230}
  • trunk/j/src/org/armedbear/lisp/SimpleBitVector.java

    r5956 r5957  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: SimpleBitVector.java,v 1.2 2004-02-25 03:05:45 piso Exp $
     5 * $Id: SimpleBitVector.java,v 1.3 2004-02-25 13:50:54 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7272    }
    7373
     74    public boolean isAdjustable()
     75    {
     76        return false;
     77    }
     78
     79    public boolean isSimpleVector()
     80    {
     81        return true;
     82    }
     83
    7484    public int capacity()
    7585    {
     
    96106        int offset = index >> 6;
    97107        return (bits[offset] & (1L << index)) != 0 ? Fixnum.ONE : Fixnum.ZERO;
    98     }
    99 
    100     protected int getBit(int index)
    101     {
    102         int offset = index >> 6;
    103         return (bits[offset] & (1L << index)) != 0 ? 1 : 0;
    104108    }
    105109
     
    122126        catch (ConditionThrowable t) {}
    123127        signal(new TypeError(newValue, "bit"));
     128    }
     129
     130    protected int getBit(int index)
     131    {
     132        int offset = index >> 6;
     133        return (bits[offset] & (1L << index)) != 0 ? 1 : 0;
    124134    }
    125135
     
    175185    }
    176186
    177     public boolean isSimpleVector()
    178     {
    179         return true;
     187    public AbstractVector adjustVector(int size, LispObject initialElement,
     188                                       LispObject initialContents)
     189        throws ConditionThrowable
     190    {
     191        SimpleBitVector v = new SimpleBitVector(size);
     192        if (initialContents != NIL) {
     193            if (initialContents.listp()) {
     194                LispObject list = initialContents;
     195                for (int i = 0; i < size; i++) {
     196                    v.set(i, list.car());
     197                    list = list.cdr();
     198                }
     199            } else if (initialContents.vectorp()) {
     200                for (int i = 0; i < size; i++)
     201                    v.set(i, initialContents.elt(i));
     202            } else
     203                signal(new TypeError(initialContents, Symbol.SEQUENCE));
     204        } else {
     205            final int limit = Math.min(capacity, size);
     206            for (int i = limit; i-- > 0;) {
     207                if (getBit(i) == 1)
     208                    v.setBit(i);
     209                else
     210                    v.clearBit(i);
     211            }
     212            if (size > capacity) {
     213                int n = Fixnum.getValue(initialElement);
     214                if (n == 1)
     215                    for (int i = capacity; i < size; i++)
     216                        v.setBit(i);
     217                else
     218                    for (int i = capacity; i < size; i++)
     219                        v.clearBit(i);
     220            }
     221        }
     222        return v;
     223    }
     224
     225    public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     226                                       int displacement)
     227        throws ConditionThrowable
     228    {
     229        return new ComplexBitVector(size, displacedTo, displacement);
    180230    }
    181231}
  • trunk/j/src/org/armedbear/lisp/SimpleString.java

    r5945 r5957  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: SimpleString.java,v 1.8 2004-02-25 01:22:43 piso Exp $
     5 * $Id: SimpleString.java,v 1.9 2004-02-25 13:50:54 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    315315    }
    316316
    317     public AbstractArray adjustArray(int size, LispObject initialElement,
    318                                      LispObject initialContents)
     317    public AbstractVector adjustVector(int size, LispObject initialElement,
     318                                       LispObject initialContents)
    319319        throws ConditionThrowable
    320320    {
     
    344344    }
    345345
    346     public AbstractArray adjustArray(int size, AbstractArray displacedTo,
    347                                      int displacement)
     346    public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     347                                       int displacement)
    348348        throws ConditionThrowable
    349349    {
  • trunk/j/src/org/armedbear/lisp/SimpleVector.java

    r5938 r5957  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: SimpleVector.java,v 1.6 2004-02-24 21:00:29 piso Exp $
     5 * $Id: SimpleVector.java,v 1.7 2004-02-25 13:50:54 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9696    }
    9797
    98     public AbstractArray adjustArray(int size, LispObject initialElement,
     98    public AbstractVector adjustVector(int size, LispObject initialElement,
    9999                                     LispObject initialContents)
    100100        throws ConditionThrowable
     
    116116        } else {
    117117            System.arraycopy(elements, 0, newArray, 0,
    118                              Math.min(elements.length, size));
    119             if (size > elements.length) {
    120                 for (int i = elements.length; i < size; i++)
     118                             Math.min(capacity, size));
     119            if (size > capacity) {
     120                for (int i = capacity; i < size; i++)
    121121                    newArray[i] = initialElement;
    122122            }
     
    127127    }
    128128
    129     public AbstractArray adjustArray(int size, AbstractArray displacedTo,
     129    public AbstractVector adjustVector(int size, AbstractArray displacedTo,
    130130                                     int displacement)
    131131        throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/adjust_array.java

    r5938 r5957  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: adjust_array.java,v 1.8 2004-02-24 21:00:29 piso Exp $
     5 * $Id: adjust_array.java,v 1.9 2004-02-25 13:50:54 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);
    6055        if (array.getRank() == 1) {
    6156            final int newSize;
     
    6459            else
    6560                newSize = Fixnum.getValue(dimensions);
    66             if (array instanceof SimpleVector) {
    67                 SimpleVector v = (SimpleVector) array;
     61            if (array instanceof AbstractVector) {
     62                AbstractVector v = (AbstractVector) array;
    6863                AbstractVector v2;
    69                 if (displacedTo != NIL)
    70                     v2 = (AbstractVector) v.adjustArray(newSize,
    71                                                         checkArray(displacedTo),
    72                                                         displacement);
    73                 else
    74                     v2 = (AbstractVector) v.adjustArray(newSize,
    75                                                         initialElement,
    76                                                         initialContents);
     64                if (displacedTo != NIL) {
     65                    final int displacement;
     66                    if (displacedIndexOffset == NIL)
     67                        displacement = 0;
     68                    else
     69                        displacement = Fixnum.getValue(displacedIndexOffset);
     70                    v2 = v.adjustVector(newSize,
     71                                        checkArray(displacedTo),
     72                                        displacement);
     73                } else {
     74                    v2 = v.adjustVector(newSize,
     75                                        initialElement,
     76                                        initialContents);
     77                }
    7778                if (fillPointer != NIL)
    7879                    v2.setFillPointer(fillPointer);
    7980                return v2;
    80             }
    81             if (array instanceof ComplexVector) {
    82                 ComplexVector v = (ComplexVector) array;
    83                 if (displacedTo != NIL)
    84                     v.adjustArray(newSize, checkArray(displacedTo),
    85                                   displacement);
    86                 else
    87                     v.adjustArray(newSize, initialElement, initialContents);
    88                 if (fillPointer != NIL)
    89                     v.setFillPointer(fillPointer);
    90                 return v;
    91             }
    92             if (array instanceof SimpleString) {
    93                 SimpleString s = (SimpleString) array;
    94                 AbstractString s2;
    95                 if (displacedTo != NIL)
    96                     s2 = (AbstractString) s.adjustArray(newSize,
    97                                                         checkArray(displacedTo),
    98                                                         displacement);
    99                 else
    100                     s2 = (AbstractString) s.adjustArray(newSize,
    101                                                         initialElement,
    102                                                         initialContents);
    103                 if (fillPointer != NIL)
    104                     s2.setFillPointer(fillPointer);
    105                 return s2;
    106             }
    107             if (array instanceof ComplexString) {
    108                 ComplexString s = (ComplexString) array;
    109                 if (displacedTo != NIL)
    110                     s.adjustArray(newSize, checkArray(displacedTo),
    111                                   displacement);
    112                 else
    113                     s.adjustArray(newSize, initialElement, initialContents);
    114                 if (fillPointer != NIL)
    115                     s.setFillPointer(fillPointer);
    116                 return s;
    11781            }
    11882        }
Note: See TracChangeset for help on using the changeset viewer.