xemacs-beta: src/fns.c comparison

comparison src/fns.c @ 647:b39c14581166

[xemacs-hg @ 2001-08-13 04:45:47 by ben] removal of unsigned, size_t, etc.

author	ben
date	Mon, 13 Aug 2001 04:46:48 +0000
parents	190b164ddcac
children	fdefd0186b75

comparison

equal deleted inserted replaced

-:00c54252fe4f
+:b39c14581166
 }
 static void
 print_bit_vector (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-size_t i;
+Element_Count i;
 Lisp_Bit_Vector *v = XBIT_VECTOR (obj);
-size_t len = bit_vector_length (v);
+Element_Count len = bit_vector_length (v);
-size_t last = len;
+Element_Count last = len;
 if (INTP (Vprint_length))
 last = min (len, XINT (Vprint_length));
 write_c_string ("#*", printcharfun);
 for (i = 0; i < last; i++)
 	  !memcmp (v1->bits, v2->bits,
 		   BIT_VECTOR_LONG_STORAGE (bit_vector_length (v1)) *
 		   sizeof (long)));
 }
-static unsigned long
+static Hash_Code
 bit_vector_hash (Lisp_Object obj, int depth)
 {
 Lisp_Bit_Vector *v = XBIT_VECTOR (obj);
 return HASH2 (bit_vector_length (v),
 		memory_hash (v->bits,
 			     BIT_VECTOR_LONG_STORAGE (bit_vector_length (v)) *
 			     sizeof (long)));
 }
