xemacs-beta: src/alloc.c comparison

comparison src/alloc.c @ 444:576fb035e263 r21-2-37

Import from CVS: tag r21-2-37

author	cvs
date	Mon, 13 Aug 2007 11:36:19 +0200
parents	abe6d1db359e
children	98528da0b7fc

comparison

equal deleted inserted replaced

-:a8296e22da4e
+:576fb035e263
 /* This cannot GC. */
 return Fcons (obj0, Fcons (obj1, Fcons (obj2, Fcons (obj3, Fcons (obj4, Fcons (obj5, Qnil))))));
 }
 DEFUN ("make-list", Fmake_list, 2, 2, 0, /*
-Return a new list of length LENGTH, with each element being INIT.
+Return a new list of length LENGTH, with each element being OBJECT.
 */
-(length, init))
+(length, object))
 {
 CHECK_NATNUM (length);
 {
 Lisp_Object val = Qnil;
 size_t size = XINT (length);
 while (size--)
-val = Fcons (init, val);
+val = Fcons (object, val);
 return val;
 }
 }
 p->size = sizei;
 return p;
 }
 Lisp_Object
-make_vector (size_t length, Lisp_Object init)
+make_vector (size_t length, Lisp_Object object)
 {
 Lisp_Vector *vecp = make_vector_internal (length);
 Lisp_Object *p = vector_data (vecp);
 while (length--)
-*p++ = init;
+*p++ = object;
 {
 Lisp_Object vector;
 XSETVECTOR (vector, vecp);
 return vector;
 }
 }
 DEFUN ("make-vector", Fmake_vector, 2, 2, 0, /*
-Return a new vector of length LENGTH, with each element being INIT.
+Return a new vector of length LENGTH, with each element being OBJECT.
 See also the function `vector'.
 */
-(length, init))
+(length, object))
 {
 CONCHECK_NATNUM (length);
-return make_vector (XINT (length), init);
+return make_vector (XINT (length), object);
 }
 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.
 XSETBIT_VECTOR (all_bit_vectors, p);
 return p;
 }
 Lisp_Object
-make_bit_vector (size_t length, Lisp_Object init)
+make_bit_vector (size_t length, Lisp_Object bit)
 {
 Lisp_Bit_Vector *p = make_bit_vector_internal (length);
 size_t num_longs = BIT_VECTOR_LONG_STORAGE (length);
-CHECK_BIT (init);
+CHECK_BIT (bit);
-if (ZEROP (init))
+if (ZEROP (bit))
 memset (p->bits, 0, num_longs * sizeof (long));
 else
 {
 size_t bits_in_last = length & (LONGBITS_POWER_OF_2 - 1);
 memset (p->bits, ~0, num_longs * sizeof (long));
 return bit_vector;
 }
 }
 DEFUN ("make-bit-vector", Fmake_bit_vector, 2, 2, 0, /*
-Return a new bit vector of length LENGTH. with each bit being INIT.
+Return a new bit vector of length LENGTH. with each bit set to BIT.
-Each element is set to INIT.  See also the function `bit-vector'.
+BIT must be one of the integers 0 or 1.  See also the function `bit-vector'.
 */
-(length, init))
+(length, bit))
 {
 CONCHECK_NATNUM (length);
-return make_bit_vector (XINT (length), init);
+return make_bit_vector (XINT (length), bit);
 }
 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.
+Each argument must be one of the integers 0 or 1.
 */
 (int nargs, Lisp_Object *args))
 {
 int i;
 Lisp_Bit_Vector *p = make_bit_vector_internal (nargs);
 }
 #endif /* MULE */
 DEFUN ("make-string", Fmake_string, 2, 2, 0, /*
-Return a new string of length LENGTH, with each character being INIT.
+Return a new string consisting of LENGTH copies of CHARACTER.
-LENGTH must be an integer and INIT must be a character.
+LENGTH must be a non-negative integer.
 */
-(length, init))
+(length, character))
 {
 CHECK_NATNUM (length);
-CHECK_CHAR_COERCE_INT (init);
+CHECK_CHAR_COERCE_INT (character);
 {
 Bufbyte init_str[MAX_EMCHAR_LEN];
-int len = set_charptr_emchar (init_str, XCHAR (init));
+int len = set_charptr_emchar (init_str, XCHAR (character));
 Lisp_Object val = make_uninit_string (len * XINT (length));
 if (len == 1)
 /* Optimize the single-byte case */
-memset (XSTRING_DATA (val), XCHAR (init), XSTRING_LENGTH (val));
+memset (XSTRING_DATA (val), XCHAR (character), XSTRING_LENGTH (val));
 else
 {
 	size_t i;
 	Bufbyte *ptr = XSTRING_DATA (val);
 Old:
 Make a copy of OBJECT in pure storage.
 Recursively copies contents of vectors and cons cells.
 Does not copy symbols.
 */
-(obj))
+(object))
 {
-return obj;
+return object;
 }
 /************************************************************************/
 /*			   Garbage Collection				*/
 #ifdef ERROR_CHECK_GC
 #define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type)			\
 do {									\
 struct typename##_block *SFTB_current;				\
-struct typename##_block **SFTB_prev;					\
 int SFTB_limit;							\
 int num_free = 0, num_used = 0;					\
 									\
-for (SFTB_prev = &current_##typename##_block,				\
+for (SFTB_current = current_##typename##_block,			\
-SFTB_current = current_##typename##_block,			\
 SFTB_limit = current_##typename##_block_index;			\
 SFTB_current;							\
 )								\
 {									\
 int SFTB_iii;							\
 	    {								\
 	      num_used++;						\
 	      UNMARK_##typename (SFTB_victim);				\
 	    }								\
 	}								\
-SFTB_prev = &(SFTB_current->prev);				\
 SFTB_current = SFTB_current->prev;				\
 SFTB_limit = countof (current_##typename##_block->block);		\
 }									\
 									\
 gc_count_num_##typename##_in_use = num_used;				\
 /* Explicitly free a marker.  */
 void
 free_marker (Lisp_Marker *ptr)
 {
 /* Perhaps this will catch freeing an already-freed marker. */
-gc_checking_assert (ptr->lheader.type = lrecord_type_marker);
+gc_checking_assert (ptr->lheader.type == lrecord_type_marker);
 #ifndef ALLOC_NO_POOLS
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (marker, Lisp_Marker, ptr);
 #endif /* ALLOC_NO_POOLS */
 }
 {
 return make_int (consing_since_gc);
 }
 #if 0
-DEFUN ("memory-limit", Fmemory_limit, 0, 0, "", /*
+DEFUN ("memory-limit", Fmemory_limit, 0, 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.
 */
 ())

Mercurial > hg > xemacs-beta

comparison src/alloc.c @ 444:576fb035e263 r21-2-37