Changeset 5960


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

Work in progress.

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

Legend:

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

    r5957 r5960  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexString.java,v 1.8 2004-02-25 13:50:54 piso Exp $
     5 * $Id: ComplexString.java,v 1.9 2004-02-25 15:24:20 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    289289    }
    290290
    291     public AbstractVector adjustVector(int size, LispObject initialElement,
     291    public AbstractVector adjustVector(int newCapacity,
     292                                       LispObject initialElement,
    292293                                       LispObject initialContents)
    293294        throws ConditionThrowable
    294295    {
    295         if (chars == null) {
    296             // Copy array.
    297             chars = new char[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);
     296        if (initialContents != NIL) {
     297            // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
     298            // ARRAY. In this case none of the original contents of array
     299            // appears in the resulting array."
     300            char[] newChars = new char[newCapacity];
     301            if (initialContents.listp()) {
     302                LispObject list = initialContents;
     303                for (int i = 0; i < newCapacity; i++) {
     304                    newChars[i] = LispCharacter.getValue(list.car());
     305                    list = list.cdr();
    302306                }
    303             } else {
    304                 for (int i = 0; i < capacity; i++) {
    305                     LispCharacter character =
    306                         (LispCharacter) array.getRowMajor(displacement + i);
    307                     chars[i] = character.value;
     307            } else if (initialContents.vectorp()) {
     308                for (int i = 0; i < newCapacity; i++)
     309                    newChars[i] = LispCharacter.getValue(initialContents.elt(i));
     310            } else
     311                signal(new TypeError(initialContents, Symbol.SEQUENCE));
     312            chars = newChars;
     313        } else {
     314            if (chars == null) {
     315                // Displaced array. Copy existing characters.
     316                chars = new char[newCapacity];
     317                final int limit = Math.min(capacity, newCapacity);
     318                if (array instanceof AbstractString) {
     319                    AbstractString string = (AbstractString) array;
     320                    for (int i = 0; i < limit; i++) {
     321                        chars[i] = string.getChar(displacement + i);
     322                    }
     323                } else {
     324                    for (int i = 0; i < limit; i++) {
     325                        LispCharacter character =
     326                            (LispCharacter) array.getRowMajor(displacement + i);
     327                        chars[i] = character.value;
     328                    }
    308329                }
    309             }
    310             array = null;
    311             displacement = 0;
    312             isDisplaced = false;
    313         }
    314         if (capacity != size) {
    315             char[] newArray = new char[size];
    316             if (initialContents != NIL) {
    317                 if (initialContents.listp()) {
    318                     LispObject list = initialContents;
    319                     for (int i = 0; i < size; i++) {
    320                         newArray[i] = LispCharacter.getValue(list.car());
    321                         list = list.cdr();
    322                     }
    323                 } else if (initialContents.vectorp()) {
    324                     for (int i = 0; i < size; i++)
    325                         newArray[i] = LispCharacter.getValue(initialContents.elt(i));
    326                 } else
    327                     signal(new TypeError(initialContents, Symbol.SEQUENCE));
    328             } else {
    329                 System.arraycopy(chars, 0, newArray, 0,
    330                                  Math.min(capacity, size));
    331                 if (size > capacity) {
    332                     final char c;
    333                     if (initialElement != NIL)
    334                         c = LispCharacter.getValue(initialElement);
    335                     else
    336                         c = 0;
    337                     for (int i = capacity; i < size; i++)
    338                         newArray[i] = c;
    339                 }
    340             }
    341             chars = newArray;
    342             capacity = chars.length;
    343         }
     330            } else if (capacity != newCapacity) {
     331                char[] newElements = new char[newCapacity];
     332                System.arraycopy(chars, 0, newElements, 0,
     333                                 Math.min(capacity, newCapacity));
     334                chars = newElements;
     335            }
     336            // Initialize new elements (if any).
     337            final char c;
     338            if (initialElement != NIL)
     339                c = LispCharacter.getValue(initialElement);
     340            else
     341                c = 0;
     342            for (int i = capacity; i < newCapacity; i++)
     343                chars[i] = c;
     344        }
     345        capacity = newCapacity;
     346        array = null;
     347        displacement = 0;
     348        isDisplaced = false;
    344349        return this;
    345350    }
    346351
    347     public AbstractVector adjustVector(int size, AbstractArray displacedTo,
     352    public AbstractVector adjustVector(int newCapacity,
     353                                       AbstractArray displacedTo,
    348354                                       int displacement)
    349355        throws ConditionThrowable
    350356    {
    351         capacity = size;
     357        capacity = newCapacity;
    352358        array = displacedTo;
    353359        this.displacement = displacement;
  • trunk/j/src/org/armedbear/lisp/ComplexVector.java

    r5958 r5960  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexVector.java,v 1.8 2004-02-25 14:41:15 piso Exp $
     5 * $Id: ComplexVector.java,v 1.9 2004-02-25 15:23:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    331331            // ARRAY. In this case none of the original contents of array
    332332            // appears in the resulting array."
    333             LispObject[] newArray = new LispObject[newCapacity];
     333            LispObject[] newElements = new LispObject[newCapacity];
    334334            if (initialContents.listp()) {
    335335                LispObject list = initialContents;
    336336                for (int i = 0; i < newCapacity; i++) {
    337                     newArray[i] = list.car();
     337                    newElements[i] = list.car();
    338338                    list = list.cdr();
    339339                }
    340340            } else if (initialContents.vectorp()) {
    341341                for (int i = 0; i < newCapacity; i++)
    342                     newArray[i] = initialContents.elt(i);
     342                    newElements[i] = initialContents.elt(i);
    343343            } else
    344344                signal(new TypeError(initialContents, Symbol.SEQUENCE));
    345             elements = newArray;
     345            elements = newElements;
    346346        } else {
    347347            if (elements == null) {
     
    351351                for (int i = 0; i < limit; i++)
    352352                    elements[i] = array.getRowMajor(displacement + i);
    353                 array = null;
    354                 displacement = 0;
    355                 isDisplaced = false;
    356353            } else if (capacity != newCapacity) {
    357354                LispObject[] newElements = new LispObject[newCapacity];
Note: See TracChangeset for help on using the changeset viewer.