xemacs-beta: src/lisp.h comparison

comparison src/lisp.h @ 5126:2a462149bd6a ben-lisp-object

merge

author	Ben Wing <ben@xemacs.org>
date	Wed, 24 Feb 2010 19:04:27 -0600
parents	b5df3737028a 92dc90c0bb40
children	a9c41067dd88

comparison

equal deleted inserted replaced

-:b5df3737028a
+:2a462149bd6a
 these become needed, they can always be defined. */
 #ifdef ERROR_CHECK_STRUCTURES
 /* Check for problems with the catch list and specbind stack */
 #define ERROR_CHECK_CATCH
-/* Check for incoherent Dynarr structures, attempts to access Dynarr
+/* Check for incoherent dynarr structures, attempts to access Dynarr
-positions out of range, reentrant use of Dynarrs through Dynarr locking,
+positions out of range, reentrant use of dynarrs through dynarr locking,
 etc. */
 #define ERROR_CHECK_DYNARR
 /* Check for insufficient use of call_trapping_problems(), particularly
 due to glyph-related changes causing eval or QUIT within redisplay */
 #define ERROR_CHECK_TRAPPING_PROBLEMS
 MODULE_API void assert_failed (const Ascbyte *, int, const Ascbyte *);
 #define ABORT() assert_failed (__FILE__, __LINE__, "ABORT()")
 #define abort_with_message(msg) assert_failed (__FILE__, __LINE__, msg)
 /* This used to be ((void) (0)) but that triggers lots of unused variable
-warnings.  It's pointless to force all that code to be rewritten, with
+warnings -- furthermore, if `x' has any side effects, e.g.
-added ifdefs.  Any reasonable compiler will eliminate an expression with
+assert (++depth <= 20);, we DEFINITELY want to execute the code inside of
+`x'.  Any reasonable compiler will eliminate an expression with
 no effects.  We keep this abstracted out like this in case we want to
 change it in the future. */
 #define disabled_assert(x) ((void) (x))
 #define disabled_assert_with_message(x, msg) ((void) msg, disabled_assert (x))
 #define disabled_assert_at_line(x, file, line) \
 /* Note that the simplest typedefs are near the top of this file. */
 /* We put typedefs here so that prototype declarations don't choke.
 Note that we don't actually declare the structures here (except
-maybe for simple structures like Dynarrs); that keeps them private
+maybe for simple structures like dynarrs); that keeps them private
 to the routines that actually use them. */
 /* ------------------------------- */
 /*    Error_Behavior typedefs      */
 /* ------------------------------- */
 EMACS_UINT p = XUINT (obj);
 return (void *) (p << 1);
 }
 /************************************************************************/
-/**    Definitions of dynamic arrays (Dynarrs) and other allocators    **/
+/**    Definitions of dynamic arrays (dynarrs) and other allocators    **/
 /************************************************************************/
 BEGIN_C_DECLS
 /************* Dynarr declaration *************/
 #define Dynarr_declare(type)			\
 struct lrecord_header header;			\
 type *base;					\
 DECLARE_DYNARR_LISP_IMP ()			\
 DECLARE_DYNARR_LOCKED ()			\
-int elsize;					\
+int elsize_;					\
 int len_;					\
 int largest_;					\
 int max_
 typedef struct dynarr
 { XD_INT_RESET,  offsetof (base_type, max_), XD_INDIRECT(1, 0) }
 #endif /* NEW_GC */
 /************* Dynarr verification *************/
