xemacs-beta: src/elhash.c comparison

comparison src/elhash.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	9ee227acff29
children	25f70ba0133c

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 ht->harray = Qnil;            /* Let GC do its job */
 return;
 }
-DEFUN ("hashtablep", Fhashtablep, Shashtablep, 1, 1, 0 /*
+DEFUN ("hashtablep", Fhashtablep, 1, 1, 0, /*
 Return t if OBJ is a hashtable, else nil.
-*/ )
+*/
-(obj)
+(obj))
-Lisp_Object obj;
 {
 return ((HASHTABLEP (obj)) ? Qt : Qnil);
 }
 signal_simple_error ("Invalid hashtable test fun", sym);
 return HASHTABLE_EQ; /* not reached */
 }
-DEFUN ("make-hashtable", Fmake_hashtable, Smake_hashtable, 1, 2, 0 /*
+DEFUN ("make-hashtable", Fmake_hashtable, 1, 2, 0, /*
 Make a hashtable of initial size SIZE.
 Comparison between keys is done with TEST-FUN, which must be one of
 `eq', `eql', or `equal'.  The default is `eql'; i.e. two keys must
 be the same object (or have the same floating-point value, for floats)
 to be considered equivalent.
 See also `make-weak-hashtable', `make-key-weak-hashtable', and
 `make-value-weak-hashtable'.
-*/ )
+*/
-(size, test_fun)
+(size, test_fun))
-Lisp_Object size, test_fun;
 {
 CHECK_NATNUM (size);
 return make_lisp_hashtable (XINT (size), HASHTABLE_NONWEAK,
 			      decode_hashtable_test_fun (test_fun));
 }
-DEFUN ("copy-hashtable", Fcopy_hashtable, Scopy_hashtable, 1, 1, 0 /*
+DEFUN ("copy-hashtable", Fcopy_hashtable, 1, 1, 0, /*
 Make a new hashtable which contains the same keys and values
 as the given table.  The keys and values will not themselves be copied.
-*/ )
+*/
-(old_table)
+(old_table))
-Lisp_Object old_table;
 {
 struct _C_hashtable old_htbl;
 struct _C_hashtable new_htbl;
 struct hashtable_struct *old_ht;
 struct hashtable_struct *new_ht;
 return (result);
 }
-DEFUN ("gethash", Fgethash, Sgethash, 2, 3, 0 /*
+DEFUN ("gethash", Fgethash, 2, 3, 0, /*
 Find hash value for KEY in TABLE.
 If there is no corresponding value, return DEFAULT (defaults to nil).
-*/ )
+*/
-(key, table, defalt)
+(key, table, defalt))
-Lisp_Object key, table, defalt; /* One can't even spell correctly in C */
 {
 CONST void *vval;
 struct _C_hashtable htbl;
 if (!gc_in_progress)
 CHECK_HASHTABLE (table);
 else
 return defalt;
 }
-DEFUN ("remhash", Fremhash, Sremhash, 2, 2, 0 /*
+DEFUN ("remhash", Fremhash, 2, 2, 0, /*
 Remove hash value for KEY in TABLE.
-*/ )
+*/
-(key, table)
+(key, table))
-Lisp_Object key, table;
 {
 struct _C_hashtable htbl;
 CHECK_HASHTABLE (table);
 ht_copy_to_c (XHASHTABLE (table), &htbl);
 ht_copy_from_c (&htbl, XHASHTABLE (table));
 return Qnil;
 }
-DEFUN ("puthash", Fputhash, Sputhash, 3, 3, 0 /*
+DEFUN ("puthash", Fputhash, 3, 3, 0, /*
 Hash KEY to VAL in TABLE.
-*/ )
+*/
-(key, val, table)
+(key, val, table))
-Lisp_Object key, val, table;
 {
 struct hashtable_struct *ht;
 void *vkey = LISP_TO_VOID (key);
 CHECK_HASHTABLE (table);
 UNGCPRO;
 }
 return (val);
 }
-DEFUN ("clrhash", Fclrhash, Sclrhash, 1, 1, 0 /*
+DEFUN ("clrhash", Fclrhash, 1, 1, 0, /*
 Flush TABLE.
-*/ )
+*/
-(table)
+(table))
-Lisp_Object table;
 {
 struct _C_hashtable htbl;
 CHECK_HASHTABLE (table);
 ht_copy_to_c (XHASHTABLE (table), &htbl);
 clrhash (&htbl);
 ht_copy_from_c (&htbl, XHASHTABLE (table));
 return Qnil;
 }
-DEFUN ("hashtable-fullness", Fhashtable_fullness, Shashtable_fullness, 1, 1, 0 /*
+DEFUN ("hashtable-fullness", Fhashtable_fullness, 1, 1, 0, /*
 Return number of entries in TABLE.
-*/ )
+*/
-(table)
+(table))
-Lisp_Object table;
 {
 struct _C_hashtable htbl;
 CHECK_HASHTABLE (table);
 ht_copy_to_c (XHASHTABLE (table), &htbl);
 return (make_int (htbl.fullness));
 VOID_TO_LISP (fn, void_fn);
 call2 (fn, key, val);
 }
