Changeset 8192


Ignore:
Timestamp:
11/23/04 17:39:42 (17 years ago)
Author:
piso
Message:

Hash table refactoring.

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

Legend:

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

    r7459 r8192  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: EqHashTable.java,v 1.3 2004-08-19 18:13:15 piso Exp $
     5 * $Id: EqHashTable.java,v 1.4 2004-11-23 17:39:42 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727                       LispObject rehashThreshold)
    2828    {
    29         super(TEST_EQ, size, rehashSize, rehashThreshold);
     29        super(size, rehashSize, rehashThreshold);
     30    }
     31   
     32    public Symbol getTest()
     33    {
     34        return Symbol.EQ;
    3035    }
    3136
  • trunk/j/src/org/armedbear/lisp/EqlHashTable.java

    r7459 r8192  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: EqlHashTable.java,v 1.2 2004-08-19 18:11:48 piso Exp $
     5 * $Id: EqlHashTable.java,v 1.3 2004-11-23 17:39:42 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727                        LispObject rehashThreshold)
    2828    {
    29         super(TEST_EQL, size, rehashSize, rehashThreshold);
     29        super(size, rehashSize, rehashThreshold);
     30    }
     31
     32    public Symbol getTest()
     33    {
     34        return Symbol.EQL;
    3035    }
    3136
  • trunk/j/src/org/armedbear/lisp/EqualHashTable.java

    r7459 r8192  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: EqualHashTable.java,v 1.3 2004-08-19 18:14:02 piso Exp $
     5 * $Id: EqualHashTable.java,v 1.4 2004-11-23 17:39:42 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727                          LispObject rehashThreshold)
    2828    {
    29         super(TEST_EQUAL, size, rehashSize, rehashThreshold);
     29        super(size, rehashSize, rehashThreshold);
     30    }
     31
     32    public Symbol getTest()
     33    {
     34        return Symbol.EQUAL;
    3035    }
    3136
  • trunk/j/src/org/armedbear/lisp/EqualpHashTable.java

    r7459 r8192  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: EqualpHashTable.java,v 1.4 2004-08-19 18:12:42 piso Exp $
     5 * $Id: EqualpHashTable.java,v 1.5 2004-11-23 17:39:42 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727                           LispObject rehashThreshold)
    2828    {
    29         super(TEST_EQUALP, size, rehashSize, rehashThreshold);
     29        super(size, rehashSize, rehashThreshold);
     30    }
     31
     32    public Symbol getTest()
     33    {
     34        return Symbol.EQUALP;
    3035    }
    3136
  • trunk/j/src/org/armedbear/lisp/HashTable.java

    r8155 r8192  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: HashTable.java,v 1.45 2004-11-12 13:57:06 piso Exp $
     5 * $Id: HashTable.java,v 1.46 2004-11-23 17:39:42 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2424public abstract class HashTable extends LispObject
    2525{
    26     protected static final int TEST_EQ     = 0;
    27     protected static final int TEST_EQL    = 1;
    28     protected static final int TEST_EQUAL  = 2;
    29     protected static final int TEST_EQUALP = 3;
    30 
    31     private int test;
    32 
    3326    protected final LispObject rehashSize;
    3427    protected final LispObject rehashThreshold;
     
    4437
    4538    // The number of key-value pairs.
    46     private int count;
    47 
    48     protected HashTable(int test, int size, LispObject rehashSize,
     39    protected int count;
     40
     41    protected HashTable(int size, LispObject rehashSize,
    4942                        LispObject rehashThreshold)
    5043    {
    51         this.test = test;
    5244        this.rehashSize = rehashSize;
    5345        this.rehashThreshold = rehashThreshold;
     
    8880            if (count != ht.count)
    8981                return false;
    90             if (test != ht.test)
     82            if (getTest() != ht.getTest())
    9183                return false;
    9284            LispObject entries = ENTRIES();
     
    148140
    149141    // remhash key hash-table => generalized-boolean
    150     public synchronized LispObject remhash(LispObject key) throws ConditionThrowable
     142    public synchronized LispObject remhash(LispObject key)
     143        throws ConditionThrowable
    151144    {
    152145        // A value in a Lisp hash table can never be null, so...
     
    154147    }
    155148
    156     public String writeToString()
    157     {
    158         StringBuffer sb = new StringBuffer();
    159         switch (test) {
    160             case TEST_EQ:
    161                 sb.append("EQ");
    162                 break;
    163             case TEST_EQL:
    164                 sb.append("EQL");
    165                 break;
    166             case TEST_EQUAL:
    167                 sb.append("EQUAL");
    168                 break;
    169             case TEST_EQUALP:
    170                 sb.append("EQUALP");
    171                 break;
    172             default:
    173                 Debug.bug();
    174         }
     149    public String writeToString() throws ConditionThrowable
     150    {
     151        StringBuffer sb = new StringBuffer(getTest().writeToString());
    175152        sb.append(" hash table, ");
    176153        sb.append(count);
     
    247224        throws ConditionThrowable;
    248225
    249     private void rehash() throws ConditionThrowable
     226    protected void rehash() throws ConditionThrowable
    250227    {
    251228        HashEntry[] oldBuckets = buckets;
     
    312289        long result = 2062775257; // Chosen at random.
    313290        result = mix(result, count);
    314         result = mix(result, test);
     291        result = mix(result, getTest().sxhash());
    315292        return (int) (result & 0x7fffffff);
    316293    }
     
    487464        public LispObject execute(LispObject arg) throws ConditionThrowable
    488465        {
    489             if (arg instanceof HashTable)
     466            try {
    490467                return ((HashTable)arg).ENTRIES();
    491             return signal(new TypeError(arg, Symbol.HASH_TABLE));
    492         }
    493     };
     468            }
     469            catch (ClassCastException e) {
     470                return signal(new TypeError(arg, Symbol.HASH_TABLE));
     471            }
     472        }
     473    };
     474   
     475    public abstract Symbol getTest();
    494476
    495477    private static final Primitive HASH_TABLE_TEST =
     
    498480        public LispObject execute(LispObject arg) throws ConditionThrowable
    499481        {
    500             if (arg instanceof HashTable) {
    501                 switch (((HashTable)arg).test) {
    502                     case TEST_EQ:
    503                         return Symbol.EQ;
    504                     case TEST_EQL:
    505                         return Symbol.EQL;
    506                     case TEST_EQUAL:
    507                         return Symbol.EQUAL;
    508                     case TEST_EQUALP:
    509                         return Symbol.EQUALP;
    510                     default:
    511                         Debug.assertTrue(false);
    512                         return NIL;
    513                 }
    514             }
    515             return signal(new TypeError(arg, Symbol.HASH_TABLE));
     482            try {
     483                return ((HashTable)arg).getTest();
     484            }
     485            catch (ClassCastException e) {
     486                return signal(new TypeError(arg, Symbol.HASH_TABLE));
     487            }
    516488        }
    517489    };
     
    522494        public LispObject execute(LispObject arg) throws ConditionThrowable
    523495        {
    524             if (arg instanceof HashTable)
     496            try {
    525497                return new Fixnum(((HashTable)arg).buckets.length);
    526             return signal(new TypeError(arg, Symbol.HASH_TABLE));
     498            }
     499            catch (ClassCastException e) {
     500                return signal(new TypeError(arg, Symbol.HASH_TABLE));
     501            }
    527502        }
    528503    };
     
    533508        public LispObject execute(LispObject arg) throws ConditionThrowable
    534509        {
    535             if (arg instanceof HashTable)
     510            try {
    536511                return ((HashTable)arg).rehashSize;
    537             return signal(new TypeError(arg, Symbol.HASH_TABLE));
     512            }
     513            catch (ClassCastException e) {
     514                return signal(new TypeError(arg, Symbol.HASH_TABLE));
     515            }
    538516        }
    539517    };
     
    544522        public LispObject execute(LispObject arg) throws ConditionThrowable
    545523        {
    546             if (arg instanceof HashTable)
     524            try {
    547525                return ((HashTable)arg).rehashThreshold;
    548             return signal(new TypeError(arg, Symbol.HASH_TABLE));
     526            }
     527            catch (ClassCastException e) {
     528                return signal(new TypeError(arg, Symbol.HASH_TABLE));
     529            }
    549530        }
    550531    };
Note: See TracChangeset for help on using the changeset viewer.