Changeset 5934


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

Work in progress.

File:
1 edited

Legend:

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

    r5926 r5934  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexString.java,v 1.4 2004-02-24 12:55:06 piso Exp $
     5 * $Id: ComplexString.java,v 1.5 2004-02-24 15:37:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    181181    public void shrink(int n) throws ConditionThrowable
    182182    {
    183         if (n < chars.length) {
    184             char[] newArray = new char[n];
    185             System.arraycopy(chars, 0, newArray, 0, n);
    186             chars = newArray;
    187             return;
    188         }
    189         if (n == chars.length)
    190             return;
     183        if (chars != null) {
     184            if (n < capacity) {
     185                char[] newArray = new char[n];
     186                System.arraycopy(chars, 0, newArray, 0, n);
     187                chars = newArray;
     188                capacity = n;
     189                return;
     190            }
     191            if (n == capacity)
     192                return;
     193        }
    191194        signal(new LispError());
    192195    }
     
    243246            }
    244247            catch (ArrayIndexOutOfBoundsException e) {
    245                 badIndex(index, chars.length);
     248                badIndex(index, capacity);
    246249                return 0; // Not reached.
    247250            }
     
    257260            }
    258261            catch (ArrayIndexOutOfBoundsException e) {
    259                 badIndex(index, chars.length);
     262                badIndex(index, capacity);
    260263            }
    261264        } else
     
    289292    {
    290293        if (chars != null) {
    291             if (chars.length < minCapacity) {
     294            if (capacity < minCapacity) {
    292295                char[] newArray = new char[minCapacity];
    293                 System.arraycopy(chars, 0, newArray, 0, chars.length);
     296                System.arraycopy(chars, 0, newArray, 0, capacity);
    294297                chars = newArray;
    295298                capacity = minCapacity;
     
    322325            isDisplaced = false;
    323326        }
    324         if (chars.length != size) {
     327        if (capacity != size) {
    325328            char[] newArray = new char[size];
    326329            if (initialContents != NIL) {
     
    338341            } else {
    339342                System.arraycopy(chars, 0, newArray, 0,
    340                                  Math.min(chars.length, size));
    341                 if (size > chars.length) {
     343                                 Math.min(capacity, size));
     344                if (size > capacity) {
    342345                    final char c;
    343346                    if (initialElement != NIL)
     
    345348                    else
    346349                        c = 0;
    347                     for (int i = chars.length; i < size; i++)
     350                    for (int i = capacity; i < size; i++)
    348351                        newArray[i] = c;
    349352                }
     
    391394        if (fillPointer < 0)
    392395            noFillPointer();
    393         if (fillPointer >= chars.length) {
     396        if (fillPointer >= capacity) {
    394397            // Need to extend vector.
    395             ensureCapacity(chars.length * 2 + 1);
     398            ensureCapacity(capacity * 2 + 1);
    396399        }
    397400        chars[fillPointer] = LispCharacter.getValue(element);
     
    405408        if (fillPointer < 0)
    406409            noFillPointer();
    407         if (fillPointer >= chars.length) {
     410        if (fillPointer >= capacity) {
    408411            // Need to extend vector.
    409             ext = Math.max(ext, chars.length + 1);
    410             ensureCapacity(chars.length + ext);
     412            ext = Math.max(ext, capacity + 1);
     413            ensureCapacity(capacity + ext);
    411414        }
    412415        chars[fillPointer] = LispCharacter.getValue(element);
Note: See TracChangeset for help on using the changeset viewer.