Changeset 11562


Ignore:
Timestamp:
01/17/09 13:56:59 (12 years ago)
Author:
ehuelsmann
Message:

Change and document the internal adjustArray() protocol: we can't use NIL as a marker for "absent initial contents": It's valid for ZeroRankArray?.

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

Legend:

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

    r11557 r11562  
    317317    }
    318318
    319   public abstract AbstractArray adjustArray(int[] dims,
     319    /** Returns a newly allocated array or the current array with
     320     * adjusted dimensions.
     321     *
     322     * @param dims
     323     * @param initialElement @c null if none
     324     * @param initialContents @c null if none
     325     * @return @c this or a new array
     326     * @throws org.armedbear.lisp.ConditionThrowable
     327     */
     328    public abstract AbstractArray adjustArray(int[] dims,
    320329                                              LispObject initialElement,
    321330                                              LispObject initialContents)
    322     throws ConditionThrowable;
    323 
    324   public abstract AbstractArray adjustArray(int[] dims,
     331        throws ConditionThrowable;
     332
     333    /**
     334     *
     335     * @param dims
     336     * @param displacedTo
     337     * @param displacement
     338     * @return
     339     * @throws org.armedbear.lisp.ConditionThrowable
     340     */
     341    public abstract AbstractArray adjustArray(int[] dims,
    325342                                              AbstractArray displacedTo,
    326343                                              int displacement)
    327     throws ConditionThrowable;
     344        throws ConditionThrowable;
    328345}
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

    r11557 r11562  
    264264        throws ConditionThrowable
    265265    {
    266         if (initialContents != NIL) {
     266        if (initialContents != null) {
    267267            LispObject[] newElements = new LispObject[newCapacity];
    268268            if (initialContents.listp()) {
     
    283283            System.arraycopy(elements, 0, newElements, 0,
    284284                             Math.min(capacity, newCapacity));
    285             for (int i = capacity; i < newCapacity; i++)
    286                 newElements[i] = initialElement;
     285            if (initialElement != null)
     286                for (int i = capacity; i < newCapacity; i++)
     287                    newElements[i] = initialElement;
    287288            return new BasicVector_UnsignedByte16(newElements);
    288289        }
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java

    r11557 r11562  
    276276    throws ConditionThrowable
    277277  {
    278     if (initialContents != NIL)
     278    if (initialContents != null)
    279279      {
    280280        LispObject[] newElements = new LispObject[newCapacity];
     
    302302        System.arraycopy(elements, 0, newElements, 0,
    303303                         Math.min(capacity, newCapacity));
    304         for (int i = capacity; i < newCapacity; i++)
    305           newElements[i] = initialElement;
     304        if (initialElement != null)
     305            for (int i = capacity; i < newCapacity; i++)
     306                newElements[i] = initialElement;
    306307        return new BasicVector_UnsignedByte32(newElements);
    307308      }
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

    r11557 r11562  
    274274    throws ConditionThrowable
    275275  {
    276     if (initialContents != NIL)
     276    if (initialContents != null)
    277277      {
    278278        LispObject[] newElements = new LispObject[newCapacity];
     
    300300        System.arraycopy(elements, 0, newElements, 0,
    301301                         Math.min(capacity, newCapacity));
    302         for (int i = capacity; i < newCapacity; i++)
    303           newElements[i] = initialElement;
     302        if (initialElement != null)
     303            for (int i = capacity; i < newCapacity; i++)
     304                newElements[i] = initialElement;
    304305        return new BasicVector_UnsignedByte8(newElements);
    305306      }
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray.java

    r11557 r11562  
    243243            throws ConditionThrowable {
    244244        if (isAdjustable()) {
    245             if (initialContents != NIL)
     245            if (initialContents != null)
    246246                setInitialContents(0, dims, initialContents, 0);
    247247            else {
     
    249249                // all of the array code yet
    250250                SimpleArray_T tempArray = new SimpleArray_T(dims, elementType);
    251                 tempArray.fill(initialElement);
     251                if (initialElement != null)
     252                    tempArray.fill(initialElement);
    252253                SimpleArray_T.copyArray(this, tempArray);
    253254                this.data = tempArray.data;
     
    258259            return this;
    259260        } else {
    260             if (initialContents != NIL)
     261            if (initialContents != null)
    261262                return new ComplexArray(dims, elementType, initialContents);
    262263            else {
    263264                ComplexArray newArray = new ComplexArray(dims, elementType);
    264                 newArray.fill(initialElement);
     265                if (initialElement != null)
     266                    newArray.fill(initialElement);
    265267                return newArray;
    266268            }
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

    r11560 r11562  
    240240            throws ConditionThrowable {
    241241        if (isAdjustable()) {
    242             if (initialContents != NIL)
     242            if (initialContents != null)
    243243                setInitialContents(0, dims, initialContents, 0);
    244244            else {
     
    246246                // all of the array code yet
    247247                SimpleArray_UnsignedByte32 tempArray = new SimpleArray_UnsignedByte32(dims);
    248                 tempArray.fill(initialElement);
     248                if (initialElement != null)
     249                    tempArray.fill(initialElement);
    249250                SimpleArray_UnsignedByte32.copyArray(this, tempArray);
    250251                this.data = tempArray.data;
     
    255256            return this;
    256257        } else {
    257             if (initialContents != NIL)
     258            if (initialContents != null)
    258259                return new ComplexArray_UnsignedByte32(dims, initialContents);
    259260            else {
    260261                ComplexArray_UnsignedByte32 newArray = new ComplexArray_UnsignedByte32(dims);
    261                 newArray.fill(initialElement);
     262                if (initialElement != null)
     263                    newArray.fill(initialElement);
    262264                return newArray;
    263265            }
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r11560 r11562  
    242242            throws ConditionThrowable {
    243243        if (isAdjustable()) {
    244             if (initialContents != NIL)
     244            if (initialContents != null)
    245245                setInitialContents(0, dims, initialContents, 0);
    246246            else {
     
    248248                // all of the array code yet
    249249                SimpleArray_UnsignedByte8 tempArray = new SimpleArray_UnsignedByte8(dims);
    250                 tempArray.fill(initialElement);
     250                if (initialElement != null)
     251                    tempArray.fill(initialElement);
    251252                SimpleArray_UnsignedByte8.copyArray(this, tempArray);
    252253                this.data = tempArray.data;
     
    257258            return this;
    258259        } else {
    259             if (initialContents != NIL)
     260            if (initialContents != null)
    260261                return new ComplexArray_UnsignedByte8(dims, initialContents);
    261262            else {
    262263                ComplexArray_UnsignedByte8 newArray = new ComplexArray_UnsignedByte8(dims);
    263                 newArray.fill(initialElement);
     264                if (initialElement != null)
     265                    newArray.fill(initialElement);
    264266                return newArray;
    265267            }
  • trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java

    r11557 r11562  
    346346            if ((newCapacity & LONG_MASK) != 0)
    347347                ++size;
    348             if (initialContents != NIL) {
     348            if (initialContents != null) {
    349349                bits = new long[size];
    350350                capacity = newCapacity;
     
    365365                                 Math.min(bits.length, newBits.length));
    366366                bits = newBits;
    367                 if (newCapacity > capacity) {
     367                if (newCapacity > capacity && initialElement != null) {
    368368                    int n = Fixnum.getValue(initialElement);
    369369                    if (n == 1)
  • trunk/abcl/src/org/armedbear/lisp/ComplexString.java

    r11557 r11562  
    603603    throws ConditionThrowable
    604604  {
    605     if (initialContents != NIL)
     605    if (initialContents != null)
    606606      {
    607607        // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
     
    659659            chars = newElements;
    660660          }
    661         if (initialElement != NIL && capacity < newCapacity)
     661        if (initialElement != null && capacity < newCapacity)
    662662          {
    663663            // Initialize new elements.
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector.java

    r11557 r11562  
    371371        throws ConditionThrowable
    372372    {
    373         if (initialContents != NIL) {
     373        if (initialContents != null) {
    374374            // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
    375375            // ARRAY. In this case none of the original contents of array
     
    402402            }
    403403            // Initialize new elements (if any).
    404             for (int i = capacity; i < newCapacity; i++)
    405                 elements[i] = initialElement;
     404            if (initialElement != null)
     405                for (int i = capacity; i < newCapacity; i++)
     406                    elements[i] = initialElement;
    406407        }
    407408        capacity = newCapacity;
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java

    r11557 r11562  
    373373        throws ConditionThrowable
    374374    {
    375         if (initialContents != NIL) {
     375        if (initialContents != null) {
    376376            // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
    377377            // ARRAY. In this case none of the original contents of array
     
    404404            }
    405405            // Initialize new elements (if aapplicable).
    406             if (initialElement != NIL) {
     406            if (initialElement != null) {
    407407                for (int i = capacity; i < newCapacity; i++)
    408408                    elements[i] = initialElement;
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

    r11557 r11562  
    385385        throws ConditionThrowable
    386386    {
    387         if (initialContents != NIL) {
     387        if (initialContents != null) {
    388388            // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
    389389            // ARRAY. In this case none of the original contents of array
     
    416416            }
    417417            // Initialize new elements (if aapplicable).
    418             if (initialElement != NIL) {
     418            if (initialElement != null) {
    419419                byte b = coerceLispObjectToJavaByte(initialElement);
    420420                for (int i = capacity; i < newCapacity; i++)
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java

    r11557 r11562  
    328328    throws ConditionThrowable
    329329  {
    330     if (initialContents != NIL)
     330    if (initialContents != null)
    331331      return new SimpleArray_T(dimv, elementType, initialContents);
    332332    for (int i = 0; i < dimv.length; i++)
     
    335335          {
    336336            SimpleArray_T newArray = new SimpleArray_T(dimv, elementType);
    337             newArray.fill(initialElement);
     337            if (initialElement != null)
     338                newArray.fill(initialElement);
    338339            copyArray(this, newArray);
    339340            return newArray;
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java

    r11488 r11562  
    304304        throws ConditionThrowable
    305305    {
    306         if (initialContents != NIL)
     306        if (initialContents != null)
    307307            return new SimpleArray_UnsignedByte16(dimv, initialContents);
    308308        for (int i = 0; i < dimv.length; i++) {
     
    310310                SimpleArray_UnsignedByte16 newArray =
    311311                    new SimpleArray_UnsignedByte16(dimv);
    312                 newArray.fill(initialElement);
     312                if (initialElement != null)
     313                    newArray.fill(initialElement);
    313314                copyArray(this, newArray);
    314315                return newArray;
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java

    r11557 r11562  
    294294        throws ConditionThrowable
    295295    {
    296         if (initialContents != NIL)
     296        if (initialContents != null)
    297297            return new SimpleArray_UnsignedByte32(dimv, initialContents);
    298298        for (int i = 0; i < dimv.length; i++) {
     
    300300                SimpleArray_UnsignedByte32 newArray =
    301301                    new SimpleArray_UnsignedByte32(dimv);
    302                 newArray.fill(initialElement);
     302                if (initialElement != null)
     303                    newArray.fill(initialElement);
    303304                copyArray(this, newArray);
    304305                return newArray;
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java

    r11557 r11562  
    291291        throws ConditionThrowable
    292292    {
    293         if (initialContents != NIL)
     293        if (initialContents != null)
    294294            return new SimpleArray_UnsignedByte8(dimv, initialContents);
    295295        for (int i = 0; i < dimv.length; i++) {
     
    297297                SimpleArray_UnsignedByte8 newArray =
    298298                    new SimpleArray_UnsignedByte8(dimv);
    299                 newArray.fill(initialElement);
     299                if (initialElement != null)
     300                    newArray.fill(initialElement);
    300301                copyArray(this, newArray);
    301302                return newArray;
  • trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java

    r11557 r11562  
    200200        throws ConditionThrowable
    201201    {
    202         if (initialContents != NIL) {
     202        if (initialContents != null) {
    203203            SimpleBitVector v = new SimpleBitVector(newCapacity);
    204204            if (initialContents.listp()) {
     
    224224                    v.clearBit(i);
    225225            }
    226             if (initialElement != NIL && capacity < newCapacity) {
     226            if (initialElement != null && capacity < newCapacity) {
    227227                int n = Fixnum.getValue(initialElement);
    228228                if (n == 1)
  • trunk/abcl/src/org/armedbear/lisp/SimpleString.java

    r11557 r11562  
    466466        throws ConditionThrowable
    467467    {
    468         if (initialContents != NIL) {
     468        if (initialContents != null) {
    469469            char[] newChars = new char[newCapacity];
    470470            if (initialContents.listp()) {
     
    484484            char[] newChars = new char[newCapacity];
    485485            System.arraycopy(chars, 0, newChars, 0, Math.min(newCapacity, capacity));
    486             if (initialElement != NIL && capacity < newCapacity) {
     486            if (initialElement != null && capacity < newCapacity) {
    487487                final char c = LispCharacter.getValue(initialElement);
    488488                for (int i = capacity; i < newCapacity; i++)
  • trunk/abcl/src/org/armedbear/lisp/SimpleVector.java

    r11557 r11562  
    337337    throws ConditionThrowable
    338338  {
    339     if (initialContents != NIL)
     339    if (initialContents != null)
    340340      {
    341341        LispObject[] newData = new LispObject[newCapacity];
     
    363363        System.arraycopy(data, 0, newData, 0,
    364364                         Math.min(capacity, newCapacity));
    365         for (int i = capacity; i < newCapacity; i++)
    366           newData[i] = initialElement;
     365        if (initialElement != null)
     366            for (int i = capacity; i < newCapacity; i++)
     367                newData[i] = initialElement;
    367368        return new SimpleVector(newData);
    368369      }
  • trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java

    r11557 r11562  
    170170    throws ConditionThrowable {
    171171      if (isAdjustable()) {
    172           if (initialContents != NIL)
     172          // initial element doesn't matter:
     173          // we're not creating new elements
     174          if (initialContents != null)
    173175              data = initialContents;
    174           else
    175               data = initialElement;
    176176          return this;
    177177      } else {
    178178          return new ZeroRankArray(elementType,
    179                   initialContents != NIL ? initialContents : initialElement,
    180                   false);
     179                  initialContents != null ? initialContents :
     180                      initialElement != null ? initialElement : data, false);
    181181      }
    182182  }
  • trunk/abcl/src/org/armedbear/lisp/adjust_array.java

    r11561 r11562  
    5252        LispObject dimensions = args[1];
    5353        LispObject elementType = args[2];
    54         LispObject initialElement = args[3];
    55         LispObject initialElementProvided = args[4];
    56         LispObject initialContents = args[5];
    57         LispObject initialContentsProvided = args[6];
     54        boolean initialElementProvided = args[4] != NIL;
     55        boolean initialContentsProvided = args[6] != NIL;
     56        LispObject initialElement = initialElementProvided ? args[3] : null;
     57        LispObject initialContents = initialContentsProvided ? args[5] : null;
    5858        LispObject fillPointer = args[7];
    5959        LispObject displacedTo = args[8];
    6060        LispObject displacedIndexOffset = args[9];
    61         if (initialElementProvided != NIL && initialContentsProvided != NIL) {
     61        if (initialElementProvided && initialContentsProvided) {
    6262            return error(new LispError("ADJUST-ARRAY: cannot specify both initial element and initial contents."));
    6363        }
     
    6868        }
    6969        if (array.getRank() == 0) {
    70             return array.adjustArray(new int[0], NIL,
    71                     (initialContentsProvided != NIL) ? initialContents : initialElement);
     70            return array.adjustArray(new int[0], initialElement, initialContents);
    7271        }
    73         if (initialElementProvided == NIL && array.getElementType() == T)
     72        if (!initialElementProvided && array.getElementType() == T)
    7473            initialElement = Fixnum.ZERO;
    7574        if (array.getRank() == 1) {
Note: See TracChangeset for help on using the changeset viewer.