xemacs-beta: src/data.c comparison

comparison src/data.c @ 5118:e0db3c197671 ben-lisp-object

merge up to latest default branch, doesn't compile yet

author	Ben Wing <ben@xemacs.org>
date	Sat, 26 Dec 2009 21:18:49 -0600
parents	3742ea8250b5 aa5ed11f473b
children	623d57b7fbe8

comparison

equal deleted inserted replaced

-:3742ea8250b5
+:e0db3c197671
 {
 if (val < min || val > max)
 args_out_of_range_3 (make_int (val), make_int (min), make_int (max));
 }
-/* On some machines, XINT needs a temporary location.
-Here it is, in case it is needed.  */
-EMACS_INT sign_extend_temp;
-/* On a few machines, XINT can only be done by calling this.  */
-/* XEmacs:  only used by m/convex.h */
-EMACS_INT sign_extend_lisp_int (EMACS_INT num);
-EMACS_INT
-sign_extend_lisp_int (EMACS_INT num)
-{
-if (num & (1L << (INT_VALBITS - 1)))
-return num | ((-1L) << INT_VALBITS);
-else
-return num & (EMACS_INT) ((1UL << INT_VALBITS) - 1);
-}
 /* Data type predicates */
 DEFUN ("eq", Feq, 2, 2, 0, /*
 Return t if the two args are the same Lisp object.
 return NILP (object) ? Qt : Qnil;
 }
 DEFUN ("consp", Fconsp, 1, 1, 0, /*
 Return t if OBJECT is a cons cell.  `nil' is not a cons cell.
+See the documentation for `cons' or the Lisp manual for more details on what
+a cons cell is.
 */
 (object))
 {
 return CONSP (object) ? Qt : Qnil;
 }
 DEFUN ("atom", Fatom, 1, 1, 0, /*
 Return t if OBJECT is not a cons cell.  `nil' is not a cons cell.
+See the documentation for `cons' or the Lisp manual for more details on what
+a cons cell is.
 */
 (object))
 {
 return CONSP (object) ? Qnil : Qt;
 }
 DEFUN ("listp", Flistp, 1, 1, 0, /*
 Return t if OBJECT is a list.  `nil' is a list.
+A list is either the Lisp object nil (a symbol), interpreted as the empty
+list in this context, or a cons cell whose CDR refers to either nil or a
+cons cell.  A "proper list" contains no cycles.
 */
 (object))
 {
 return LISTP (object) ? Qt : Qnil;
 }
 return TRUE_LIST_P (object) ? Qt : Qnil;
 }
 DEFUN ("symbolp", Fsymbolp, 1, 1, 0, /*
 Return t if OBJECT is a symbol.
+A symbol is a Lisp object with a name. It can optionally have any and all of
+a value, a property list and an associated function.
 */
 (object))
 {
 return SYMBOLP (object) ? Qt : Qnil;
 }
 /* Extract and set components of lists */
 DEFUN ("car", Fcar, 1, 1, 0, /*
-Return the car of LIST.  If arg is nil, return nil.
+Return the car of CONS.  If CONS is nil, return nil.
-Error if arg is not nil and not a cons cell.  See also `car-safe'.
+The car of a list or a dotted pair is its first element.
-*/
-(list))
+Error if CONS is not nil and not a cons cell.  See also `car-safe'.
+*/
+(cons))
 {
 while (1)
 {
-if (CONSP (list))
+if (CONSP (cons))
-	return XCAR (list);
+	return XCAR (cons);
-else if (NILP (list))
+else if (NILP (cons))
 	return Qnil;
 else
-	list = wrong_type_argument (Qlistp, list);
+	cons = wrong_type_argument (Qlistp, cons);
 }
 }
 DEFUN ("car-safe", Fcar_safe, 1, 1, 0, /*
 Return the car of OBJECT if it is a cons cell, or else nil.
 {
 return CONSP (object) ? XCAR (object) : Qnil;
 }
 DEFUN ("cdr", Fcdr, 1, 1, 0, /*
-Return the cdr of LIST.  If arg is nil, return nil.
+Return the cdr of CONS.  If CONS is nil, return nil.
+The cdr of a list is the list without its first element.  The cdr of a
+dotted pair (A . B) is the second element, B.
 Error if arg is not nil and not a cons cell.  See also `cdr-safe'.
 */