+/* Dynarr locking and verification.
+[I] VERIFICATION
+Verification routines simply return their basic argument, possibly
+casted, but in the process perform some verification on it, aborting if
+the verification fails.  The verification routines take FILE and LINE
+parameters, and use them to output the file and line of the caller
+when an abort occurs, rather than the file and line of the inline
+function, which is less than useful.
+There are three basic types of verification routines:
+(1) Verify the dynarr itself.  This verifies the basic invariant
+involving the length/size values:
+0 <= Dynarr_length(d) <= Dynarr_largest(d) <= Dynarr_max(d)
+(2) Verify the dynarr itself prior to modifying it.  This performs
+the same verification as previously, but also checks that the
+dynarr is not locked (see below).
+(3) Verify a dynarr position.  Unfortunately we have to have
+different verification routines depending on which kind of operation
+is being performed:
+(a) For Dynarr_at(), we check that the POS is bounded by Dynarr_largest(),
+i.e. 0 <= POS < Dynarr_largest().
+(b) For Dynarr_atp_allow_end(), we also have to allow
+POS == Dynarr_largest().
+(c) For Dynarr_atp(), we behave largely like Dynarr_at() but make a
+special exception when POS == 0 and Dynarr_largest() == 0 -- see
+comment below.
+(d) Some other routines contain the POS verification within their code,
+and make the check 0 <= POS < Dynarr_length() or
+0 <= POS <= Dynarr_length().
+#### It is not well worked-out whether and in what circumstances it's
+allowed to use a position that is between Dynarr_length() and
+Dynarr_largest().  The ideal solution is to never allow this, and require
+instead that code first change the length before accessing higher
+positions.  That would require looking through all the code that accesses
+dynarrs and fixing it appropriately (especially redisplay code, and
+especially redisplay code in the vicinity of a reference to
+Dynarr_largest(), since such code usually checks explicitly to see whether
+there is extra stuff between Dynarr_length() and Dynarr_largest().)
+[II] LOCKING
+The idea behind dynarr locking is simple: Locking a dynarr prevents
+any modification from occurring, or rather, leads to an abort upon
+any attempt to modify a dynarr.
+Dynarr locking was originally added to catch some sporadic and hard-to-
+debug crashes in the redisplay code where dynarrs appeared to be getting
+corrupted in an unexpected fashion.  The solution was to lock the
+dynarrs that were getting corrupted (in this case, the display-line
+dynarrs) around calls to routines that weren't supposed to be changing
+these dynarrs but might somehow be calling code that modified them.
+This eventually revealed that there was a reentrancy problem with
+redisplay that involved the QUIT mechanism and the processing done in
+order to determine whether C-g had been pressed -- this processing
+involves retrieving, processing and queueing pending events to see
+whether any of them result in a C-g keypress.  However, at least under
+MS Windows this can result in redisplay being called reentrantly.
+For more info:--
+(Info-goto-node "(internals)Critical Redisplay Sections")
+*/
 #ifdef ERROR_CHECK_DYNARR
 DECLARE_INLINE_HEADER (
 int
-Dynarr_verify_pos_at (void *d, int pos, const Ascbyte *file, int line)
+Dynarr_verify_pos_at (void *d, Elemcount pos, const Ascbyte *file, int line)
 )
 {
 Dynarr *dy = (Dynarr *) d;
 /* We use `largest', not `len', because the redisplay code often
 accesses stuff between len and largest. */
 return pos;
 }
 DECLARE_INLINE_HEADER (
 int
-Dynarr_verify_pos_atp (void *d, int pos, const Ascbyte *file, int line)
+Dynarr_verify_pos_atp (void *d, Elemcount pos, const Ascbyte *file, int line)
 )
 {
 Dynarr *dy = (Dynarr *) d;
 /* We use `largest', not `len', because the redisplay code often
 accesses stuff between len and largest. */
 return pos;
 }
 DECLARE_INLINE_HEADER (
 int
-Dynarr_verify_pos_atp_allow_end (void *d, int pos, const Ascbyte *file,
+Dynarr_verify_pos_atp_allow_end (void *d, Elemcount pos, const Ascbyte *file,
 				 int line)
 )
 {
 Dynarr *dy = (Dynarr *) d;
 /* We use `largest', not `len', because the redisplay code often
 return Dynarr_verify_1 (d, file, line);
 }
 #define Dynarr_verify(d) Dynarr_verify_1 (d, __FILE__, __LINE__)
 #define Dynarr_verify_mod(d) Dynarr_verify_mod_1 (d, __FILE__, __LINE__)
-#define Dynarr_lock(d)				\
-do {						\
+DECLARE_INLINE_HEADER (
-Dynarr *dy = Dynarr_verify_mod (d);		\
+void
-dy->locked = 1;				\
+Dynarr_lock (void *d)
-} while (0)
+)
-#define Dynarr_unlock(d)			\
+{
-do {						\
+Dynarr *dy = Dynarr_verify_mod (d);
-Dynarr *dy = Dynarr_verify (d);		\
+dy->locked = 1;
-dy->locked = 0;				\
+}
-} while (0)
-#else
+DECLARE_INLINE_HEADER (
+void
+Dynarr_unlock (void *d)
+)
+{
+Dynarr *dy = Dynarr_verify (d);
+assert (dy->locked);
+dy->locked = 0;
+}
+#else /* not ERROR_CHECK_DYNARR */
 #define Dynarr_verify(d) ((Dynarr *) d)
 #define Dynarr_verify_mod(d) ((Dynarr *) d)
 #define Dynarr_lock(d) DO_NOTHING
 #define Dynarr_unlock(d) DO_NOTHING
 #endif /* ERROR_CHECK_DYNARR */
 /************* Dynarr creation *************/
 MODULE_API void *Dynarr_newf (Bytecount elsize);
 #define Dynarr_past_lastp(d) Dynarr_atp_allow_end (d, Dynarr_length (d))
 /************* Dynarr length/size retrieval and setting *************/
-/* Retrieve the length of a Dynarr.  The `+ 0' is to ensure that this cannot
+/* Retrieve the length of a dynarr.  The `+ 0' is to ensure that this cannot
 be used as an lvalue. */
 #define Dynarr_length(d) (Dynarr_verify (d)->len_ + 0)
-/* Retrieve the largest ever length seen of a Dynarr.  The `+ 0' is to
+/* Retrieve the largest ever length seen of a dynarr.  The `+ 0' is to
 ensure that this cannot be used as an lvalue. */
 #define Dynarr_largest(d) (Dynarr_verify (d)->largest_ + 0)
 /* Retrieve the number of elements that fit in the currently allocated
 space.  The `+ 0' is to ensure that this cannot be used as an lvalue. */
 #define Dynarr_max(d) (Dynarr_verify (d)->max_ + 0)
-/* Retrieve the advertised memory usage of a Dynarr, i.e. the number of
+/* Return the size in bytes of an element in a dynarr. */
-bytes occupied by the elements in the Dynarr, not counting any overhead. */
+#define Dynarr_elsize(d) (Dynarr_verify (d)->elsize_ + 0)
-#define Dynarr_sizeof(d) (Dynarr_length (d) * (d)->elsize)
+/* Retrieve the advertised memory usage of a dynarr, i.e. the number of
-/* Actually set the length of a Dynarr.  This is a low-level routine that
+bytes occupied by the elements in the dynarr, not counting any overhead. */
-should not be directly used; use Dynarr_set_length() instead if you need
+#define Dynarr_sizeof(d) (Dynarr_length (d) * Dynarr_elsize (d))
-to, but be very careful when doing so! */
-#define Dynarr_set_length_1(d, n)					\
+/* Actually set the length of a dynarr.  This is a low-level routine that
-do {									\
+should not be directly used; use Dynarr_set_length() or
-Elemcount _dsl1_n = (n);						\
+Dynarr_set_lengthr() instead. */
-dynarr_checking_assert (_dsl1_n >= 0 && _dsl1_n <= Dynarr_max (d));	\
+DECLARE_INLINE_HEADER (
-(void) Dynarr_verify_mod (d);						\
+void
-(d)->len_ = _dsl1_n;							\
+Dynarr_set_length_1 (void *d, Elemcount len)
-/* Use the raw field references here otherwise we get a crash because	\
+)
-we've set the length but not yet fixed up the largest value. */	\
+{
-if ((d)->len_ > (d)->largest_)					\
+Dynarr *dy = Dynarr_verify_mod (d);
-(d)->largest_ = (d)->len_;						\
+dynarr_checking_assert (len >= 0 && len <= Dynarr_max (dy));
-(void) Dynarr_verify_mod (d);						\
+/* Use the raw field references here otherwise we get a crash because
-} while (0)
+we've set the length but not yet fixed up the largest value. */
+dy->len_ = len;
-/* The following two defines will get you into real trouble if you aren't
+if (dy->len_ > dy->largest_)
-careful.  But they can save a lot of execution time when used wisely. */
+dy->largest_ = dy->len_;
-#define Dynarr_set_length(d, n)						\
+(void) Dynarr_verify_mod (d);
-do {									\
+}
-Elemcount _dsl_n = (n);						\
-dynarr_checking_assert (_dsl_n >= 0 && _dsl_n <= Dynarr_largest (d)); \
+/* "Restricted set-length": Set the length of dynarr D to LEN,
-Dynarr_set_length_1 (d, _dsl_n);					\
+which must be in the range [0, Dynarr_largest(d)]. */
-} while (0)
-#define Dynarr_increment(d) \
+DECLARE_INLINE_HEADER (
-Dynarr_set_length (d, Dynarr_length (d) + 1)
+void
+Dynarr_set_lengthr (void *d, Elemcount len)
-/* Reset the Dynarr's length to 0. */
+)
-#define Dynarr_reset(d) Dynarr_set_length (d, 0)
+{
+Dynarr *dy = Dynarr_verify_mod (d);
-MODULE_API void Dynarr_resize (void *dy, Elemcount size);
+dynarr_checking_assert (len >= 0 && len <= Dynarr_largest (dy));
+Dynarr_set_length_1 (dy, len);
-#define Dynarr_resize_if(d, numels)			\
+}
-do {							\
-Elemcount _dri_numels = (numels);			\
+/* "Restricted increment": Increment the length of dynarr D by 1; the resulting
-if (Dynarr_length (d) + _dri_numels > Dynarr_max (d))	\
+length must be in the range [0, Dynarr_largest(d)]. */
-Dynarr_resize (d, Dynarr_length (d) + _dri_numels);	\
-} while (0)
+#define Dynarr_incrementr(d) Dynarr_set_lengthr (d, Dynarr_length (d) + 1)
+MODULE_API void Dynarr_resize (void *d, Elemcount size);
+DECLARE_INLINE_HEADER (
+void
+Dynarr_resize_to_fit (void *d, Elemcount size)
+)
+{
+Dynarr *dy = Dynarr_verify_mod (d);
+if (size > Dynarr_max (dy))
+Dynarr_resize (dy, size);
+}
+#define Dynarr_resize_to_add(d, numels)			\
+Dynarr_resize_to_fit (d, Dynarr_length (d) + numels)
+/* This is an optimization.  This is like Dynarr_set_length() but the length
+is guaranteed to be at least as big as the existing length. */
+DECLARE_INLINE_HEADER (
+void
+Dynarr_increase_length (void *d, Elemcount len)
+)
+{
+Dynarr *dy = Dynarr_verify_mod (d);
+dynarr_checking_assert (len >= Dynarr_length (dy));
+Dynarr_resize_to_fit (dy, len);
+Dynarr_set_length_1 (dy, len);
+}
+/* Set the length of dynarr D to LEN.  If the length increases, resize as
+necessary to fit. (NOTE: This will leave uninitialized memory.  If you
+aren't planning on immediately overwriting the memory, use
+Dynarr_set_length_and_zero() to zero out all the memory that would
+otherwise be uninitialized.) */
+DECLARE_INLINE_HEADER (
+void
+Dynarr_set_length (void *d, Elemcount len)
+)
+{
+Dynarr *dy = Dynarr_verify_mod (d);
+Elemcount old_len = Dynarr_length (dy);
+if (old_len >= len)
+Dynarr_set_lengthr (dy, len);
+else
+Dynarr_increase_length (d, len);
+}
+#define Dynarr_increment(d) Dynarr_increase_length (d, Dynarr_length (d) + 1)
+/* Zero LEN contiguous elements starting at POS. */
+DECLARE_INLINE_HEADER (
+void
+Dynarr_zero_many (void *d, Elemcount pos, Elemcount len)
+)
+{
+Dynarr *dy = Dynarr_verify_mod (d);
+memset ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), 0,
+	  len*Dynarr_elsize (dy));
+}
+/* This is an optimization.  This is like Dynarr_set_length_and_zero() but
+the length is guaranteed to be at least as big as the existing
+length. */
+DECLARE_INLINE_HEADER (
+void
+Dynarr_increase_length_and_zero (void *d, Elemcount len)
+)
+{
+Dynarr *dy = Dynarr_verify_mod (d);
+Elemcount old_len = Dynarr_length (dy);
+Dynarr_increase_length (dy, len);
+Dynarr_zero_many (dy, old_len, len - old_len);
+}
+/* Set the length of dynarr D to LEN.  If the length increases, resize as
+necessary to fit and zero out all the elements between the old and new
+lengths. */
+DECLARE_INLINE_HEADER (
+void
+Dynarr_set_length_and_zero (void *d, Elemcount len)
+)
+{
+Dynarr *dy = Dynarr_verify_mod (d);
+Elemcount old_len = Dynarr_length (dy);
+if (old_len >= len)
+Dynarr_set_lengthr (dy, len);
+else
+Dynarr_increase_length_and_zero (d, len);
+}
+/* Reset the dynarr's length to 0. */
+#define Dynarr_reset(d) Dynarr_set_lengthr (d, 0)
 #ifdef MEMORY_USAGE_STATS
 struct overhead_stats;
 Bytecount Dynarr_memory_usage (void *d, struct overhead_stats *stats);
 #endif
-/************* Adding/deleting elements to/from a Dynarr *************/
+/************* Adding/deleting elements to/from a dynarr *************/
+/* Set the Lisp implementation of the element at POS in dynarr D.  Only
+does this if the dynarr holds Lisp objects of a particular type (the
+objects themselves, not pointers to them), and only under NEW_GC. */
 #ifdef NEW_GC
-#define Dynarr_add(d, el)						\
+#define DYNARR_SET_LISP_IMP(d, pos)					\
 do {									\
-const struct lrecord_implementation *imp = (d)->lisp_imp;		\
+if ((d)->lisp_imp)							\
-(void) Dynarr_verify_mod (d);						\
-Dynarr_resize_if (d, 1);						\
-((d)->base)[Dynarr_length (d)] = (el);				\
-if (imp)								\
 set_lheader_implementation						\
-((struct lrecord_header *)&(((d)->base)[Dynarr_length (d)]), imp);	\
+((struct lrecord_header *)&(((d)->base)[pos]), (d)->lisp_imp);	\
-Dynarr_set_length_1 (d, Dynarr_length (d) + 1);			\
+} while (0)
-(void) Dynarr_verify_mod (d);						\
+#else
+#define DYNARR_SET_LISP_IMP(d, pos) DO_NOTHING
+#endif /* (not) NEW_GC */
+/* Add Element EL to the end of dynarr D. */
+#define Dynarr_add(d, el)			\
+do {						\
+Elemcount _da_pos = Dynarr_length (d);	\
+(void) Dynarr_verify_mod (d);			\
+Dynarr_increment (d);				\
+((d)->base)[_da_pos] = (el);			\
+DYNARR_SET_LISP_IMP (d, _da_pos);		\
 } while (0)
-#else /* not NEW_GC */
-#define Dynarr_add(d, el)				\
+/* Set EL as the element at position POS in dynarr D.
+Expand the dynarr as necessary so that its length is enough to include
+position POS within it, and zero out any new elements created as a
+result of expansion, other than the one at POS. */
+#define Dynarr_set(d, pos, el)				\
 do {							\
+Elemcount _ds_pos = (pos);				\
 (void) Dynarr_verify_mod (d);				\
-Dynarr_resize_if (d, 1);				\
+if (Dynarr_length (d) < _ds_pos + 1)			\
-((d)->base)[Dynarr_length (d)] = (el);		\
+Dynarr_increase_length_and_zero (d, _ds_pos + 1);	\
-Dynarr_set_length_1 (d, Dynarr_length (d) + 1);	\
+((d)->base)[_ds_pos] = (el);				\
-(void) Dynarr_verify_mod (d);				\
+DYNARR_SET_LISP_IMP (d, _ds_pos);			\
 } while (0)
-#endif /* not NEW_GC */
+/* Add LEN contiguous elements, stored at BASE, to dynarr D.  If BASE is
+NULL, reserve space but don't store anything. */
-MODULE_API void Dynarr_insert_many (void *d, const void *el, int len,
-				    int start);
+DECLARE_INLINE_HEADER (
-MODULE_API void Dynarr_delete_many (void *d, int start, int len);
+void
+Dynarr_add_many (void *d, const void *base, Elemcount len)
-#define Dynarr_insert_many_at_start(d, el, len)	\
+)
-Dynarr_insert_many (d, el, len, 0)
+{
+/* This duplicates Dynarr_insert_many to some extent; but since it is
+called so often, it seemed useful to remove the unnecessary stuff
+from that function and to make it inline */
+Dynarr *dy = Dynarr_verify_mod (d);
+Elemcount pos = Dynarr_length (dy);
+Dynarr_increase_length (dy, Dynarr_length (dy) + len);
+if (base)
+memcpy ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), base,
+	    len*Dynarr_elsize (dy));
+}
+/* Insert LEN elements, currently pointed to by BASE, into dynarr D
+starting at position POS. */
+MODULE_API void Dynarr_insert_many (void *d, const void *base, Elemcount len,
+				    Elemcount pos);
+/* Prepend LEN elements, currently pointed to by BASE, to the beginning. */
+#define Dynarr_prepend_many(d, base, len) Dynarr_insert_many (d, base, len, 0)
+/* Add literal string S to dynarr D, which should hold chars or unsigned
+chars.  The final zero byte is not stored. */
 #define Dynarr_add_literal_string(d, s) Dynarr_add_many (d, s, sizeof (s) - 1)
