Changeset 5923


Ignore:
Timestamp:
02/24/04 12:30:37 (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/AbstractArray.java

    r5910 r5923  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: AbstractArray.java,v 1.16 2004-02-24 00:42:01 piso Exp $
     5 * $Id: AbstractArray.java,v 1.17 2004-02-24 12:30:37 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2424public abstract class AbstractArray extends LispObject
    2525{
    26     protected boolean isDisplaced;
    27 
    2826    public LispObject typep(LispObject type) throws ConditionThrowable
    2927    {
     
    5452    }
    5553
    56     public final boolean isDisplaced()
     54    public boolean isDisplaced()
    5755    {
    58         return isDisplaced;
     56        return false;
    5957    }
    6058
  • trunk/j/src/org/armedbear/lisp/ComplexVector.java

    r5917 r5923  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexVector.java,v 1.1 2004-02-24 11:20:09 piso Exp $
     5 * $Id: ComplexVector.java,v 1.2 2004-02-24 12:29:08 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626public class ComplexVector extends AbstractVector
    2727{
     28    private int capacity;
     29    private int fillPointer = -1; // -1 indicates no fill pointer.
     30    private boolean isDisplaced;
     31
     32    // For non-displaced arrays.
    2833    private LispObject[] elements;
    29     private int capacity;
     34
     35    // For displaced arrays.
     36    private AbstractArray array;
     37    private int displacement;
    3038
    3139    public ComplexVector(int capacity)
     
    5967    }
    6068
     69    public boolean hasFillPointer()
     70    {
     71        return fillPointer >= 0;
     72    }
     73
     74    public int getFillPointer()
     75    {
     76        return fillPointer;
     77    }
     78
     79    public void setFillPointer(int n)
     80    {
     81        fillPointer = n;
     82    }
     83
     84    public void setFillPointer(LispObject obj) throws ConditionThrowable
     85    {
     86        if (obj == T)
     87            fillPointer = capacity();
     88        else {
     89            int n = Fixnum.getValue(obj);
     90            if (n > capacity()) {
     91                StringBuffer sb = new StringBuffer("The new fill pointer (");
     92                sb.append(n);
     93                sb.append(") exceeds the capacity of the vector (");
     94                sb.append(capacity());
     95                sb.append(").");
     96                signal(new LispError(sb.toString()));
     97            } else if (n < 0) {
     98                StringBuffer sb = new StringBuffer("The new fill pointer (");
     99                sb.append(n);
     100                sb.append(") is negative.");
     101                signal(new LispError(sb.toString()));
     102            } else
     103                fillPointer = n;
     104        }
     105    }
     106
     107    public boolean isDisplaced()
     108    {
     109        return isDisplaced;
     110    }
     111
    61112    public LispObject getElementType()
    62113    {
     
    66117    public boolean isSimpleVector()
    67118    {
    68         return fillPointer < 0;
     119        return false;
    69120    }
    70121
     
    241292    }
    242293
     294    public LispObject vectorPushExtend(LispObject element)
     295        throws ConditionThrowable
     296    {
     297        if (fillPointer < 0)
     298            noFillPointer();
     299        if (fillPointer >= capacity) {
     300            // Need to extend vector.
     301            ensureCapacity(capacity * 2 + 1);
     302        }
     303        set(fillPointer, element);
     304        return new Fixnum(fillPointer++);
     305    }
     306
     307    public LispObject vectorPushExtend(LispObject element, LispObject extension)
     308        throws ConditionThrowable
     309    {
     310        int ext = Fixnum.getValue(extension);
     311        if (fillPointer < 0)
     312            noFillPointer();
     313        if (fillPointer >= capacity) {
     314            // Need to extend vector.
     315            ext = Math.max(ext, capacity + 1);
     316            ensureCapacity(capacity + ext);
     317        }
     318        set(fillPointer, element);
     319        return new Fixnum(fillPointer++);
     320    }
     321
    243322    public String toString()
    244323    {
Note: See TracChangeset for help on using the changeset viewer.