-(list))
+(cons))
 {
 while (1)
 {
-if (CONSP (list))
+if (CONSP (cons))
-	return XCDR (list);
+	return XCDR (cons);
-else if (NILP (list))
+else if (NILP (cons))
 	return Qnil;
 else
-	list = wrong_type_argument (Qlistp, list);
+	cons = wrong_type_argument (Qlistp, cons);
 }
 }
 DEFUN ("cdr-safe", Fcdr_safe, 1, 1, 0, /*
 Return the cdr of OBJECT if it is a cons cell, else nil.
 return CONSP (object) ? XCDR (object) : Qnil;
 }
 DEFUN ("setcar", Fsetcar, 2, 2, 0, /*
 Set the car of CONS-CELL to be NEWCAR.  Return NEWCAR.
+The car of a list or a dotted pair is its first element.
 */
 (cons_cell, newcar))
 {
 if (!CONSP (cons_cell))
 cons_cell = wrong_type_argument (Qconsp, cons_cell);
 return newcar;
 }
 DEFUN ("setcdr", Fsetcdr, 2, 2, 0, /*
 Set the cdr of CONS-CELL to be NEWCDR.  Return NEWCDR.
+The cdr of a list is the list without its first element.  The cdr of a
+dotted pair (A . B) is the second element, B.
 */
 (cons_cell, newcdr))
 {
 if (!CONSP (cons_cell))
 cons_cell = wrong_type_argument (Qconsp, cons_cell);
 #endif /* WITH_NUMBER_TYPES */
 DEFUN ("=", Feqlsign, 1, MANY, 0, /*
 Return t if all the arguments are numerically equal.
 The arguments may be numbers, characters or markers.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 ARITHCOMPARE_MANY (==, eql)
 }
 DEFUN ("<", Flss, 1, MANY, 0, /*
 Return t if the sequence of arguments is monotonically increasing.
-The arguments may be numbers, characters or markers.
+(That is, if there is a second argument, it must be numerically greater than
+the first.  If there is a third, it must be numerically greater than the
+second, and so on.)  At least one argument is required.
+The arguments may be numbers, characters or markers.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 ARITHCOMPARE_MANY (<, lt)
 }
 DEFUN (">", Fgtr, 1, MANY, 0, /*
 Return t if the sequence of arguments is monotonically decreasing.
+(That is, if there is a second argument, it must be numerically less than
+the first.  If there is a third, it must be numerically less than the
+second, and so forth.)  At least one argument is required.
 The arguments may be numbers, characters or markers.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 ARITHCOMPARE_MANY (>, gt)
 }
 DEFUN ("<=", Fleq, 1, MANY, 0, /*
 Return t if the sequence of arguments is monotonically nondecreasing.
 The arguments may be numbers, characters or markers.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 ARITHCOMPARE_MANY (<=, le)
 }
 DEFUN (">=", Fgeq, 1, MANY, 0, /*
 Return t if the sequence of arguments is monotonically nonincreasing.
 The arguments may be numbers, characters or markers.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 ARITHCOMPARE_MANY (>=, ge)
 }
 complexity are higher, which means that those algorithms will run SLOWER
 than this one in the common case.  Optimize the common case! */
 DEFUN ("/=", Fneq, 1, MANY, 0, /*
 Return t if no two arguments are numerically equal.
 The arguments may be numbers, characters or markers.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef WITH_NUMBER_TYPES
 REGISTER int i, j;
 DEFUN ("+", Fplus, 0, MANY, 0, /*
 Return sum of any number of arguments.
 The arguments should all be numbers, characters or markers.
+arguments: (&rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef WITH_NUMBER_TYPES
 REGISTER int i;
 DEFUN ("-", Fminus, 1, MANY, 0, /*
 Negate number or subtract numbers, characters or markers.
 With one arg, negates it.  With more than one arg,
 subtracts all but the first from the first.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef WITH_NUMBER_TYPES
 REGISTER int i;
 }
 DEFUN ("*", Ftimes, 0, MANY, 0, /*
 Return product of any number of arguments.
 The arguments should all be numbers, characters or markers.
+arguments: (&rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef WITH_NUMBER_TYPES
 REGISTER int i;
 DEFUN ("div", Fdiv, 1, MANY, 0, /*
 Same as `/', but dividing integers creates a ratio instead of truncating.
 Note that this is a departure from Common Lisp, where / creates ratios when
 dividing integers.  Having a separate function lets us avoid breaking existing
 Emacs Lisp code that expects / to do integer division.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 REGISTER int i;
 Lisp_Object accum, divisor;
 return Qnil; /* not (usually) reached */
 }
 #endif /* HAVE_RATIO */
 DEFUN ("/", Fquo, 1, MANY, 0, /*
-Return first argument divided by all the remaining arguments.
+Return FIRST divided by all the remaining arguments.
 The arguments must be numbers, characters or markers.
 With one argument, reciprocates the argument.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef WITH_NUMBER_TYPES
 REGISTER int i;
 DEFUN ("max", Fmax, 1, MANY, 0, /*
 Return largest of all the arguments.
 All arguments must be real numbers, characters or markers.
 The value is always a number; markers and characters are converted
 to numbers.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef WITH_NUMBER_TYPES
 REGISTER int i, maxindex = 0;
 DEFUN ("min", Fmin, 1, MANY, 0, /*
 Return smallest of all the arguments.
 All arguments must be numbers, characters or markers.
 The value is always a number; markers and characters are converted
 to numbers.
+arguments: (FIRST &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef WITH_NUMBER_TYPES
 REGISTER int i, minindex = 0;
 }
 DEFUN ("logand", Flogand, 0, MANY, 0, /*
 Return bitwise-and of all the arguments.
 Arguments may be integers, or markers or characters converted to integers.
+arguments: (&rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef HAVE_BIGNUM
 REGISTER int i;
 }
 DEFUN ("logior", Flogior, 0, MANY, 0, /*
 Return bitwise-or of all the arguments.
 Arguments may be integers, or markers or characters converted to integers.
+arguments: (&rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef HAVE_BIGNUM
 REGISTER int i;
 }
 DEFUN ("logxor", Flogxor, 0, MANY, 0, /*
 Return bitwise-exclusive-or of all the arguments.
 Arguments may be integers, or markers or characters converted to integers.
+arguments: (&rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 #ifdef HAVE_BIGNUM
 REGISTER int i;
 { XD_LO_LINK,     offsetof (struct weak_list, next_weak),
 0, { 0 }, XD_FLAG_NO_KKCC },
 { XD_END }
 };
-DEFINE_LISP_OBJECT ("weak-list", weak_list,
+DEFINE_DUMPABLE_LISP_OBJECT ("weak-list", weak_list,
-			       mark_weak_list, print_weak_list,
+			     mark_weak_list, print_weak_list,
-			       0, weak_list_equal, weak_list_hash,
+			     0, weak_list_equal, weak_list_hash,
-			       weak_list_description,
+			     weak_list_description,
-			       struct weak_list);
+			     struct weak_list);
 /*
 -- we do not mark the list elements (either the elements themselves
 or the cons cells that hold them) in the normal marking phase.
 -- at the end of marking, we go through all weak lists that are
 marked, and mark the cons cells that hold all marked
 static const struct memory_description weak_box_description[] = {
 { XD_LO_LINK, offsetof (struct weak_box, value) },
 { XD_END}
 };
-DEFINE_NONDUMPABLE_LISP_OBJECT ("weak-box", weak_box, mark_weak_box,
+DEFINE_NODUMP_LISP_OBJECT ("weak-box", weak_box, mark_weak_box,
 					   print_weak_box, 0, weak_box_equal,
 					   weak_box_hash, weak_box_description,
 					   struct weak_box);
 DEFUN ("make-weak-box", Fmake_weak_box, 1, 1, 0, /*
 { XD_LISP_OBJECT, offsetof(struct ephemeron, value),
 0, { 0 }, XD_FLAG_NO_KKCC },
 { XD_END }
 };
-DEFINE_NONDUMPABLE_LISP_OBJECT ("ephemeron", ephemeron,
+DEFINE_NODUMP_LISP_OBJECT ("ephemeron", ephemeron,
 					   mark_ephemeron, print_ephemeron,
 					   0, ephemeron_equal, ephemeron_hash,
 					   ephemeron_description,
 					   struct ephemeron);

Mercurial > hg > xemacs-beta

comparison src/data.c @ 5118:e0db3c197671 ben-lisp-object