-#define Dynarr_add_lisp_string(d, s, codesys)			\
+/* Convert Lisp string S to an external encoding according to CODESYS and
+add to dynarr D, which should hold chars or unsigned chars.  No final
+zero byte is appended. */
+/* #### This should be an inline function but LISP_STRING_TO_SIZED_EXTERNAL
+isn't declared yet. */
+#define Dynarr_add_ext_lisp_string(d, s, codesys)		\
 do {								\
 Lisp_Object dyna_ls_s = (s);					\
 Lisp_Object dyna_ls_cs = (codesys);				\
 Extbyte *dyna_ls_eb;						\
 Bytecount dyna_ls_bc;						\
 LISP_STRING_TO_SIZED_EXTERNAL (dyna_ls_s, dyna_ls_eb,		\
 				 dyna_ls_bc, dyna_ls_cs);	\
 Dynarr_add_many (d, dyna_ls_eb, dyna_ls_bc);			\
 } while (0)
-/* Add LEN contiguous elements to a Dynarr */
+/* Delete LEN elements starting at position POS. */
-DECLARE_INLINE_HEADER (
+MODULE_API void Dynarr_delete_many (void *d, Elemcount pos, Elemcount len);
-void
-Dynarr_add_many (void *d, const void *el, int len)
+/* Pop off (i.e. delete) the last element from the dynarr and return it */
-)
-{
-/* This duplicates Dynarr_insert_many to some extent; but since it is
-called so often, it seemed useful to remove the unnecessary stuff
-from that function and to make it inline */
-Dynarr *dy = Dynarr_verify_mod (d);
-Dynarr_resize_if (dy, len);
-/* Some functions call us with a value of 0 to mean "reserve space but
-don't write into it" */
-if (el)
-memcpy ((char *) dy->base + Dynarr_sizeof (dy), el, len*dy->elsize);
-Dynarr_set_length_1 (dy, Dynarr_length (dy) + len);
-(void) Dynarr_verify_mod (dy);
-}
 #define Dynarr_pop(d)					\
 (dynarr_checking_assert (Dynarr_length (d) > 0),	\
 Dynarr_verify_mod (d)->len_--,			\
 Dynarr_at (d, Dynarr_length (d)))
