xemacs-beta: src/fns.c comparison

comparison src/fns.c @ 424:11054d720c21 r21-2-20

Import from CVS: tag r21-2-20

author	cvs
date	Mon, 13 Aug 2007 11:26:11 +0200
parents	41dbb7a9d5f2
children

comparison

equal deleted inserted replaced

-:28d9c139be4c
+:11054d720c21
 Lisp_Object Qidentity;
 static int internal_old_equal (Lisp_Object, Lisp_Object, int);
 static Lisp_Object
-mark_bit_vector (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_bit_vector (Lisp_Object obj)
 {
 return Qnil;
 }
 static void
 print_bit_vector (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-int i;
+size_t i;
 struct Lisp_Bit_Vector *v = XBIT_VECTOR (obj);
-int len = bit_vector_length (v);
+size_t len = bit_vector_length (v);
-int last = len;
+size_t last = len;
 if (INTP (Vprint_length))
 last = min (len, XINT (Vprint_length));
 write_c_string ("#*", printcharfun);
 for (i = 0; i < last; i++)
 		memory_hash (v->bits,
 			     BIT_VECTOR_LONG_STORAGE (bit_vector_length (v)) *
 			     sizeof (long)));
 }
+static const struct lrecord_description bit_vector_description[] = {
+{ XD_LISP_OBJECT, offsetof(Lisp_Bit_Vector, next), 1 },
+{ XD_END }
+};
 DEFINE_BASIC_LRECORD_IMPLEMENTATION ("bit-vector", bit_vector,
 				     mark_bit_vector, print_bit_vector, 0,
-				     bit_vector_equal, bit_vector_hash, 0,
+				     bit_vector_equal, bit_vector_hash,
+				     bit_vector_description,
 				     struct Lisp_Bit_Vector);
 DEFUN ("identity", Fidentity, 1, 1, 0, /*
 Return the argument unchanged.
 */
 retry:
 if (STRINGP (sequence))
 return make_int (XSTRING_CHAR_LENGTH (sequence));
 else if (CONSP (sequence))
 {
-int len;
+size_t 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;
-int len;
+size_t 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;
-int len;
+size_t len;
 for (tortoise = hare = XCDR (list), len = 1;
 CONSP (hare);
 hare = XCDR (hare), len++)
 {
 If SEQ is a string, relevant parts of the string-extent-data are copied
 to the new string.
 */
 (seq, from, to))
 {
-int len, f, t;
+EMACS_INT len, f, t;
 if (STRINGP (seq))
 return Fsubstring (seq, from, to);
 if (!LISTP (seq) && !VECTORP (seq) && !BIT_VECTORP (seq))
 args_out_of_range_3 (seq, make_int (f), make_int (t));
 if (VECTORP (seq))
 {
 Lisp_Object result = make_vector (t - f, Qnil);
-int i;
+EMACS_INT i;
 Lisp_Object *in_elts  = XVECTOR_DATA (seq);
 Lisp_Object *out_elts = XVECTOR_DATA (result);
 for (i = f; i < t; i++)
 	out_elts[i - f] = in_elts[i];
 }
 if (LISTP (seq))
 {
 Lisp_Object result = Qnil;
-int i;
+EMACS_INT i;
 seq = Fnthcdr (make_int (f), seq);
 for (i = f; i < t; i++)
 	{
 }
 /* bit vector */
 {
 Lisp_Object result = make_bit_vector (t - f, Qzero);
-int i;
+EMACS_INT i;
 for (i = f; i < t; i++)
 set_bit_vector_bit (XBIT_VECTOR (result), i - f,
 			  bit_vector_bit (XBIT_VECTOR (seq), i));
 return result;
 DEFUN ("nthcdr", Fnthcdr, 2, 2, 0, /*
 Take cdr N times on LIST, and return the result.
 */
 (n, list))
 {
-REGISTER int i;
+REGISTER size_t i;
 REGISTER Lisp_Object tail = list;
 CHECK_NATNUM (n);
 for (i = XINT (n); i; i--)
 {
 if (CONSP (tail))
 BIT_VECTORP (sequence))
 return Faref (sequence, n);
 #ifdef LOSING_BYTECODE
 else if (COMPILED_FUNCTIONP (sequence))
 {
-int idx = XINT (n);
+EMACS_INT idx = XINT (n);
 if (idx < 0)
 {
 lose:
 args_out_of_range (sequence, n);
 }
 If N is zero, then the atom that terminates the list is returned.
 If N is greater than the length of LIST, then LIST itself is returned.
 */
 (list, n))
 {
-int int_n, count;
+EMACS_INT int_n, count;
 Lisp_Object retval, tortoise, hare;
 CHECK_LIST (list);
 if (NILP (n))
 Modify LIST to remove the last N (default 1) elements.
 If LIST has N or fewer elements, nil is returned and LIST is unmodified.
 */
 (list, n))
 {
-int int_n;
+EMACS_INT int_n;
 CHECK_LIST (list);
 if (NILP (n))
 int_n = 1;
 noprops:
 signal_simple_error ("Object type has no settable properties", object);
 }
 return value;
-}
-void
-pure_put (Lisp_Object sym, Lisp_Object prop, Lisp_Object val)
-{
-Fput (sym, prop, Fpurecopy (val));
 }
 DEFUN ("remprop", Fremprop, 2, 2, 0, /*
 Remove from OBJECT's property list the property PROPNAME and its
 value.  OBJECT can be a symbol, face, extent, or string.  Returns
 UNGCPRO;
 return result;
 }
-DEFUN ("mapc", Fmapc, 2, 2, 0, /*
+DEFUN ("mapc-internal", Fmapc_internal, 2, 2, 0, /*
 Apply FUNCTION to each element of SEQUENCE.
 SEQUENCE may be a list, a vector, a bit vector, or a string.
 This function is like `mapcar' but does not accumulate the results,
 which is more efficient if you do not use the results.
+The difference between this and `mapc' is that `mapc' supports all
+the spiffy Common Lisp arguments.  You should normally use `mapc'.
 */
 (fn, seq))
 {
 mapcar1 (XINT (Flength (seq)), 0, fn, seq);
 DEFSUBR (Fold_equal);
 DEFSUBR (Ffillarray);
 DEFSUBR (Fnconc);
 DEFSUBR (Fmapcar);
 DEFSUBR (Fmapvector);
-DEFSUBR (Fmapc);
+DEFSUBR (Fmapc_internal);
 DEFSUBR (Fmapconcat);
 DEFSUBR (Fload_average);
 DEFSUBR (Ffeaturep);
 DEFSUBR (Frequire);
 DEFSUBR (Fprovide);

Mercurial > hg > xemacs-beta

comparison src/fns.c @ 424:11054d720c21 r21-2-20