Changeset 5926


Ignore:
Timestamp:
02/24/04 12:56:09 (17 years ago)
Author:
piso
Message:

Work in progress.

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

Legend:

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

    r5910 r5926  
    2323public abstract class AbstractVector extends AbstractArray
    2424{
    25     protected int fillPointer = -1; // -1 indicates no fill pointer.
    26 
    27     public boolean hasFillPointer()
    28     {
    29         return fillPointer >= 0;
    30     }
    31 
    3225    public LispObject typep(LispObject type) throws ConditionThrowable
    3326    {
     
    4033        if (type == BuiltInClass.SEQUENCE)
    4134            return T;
    42         if (type == Symbol.SIMPLE_VECTOR)
    43             return isSimpleVector() ? T : NIL;
    44         if (type == Symbol.SIMPLE_ARRAY)
    45             return fillPointer < 0 ? T : NIL;
    4635        return super.typep(type);
     36    }
     37
     38    public final LispObject VECTORP()
     39    {
     40        return T;
    4741    }
    4842
     
    134128    }
    135129
    136     public int getFillPointer()
     130    public int getFillPointer() throws ConditionThrowable
    137131    {
    138         return fillPointer;
     132        noFillPointer();
     133        return -1; // Not reached.
    139134    }
    140135
    141     public void setFillPointer(int n)
     136    public void setFillPointer(int n) throws ConditionThrowable
    142137    {
    143         fillPointer = n;
     138        noFillPointer();
    144139    }
    145140
    146141    public void setFillPointer(LispObject obj) throws ConditionThrowable
    147142    {
    148         if (obj == T)
    149             fillPointer = capacity();
    150         else {
    151             int n = Fixnum.getValue(obj);
    152             if (n > capacity()) {
    153                 StringBuffer sb = new StringBuffer("The new fill pointer (");
    154                 sb.append(n);
    155                 sb.append(") exceeds the capacity of the vector (");
    156                 sb.append(capacity());
    157                 sb.append(").");
    158                 signal(new LispError(sb.toString()));
    159             } else if (n < 0) {
    160                 StringBuffer sb = new StringBuffer("The new fill pointer (");
    161                 sb.append(n);
    162                 sb.append(") is negative.");
    163                 signal(new LispError(sb.toString()));
    164             } else
    165                 fillPointer = n;
    166         }
     143        noFillPointer();
    167144    }
    168145
     
    191168        throws ConditionThrowable
    192169    {
    193         final int fp = getFillPointer();
    194         if (fp < 0)
    195             noFillPointer();
    196         if (fp >= capacity()) {
    197             // Need to extend vector.
    198             ensureCapacity(capacity() * 2 + 1);
    199         }
    200         set(fp, element);
    201         setFillPointer(fp + 1);
    202         return new Fixnum(fp);
     170        return noFillPointer();
    203171    }
    204172
     
    206174        throws ConditionThrowable
    207175    {
    208         int ext = Fixnum.getValue(extension);
    209         final int fp = getFillPointer();
    210         if (fp < 0)
    211             noFillPointer();
    212         if (fp >= capacity()) {
    213             // Need to extend vector.
    214             ext = Math.max(ext, capacity() + 1);
    215             ensureCapacity(capacity() + ext);
    216         }
    217         set(fp, element);
    218         setFillPointer(fp + 1);
    219         return new Fixnum(fp);
     176        return noFillPointer();
    220177    }
    221178}
  • trunk/j/src/org/armedbear/lisp/BitVector.java

    r5755 r5926  
    22 * BitVector.java
    33 *
    4  * Copyright (C) 2003 Peter Graves
    5  * $Id: BitVector.java,v 1.30 2004-02-11 00:11:26 piso Exp $
     4 * Copyright (C) 2003-2004 Peter Graves
     5 * $Id: BitVector.java,v 1.31 2004-02-24 12:56:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727
    2828    private int capacity;
     29    private int fillPointer = -1; // -1 indicates no fill pointer.
    2930    private long[] bits;
    3031
     
    7273        if (type == Symbol.SIMPLE_BIT_VECTOR)
    7374            return isSimpleVector() ? T : NIL;
    74         if (type == Symbol.SIMPLE_VECTOR)
    75             return NIL; // Can't hold elements of any type, only bits.
    7675        if (type == BuiltInClass.BIT_VECTOR)
    7776            return T;
     77        if (type == Symbol.SIMPLE_ARRAY)
     78            return fillPointer < 0 ? T : NIL; // FIXME displaced, adjustable
    7879        return super.typep(type);
    7980    }
     
    8283    {
    8384        return T;
     85    }
     86
     87    public boolean hasFillPointer()
     88    {
     89        return fillPointer >= 0;
     90    }
     91
     92    public int getFillPointer()
     93    {
     94        return fillPointer;
     95    }
     96
     97    public void setFillPointer(int n)
     98    {
     99        fillPointer = n;
     100    }
     101
     102    public void setFillPointer(LispObject obj) throws ConditionThrowable
     103    {
     104        if (obj == T)
     105            fillPointer = capacity();
     106        else {
     107            int n = Fixnum.getValue(obj);
     108            if (n > capacity()) {
     109                StringBuffer sb = new StringBuffer("The new fill pointer (");
     110                sb.append(n);
     111                sb.append(") exceeds the capacity of the vector (");
     112                sb.append(capacity());
     113                sb.append(").");
     114                signal(new LispError(sb.toString()));
     115            } else if (n < 0) {
     116                StringBuffer sb = new StringBuffer("The new fill pointer (");
     117                sb.append(n);
     118                sb.append(") is negative.");
     119                signal(new LispError(sb.toString()));
     120            } else
     121                fillPointer = n;
     122        }
    84123    }
    85124
     
    304343    }
    305344
     345    // FIXME
     346    public LispObject vectorPushExtend(LispObject element)
     347        throws ConditionThrowable
     348    {
     349        final int fp = getFillPointer();
     350        if (fp < 0)
     351            noFillPointer();
     352        if (fp >= capacity()) {
     353            // Need to extend vector.
     354            ensureCapacity(capacity() * 2 + 1);
     355        }
     356        set(fp, element);
     357        setFillPointer(fp + 1);
     358        return new Fixnum(fp);
     359    }
     360
     361    // FIXME
     362    public LispObject vectorPushExtend(LispObject element, LispObject extension)
     363        throws ConditionThrowable
     364    {
     365        int ext = Fixnum.getValue(extension);
     366        final int fp = getFillPointer();
     367        if (fp < 0)
     368            noFillPointer();
     369        if (fp >= capacity()) {
     370            // Need to extend vector.
     371            ext = Math.max(ext, capacity() + 1);
     372            ensureCapacity(capacity() + ext);
     373        }
     374        set(fp, element);
     375        setFillPointer(fp + 1);
     376        return new Fixnum(fp);
     377    }
     378
    306379    public String toString()
    307380    {
  • trunk/j/src/org/armedbear/lisp/ComplexString.java

    r5908 r5926  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: ComplexString.java,v 1.3 2004-02-23 19:56:55 piso Exp $
     5 * $Id: ComplexString.java,v 1.4 2004-02-24 12:55:06 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525{
    2626    private int capacity;
     27    private int fillPointer = -1; // -1 indicates no fill pointer.
     28    private boolean isDisplaced;
    2729
    2830    // For non-displaced arrays.
     
    5658    {
    5759        return BuiltInClass.STRING;
     60    }
     61
     62    public boolean hasFillPointer()
     63    {
     64        return fillPointer >= 0;
     65    }
     66
     67    public int getFillPointer()
     68    {
     69        return fillPointer;
     70    }
     71
     72    public void setFillPointer(int n)
     73    {
     74        fillPointer = n;
     75    }
     76
     77    public void setFillPointer(LispObject obj) throws ConditionThrowable
     78    {
     79        if (obj == T)
     80            fillPointer = capacity();
     81        else {
     82            int n = Fixnum.getValue(obj);
     83            if (n > capacity()) {
     84                StringBuffer sb = new StringBuffer("The new fill pointer (");
     85                sb.append(n);
     86                sb.append(") exceeds the capacity of the vector (");
     87                sb.append(capacity());
     88                sb.append(").");
     89                signal(new LispError(sb.toString()));
     90            } else if (n < 0) {
     91                StringBuffer sb = new StringBuffer("The new fill pointer (");
     92                sb.append(n);
     93                sb.append(") is negative.");
     94                signal(new LispError(sb.toString()));
     95            } else
     96                fillPointer = n;
     97        }
     98    }
     99
     100    public boolean isDisplaced()
     101    {
     102        return isDisplaced;
    58103    }
    59104
Note: See TracChangeset for help on using the changeset viewer.