-#define Dynarr_delete(d, i) Dynarr_delete_many (d, i, 1)
+/* Delete the item at POS */
+#define Dynarr_delete(d, pos) Dynarr_delete_many (d, pos, 1)
+/* Delete the item located at memory address P, which must be a `type *'
+pointer, where `type' is the type of the elements of the dynarr. */
 #define Dynarr_delete_by_pointer(d, p) \
 Dynarr_delete_many (d, (p) - ((d)->base), 1)
+/* Delete all elements that are numerically equal to EL. */
 #define Dynarr_delete_object(d, el)		\
 do						\
 {						\
 REGISTER int i;				\
 #define MARKERP(x) RECORDP (x, marker)
 #define CHECK_MARKER(x) CHECK_RECORD (x, marker)
 #define CONCHECK_MARKER(x) CONCHECK_RECORD (x, marker)
 /* The second check was looking for GCed markers still in use */
-/* if (INTP (XMARKER (x)->lheader.next.v)) ABORT (); */
+/* assert (!INTP (XMARKER (x)->lheader.next.v)); */
 #define marker_next(m) ((m)->next)
 #define marker_prev(m) ((m)->prev)
 /*-------------------basic int (no connection to char)------------------*/
 {
 assert_at_line (INTP (obj), file, line);
 return XREALINT (obj);
 }
-#else /* no error checking */
+#else /* not ERROR_CHECK_TYPES */
 #define XINT(obj) XREALINT (obj)
-#endif /* no error checking */
+#endif /* (not) ERROR_CHECK_TYPES */
 #define CHECK_INT(x) do {			\
 if (!INTP (x))				\
 dead_wrong_type_argument (Qintegerp, x);	\
 } while (0)
 #define CONCHECK_INT(x) do {			\
 if (!INTP (x))				\
 x = wrong_type_argument (Qintegerp, x);	\
 } while (0)
+/* NOTE NOTE NOTE! This definition of "natural number" is mathematically
+wrong.  Mathematically, a natural number is a positive integer; 0
+isn't included.  This would be better called NONNEGINT(). */
 #define NATNUMP(x) (INTP (x) && XINT (x) >= 0)
 #define CHECK_NATNUM(x) do {			\
 if (!NATNUMP (x))				\

Mercurial > hg > xemacs-beta

comparison src/lisp.h @ 5126:2a462149bd6a ben-lisp-object