xemacs-beta: src/alloc.c comparison

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

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	441bb1e64a06

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 DECLARE_FIXED_TYPE_ALLOC (cons, struct Lisp_Cons);
 /* conses are used and freed so often that we set this really high */
 /* #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_cons 20000 */
 #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_cons 2000
-DEFUN ("cons", Fcons, Scons, 2, 2, 0 /*
+DEFUN ("cons", Fcons, 2, 2, 0, /*
 Create a new cons, give it CAR and CDR as components, and return it.
-*/ )
+*/
-(car, cdr)
+(car, cdr))
-Lisp_Object car, cdr;
 {
 /* This cannot GC. */
 Lisp_Object val = Qnil;
 struct Lisp_Cons *c;
 XCAR (val) = car;
 XCDR (val) = cdr;
 return val;
 }
-DEFUN ("list", Flist, Slist, 0, MANY, 0 /*
+DEFUN ("list", Flist, 0, MANY, 0, /*
 Return a newly created list with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 Lisp_Object len, val, val_tail;
 len = make_int (nargs);
 val = Fmake_list (len, Qnil);
 {
 /* This cannot GC. */
 return Fcons (obj0, list5 (obj1, obj2, obj3, obj4, obj5));
 }
-DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0 /*
+DEFUN ("make-list", Fmake_list, 2, 2, 0, /*
 Return a newly created list of length LENGTH, with each element being INIT.
-*/ )
+*/
-(length, init)
+(length, init))
-Lisp_Object length, init;
 {
 Lisp_Object val;
 int size;
 CHECK_NATNUM (length);
 vector_data(p)[elt] = init;
 return (vector);
 }
-DEFUN ("make-vector", Fmake_vector, Smake_vector, 2, 2, 0 /*
+DEFUN ("make-vector", Fmake_vector, 2, 2, 0, /*
 Return a newly created vector of length LENGTH, with each element being INIT.
 See also the function `vector'.
-*/ )
+*/
-(length, init)
+(length, init))
-Lisp_Object length, init;
 {
 if (!INTP (length) || XINT (length) < 0)
 length = wrong_type_argument (Qnatnump, length);
 return (make_vector (XINT (length), init));
 }
-DEFUN ("vector", Fvector, Svector, 0, MANY, 0 /*
+DEFUN ("vector", Fvector, 0, MANY, 0, /*
 Return a newly created vector with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 Lisp_Object vector = Qnil;
 int elt;
 struct Lisp_Vector *p;
 set_bit_vector_bit (p, i, bytevec[i]);
 return bit_vector;
 }
-DEFUN ("make-bit-vector", Fmake_bit_vector, Smake_bit_vector, 2, 2, 0 /*
+DEFUN ("make-bit-vector", Fmake_bit_vector, 2, 2, 0, /*
 Return a newly created bit vector of length LENGTH.
 Each element is set to INIT.  See also the function `bit-vector'.
-*/ )
+*/
-(length, init)
+(length, init))
-Lisp_Object length, init;
 {
 if (!INTP (length) || XINT (length) < 0)
 length = wrong_type_argument (Qnatnump, length);
 return (make_bit_vector (XINT (length), init));
 }
-DEFUN ("bit-vector", Fbit_vector, Sbit_vector, 0, MANY, 0 /*
+DEFUN ("bit-vector", Fbit_vector, 0, MANY, 0, /*
 Return a newly created bit vector with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 Lisp_Object bit_vector = Qnil;
 int elt;
 struct Lisp_Bit_Vector *p;
 #endif
 XSETCOMPILED_FUNCTION (new, b);
 return (new);
 }
-DEFUN ("make-byte-code", Fmake_byte_code, Smake_byte_code, 4, MANY, 0 /*
+DEFUN ("make-byte-code", Fmake_byte_code, 4, MANY, 0, /*
 Create a compiled-function object.
 Usage: (arglist instructions constants stack-size
 	&optional doc-string interactive-spec)
 Note that, unlike all other emacs-lisp functions, calling this with five
 arguments is NOT the same as calling it with six arguments, the last of
 which is nil.  If the INTERACTIVE arg is specified as nil, then that means
 that this function was defined with `(interactive)'.  If the arg is not
 specified, then that means the function is not interactive.
 This is terrible behavior which is retained for compatibility with old
 `.elc' files which expected these semantics.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 /*   In a non-insane world this function would have this arglist...
 (arglist, instructions, constants, stack_size, doc_string, interactive)
 Lisp_Object arglist, instructions, constants, stack_size, doc_string,
 	interactive;
 /**********************************************************************/
 DECLARE_FIXED_TYPE_ALLOC (symbol, struct Lisp_Symbol);
 #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_symbol 1000
-DEFUN ("make-symbol", Fmake_symbol, Smake_symbol, 1, 1, 0 /*
+DEFUN ("make-symbol", Fmake_symbol, 1, 1, 0, /*
 Return a newly allocated uninterned symbol whose name is NAME.
 Its value and function definition are void, and its property list is nil.
-*/ )
+*/
-(str)
+(str))
-Lisp_Object str;
 {
 Lisp_Object val;
 struct Lisp_Symbol *p;
 CHECK_STRING (str);
 /**********************************************************************/
 DECLARE_FIXED_TYPE_ALLOC (marker, struct Lisp_Marker);
 #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_marker 1000
-DEFUN ("make-marker", Fmake_marker, Smake_marker, 0, 0, 0 /*
+DEFUN ("make-marker", Fmake_marker, 0, 0, 0, /*
 Return a newly allocated marker which does not point at any place.
-*/ )
+*/
-()
+())
 {
 Lisp_Object val;
 struct Lisp_Marker *p;
 ALLOCATE_FIXED_TYPE (marker, struct Lisp_Marker, p);
 #ifdef VERIFY_STRING_CHARS_INTEGRITY
 verify_string_chars_integrity ();
 #endif
 }
