Changeset 5938


Ignore:
Timestamp:
02/24/04 21:00:29 (17 years ago)
Author:
piso
Message:

Work in progress.

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

Legend:

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

    r5937 r5938  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexString.java,v 1.6 2004-02-24 16:35:26 piso Exp $
     5 * $Id: ComplexString.java,v 1.7 2004-02-24 21:00:28 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    296296            // Copy array.
    297297            chars = new char[capacity];
    298             System.arraycopy(array.chars(), displacement, chars, 0, capacity);
     298            if (array instanceof AbstractString) {
     299                AbstractString string = (AbstractString) array;
     300                for (int i = 0; i < capacity; i++) {
     301                    chars[i] = string.getChar(displacement + i);
     302                }
     303            } else {
     304                for (int i = 0; i < capacity; i++) {
     305                    LispCharacter character =
     306                        (LispCharacter) array.getRowMajor(displacement + i);
     307                    chars[i] = character.value;
     308                }
     309            }
    299310            array = null;
    300311            displacement = 0;
  • trunk/j/src/org/armedbear/lisp/ComplexVector.java

    r5937 r5938  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexVector.java,v 1.3 2004-02-24 16:35:08 piso Exp $
     5 * $Id: ComplexVector.java,v 1.4 2004-02-24 21:00:29 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4545    }
    4646
    47     public ComplexVector(LispObject list) throws ConditionThrowable
    48     {
    49         elements = list.copyToArray();
    50         capacity = elements.length;
    51     }
    52 
    53     public ComplexVector(LispObject[] array)
    54     {
    55         elements = array;
    56         capacity = array.length;
     47    public ComplexVector(int capacity, AbstractArray array, int displacement)
     48    {
     49        this.capacity = capacity;
     50        this.array = array;
     51        this.displacement = displacement;
     52        isDisplaced = true;
    5753    }
    5854
     
    110106    }
    111107
     108    public LispObject arrayDisplacement()
     109    {
     110        if (array != null)
     111            return LispThread.currentThread().setValues(array, new Fixnum(displacement));
     112        return super.arrayDisplacement();
     113    }
     114
    112115    public LispObject getElementType()
    113116    {
     
    129132        throws ConditionThrowable
    130133    {
     134        if (elements == null) {
     135            // Copy array.
     136            elements = new LispObject[capacity];
     137            for (int i = 0; i < capacity; i++)
     138                elements[i] = array.getRowMajor(displacement + i);
     139            array = null;
     140            displacement = 0;
     141            isDisplaced = false;
     142        }
    131143        if (elements.length != size) {
    132144            LispObject[] newArray = new LispObject[size];
     
    157169    }
    158170
     171    public AbstractArray adjustArray(int size, AbstractArray displacedTo,
     172                                     int displacement)
     173        throws ConditionThrowable
     174    {
     175        capacity = size;
     176        array = displacedTo;
     177        this.displacement = displacement;
     178        elements = null;
     179        isDisplaced = true;
     180        return this;
     181    }
     182
    159183    public int length()
    160184    {
     
    171195
    172196    // Ignores fill pointer.
     197    // FIXME inline
    173198    public LispObject AREF(LispObject index) throws ConditionThrowable
    174199    {
    175         try {
    176             return elements[Fixnum.getValue(index)];
    177         }
    178         catch (ArrayIndexOutOfBoundsException e) {
    179             badIndex(Fixnum.getValue(index), elements.length);
    180             return NIL; // Not reached.
    181         }
    182     }
    183 
     200        return get(Fixnum.getValue(index));
     201    }
     202
     203    // FIXME inline
    184204    public LispObject getRowMajor(int index) throws ConditionThrowable
    185205    {
    186         try {
    187             return elements[index];
    188         }
    189         catch (ArrayIndexOutOfBoundsException e) {
    190             badIndex(index, elements.length);
    191             return NIL; // Not reached.
    192         }
    193     }
    194 
     206        return get(index);
     207    }
     208
     209    // FIXME inline
    195210    public void setRowMajor(int index, LispObject newValue) throws ConditionThrowable
    196211    {
    197         try {
    198             elements[index] = newValue;
    199         }
    200         catch (ArrayIndexOutOfBoundsException e) {
    201             badIndex(index, elements.length);
    202         }
     212        set(index, newValue);
    203213    }
    204214
    205215    public LispObject get(int index) throws ConditionThrowable
    206216    {
    207         try {
    208             return elements[index];
    209         }
    210         catch (ArrayIndexOutOfBoundsException e) {
    211             badIndex(index, elements.length);
    212             return NIL; // Not reached.
    213         }
     217        if (elements != null) {
     218            try {
     219                return elements[index];
     220            }
     221            catch (ArrayIndexOutOfBoundsException e) {
     222                badIndex(index, elements.length);
     223                return NIL; // Not reached.
     224            }
     225        } else
     226            return array.getRowMajor(index + displacement);
    214227    }
    215228
    216229    public void set(int index, LispObject newValue) throws ConditionThrowable
    217230    {
    218         try {
    219             elements[index] = newValue;
    220         }
    221         catch (ArrayIndexOutOfBoundsException e) {
    222             badIndex(index, elements.length);
    223         }
     231        if (elements != null) {
     232            try {
     233                elements[index] = newValue;
     234            }
     235            catch (ArrayIndexOutOfBoundsException e) {
     236                badIndex(index, elements.length);
     237            }
     238        } else
     239            array.setRowMajor(index + displacement, newValue);
    224240    }
    225241
     
    338354    {
    339355        StringBuffer sb = new StringBuffer("#(");
    340         // FIXME The limit should be based on the value of *PRINT-LENGTH*.
    341         final int limit = Math.min(length(), 10);
    342         for (int i = 0; i < limit; i++) {
    343             if (i > 0)
    344                 sb.append(' ');
    345             sb.append(elements[i]);
    346         }
    347         if (limit < length())
    348             sb.append(" ...");
    349         sb.append(')');
     356        try {
     357            // FIXME The limit should be based on the value of *PRINT-LENGTH*.
     358            final int limit = Math.min(length(), 10);
     359            for (int i = 0; i < limit; i++) {
     360                if (i > 0)
     361                    sb.append(' ');
     362                sb.append(get(i));
     363            }
     364            if (limit < length())
     365                sb.append(" ...");
     366            sb.append(')');
     367        }
     368        catch (ConditionThrowable t) {
     369            // Shouldn't happen.
     370            Debug.trace(t);
     371        }
    350372        return sb.toString();
    351373    }
  • trunk/j/src/org/armedbear/lisp/SimpleVector.java

    r5935 r5938  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: SimpleVector.java,v 1.5 2004-02-24 15:39:05 piso Exp $
     5 * $Id: SimpleVector.java,v 1.6 2004-02-24 21:00:29 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    127127    }
    128128
     129    public AbstractArray adjustArray(int size, AbstractArray displacedTo,
     130                                     int displacement)
     131        throws ConditionThrowable
     132    {
     133        return new ComplexVector(size, displacedTo, displacement);
     134    }
     135
    129136    public int length()
    130137    {
  • trunk/j/src/org/armedbear/lisp/adjust_array.java

    r5919 r5938  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: adjust_array.java,v 1.7 2004-02-24 11:23:47 piso Exp $
     5 * $Id: adjust_array.java,v 1.8 2004-02-24 21:00:29 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5858        else
    5959            displacement = Fixnum.getValue(displacedIndexOffset);
    60         if (array instanceof SimpleVector) {
    61             SimpleVector v = (SimpleVector) array;
    62             LispObject newSize = null;
    63             if (dimensions instanceof Cons) {
    64                 if (dimensions.length() == 1)
    65                     newSize = dimensions.car();
    66             } else
    67                 newSize = dimensions;
    68             if (newSize != null) {
    69                 AbstractVector v2 =
    70                     (AbstractVector) v.adjustArray(Fixnum.getValue(newSize),
    71                                                    initialElement,
    72                                                    initialContents);
     60        if (array.getRank() == 1) {
     61            final int newSize;
     62            if (dimensions instanceof Cons && dimensions.length() == 1)
     63                newSize = Fixnum.getValue(dimensions.car());
     64            else
     65                newSize = Fixnum.getValue(dimensions);
     66            if (array instanceof SimpleVector) {
     67                SimpleVector v = (SimpleVector) array;
     68                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);
    7377                if (fillPointer != NIL)
    7478                    v2.setFillPointer(fillPointer);
    7579                return v2;
    7680            }
    77         }
    78         if (array instanceof ComplexVector) {
    79             ComplexVector v = (ComplexVector) array;
    80             LispObject newSize = null;
    81             if (dimensions instanceof Cons) {
    82                 if (dimensions.length() == 1)
    83                     newSize = dimensions.car();
    84             } else
    85                 newSize = dimensions;
    86             if (newSize != null) {
    87                 v.adjustArray(Fixnum.getValue(newSize), initialElement,
    88                               initialContents);
     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);
    8988                if (fillPointer != NIL)
    9089                    v.setFillPointer(fillPointer);
    9190                return v;
    9291            }
    93         }
    94         if (array instanceof SimpleString) {
    95             SimpleString s = (SimpleString) array;
    96             LispObject newSize = null;
    97             if (dimensions instanceof Cons) {
    98                 if (dimensions.length() == 1)
    99                     newSize = dimensions.car();
    100             } else
    101                 newSize = dimensions;
    102             if (newSize != null) {
     92            if (array instanceof SimpleString) {
     93                SimpleString s = (SimpleString) array;
    10394                AbstractString s2;
    10495                if (displacedTo != NIL)
    105                     s2 = (AbstractString) s.adjustArray(Fixnum.getValue(newSize),
     96                    s2 = (AbstractString) s.adjustArray(newSize,
    10697                                                        checkArray(displacedTo),
    10798                                                        displacement);
    10899                else
    109                     s2 = (AbstractString) s.adjustArray(Fixnum.getValue(newSize),
     100                    s2 = (AbstractString) s.adjustArray(newSize,
    110101                                                        initialElement,
    111102                                                        initialContents);
     
    114105                return s2;
    115106            }
    116         }
    117         if (array instanceof ComplexString) {
    118             ComplexString s = (ComplexString) array;
    119             LispObject newSize = null;
    120             if (dimensions instanceof Cons) {
    121                 if (dimensions.length() == 1)
    122                     newSize = dimensions.car();
    123             } else
    124                 newSize = dimensions;
    125             if (newSize != null) {
     107            if (array instanceof ComplexString) {
     108                ComplexString s = (ComplexString) array;
    126109                if (displacedTo != NIL)
    127                     s.adjustArray(Fixnum.getValue(newSize),
    128                                   checkArray(displacedTo),
     110                    s.adjustArray(newSize, checkArray(displacedTo),
    129111                                  displacement);
    130112                else
    131                     s.adjustArray(Fixnum.getValue(newSize), initialElement,
    132                                   initialContents);
     113                    s.adjustArray(newSize, initialElement, initialContents);
    133114                if (fillPointer != NIL)
    134115                    s.setFillPointer(fillPointer);
  • trunk/j/src/org/armedbear/lisp/make_array.java

    r5918 r5938  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: make_array.java,v 1.15 2004-02-24 11:23:02 piso Exp $
     5 * $Id: make_array.java,v 1.16 2004-02-24 21:00:29 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7070            else
    7171                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;
     72            if (rank == 1) {
     73                if (array.getElementType() == Symbol.CHARACTER) {
     74                    ComplexString s = new ComplexString(dimv[0], array, displacement);
     75                    if (fillPointer != NIL)
     76                        s.setFillPointer(fillPointer);
     77                    return s;
     78                } else {
     79                    ComplexVector v = new ComplexVector(dimv[0], array, displacement);
     80                    if (fillPointer != NIL)
     81                        v.setFillPointer(fillPointer);
     82                    return v;
     83                }
    7784            }
    7885            DisplacedArray displacedArray = new DisplacedArray(dimv, array, displacement);
Note: See TracChangeset for help on using the changeset viewer.