Changeset 5958


Ignore:
Timestamp:
02/25/04 14:41:15 (17 years ago)
Author:
piso
Message:

Work in progress.

File:
1 edited

Legend:

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

    r5957 r5958  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexVector.java,v 1.7 2004-02-25 13:50:54 piso Exp $
     5 * $Id: ComplexVector.java,v 1.8 2004-02-25 14:41:15 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    128128    }
    129129
    130     public AbstractVector adjustVector(int size, LispObject initialElement,
    131                                        LispObject initialContents)
    132         throws ConditionThrowable
    133     {
    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         }
    143         if (elements.length != size) {
    144             LispObject[] newArray = new LispObject[size];
    145             if (initialContents != NIL) {
    146                 if (initialContents.listp()) {
    147                     LispObject list = initialContents;
    148                     for (int i = 0; i < size; i++) {
    149                         newArray[i] = list.car();
    150                         list = list.cdr();
    151                     }
    152                 } else if (initialContents.vectorp()) {
    153                     for (int i = 0; i < size; i++)
    154                         newArray[i] = initialContents.elt(i);
    155                 } else
    156                     signal(new TypeError(initialContents, Symbol.SEQUENCE));
    157             } else {
    158                 System.arraycopy(elements, 0, newArray, 0,
    159                                  Math.min(elements.length, size));
    160                 if (size > elements.length) {
    161                     for (int i = elements.length; i < size; i++)
    162                         newArray[i] = initialElement;
    163                 }
    164             }
    165             elements = newArray;
    166             capacity = size;
    167         }
    168         return this;
    169     }
    170 
    171     public AbstractVector adjustVector(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 
    183130    public int length()
    184131    {
     
    298245        }
    299246        return this;
     247    }
     248
     249    public String toString()
     250    {
     251        StringBuffer sb = new StringBuffer("#(");
     252        try {
     253            // FIXME The limit should be based on the value of *PRINT-LENGTH*.
     254            final int limit = Math.min(length(), 10);
     255            for (int i = 0; i < limit; i++) {
     256                if (i > 0)
     257                    sb.append(' ');
     258                sb.append(get(i));
     259            }
     260            if (limit < length())
     261                sb.append(" ...");
     262            sb.append(')');
     263        }
     264        catch (ConditionThrowable t) {
     265            // Shouldn't happen.
     266            Debug.trace(t);
     267        }
     268        return sb.toString();
    300269    }
    301270
     
    353322    }
    354323
    355     public String toString()
    356     {
    357         StringBuffer sb = new StringBuffer("#(");
    358         try {
    359             // FIXME The limit should be based on the value of *PRINT-LENGTH*.
    360             final int limit = Math.min(length(), 10);
    361             for (int i = 0; i < limit; i++) {
    362                 if (i > 0)
    363                     sb.append(' ');
    364                 sb.append(get(i));
    365             }
    366             if (limit < length())
    367                 sb.append(" ...");
    368             sb.append(')');
    369         }
    370         catch (ConditionThrowable t) {
    371             // Shouldn't happen.
    372             Debug.trace(t);
    373         }
    374         return sb.toString();
     324    public AbstractVector adjustVector(int newCapacity,
     325                                       LispObject initialElement,
     326                                       LispObject initialContents)
     327        throws ConditionThrowable
     328    {
     329        if (initialContents != NIL) {
     330            // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
     331            // ARRAY. In this case none of the original contents of array
     332            // appears in the resulting array."
     333            LispObject[] newArray = new LispObject[newCapacity];
     334            if (initialContents.listp()) {
     335                LispObject list = initialContents;
     336                for (int i = 0; i < newCapacity; i++) {
     337                    newArray[i] = list.car();
     338                    list = list.cdr();
     339                }
     340            } else if (initialContents.vectorp()) {
     341                for (int i = 0; i < newCapacity; i++)
     342                    newArray[i] = initialContents.elt(i);
     343            } else
     344                signal(new TypeError(initialContents, Symbol.SEQUENCE));
     345            elements = newArray;
     346        } else {
     347            if (elements == null) {
     348                // Displaced array. Copy existing elements.
     349                elements = new LispObject[newCapacity];
     350                final int limit = Math.min(capacity, newCapacity);
     351                for (int i = 0; i < limit; i++)
     352                    elements[i] = array.getRowMajor(displacement + i);
     353                array = null;
     354                displacement = 0;
     355                isDisplaced = false;
     356            } else if (capacity != newCapacity) {
     357                LispObject[] newElements = new LispObject[newCapacity];
     358                System.arraycopy(elements, 0, newElements, 0,
     359                                 Math.min(capacity, newCapacity));
     360                elements = newElements;
     361            }
     362            // Initialize new elements (if any).
     363            for (int i = capacity; i < newCapacity; i++)
     364                elements[i] = initialElement;
     365        }
     366        capacity = newCapacity;
     367        array = null;
     368        displacement = 0;
     369        isDisplaced = false;
     370        return this;
     371    }
     372
     373    public AbstractVector adjustVector(int newCapacity,
     374                                       AbstractArray displacedTo,
     375                                       int displacement)
     376        throws ConditionThrowable
     377    {
     378        capacity = newCapacity;
     379        array = displacedTo;
     380        this.displacement = displacement;
     381        elements = null;
     382        isDisplaced = true;
     383        return this;
    375384    }
    376385}
Note: See TracChangeset for help on using the changeset viewer.