-static size_t
+static Memory_Count
 size_bit_vector (const void *lheader)
 {
 Lisp_Bit_Vector *v = (Lisp_Bit_Vector *) lheader;
 return FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Bit_Vector, unsigned long, bits,
 				       BIT_VECTOR_LONG_STORAGE (bit_vector_length (v)));
 retry:
 if (STRINGP (sequence))
 return make_int (XSTRING_CHAR_LENGTH (sequence));
 else if (CONSP (sequence))
 {
-size_t len;
+Element_Count len;
 GET_EXTERNAL_LIST_LENGTH (sequence, len);
 return make_int (len);
 }
 else if (VECTORP (sequence))
 return make_int (XVECTOR_LENGTH (sequence));
 which is at least the number of distinct elements.
 */
 (list))
 {
 Lisp_Object hare, tortoise;
-size_t len;
+Element_Count len;
 for (hare = tortoise = list, len = 0;
 CONSP (hare) && (! EQ (hare, tortoise) || len == 0);
 hare = XCDR (hare), len++)
 {
 copy_list (Lisp_Object list)
 {
 Lisp_Object list_copy = Fcons (XCAR (list), XCDR (list));
 Lisp_Object last = list_copy;
 Lisp_Object hare, tortoise;
-size_t len;
+Element_Count len;
 for (tortoise = hare = XCDR (list), len = 1;
 CONSP (hare);
 hare = XCDR (hare), len++)
 {
 DEFUN ("nthcdr", Fnthcdr, 2, 2, 0, /*
 Take cdr N times on LIST, and return the result.
 */
 (n, list))
 {
-REGISTER size_t i;
+REGISTER EMACS_INT i;
 REGISTER Lisp_Object tail = list;
 CHECK_NATNUM (n);
 for (i = XINT (n); i; i--)
 {
 if (CONSP (tail))
 bump_string_modiff (array);
 }
 else if (VECTORP (array))
 {
 Lisp_Object *p = XVECTOR_DATA (array);
-size_t len = XVECTOR_LENGTH (array);
+Element_Count len = XVECTOR_LENGTH (array);
 CHECK_LISP_WRITEABLE (array);
 while (len--)
 	*p++ = item;
 }
 else if (BIT_VECTORP (array))
 {
 Lisp_Bit_Vector *v = XBIT_VECTOR (array);
-size_t len = bit_vector_length (v);
+Element_Count len = bit_vector_length (v);
 int bit;
 CHECK_BIT (item);
 bit = XINT (item);
 CHECK_LISP_WRITEABLE (array);
 while (len--)
 if (CONSP (args[0]))
 {
 /* (setcdr (last args[0]) args[1]) */
 Lisp_Object tortoise, hare;
-size_t count;
+Element_Count count;
 for (hare = tortoise = args[0], count = 0;
 	   CONSP (XCDR (hare));
 	   hare = XCDR (hare), count++)
 	{
 	      Lisp_Object next = args[argnum];
 	    retry_next:
 	      if (CONSP (next) || argnum == nargs -1)
 		{
 		  /* (setcdr (last val) next) */
-		  size_t count;
+		  Element_Count count;
 		  for (count = 0;
 		       CONSP (XCDR (last_cons));
 		       last_cons = XCDR (last_cons), count++)
 		    {
 LENI is the length of VALS, which should also be the length of SEQUENCE.
 If VALS is a null pointer, do not accumulate the results. */
 static void
-mapcar1 (size_t leni, Lisp_Object *vals,
+mapcar1 (Element_Count leni, Lisp_Object *vals,
 	 Lisp_Object function, Lisp_Object sequence)
 {
 Lisp_Object result;
 Lisp_Object args[2];
 struct gcpro gcpro1;
 	 So we use EXTERNAL_LIST_LOOP_3_NO_DECLARE and GCPRO the tail. */
 if (vals)
 	{
 	  Lisp_Object *val = vals;
-	  size_t i;
+	  Element_Count i;
 	  LIST_LOOP_2 (elt, sequence)
 	      *val++ = elt;
 	  gcpro1.nvars = leni;
 	}
 }
 else if (VECTORP (sequence))
 {
 Lisp_Object *objs = XVECTOR_DATA (sequence);
-size_t i;
+Element_Count i;
 for (i = 0; i < leni; i++)
 	{
 	  args[1] = *objs++;
 	  result = Ffuncall (2, args);
 	  if (vals) vals[gcpro1.nvars++] = result;
 	}
 }
 else if (BIT_VECTORP (sequence))
 {
 Lisp_Bit_Vector *v = XBIT_VECTOR (sequence);
-size_t i;
+Element_Count i;
 for (i = 0; i < leni; i++)
 	{
 	  args[1] = make_int (bit_vector_bit (v, i));
 	  result = Ffuncall (2, args);
 	  if (vals) vals[gcpro1.nvars++] = result;
 The result is a list of the same length as SEQUENCE.
 SEQUENCE may be a list, a vector, a bit vector, or a string.
 */
 (function, sequence))
 {
-size_t len = XINT (Flength (sequence));
+Element_Count len = XINT (Flength (sequence));
 Lisp_Object *args = alloca_array (Lisp_Object, len);
 mapcar1 (len, args, function, sequence);
-return Flist (len, args);
+return Flist ((int) len, args);
 }
 DEFUN ("mapvector", Fmapvector, 2, 2, 0, /*
 Apply FUNCTION to each element of SEQUENCE; return a vector of the results.
 The result is a vector of the same length as SEQUENCE.
 SEQUENCE may be a list, a vector, a bit vector, or a string.
 */
 (function, sequence))
 {
-size_t len = XINT (Flength (sequence));
+Element_Count len = XINT (Flength (sequence));
 Lisp_Object result = make_vector (len, Qnil);
 struct gcpro gcpro1;
 GCPRO1 (result);
 mapcar1 (len, XVECTOR_DATA (result), function, sequence);
 /* We need to setup proper unwinding, because there is a number of
 ways these functions can blow up, and we don't want to have memory
 leaks in those cases.  */
 #define XMALLOC_OR_ALLOCA(ptr, len, type) do {			\
-size_t XOA_len = (len);					\
+Element_Count XOA_len = (len);				\
 if (XOA_len > MAX_ALLOCA)					\
 {								\
 ptr = xnew_array (type, XOA_len);				\
 record_unwind_protect (free_malloced_ptr,			\
 			     make_opaque_ptr ((void *)ptr));	\

Mercurial > hg > xemacs-beta

comparison src/fns.c @ 647:b39c14581166