-DEFUN ("make-string", Fmake_string, Smake_string, 2, 2, 0 /*
+DEFUN ("make-string", Fmake_string, 2, 2, 0, /*
 Return a newly created string of length LENGTH, with each element being INIT.
 LENGTH must be an integer and INIT must be a character.
-*/ )
+*/
-(length, init)
+(length, init))
-Lisp_Object length, init;
 {
 Lisp_Object val;
 CHECK_NATNUM (length);
 CHECK_CHAR_COERCE_INT (init);
 }
 #endif
-DEFUN ("purecopy", Fpurecopy, Spurecopy, 1, 1, 0 /*
+DEFUN ("purecopy", Fpurecopy, 1, 1, 0, /*
 Make a copy of OBJECT in pure storage.
 Recursively copies contents of vectors and cons cells.
 Does not copy symbols.
-*/ )
+*/
-(obj)
+(obj))
-Lisp_Object obj;
 {
 int i;
 if (!purify_flag)
 return (obj);
 struct type##_block *x = current_##type##_block;			\
 while (x) { s += sizeof (*x) + MALLOC_OVERHEAD; x = x->prev; }	\
 (pl) = gc_plist_hack ((name), s, (pl));				\
 }
-DEFUN ("garbage-collect", Fgarbage_collect, Sgarbage_collect, 0, 0, "" /*
+DEFUN ("garbage-collect", Fgarbage_collect, 0, 0, "", /*
 Reclaim storage for Lisp objects no longer needed.
 Returns info on amount of space in use:
 ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
 (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
 PLIST)
 where `PLIST' is a list of alternating keyword/value pairs providing
 more detailed information.
 Garbage collection happens automatically if you cons more than
 `gc-cons-threshold' bytes of Lisp data since previous garbage collection.
-*/ )
+*/
-()
+())
 {
 Lisp_Object pl = Qnil;
 Lisp_Object ret[6];
 int i;
 ret[5] = pl;
 return (Flist (6, ret));
 }
 #undef HACK_O_MATIC
-DEFUN ("consing-since-gc", Fconsing_since_gc, Sconsing_since_gc, 0, 0, "" /*
+DEFUN ("consing-since-gc", Fconsing_since_gc, 0, 0, "", /*
 Return the number of bytes consed since the last garbage collection.
 \"Consed\" is a misnomer in that this actually counts allocation
 of all different kinds of objects, not just conses.
 If this value exceeds `gc-cons-threshold', a garbage collection happens.
-*/ )
+*/
-()
+())
 {
 return (make_int (consing_since_gc));
 }
-DEFUN ("memory-limit", Fmemory_limit, Smemory_limit, 0, 0, "" /*
+DEFUN ("memory-limit", Fmemory_limit, 0, 0, "", /*
 Return the address of the last byte Emacs has allocated, divided by 1024.
 This may be helpful in debugging Emacs's memory usage.
 The value is divided by 1024 to make sure it will fit in a lisp integer.
-*/ )
+*/
-()
+())
 {
 return (make_int ((EMACS_INT) sbrk (0) / 1024));
 }
 {
 defsymbol (&Qpre_gc_hook, "pre-gc-hook");
 defsymbol (&Qpost_gc_hook, "post-gc-hook");
 defsymbol (&Qgarbage_collecting, "garbage-collecting");
-defsubr (&Scons);
+DEFSUBR (Fcons);
-defsubr (&Slist);
+DEFSUBR (Flist);
-defsubr (&Svector);
+DEFSUBR (Fvector);
-defsubr (&Sbit_vector);
+DEFSUBR (Fbit_vector);
-defsubr (&Smake_byte_code);
+DEFSUBR (Fmake_byte_code);
-defsubr (&Smake_list);
+DEFSUBR (Fmake_list);
-defsubr (&Smake_vector);
+DEFSUBR (Fmake_vector);
-defsubr (&Smake_bit_vector);
+DEFSUBR (Fmake_bit_vector);
-defsubr (&Smake_string);
+DEFSUBR (Fmake_string);
-defsubr (&Smake_symbol);
+DEFSUBR (Fmake_symbol);
-defsubr (&Smake_marker);
+DEFSUBR (Fmake_marker);
-defsubr (&Spurecopy);
+DEFSUBR (Fpurecopy);
-defsubr (&Sgarbage_collect);
+DEFSUBR (Fgarbage_collect);
-defsubr (&Smemory_limit);
+DEFSUBR (Fmemory_limit);
-defsubr (&Sconsing_since_gc);
+DEFSUBR (Fconsing_since_gc);
 }
 void
 vars_of_alloc (void)
 {

Mercurial > hg > xemacs-beta

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