-DEFUN ("maphash", Fmaphash, Smaphash, 2, 2, 0 /*
+DEFUN ("maphash", Fmaphash, 2, 2, 0, /*
 Map FUNCTION over entries in TABLE, calling it with two args,
 each key and value in the table.
-*/ )
+*/
-(function, table)
+(function, table))
-Lisp_Object function, table;
 {
 struct _C_hashtable htbl;
 struct gcpro gcpro1, gcpro2;
 verify_function (function, GETTEXT ("hashtable mapping function"));
 }
 #endif /* 0 */
-DEFUN ("make-weak-hashtable", Fmake_weak_hashtable, Smake_weak_hashtable,
+DEFUN ("make-weak-hashtable", Fmake_weak_hashtable, 1, 2, 0, /*
-1, 2, 0 /*
 Make a fully weak hashtable of initial size SIZE.
 A weak hashtable is one whose pointers do not count as GC referents:
 for any key-value pair in the hashtable, if the only remaining pointer
 to either the key or the value is in a weak hash table, then the pair
 will be removed from the table, and the key and value collected.  A
 non-weak hash table (or any other pointer) would prevent the object
 from being collected.
 You can also create semi-weak hashtables; see `make-key-weak-hashtable'
 and `make-value-weak-hashtable'.
-*/ )
+*/
-(size, test_fun)
+(size, test_fun))
-Lisp_Object size, test_fun;
 {
 CHECK_NATNUM (size);
 return make_lisp_hashtable (XINT (size), HASHTABLE_WEAK,
 			      decode_hashtable_test_fun (test_fun));
 }
-DEFUN ("make-key-weak-hashtable", Fmake_key_weak_hashtable,
+DEFUN ("make-key-weak-hashtable", Fmake_key_weak_hashtable, 1, 2, 0, /*
-Smake_key_weak_hashtable, 1, 2, 0 /*
 Make a key-weak hashtable of initial size SIZE.
 A key-weak hashtable is similar to a fully-weak hashtable (see
 `make-weak-hashtable') except that a key-value pair will be removed
 only if the key remains unmarked outside of weak hashtables.  The pair
 will remain in the hashtable if the key is pointed to by something other
 than a weak hashtable, even if the value is not.
-*/ )
+*/
-(size, test_fun)
+(size, test_fun))
-Lisp_Object size, test_fun;
 {
 CHECK_NATNUM (size);
 return make_lisp_hashtable (XINT (size), HASHTABLE_KEY_WEAK,
 			      decode_hashtable_test_fun (test_fun));
 }
-DEFUN ("make-value-weak-hashtable", Fmake_value_weak_hashtable,
+DEFUN ("make-value-weak-hashtable", Fmake_value_weak_hashtable, 1, 2, 0, /*
-Smake_value_weak_hashtable, 1, 2, 0 /*
 Make a value-weak hashtable of initial size SIZE.
 A value-weak hashtable is similar to a fully-weak hashtable (see
 `make-weak-hashtable') except that a key-value pair will be removed only
 if the value remains unmarked outside of weak hashtables.  The pair will
 remain in the hashtable if the value is pointed to by something other
 than a weak hashtable, even if the key is not.
-*/ )
+*/
-(size, test_fun)
+(size, test_fun))
-Lisp_Object size, test_fun;
 {
 CHECK_NATNUM (size);
 return make_lisp_hashtable (XINT (size), HASHTABLE_VALUE_WEAK,
 			      decode_hashtable_test_fun (test_fun));
 }
 /************************************************************************/
 void
 syms_of_elhash (void)
 {
-defsubr (&Smake_hashtable);
+DEFSUBR (Fmake_hashtable);
-defsubr (&Scopy_hashtable);
+DEFSUBR (Fcopy_hashtable);
-defsubr (&Shashtablep);
+DEFSUBR (Fhashtablep);
-defsubr (&Sgethash);
+DEFSUBR (Fgethash);
-defsubr (&Sputhash);
+DEFSUBR (Fputhash);
-defsubr (&Sremhash);
+DEFSUBR (Fremhash);
-defsubr (&Sclrhash);
+DEFSUBR (Fclrhash);
-defsubr (&Smaphash);
+DEFSUBR (Fmaphash);
-defsubr (&Shashtable_fullness);
+DEFSUBR (Fhashtable_fullness);
-defsubr (&Smake_weak_hashtable);
+DEFSUBR (Fmake_weak_hashtable);
-defsubr (&Smake_key_weak_hashtable);
+DEFSUBR (Fmake_key_weak_hashtable);
-defsubr (&Smake_value_weak_hashtable);
+DEFSUBR (Fmake_value_weak_hashtable);
 defsymbol (&Qhashtablep, "hashtablep");
 }
 void
 vars_of_elhash (void)

Mercurial > hg > xemacs-beta

comparison src/elhash.c @ 20:859a2309aef8 r19-15b93