Changeset 11557


Ignore:
Timestamp:
01/15/09 23:19:35 (12 years ago)
Author:
ehuelsmann
Message:

Fix ticket #28: Expressly adjustable array not adjustable.

Renames adjustVector() to adjustArray() and implements adjustArray() on arrays.

Note: This is not the nicest solution; it removes 'private' modifiers, however,

given the size of the commit, it seems like an issue to be resolved in a later
cleanup of the Array vs Vector code.

Location:
trunk/abcl/src/org/armedbear/lisp
Files:
22 edited

Legend:

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

    r11488 r11557  
    8585        noFillPointer();
    8686        return -1; // Not reached.
     87    }
     88
     89    public void setFillPointer(LispObject fillPointer) throws ConditionThrowable
     90    {
     91        setFillPointer(fillPointer.intValue());
     92    }
     93
     94    public void setFillPointer(int fillPointer) throws ConditionThrowable
     95    {
     96        noFillPointer();
    8797    }
    8898
     
    212222        if (this instanceof SimpleArray_T)
    213223            sb.append("SIMPLE-");
    214         sb.append("ARRAY T (");
     224        sb.append("ARRAY " + getElementType().writeToString() + " (");
    215225        for (int i = 0; i < dimv.length; i++) {
    216226            sb.append(dimv[i]);
     
    306316        }
    307317    }
     318
     319  public abstract AbstractArray adjustArray(int[] dims,
     320                                              LispObject initialElement,
     321                                              LispObject initialContents)
     322    throws ConditionThrowable;
     323
     324  public abstract AbstractArray adjustArray(int[] dims,
     325                                              AbstractArray displacedTo,
     326                                              int displacement)
     327    throws ConditionThrowable;
    308328}
  • trunk/abcl/src/org/armedbear/lisp/AbstractVector.java

    r11488 r11557  
    298298  }
    299299
    300   public abstract AbstractVector adjustVector(int size,
     300  public abstract AbstractArray adjustArray(int size,
    301301                                              LispObject initialElement,
    302302                                              LispObject initialContents)
    303303    throws ConditionThrowable;
    304 
    305   public abstract AbstractVector adjustVector(int size,
     304  public abstract AbstractArray adjustArray(int size,
    306305                                              AbstractArray displacedTo,
    307306                                              int displacement)
    308307    throws ConditionThrowable;
     308
     309
     310  public AbstractArray adjustArray(int[] dims,
     311                                              LispObject initialElement,
     312                                              LispObject initialContents)
     313    throws ConditionThrowable {
     314      return adjustArray(dims[0], initialElement, initialContents);
     315  }
     316
     317  public AbstractArray adjustArray(int[] dims,
     318                                              AbstractArray displacedTo,
     319                                              int displacement)
     320    throws ConditionThrowable {
     321      return adjustArray(dims[0], displacedTo, displacement);
     322  }
    309323}
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

    r11488 r11557  
    259259
    260260    @Override
    261     public AbstractVector adjustVector(int newCapacity,
     261    public AbstractVector adjustArray(int newCapacity,
    262262                                       LispObject initialElement,
    263263                                       LispObject initialContents)
     
    292292
    293293    @Override
    294     public AbstractVector adjustVector(int newCapacity,
     294    public AbstractVector adjustArray(int newCapacity,
    295295                                       AbstractArray displacedTo,
    296296                                       int displacement)
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java

    r11488 r11557  
    271271
    272272  @Override
    273   public AbstractVector adjustVector(int newCapacity,
     273  public AbstractVector adjustArray(int newCapacity,
    274274                                     LispObject initialElement,
    275275                                     LispObject initialContents)
     
    311311
    312312  @Override
    313   public AbstractVector adjustVector(int newCapacity,
     313  public AbstractVector adjustArray(int newCapacity,
    314314                                     AbstractArray displacedTo,
    315315                                     int displacement)
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

    r11488 r11557  
    269269
    270270  @Override
    271   public AbstractVector adjustVector(int newCapacity,
     271  public AbstractVector adjustArray(int newCapacity,
    272272                                     LispObject initialElement,
    273273                                     LispObject initialContents)
     
    309309
    310310  @Override
    311   public AbstractVector adjustVector(int newCapacity,
     311  public AbstractVector adjustArray(int newCapacity,
    312312                                     AbstractArray displacedTo,
    313313                                     int displacement)
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray.java

    r11488 r11557  
    3838    private final int[] dimv;
    3939    private final LispObject elementType;
    40     private final int totalSize;
     40    private int totalSize;
    4141
    4242    // For non-displaced arrays.
     
    236236        return writeToString(dimv);
    237237    }
     238
     239    @Override
     240    public AbstractArray adjustArray(int[] dims,
     241                                              LispObject initialElement,
     242                                              LispObject initialContents)
     243            throws ConditionThrowable {
     244        if (isAdjustable()) {
     245            if (initialContents != NIL)
     246                setInitialContents(0, dims, initialContents, 0);
     247            else {
     248                //### FIXME Take the easy way out: we don't want to reorganize
     249                // all of the array code yet
     250                SimpleArray_T tempArray = new SimpleArray_T(dims, elementType);
     251                tempArray.fill(initialElement);
     252                SimpleArray_T.copyArray(this, tempArray);
     253                this.data = tempArray.data;
     254
     255                for (int i = 0; i < dims.length; i++)
     256                    dimv[i] = dims[i];
     257            }
     258            return this;
     259        } else {
     260            if (initialContents != NIL)
     261                return new ComplexArray(dims, elementType, initialContents);
     262            else {
     263                ComplexArray newArray = new ComplexArray(dims, elementType);
     264                newArray.fill(initialElement);
     265                return newArray;
     266            }
     267        }
     268    }
     269
     270    @Override
     271    public AbstractArray adjustArray(int[] dims,
     272                                              AbstractArray displacedTo,
     273                                              int displacement)
     274            throws ConditionThrowable {
     275        if (isAdjustable()) {
     276            for (int i = 0; i < dims.length; i++)
     277                dimv[i] = dims[i];
     278
     279            this.data = null;
     280            this.array = displacedTo;
     281            this.displacement = displacement;
     282            this.totalSize = computeTotalSize(dims);
     283
     284            return this;
     285        } else {
     286            ComplexArray a = new ComplexArray(dims, displacedTo, displacement);
     287           
     288            return a;
     289        }
     290    }
    238291}
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

    r11488 r11557  
    3737{
    3838    private final int[] dimv;
    39     private final int totalSize;
     39    private int totalSize;
    4040
    4141    // For non-displaced arrays.
     
    232232        return writeToString(dimv);
    233233    }
     234
     235
     236    @Override
     237    public AbstractArray adjustArray(int[] dims,
     238                                              LispObject initialElement,
     239                                              LispObject initialContents)
     240            throws ConditionThrowable {
     241        if (isAdjustable()) {
     242            if (initialContents != NIL)
     243                setInitialContents(0, dims, initialContents, 0);
     244            else {
     245                //### FIXME Take the easy way out: we don't want to reorganize
     246                // all of the array code yet
     247                SimpleArray_UnsignedByte32 tempArray = new SimpleArray_UnsignedByte32(dims, getElementType());
     248                tempArray.fill(initialElement);
     249                SimpleArray_UnsignedByte32.copyArray(this, tempArray);
     250                this.data = tempArray.data;
     251
     252                for (int i = 0; i < dims.length; i++)
     253                    dimv[i] = dims[i];
     254            }
     255            return this;
     256        } else {
     257            if (initialContents != NIL)
     258                return new ComplexArray_UnsignedByte32(dims, initialContents);
     259            else {
     260                ComplexArray_UnsignedByte32 newArray = new ComplexArray_UnsignedByte32(dims);
     261                newArray.fill(initialElement);
     262                return newArray;
     263            }
     264        }
     265    }
     266
     267    @Override
     268    public AbstractArray adjustArray(int[] dims,
     269                                              AbstractArray displacedTo,
     270                                              int displacement)
     271            throws ConditionThrowable {
     272        if (isAdjustable()) {
     273            for (int i = 0; i < dims.length; i++)
     274                dimv[i] = dims[i];
     275
     276            this.data = null;
     277            this.array = displacedTo;
     278            this.displacement = displacement;
     279            this.totalSize = computeTotalSize(dims);
     280
     281            return this;
     282        } else {
     283            ComplexArray_UnsignedByte32 a = new ComplexArray_UnsignedByte32(dims, displacedTo, displacement);
     284
     285            return a;
     286        }
     287    }
    234288}
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r11488 r11557  
    3737{
    3838    private final int[] dimv;
    39     private final int totalSize;
     39    private int totalSize;
    4040
    4141    // For non-displaced arrays.
     
    234234        return writeToString(dimv);
    235235    }
     236
     237
     238    @Override
     239    public AbstractArray adjustArray(int[] dims,
     240                                              LispObject initialElement,
     241                                              LispObject initialContents)
     242            throws ConditionThrowable {
     243        if (isAdjustable()) {
     244            if (initialContents != NIL)
     245                setInitialContents(0, dims, initialContents, 0);
     246            else {
     247                //### FIXME Take the easy way out: we don't want to reorganize
     248                // all of the array code yet
     249                SimpleArray_UnsignedByte8 tempArray = new SimpleArray_UnsignedByte8(dims, getElementType());
     250                tempArray.fill(initialElement);
     251                SimpleArray_UnsignedByte8.copyArray(this, tempArray);
     252                this.data = tempArray.data;
     253
     254                for (int i = 0; i < dims.length; i++)
     255                    dimv[i] = dims[i];
     256            }
     257            return this;
     258        } else {
     259            if (initialContents != NIL)
     260                return new ComplexArray_UnsignedByte8(dims, initialContents);
     261            else {
     262                ComplexArray_UnsignedByte8 newArray = new ComplexArray_UnsignedByte8(dims);
     263                newArray.fill(initialElement);
     264                return newArray;
     265            }
     266        }
     267    }
     268
     269    @Override
     270    public AbstractArray adjustArray(int[] dims,
     271                                              AbstractArray displacedTo,
     272                                              int displacement)
     273            throws ConditionThrowable {
     274        if (isAdjustable()) {
     275            for (int i = 0; i < dims.length; i++)
     276                dimv[i] = dims[i];
     277
     278            this.data = null;
     279            this.array = displacedTo;
     280            this.displacement = displacement;
     281            this.totalSize = computeTotalSize(dims);
     282
     283            return this;
     284        } else {
     285            ComplexArray_UnsignedByte8 a = new ComplexArray_UnsignedByte8(dims, displacedTo, displacement);
     286
     287            return a;
     288        }
     289    }
    236290}
  • trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java

    r11488 r11557  
    320320
    321321    @Override
    322     public AbstractVector adjustVector(int newCapacity,
     322    public AbstractVector adjustArray(int newCapacity,
    323323                                       LispObject initialElement,
    324324                                       LispObject initialContents)
     
    381381
    382382    @Override
    383     public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     383    public AbstractVector adjustArray(int size, AbstractArray displacedTo,
    384384                                       int displacement)
    385385        throws ConditionThrowable
  • trunk/abcl/src/org/armedbear/lisp/ComplexString.java

    r11488 r11557  
    598598
    599599  @Override
    600   public AbstractVector adjustVector(int newCapacity,
     600  public AbstractVector adjustArray(int newCapacity,
    601601                                     LispObject initialElement,
    602602                                     LispObject initialContents)
     
    675675
    676676  @Override
    677   public AbstractVector adjustVector(int newCapacity,
     677  public AbstractVector adjustArray(int newCapacity,
    678678                                     AbstractArray displacedTo,
    679679                                     int displacement)
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector.java

    r11488 r11557  
    366366
    367367    @Override
    368     public AbstractVector adjustVector(int newCapacity,
     368    public AbstractVector adjustArray(int newCapacity,
    369369                                       LispObject initialElement,
    370370                                       LispObject initialContents)
     
    413413
    414414    @Override
    415     public AbstractVector adjustVector(int newCapacity,
     415    public AbstractVector adjustArray(int newCapacity,
    416416                                       AbstractArray displacedTo,
    417417                                       int displacement)
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java

    r11488 r11557  
    368368
    369369    @Override
    370     public AbstractVector adjustVector(int newCapacity,
     370    public AbstractVector adjustArray(int newCapacity,
    371371                                       LispObject initialElement,
    372372                                       LispObject initialContents)
     
    417417
    418418    @Override
    419     public AbstractVector adjustVector(int newCapacity,
     419    public AbstractVector adjustArray(int newCapacity,
    420420                                       AbstractArray displacedTo,
    421421                                       int displacement)
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

    r11488 r11557  
    380380
    381381    @Override
    382     public AbstractVector adjustVector(int newCapacity,
     382    public AbstractVector adjustArray(int newCapacity,
    383383                                       LispObject initialElement,
    384384                                       LispObject initialContents)
     
    430430
    431431    @Override
    432     public AbstractVector adjustVector(int newCapacity,
     432    public AbstractVector adjustArray(int newCapacity,
    433433                                       AbstractArray displacedTo,
    434434                                       int displacement)
  • trunk/abcl/src/org/armedbear/lisp/NilVector.java

    r11488 r11557  
    248248
    249249    @Override
    250     public AbstractVector adjustVector(int newCapacity,
     250    public AbstractVector adjustArray(int newCapacity,
    251251                                       LispObject initialElement,
    252252                                       LispObject initialContents)
     
    259259
    260260    @Override
    261     public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     261    public AbstractVector adjustArray(int size, AbstractArray displacedTo,
    262262                                       int displacement)
    263263        throws ConditionThrowable
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java

    r11555 r11557  
    3939  private final LispObject elementType;
    4040  private final int totalSize;
    41   private final LispObject[] data;
     41  final LispObject[] data;
    4242
    4343  public SimpleArray_T(int[] dimv, LispObject elementType)
     
    8888    data = new LispObject[totalSize];
    8989    setInitialContents(0, dimv, initialContents, 0);
     90  }
     91
     92  public SimpleArray_T(final int[] dimv, final LispObject[] initialData,
     93          final LispObject elementType) {
     94      this.dimv = dimv;
     95      this.elementType = elementType;
     96      this.data = initialData;
     97      this.totalSize = computeTotalSize(dimv);
    9098  }
    9199
     
    315323  }
    316324
     325  @Override
    317326  public AbstractArray adjustArray(int[] dimv, LispObject initialElement,
    318327                                   LispObject initialContents)
     
    331340          }
    332341      }
    333     // New dimensions are identical to old dimensions.
    334     return this;
     342    // New dimensions are identical to old dimensions, yet
     343    // we're not mutable, so, we need to return a new array
     344    return new SimpleArray_T(dimv, data.clone(), elementType);
    335345  }
    336346
    337347  // Copy a1 to a2 for index tuples that are valid for both arrays.
    338   private static void copyArray(AbstractArray a1, AbstractArray a2)
     348  static void copyArray(AbstractArray a1, AbstractArray a2)
    339349    throws ConditionThrowable
    340350  {
     
    367377  }
    368378
     379  @Override
    369380  public AbstractArray adjustArray(int[] dimv, AbstractArray displacedTo,
    370381                                   int displacement)
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java

    r11488 r11557  
    4040
    4141    // FIXME We should really use an array of unboxed values!
    42     private final LispObject[] data;
     42    final LispObject[] data;
    4343
    4444    public SimpleArray_UnsignedByte32(int[] dimv)
     
    310310
    311311    // Copy a1 to a2 for index tuples that are valid for both arrays.
    312     private static void copyArray(AbstractArray a1, AbstractArray a2)
     312    static void copyArray(AbstractArray a1, AbstractArray a2)
    313313        throws ConditionThrowable
    314314    {
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java

    r11488 r11557  
    3838    private final int[] dimv;
    3939    private final int totalSize;
    40     private final byte[] data;
     40    final byte[] data;
    4141
    4242    public SimpleArray_UnsignedByte8(int[] dimv)
     
    307307
    308308    // Copy a1 to a2 for index tuples that are valid for both arrays.
    309     private static void copyArray(AbstractArray a1, AbstractArray a2)
     309    static void copyArray(AbstractArray a1, AbstractArray a2)
    310310        throws ConditionThrowable
    311311    {
  • trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java

    r11539 r11557  
    195195
    196196    @Override
    197     public AbstractVector adjustVector(int newCapacity,
     197    public AbstractVector adjustArray(int newCapacity,
    198198                                       LispObject initialElement,
    199199                                       LispObject initialContents)
     
    240240
    241241    @Override
    242     public AbstractVector adjustVector(int newCapacity,
     242    public AbstractVector adjustArray(int newCapacity,
    243243                                       AbstractArray displacedTo,
    244244                                       int displacement)
  • trunk/abcl/src/org/armedbear/lisp/SimpleString.java

    r11488 r11557  
    461461
    462462    @Override
    463     public AbstractVector adjustVector(int newCapacity,
     463    public AbstractVector adjustArray(int newCapacity,
    464464                                       LispObject initialElement,
    465465                                       LispObject initialContents)
     
    496496
    497497    @Override
    498     public AbstractVector adjustVector(int newCapacity,
     498    public AbstractVector adjustArray(int newCapacity,
    499499                                       AbstractArray displacedTo,
    500500                                       int displacement)
  • trunk/abcl/src/org/armedbear/lisp/SimpleVector.java

    r11488 r11557  
    332332
    333333  @Override
    334   public AbstractVector adjustVector(int newCapacity,
     334  public AbstractVector adjustArray(int newCapacity,
    335335                                     LispObject initialElement,
    336336                                     LispObject initialContents)
     
    372372
    373373  @Override
    374   public AbstractVector adjustVector(int newCapacity,
     374  public AbstractVector adjustArray(int newCapacity,
    375375                                     AbstractArray displacedTo,
    376376                                     int displacement)
  • trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java

    r11488 r11557  
    163163        return unreadableString(sb.toString());
    164164    }
     165
     166  @Override
     167  public AbstractArray adjustArray(int[] dims,
     168                                              LispObject initialElement,
     169                                              LispObject initialContents)
     170    throws ConditionThrowable {
     171      if (isAdjustable()) {
     172          if (initialContents != NIL)
     173              data = initialContents;
     174          else
     175              data = initialElement;
     176          return this;
     177      } else {
     178          return new ZeroRankArray(elementType,
     179                  initialContents != NIL ? initialContents : initialElement,
     180                  false);
     181      }
     182  }
     183
     184  @Override
     185  public AbstractArray adjustArray(int[] dims,
     186                                              AbstractArray displacedTo,
     187                                              int displacement)
     188    throws ConditionThrowable {
     189      error(new TypeError("Displacement not supported for array of rank 0."));
     190      return null;
     191  }
    165192}
  • trunk/abcl/src/org/armedbear/lisp/adjust_array.java

    r11488 r11557  
    6868        }
    6969        if (array.getRank() == 0) {
    70             if (initialContentsProvided != NIL)
    71                 array.aset(0, initialContents);
    72             return array;
     70            return array.adjustArray(new int[0], NIL,
     71                    (initialContentsProvided != NIL) ? initialContents : initialElement);
    7372        }
    7473        if (initialElementProvided == NIL && array.getElementType() == T)
     
    8281            if (array instanceof AbstractVector) {
    8382                AbstractVector v = (AbstractVector) array;
    84                 AbstractVector v2;
     83                AbstractArray v2;
    8584                if (displacedTo != NIL) {
    8685                    final int displacement;
     
    8988                    else
    9089                        displacement = Fixnum.getValue(displacedIndexOffset);
    91                     v2 = v.adjustVector(newSize,
     90                    v2 = v.adjustArray(newSize,
    9291                                        checkArray(displacedTo),
    9392                                        displacement);
    9493                } else {
    95                     v2 = v.adjustVector(newSize,
     94                    v2 = v.adjustArray(newSize,
    9695                                        initialElement,
    9796                                        initialContents);
     
    113112        } else
    114113            dimv[0] = Fixnum.getValue(dimensions);
    115         if (array instanceof SimpleArray_T) {
    116             SimpleArray_T a = (SimpleArray_T) array;
    117             if (displacedTo != NIL) {
    118                 final int displacement;
    119                 if (displacedIndexOffset == NIL)
    120                     displacement = 0;
    121                 else
    122                     displacement = Fixnum.getValue(displacedIndexOffset);
    123                 return a.adjustArray(dimv,
     114
     115        if (displacedTo != NIL) {
     116            final int displacement;
     117            if (displacedIndexOffset == NIL)
     118                displacement = 0;
     119            else
     120                displacement = Fixnum.getValue(displacedIndexOffset);
     121            return array.adjustArray(dimv,
    124122                                     checkArray(displacedTo),
    125123                                     displacement);
    126             } else {
    127                 return a.adjustArray(dimv,
     124        } else {
     125            return array.adjustArray(dimv,
    128126                                     initialElement,
    129127                                     initialContents);
    130             }
    131128        }
    132         return error(new LispError("ADJUST-ARRAY: unsupported case."));
    133129    }
    134130
Note: See TracChangeset for help on using the changeset viewer.