Changeset 5942


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

Refactoring.

File:
1 edited

Legend:

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

    r5937 r5942  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: BitVector.java,v 1.32 2004-02-24 16:33:14 piso Exp $
     5 * $Id: BitVector.java,v 1.33 2004-02-24 22:23:12 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public final class BitVector extends AbstractVector
     24public final class BitVector extends AbstractBitVector
    2525{
    26     private static final int LONG_MASK = 0x3f;
    27 
    2826    private int capacity;
    2927    private int fillPointer = -1; // -1 indicates no fill pointer.
    3028    private long[] bits;
    3129
    32     public BitVector(int length) throws ConditionThrowable
    33     {
    34         if (length < 0)
    35             throw new NegativeArraySizeException();
    36         capacity = length;
    37         int size = length >>> 6;
    38         if ((length & LONG_MASK) != 0)
     30    public BitVector(int capacity) throws ConditionThrowable
     31    {
     32        this.capacity = capacity;
     33        int size = capacity >>> 6;
     34        if ((capacity & LONG_MASK) != 0)
    3935            ++size;
    4036        bits = new long[size];
    4137    }
    4238
    43     public BitVector(String s) throws ConditionThrowable
    44     {
    45         this(s.length());
    46         for (int i = s.length(); i-- > 0;) {
    47             char c = s.charAt(i);
    48             if (c == '0')
    49                 ;
    50             else if (c == '1')
    51                 set(i);
    52             else
    53                 Debug.assertTrue(false);
    54         }
    55     }
    56 
    5739    public LispObject typeOf()
    5840    {
    59         if (isSimpleVector())
    60             return list2(Symbol.SIMPLE_BIT_VECTOR, new Fixnum(length()));
    6141        return list2(Symbol.BIT_VECTOR, new Fixnum(length()));
    62     }
    63 
    64     public LispClass classOf()
    65     {
    66         return BuiltInClass.BIT_VECTOR;
    67     }
    68 
    69     public LispObject typep(LispObject type) throws ConditionThrowable
    70     {
    71         if (type == Symbol.BIT_VECTOR)
    72             return T;
    73         if (type == Symbol.SIMPLE_BIT_VECTOR)
    74             return isSimpleVector() ? T : NIL;
    75         if (type == BuiltInClass.BIT_VECTOR)
    76             return T;
    77         if (type == Symbol.SIMPLE_ARRAY)
    78             return fillPointer < 0 ? T : NIL; // FIXME displaced, adjustable
    79         return super.typep(type);
    80     }
    81 
    82     public LispObject BIT_VECTOR_P()
    83     {
    84         return T;
    8542    }
    8643
     
    12380    }
    12481
    125     public LispObject getElementType()
    126     {
    127         return Symbol.BIT;
    128     }
    129 
    13082    public int capacity()
    13183    {
     
    14698    }
    14799
    148     // Ignores fill pointer.
    149     public LispObject AREF(LispObject index) throws ConditionThrowable
    150     {
    151         return get(Fixnum.getValue(index));
    152     }
    153 
    154     public LispObject reverse() throws ConditionThrowable
    155     {
    156         int length = length();
    157         BitVector result = new BitVector(length);
    158         int i, j;
    159         for (i = 0, j = length - 1; i < length; i++, j--) {
    160             if (_get(j) == 1)
    161                 result.set(i);
    162             else
    163                 result.clear(i);
    164         }
    165         return result;
    166     }
    167 
    168     public LispObject getRowMajor(int index) throws ConditionThrowable
    169     {
    170         return get(index);
    171     }
    172 
    173     public void setRowMajor(int index, LispObject newValue) throws ConditionThrowable
    174     {
    175         set(index, newValue);
    176     }
    177 
    178100    public LispObject get(int index) throws ConditionThrowable
    179101    {
     
    184106    }
    185107
    186     private int _get(int index)
     108    protected int getBit(int index)
    187109    {
    188110        int offset = index >> 6;
     
    197119            int n = Fixnum.getValue(newValue);
    198120            if (n == 1) {
    199                 set(index);
     121                setBit(index);
    200122                return;
    201123            }
    202124            if (n == 0) {
    203                 clear(index);
     125                clearBit(index);
    204126                return;
    205127            }
     
    207129        }
    208130        catch (ConditionThrowable t) {}
    209         signal(new TypeError(newValue, "bit"));
    210     }
    211 
    212     public void set(int index)
     131        signal(new TypeError(newValue, Symbol.BIT));
     132    }
     133
     134    protected void setBit(int index)
    213135    {
    214136        int offset = index >> 6;
     
    216138    }
    217139
    218     public void clear(int index)
     140    protected void clearBit(int index)
    219141    {
    220142        int offset = index >> 6;
    221143        bits[offset] &= ~(1L << index);
    222     }
    223 
    224     public LispObject subseq(int start, int end) throws ConditionThrowable
    225     {
    226         BitVector v = new BitVector(end - start);
    227         int i = start, j = 0;
    228         try {
    229             while (i < end) {
    230                 if (_get(i++) == 0)
    231                     v.clear(j++);
    232                 else
    233                     v.set(j++);
    234             }
    235             return v;
    236         }
    237         catch (ArrayIndexOutOfBoundsException e) {
    238             return signal(new TypeError("Array index out of bounds: " + i + "."));
    239         }
    240144    }
    241145
     
    281185    public boolean isSimpleVector()
    282186    {
    283         return fillPointer < 0;
    284     }
    285 
    286     public boolean equal(LispObject obj) throws ConditionThrowable
    287     {
    288         if (this == obj)
    289             return true;
    290         if (obj instanceof BitVector) {
    291             BitVector v = (BitVector) obj;
    292             if (length() != v.length())
    293                 return false;
    294             for (int i = length(); i-- > 0;) {
    295                 if (_get(i) != v._get(i))
    296                     return false;
    297             }
    298             return true;
    299         }
    300187        return false;
    301     }
    302 
    303     public boolean equalp(LispObject obj) throws ConditionThrowable
    304     {
    305         if (this == obj)
    306             return true;
    307         if (obj instanceof BitVector) {
    308             BitVector v = (BitVector) obj;
    309             if (length() != v.length())
    310                 return false;
    311             for (int i = length(); i-- > 0;) {
    312                 if (_get(i) != v._get(i))
    313                     return false;
    314             }
    315             return true;
    316         }
    317         if (obj instanceof AbstractVector)
    318             return ((AbstractVector)obj).equalp(this);
    319         return false;
    320     }
    321 
    322     public int hashCode()
    323     {
    324         int hashCode = 1;
    325         // Consider first 64 bits only.
    326         final int limit = Math.min(length(), 64);
    327         for (int i = 0; i < limit; i++)
    328             hashCode = hashCode * 31 + _get(i);
    329         return hashCode;
    330188    }
    331189
     
    376234        }
    377235    }
    378 
    379     public String toString()
    380     {
    381         final int limit = length();
    382         StringBuffer sb = new StringBuffer(limit + 2);
    383         sb.append("#*");
    384         for (int i = 0; i < limit; i++)
    385             sb.append(_get(i) == 1 ? '1' : '0');
    386         return sb.toString();
    387     }
    388236}
Note: See TracChangeset for help on using the changeset viewer.