Changeset 10366


Ignore:
Timestamp:
11/05/05 02:19:58 (16 years ago)
Author:
piso
Message:

Work in progress (tested).

File:
1 edited

Legend:

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

    r9637 r10366  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: HashTableFunctions.java,v 1.3 2005-07-11 17:20:18 piso Exp $
     5 * $Id: HashTableFunctions.java,v 1.4 2005-11-05 02:19:58 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4141            throws ConditionThrowable
    4242        {
    43             int n;
     43            final int n;
    4444            try {
    4545                n = ((Fixnum)size).value;
    4646            }
    4747            catch (ClassCastException e) {
    48                 return signal(new TypeError(size, Symbol.FIXNUM));
     48                return signalTypeError(size, Symbol.FIXNUM);
    4949            }
    5050            if (test == FUNCTION_EQL || test == NIL)
     
    6161    };
    6262
    63     // ### gethash
    64     // gethash key hash-table &optional default => value, present-p
     63    // ### gethash key hash-table &optional default => value, present-p
    6564    private static final Primitive GETHASH =
    66         new Primitive("gethash", "key hash-table &optional default")
     65        new Primitive(Symbol.GETHASH, "key hash-table &optional default")
    6766    {
    6867        public LispObject execute(LispObject key, LispObject ht)
     
    7372            }
    7473            catch (ClassCastException e) {
    75                 return signal(new TypeError(ht, Symbol.HASH_TABLE));
     74                return signalTypeError(ht, Symbol.HASH_TABLE);
    7675            }
    7776        }
     
    8483            }
    8584            catch (ClassCastException e) {
    86                 return signal(new TypeError(ht, Symbol.HASH_TABLE));
     85                return signalTypeError(ht, Symbol.HASH_TABLE);
    8786            }
    8887        }
     
    10099            }
    101100            catch (ClassCastException e) {
    102                 return signal(new TypeError(ht, Symbol.HASH_TABLE));
    103             }
    104         }
    105     };
    106 
    107     // ### puthash
    108     // puthash key hash-table new-value &optional default => value
     101                return signalTypeError(ht, Symbol.HASH_TABLE);
     102            }
     103        }
     104    };
     105
     106    // ### puthash key hash-table new-value &optional default => value
    109107    private static final Primitive PUTHASH =
    110108        new Primitive("puthash", PACKAGE_SYS, true)
     
    118116            }
    119117            catch (ClassCastException e) {
    120                 return signal(new TypeError(ht, Symbol.HASH_TABLE));
     118                return signalTypeError(ht, Symbol.HASH_TABLE);
    121119            }
    122120        }
     
    129127            }
    130128            catch (ClassCastException e) {
    131                 return signal(new TypeError(ht, Symbol.HASH_TABLE));
     129                return signalTypeError(ht, Symbol.HASH_TABLE);
    132130            }
    133131        }
     
    136134    // remhash key hash-table => generalized-boolean
    137135    private static final Primitive REMHASH =
    138         new Primitive("remhash", "key hash-table")
     136        new Primitive(Symbol.REMHASH, "key hash-table")
    139137    {
    140138        public LispObject execute(LispObject key, LispObject ht)
     
    145143            }
    146144            catch (ClassCastException e) {
    147                 return signal(new TypeError(ht, Symbol.HASH_TABLE));
    148             }
    149         }
    150     };
    151 
    152     // ### clrhash
    153     // clrhash hash-table => hash-table
     145                return signalTypeError(ht, Symbol.HASH_TABLE);
     146            }
     147        }
     148    };
     149
     150    // ### clrhash hash-table => hash-table
    154151    private static final Primitive CLRHASH =
    155         new Primitive("clrhash", "hash-table")
     152        new Primitive(Symbol.CLRHASH, "hash-table")
    156153    {
    157154        public LispObject execute(LispObject ht) throws ConditionThrowable
     
    162159            }
    163160            catch (ClassCastException e) {
    164                 return signal(new TypeError(ht, Symbol.HASH_TABLE));
     161                return signalTypeError(ht, Symbol.HASH_TABLE);
    165162            }
    166163        }
     
    169166    // ### hash-table-count
    170167    private static final Primitive HASH_TABLE_COUNT =
    171         new Primitive("hash-table-count", "hash-table")
     168        new Primitive(Symbol.HASH_TABLE_COUNT, "hash-table")
    172169    {
    173170        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    177174            }
    178175            catch (ClassCastException e) {
    179                 return signal(new TypeError(arg, Symbol.HASH_TABLE));
    180             }
    181         }
    182     };
    183 
    184     // ### sxhash
    185     // sxhash object => hash-code
    186     private static final Primitive SXHASH = new Primitive("sxhash", "object")
     176                return signalTypeError(arg, Symbol.HASH_TABLE);
     177            }
     178        }
     179    };
     180
     181    // ### sxhash object => hash-code
     182    private static final Primitive SXHASH =
     183        new Primitive(Symbol.SXHASH, "object")
    187184    {
    188185        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    192189    };
    193190
    194     // ### psxhash
    195     // psxhash object => hash-code
     191    // ### psxhash object => hash-code
    196192    // For EQUALP hash tables.
    197193    private static final Primitive PSXHASH =
     
    206202    // ### hash-table-p
    207203    private static final Primitive HASH_TABLE_P =
    208         new Primitive("hash-table-p","object")
     204        new Primitive(Symbol.HASH_TABLE_P,"object")
    209205    {
    210206        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    224220            }
    225221            catch (ClassCastException e) {
    226                 return signal(new TypeError(arg, Symbol.HASH_TABLE));
     222                return signalTypeError(arg, Symbol.HASH_TABLE);
    227223            }
    228224        }
     
    231227    // ### hash-table-test
    232228    private static final Primitive HASH_TABLE_TEST =
    233         new Primitive("hash-table-test", "hash-table")
     229        new Primitive(Symbol.HASH_TABLE_TEST, "hash-table")
    234230    {
    235231        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    239235            }
    240236            catch (ClassCastException e) {
    241                 return signal(new TypeError(arg, Symbol.HASH_TABLE));
     237                return signalTypeError(arg, Symbol.HASH_TABLE);
    242238            }
    243239        }
     
    246242    // ### hash-table-size
    247243    private static final Primitive HASH_TABLE_SIZE =
    248         new Primitive("hash-table-size", "hash-table")
     244        new Primitive(Symbol.HASH_TABLE_SIZE, "hash-table")
    249245    {
    250246        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    254250            }
    255251            catch (ClassCastException e) {
    256                 return signal(new TypeError(arg, Symbol.HASH_TABLE));
     252                return signalTypeError(arg, Symbol.HASH_TABLE);
    257253            }
    258254        }
     
    261257    // ### hash-table-rehash-size
    262258    private static final Primitive HASH_TABLE_REHASH_SIZE =
    263         new Primitive("hash-table-rehash-size", "hash-table")
     259        new Primitive(Symbol.HASH_TABLE_REHASH_SIZE, "hash-table")
    264260    {
    265261        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    269265            }
    270266            catch (ClassCastException e) {
    271                 return signal(new TypeError(arg, Symbol.HASH_TABLE));
     267                return signalTypeError(arg, Symbol.HASH_TABLE);
    272268            }
    273269        }
     
    276272    // ### hash-table-rehash-threshold
    277273    private static final Primitive HASH_TABLE_REHASH_THRESHOLD =
    278         new Primitive("hash-table-rehash-threshold", "hash-table")
     274        new Primitive(Symbol.HASH_TABLE_REHASH_THRESHOLD, "hash-table")
    279275    {
    280276        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    284280            }
    285281            catch (ClassCastException e) {
    286                 return signal(new TypeError(arg, Symbol.HASH_TABLE));
     282                return signalTypeError(arg, Symbol.HASH_TABLE);
    287283            }
    288284        }
Note: See TracChangeset for help on using the changeset viewer.