xemacs-beta: src/lisp.h comparison

comparison src/lisp.h @ 5125:b5df3737028a ben-lisp-object

merge

author	Ben Wing <ben@xemacs.org>
date	Wed, 24 Feb 2010 01:58:04 -0600
parents	623d57b7fbe8 838630c0734f
children	2a462149bd6a

comparison

equal deleted inserted replaced

-:623d57b7fbe8
+:b5df3737028a
 /* Fundamental definitions for XEmacs Lisp interpreter.
 Copyright (C) 1985-1987, 1992-1995 Free Software Foundation, Inc.
 Copyright (C) 1993-1996 Richard Mlynarik.
-Copyright (C) 1995, 1996, 2000, 2001, 2002, 2003, 2004, 2005 Ben Wing.
+Copyright (C) 1995, 1996, 2000-2005, 2009, 2010 Ben Wing.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 along with XEmacs; see the file COPYING.  If not, write to
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 /* Synched up with: FSF 19.30. */
+#ifndef INCLUDED_lisp_h_
+#define INCLUDED_lisp_h_
 /* Authorship:
 Based on code from pre-release FSF 19, c. 1991.
 Various changes by Jamie Zawinski 1991-1994:
 Various macro-related changes by Jerry James, 2003:
 MODULE_API introduced;
 Compiler-specific definitions modernized and moved to compiler.h.
 */
-#ifndef INCLUDED_lisp_h_
-#define INCLUDED_lisp_h_
-/************************************************************************/
-/*			  general definitions				*/
-/************************************************************************/
 /* Conventions in comments:
 "Mule-izing" is the process of going through a file and eliminating
 assumptions that the internal format (Ibyte * text) is the same as the
 external format used by library routines.  Mule-ization should also
 %%#### marks places that need work for KKCC (the new garbage collector).
 */
-/* -------------------------- include files --------------------- */
+/************************************************************************/
+/*                            include files                             */
+/************************************************************************/
 /* We include the following generally useful header files so that you
 don't have to worry about prototypes when using the standard C
 library functions and macros.  These files shouldn't be excessively
 large so they shouldn't cause that much of a slowdown. */
 #include <stdlib.h>
+/* Evil, but ...  -Wshadow is genuinely useful but also leads to spurious
+warnings when you have a local var named `index'.  Avoid this by
+hacking around it. */
+#define index old_index
 #include <string.h>		/* primarily for memcpy, etc. */
+#undef index
 #include <stdio.h>		/* NULL, etc. */
 #include <ctype.h>
 #include <stdarg.h>
 #include <stddef.h>		/* offsetof */
 #include <sys/types.h>
 #include <limits.h>
+#ifdef __cplusplus
-/* -------------------------- error-checking ------------------------ */
+#include <limits>		/* necessary for max()/min() under G++ 4 */
+#endif
-/* The large categories established by configure can be subdivided into
-smaller subcategories, for problems in specific modules.  You can't
-control this using configure, but you can manually stick in a define as
+/************************************************************************/
-necessary. */
+/*                            error checking                            */
+/************************************************************************/
+/* ------------------------- large categories ------------------------- */
+/* How these work:
+The most common classes will be `text' and `type', followed by `structure'.
+`text' is for problems related to bad textual format.  `type' is for
+problems related to wrongly typed arguments, structure fields, etc.
+`structure' is for bad data inside of a structure.  Sometimes these are
+used "incorrectly", e.g. `type' is often used for structure-checking.
+Consider `text':
+`text_checking_assert() will assert() only when ERROR_CHECK_TEXT is defined;
+otherwise it's a no-op.  text_checking_assert_at_line() is similar, but
+allows you to override the file name and line number normally supplied in
+the message.  This is especially useful in inline header functions, and
+so there's a special inline_text_checking_assert() for this; this works
+like text_checking_assert() but supplies the file and line of the calling
+function.  In order for this to work, you need to declare your inline
+function with INLINE_TEXT_CHECK_ARGS at the end of its argument list,
+and give its function name a _1 extension or similar.  Then create a
+macro that calls your inline function and includes INLINE_TEXT_CHECK_CALL
+at the end of the parameter list.  This will arrange to pass in and receive
+the file and line (__FILE__, __LINE__) at place where the call occurs in
+the calling function; but nothing will get passed in when ERROR_CHECK_TEXT
+is not defined.
+Currently the full bevy of *foo_checking_assert* macros are defined only
+for `text' and `types'; for others, only the basic foo_checking_assert()
+macro is defined.  Writing out all the variations for all possible error
+categories would produce too much clutter.  If any of these become
+needed, they can always be defined. */
+/* #### I suggest revamping these and making proper use of the
+category/subcategory system.  Here is one proposal:
+	Major category 	Minor categories
+	--------------------------------
+	Allocation
+			Malloc
+			Dynarr
+	Display
+			Extents
+			Glyphs
+			Redisplay
+	Execution
+			Byte-Code
+			Catch
+			Garbage Collection
+			Trapping-Problems
+	Lisp Objects
+			Buffers
+			Char Tables
+			Events
+			Lstreams
+			Hash Tables
+			Range Tables
+	Types
+			Lrecord Types
+			Subtypes
+	Text
+			Byte Positions
+			Conversion
+			Eistrings
+			Itext
+			Lisp Strings
+--ben
+*/
+#define INLINE_ERROR_CHECK_ARGS , const char *__file__, int __line__
+#define INLINE_ERROR_CHECK_CALL , __FILE__, __LINE__
+#define DISABLED_INLINE_ERROR_CHECK_ARGS
+#define DISABLED_INLINE_ERROR_CHECK_CALL
+/* For assertions in inline header functions which will report the file and
+line of the calling function */
+#define inline_assert(assertion) assert_at_line (assertion, __file__, __line__)
+/* The following should not use disabled_assert_at_line() because when the
+inline assert is disabled, params __file__ and __line__ do not exist. */
+#define disabled_inline_assert(assertion) disabled_assert (assertion)
+/* ------- the specific categories -------- */
+#if defined (ERROR_CHECK_BYTE_CODE) || defined (ERROR_CHECK_DISPLAY) || defined (ERROR_CHECK_EXTENTS) || defined (ERROR_CHECK_GC) || defined (ERROR_CHECK_GLYPHS) || defined (ERROR_CHECK_MALLOC) || defined (ERROR_CHECK_STRUCTURES) || defined (ERROR_CHECK_TEXT) || defined (ERROR_CHECK_TYPES)
+#define ERROR_CHECK_ANY
+#endif
+/* KEEP THESE SORTED! */
+#ifdef ERROR_CHECK_BYTE_CODE
+#define byte_code_checking_assert(assertion) assert (assertion)
+#else /* not ERROR_CHECK_BYTE_CODE */
+#define byte_code_checking_assert(assertion) disabled_assert (assertion)
+#endif /* ERROR_CHECK_BYTE_CODE */
+#ifdef ERROR_CHECK_DISPLAY
+#define display_checking_assert(assertion) assert (assertion)
+#else /* not ERROR_CHECK_DISPLAY */
+#define display_checking_assert(assertion) disabled_assert (assertion)
+#endif /* ERROR_CHECK_DISPLAY */
+#ifdef ERROR_CHECK_EXTENTS
+#define extent_checking_assert(assertion) assert (assertion)
+#else /* not ERROR_CHECK_EXTENTS */
+#define extent_checking_assert(assertion) disabled_assert (assertion)
+#endif /* ERROR_CHECK_EXTENTS */
+#ifdef ERROR_CHECK_GC
+#define gc_checking_assert(assertion) assert (assertion)
+#else /* not ERROR_CHECK_GC */
+#define gc_checking_assert(assertion) disabled_assert (assertion)
+#endif /* ERROR_CHECK_GC */
+#ifdef ERROR_CHECK_GLYPHS
+#define glyph_checking_assert(assertion) assert (assertion)
+#else /* not ERROR_CHECK_GLYPHS */
+#define glyph_checking_assert(assertion) disabled_assert (assertion)
+#endif /* ERROR_CHECK_GLYPHS */
+#ifdef ERROR_CHECK_MALLOC
+#define malloc_checking_assert(assertion) assert (assertion)
+#else /* not ERROR_CHECK_MALLOC */
+#define malloc_checking_assert(assertion) disabled_assert (assertion)
+#endif /* ERROR_CHECK_MALLOC */
 #ifdef ERROR_CHECK_STRUCTURES
-/* Check for problems with the catch list and specbind stack */
+#define structure_checking_assert(assertion) assert (assertion)
-#define ERROR_CHECK_CATCH
+#else /* not ERROR_CHECK_STRUCTURES */
-/* Check for insufficient use of call_trapping_problems(), particularly
+#define structure_checking_assert(assertion) disabled_assert (assertion)
-due to glyph-related changes causing eval or QUIT within redisplay */
+#endif /* ERROR_CHECK_STRUCTURES */
-#define ERROR_CHECK_TRAPPING_PROBLEMS
-#endif
+#ifdef ERROR_CHECK_TEXT
+#define text_checking_assert(assertion) assert (assertion)
+#define text_checking_assert_at_line(assertion, file, line) \
+assert_at_line (assertion, file, line)
+#define inline_text_checking_assert(assertion) inline_assert (assertion)
+#define INLINE_TEXT_CHECK_ARGS INLINE_ERROR_CHECK_ARGS
+#define INLINE_TEXT_CHECK_CALL INLINE_ERROR_CHECK_CALL
+#define text_checking_assert_with_message(assertion, msg) \
+assert_with_message (assertion, msg)
+#else /* not ERROR_CHECK_TEXT */
+#define text_checking_assert(assertion) disabled_assert (assertion)
+#define text_checking_assert_at_line(assertion, file, line) \
+disabled_assert_at_line (assertion, file, line)
+#define inline_text_checking_assert(assertion) \
+disabled_inline_assert (assertion)
+#define INLINE_TEXT_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS
+#define INLINE_TEXT_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL
+#define text_checking_assert_with_message(assertion, msg) \
+disabled_assert_with_message (assertion, msg)
+#endif /* ERROR_CHECK_TEXT */
 #ifdef ERROR_CHECK_TYPES
 #define type_checking_assert(assertion) assert (assertion)
 #define type_checking_assert_at_line(assertion, file, line) \
 assert_at_line (assertion, file, line)
+#define inline_type_checking_assert(assertion) inline_assert (assertion)
+#define INLINE_TYPE_CHECK_ARGS INLINE_ERROR_CHECK_ARGS
+#define INLINE_TYPE_CHECK_CALL INLINE_ERROR_CHECK_CALL
 #define type_checking_assert_with_message(assertion, msg) \
 assert_with_message (assertion, msg)
-#else
+#else /* not ERROR_CHECK_TYPES */
-#define type_checking_assert(assertion)
+#define type_checking_assert(assertion) disabled_assert (assertion)
-#define type_checking_assert_at_line(assertion, file, line)
+#define type_checking_assert_at_line(assertion, file, line) \
-#define type_checking_assert_with_message(assertion, msg)
+disabled_assert_at_line (assertion, file, line)
-#endif
+#define inline_type_checking_assert(assertion) \
-#ifdef ERROR_CHECK_GC
+disabled_inline_assert (assertion)
-#define gc_checking_assert(assertion) assert (assertion)
+#define INLINE_TYPE_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS
-#define gc_checking_assert_at_line(assertion, file, line) \
+#define INLINE_TYPE_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL
-assert_at_line (assertion, file, line)
+#define type_checking_assert_with_message(assertion, msg) \
-#define gc_checking_assert_with_message(assertion, msg) \
+disabled_assert_with_message (assertion, msg)
-assert_with_message (assertion, msg)
+#endif /* ERROR_CHECK_TYPES */
-#else
-#define gc_checking_assert(assertion)
+/* ------------------------- small categories ------------------------- */
-#define gc_checking_assert_at_line(assertion, file, line)
-#define gc_checking_assert_with_message(assertion, msg)
+/* The large categories established by configure can be subdivided into
-#endif
+smaller subcategories, for problems in specific modules.  You can't
-#ifdef ERROR_CHECK_TEXT
+control this using configure, but you can manually stick in a define as
-#define text_checking_assert(assertion) assert (assertion)
+necessary.
-#define text_checking_assert_at_line(assertion, file, line) \
-assert_at_line (assertion, file, line)
+The idea is to go ahead and create a new type of error-checking and
-#define text_checking_assert_with_message(assertion, msg) \
+have it turned on if the larger category it is a part of is also
-assert_with_message (assertion, msg)
+turned on.  For example, ERROR_CHECK_DYNARR is considered a subcategory
-#else
+of ERROR_CHECK_STRUCTURES.
-#define text_checking_assert(assertion)
-#define text_checking_assert_at_line(assertion, file, line)
+We also define foo_checking_assert() macros for convenience, but
-#define text_checking_assert_with_message(assertion, msg)
+generally don't define the many variations of this macro as for the
-#endif
+major types above, because it produces too much clutter.  If any of
+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
+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
+#endif /* ERROR_CHECK_STRUCTURES */
+#ifdef ERROR_CHECK_CATCH
+#define catch_checking_assert(assertion) assert (assertion)
+#else /* not ERROR_CHECK_CATCH */
+#define catch_checking_assert(assertion) disabled_assert (assertion)
+#endif /* ERROR_CHECK_CATCH */
+#ifdef ERROR_CHECK_DYNARR
+#define dynarr_checking_assert(assertion) assert (assertion)
+#else /* not ERROR_CHECK_DYNARR */
+#define dynarr_checking_assert(assertion) disabled_assert (assertion)
+#endif /* ERROR_CHECK_DYNARR */
 #ifdef ERROR_CHECK_TRAPPING_PROBLEMS
 #define trapping_problems_checking_assert(assertion) assert (assertion)
-#define trapping_problems_checking_assert_at_line(assertion, file, line) \
+#else /* not ERROR_CHECK_TRAPPING_PROBLEMS */
-assert_at_line (assertion, file, line)
+#define trapping_problems_checking_assert(assertion) disabled_assert (assertion)
-#define trapping_problems_checking_assert_with_message(assertion, msg) \
+#endif /* ERROR_CHECK_TRAPPING_PROBLEMS */
-assert_with_message (assertion, msg)
-#else
-#define trapping_problems_checking_assert(assertion)
-#define trapping_problems_checking_assert_at_line(assertion, file, line)
-#define trapping_problems_checking_assert_with_message(assertion, msg)
-#endif
 /************************************************************************/
 /**                     Definitions of basic types                     **/
 /************************************************************************/
 b) [Extbyte] pointer to text in some external format, which can be
 defined as all formats other than the internal one
 c) [Ascbyte] pure ASCII text
 d) [Binbyte] binary data that is not meant to be interpreted as text
 e) [Rawbyte] general data in memory, where we don't care about whether
-it's text or binary
+it's text or binary; often used when computing memory-
+based/byte-based offsets of pointers
 f) [Boolbyte] a zero or a one
 g) [Bitbyte] a byte used for bit fields
 h) [Chbyte] null-semantics `char *'; used when casting an argument to
 an external API where the the other types may not be
 appropriate
 and line of the inline function, which is not very useful. */
 /* Highly dubious kludge */
 /*   (thanks, Jamie, I feel better now -- ben) */
 MODULE_API void assert_failed (const Ascbyte *, int, const Ascbyte *);
-#define ABORT() (assert_failed (__FILE__, __LINE__, "ABORT()"))
+#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
+added ifdefs.  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) \
+((void) file, (void) line, disabled_assert (x))
 #ifdef USE_ASSERTIONS
 # define assert(x) ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, #x))
 # define assert_with_message(x, msg) \
 ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, msg))
 # define assert_at_line(x, file, line) \
 ((x) ? (void) 0 : assert_failed (file, line, #x))
-#elif defined (DEBUG_XEMACS)
-# define assert(x) ((x) ? (void) 0 : (void) ABORT ())
-# define assert_with_message(x, msg) assert (x)
-# define assert_at_line(x, file, line) assert (x)
 #else
 /* 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
 added ifdefs.  Any reasonable compiler will eliminate an expression with
 no effects. */
-# define assert(x) ((void) (x))
+# define assert(x) disabled_assert (x)
-# define assert_with_message(x, msg) assert (x)
+# define assert_with_message(x, msg) disabled_assert_with_message (x, msg)
-# define assert_at_line(x, file, line) assert (x)
+# define assert_at_line(x, file, line) disabled_assert_at_line (x, file, line)
 #endif
 /************************************************************************/
 /**                         Memory allocation                          **/
 /************************************************************************/
 /* Basic free function */
 MODULE_API void xfree_1 (void *);
 #ifdef ERROR_CHECK_MALLOC
-/* This used to use a temporary variable, which both avoided the multiple
+/* This used to use a temporary variable.  But that triggered
-evaluation and obviated the need for the TYPE argument.  But that triggered
 complaints under strict aliasing. #### There should be a better way. */
-#define xfree(lvalue, type) do						\
+#define xfree(lvalue) do						\
 {									\
 xfree_1 (lvalue);							\
 VOIDP_CAST (lvalue) = (void *) DEADBEEF_CONSTANT;                     \
 } while (0)
 #else
-#define xfree(lvalue,type) xfree_1 (lvalue)
+#define xfree(lvalue) xfree_1 (lvalue)
 #endif /* ERROR_CHECK_MALLOC */
 /* ------------------------ stack allocation -------------------------- */
 /* Allocating excessively large blocks on the stack can cause crashes.
 {
 MUNGE_ME_FUNCTION_KEY,
 MUNGE_ME_KEY_TRANSLATION
 };
+/* The various stages of font instantiation; initial means "find a font for
+CHARSET that matches the charset's registries" and final means "find a
+font for CHARSET that matches iso10646-1, since we haven't found a font
+that matches its registry."
+*/
+enum font_specifier_matchspec_stages
+{
+STAGE_INITIAL,
+STAGE_FINAL,
+NUM_MATCHSPEC_STAGES,
+};
 /* ------------------------------- */
 /*                misc             */
 /* ------------------------------- */
 #ifdef MEMORY_USAGE_STATS
 /* OK, you can open them again */
 END_C_DECLS
+#include "lrecord.h"
+/* Turn any void * pointer into a Lisp object.  This is the counterpart of
+STORE_LISP_IN_VOID, which works in the opposite direction.  Note that
+you CANNOT use STORE_LISP_IN_VOID to undo the effects of STORE_VOID_IN_LISP!
+Instead, you GET_VOID_FROM_LISP:
+STORE_VOID_IN_LISP <--> GET_VOID_FROM_LISP         vs.
+STORE_LISP_IN_VOID <--> GET_LISP_FROM_VOID
+STORE_VOID_IN_LISP has a restriction on the void * pointers it can
+handle -- the pointer must be an even address (lowest bit set to 0).
+Generally this is not a problem as nowadays virtually all allocation is
+at least 4-byte aligned, if not 8-byte.
+However, if this proves problematic, you can use make_opaque_ptr(), which
+is guaranteed to handle any kind of void * pointer but which does
+Lisp allocation.
+*/
+DECLARE_INLINE_HEADER (
+Lisp_Object
+STORE_VOID_IN_LISP (void *ptr)
+)
+{
+EMACS_UINT p = (EMACS_UINT) ptr;
+type_checking_assert ((p & 1) == 0);
+return make_int (p >> 1);
+}
+DECLARE_INLINE_HEADER (
+void *
+GET_VOID_FROM_LISP (Lisp_Object obj)
+)
+{
+EMACS_UINT p = XUINT (obj);
+return (void *) (p << 1);
+}
 /************************************************************************/
-/**		     Definitions of basic Lisp objects		       **/
+/**    Definitions of dynamic arrays (Dynarrs) and other allocators    **/
 /************************************************************************/
-#include "lrecord.h"
 BEGIN_C_DECLS
-/* ------------------------ dynamic arrays ------------------- */
+/************* Dynarr declaration *************/
 #ifdef NEW_GC
-#ifdef ERROR_CHECK_STRUCTURES
+#define DECLARE_DYNARR_LISP_IMP()			\
-#define Dynarr_declare(type)				\
+const struct lrecord_implementation *lisp_imp;
-struct lrecord_header header;				\
-type *base;						\
-const struct lrecord_implementation *lisp_imp;	\
-int locked;						\
-int elsize;						\
-int cur;						\
-int largest;						\
-int max
 #else
-#define Dynarr_declare(type)				\
+#define DECLARE_DYNARR_LISP_IMP()
-struct lrecord_header header;				\
+#endif
-type *base;						\
-const struct lrecord_implementation *lisp_imp;	\
+#ifdef ERROR_CHECK_DYNARR
-int elsize;						\
+#define DECLARE_DYNARR_LOCKED()				\
-int cur;						\
+int locked;
-int largest;						\
-int max
-#endif /* ERROR_CHECK_STRUCTURES */
-#else /* not NEW_GC */
-#ifdef ERROR_CHECK_STRUCTURES
-#define Dynarr_declare(type)				\
-struct lrecord_header header;				\
-type *base;						\
-int locked;						\
-int elsize;						\
-int cur;						\
-int largest;						\
-int max
 #else
-#define Dynarr_declare(type)				\
+#define DECLARE_DYNARR_LOCKED()
-struct lrecord_header header;				\
+#endif
-type *base;						\
-int elsize;						\
+#define Dynarr_declare(type)			\
-int cur;						\
+struct lrecord_header header;			\
-int largest;						\
+type *base;					\
-int max
+DECLARE_DYNARR_LISP_IMP ()			\
-#endif /* ERROR_CHECK_STRUCTURES */
+DECLARE_DYNARR_LOCKED ()			\
-#endif /* not NEW_GC */
+int elsize;					\
+int len_;					\
+int largest_;					\
+int max_
 typedef struct dynarr
 {
 Dynarr_declare (void);
 } Dynarr;
+#define XD_DYNARR_DESC(base_type, sub_desc)				\
+{ XD_BLOCK_PTR, offsetof (base_type, base),				\
+XD_INDIRECT(1, 0), {sub_desc} },					\
+{ XD_INT,        offsetof (base_type, len_) },			\
+{ XD_INT_RESET,  offsetof (base_type, largest_), XD_INDIRECT(1, 0) },	\
+{ XD_INT_RESET,  offsetof (base_type, max_), XD_INDIRECT(1, 0) }
+#ifdef NEW_GC
+#define XD_LISP_DYNARR_DESC(base_type, sub_desc)			\
+{ XD_LISP_OBJECT_BLOCK_PTR, offsetof (base_type, base),		\
+XD_INDIRECT(1, 0), {sub_desc} },					\
+{ XD_INT,        offsetof (base_type, len_) },			\
+{ XD_INT_RESET,  offsetof (base_type, largest_), XD_INDIRECT(1, 0) },	\
+{ XD_INT_RESET,  offsetof (base_type, max_), XD_INDIRECT(1, 0) }
+#endif /* NEW_GC */
+/************* Dynarr verification *************/
+#ifdef ERROR_CHECK_DYNARR
+DECLARE_INLINE_HEADER (
+int
+Dynarr_verify_pos_at (void *d, int 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. */
+assert_at_line (pos >= 0 && pos < dy->largest_, file, line);
+return pos;
+}
+DECLARE_INLINE_HEADER (
+int
+Dynarr_verify_pos_atp (void *d, int 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. */
+/* [[ Code will often do something like ...
+val = make_bit_vector_from_byte_vector (Dynarr_atp (dyn, 0),
+	                                     Dynarr_length (dyn));
+which works fine when the Dynarr_length is non-zero, but when zero,
+the result of Dynarr_atp() not only points past the end of the
+allocated array, but the array may not have ever been allocated and
+hence the return value is NULL.  But the length of 0 causes the
+pointer to never get checked.  These can occur throughout the code
+so we put in a special check. --ben ]]
+Update: The common idiom `Dynarr_atp (dyn, 0)' has been changed to
+`Dynarr_begin (dyn)'.  Possibly this special check at POS 0 can be
+done only for Dynarr_begin() not for general Dynarr_atp(). --ben */
+if (pos == 0 && dy->len_ == 0)
+return pos;
+/* #### It's vaguely possible that some code could legitimately want to
+retrieve a pointer to the position just past the end of dynarr memory.
+This could happen with Dynarr_atp() but not Dynarr_at().  If so, it
+will trigger this assert().  In such cases, it should be obvious that
+the code wants to do this; rather than relaxing the assert, we should
+probably create a new macro Dynarr_atp_allow_end() which is like
+Dynarr_atp() but which allows for pointing at invalid addresses -- we
+really want to check for cases of accessing just past the end of
+memory, which is a likely off-by-one problem to occur and will usually
+not trigger a protection fault (instead, you'll just get random
+behavior, possibly overwriting other memory, which is bad). --ben */
+assert_at_line (pos >= 0 && pos < dy->largest_, file, line);
+return pos;
+}
+DECLARE_INLINE_HEADER (
+int
+Dynarr_verify_pos_atp_allow_end (void *d, int 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.
+We also allow referencing the very end, past the end of allocated
+legitimately space.  See comments in Dynarr_verify_pos_atp.()*/
+assert_at_line (pos >= 0 && pos <= dy->largest_, file, line);
+return pos;
+}
+#else
+#define Dynarr_verify_pos_at(d, pos, file, line) (pos)
+#define Dynarr_verify_pos_atp(d, pos, file, line) (pos)
+#define Dynarr_verify_pos_atp_allow_end(d, pos, file, line) (pos)
+#endif /* ERROR_CHECK_DYNARR */
+#ifdef ERROR_CHECK_DYNARR
+DECLARE_INLINE_HEADER (
+Dynarr *
+Dynarr_verify_1 (void *d, const Ascbyte *file, int line)
+)
+{
+Dynarr *dy = (Dynarr *) d;
+assert_at_line (dy->len_ >= 0 && dy->len_ <= dy->largest_ &&
+		  dy->largest_ <= dy->max_, file, line);
+return dy;
+}
+DECLARE_INLINE_HEADER (
+Dynarr *
+Dynarr_verify_mod_1 (void *d, const Ascbyte *file, int line)
+)
+{
+Dynarr *dy = (Dynarr *) d;
+assert_at_line (!dy->locked, file, line);
+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 {						\
+Dynarr *dy = Dynarr_verify_mod (d);		\
+dy->locked = 1;				\
+} while (0)
+#define Dynarr_unlock(d)			\
+do {						\
+Dynarr *dy = Dynarr_verify (d);		\
+dy->locked = 0;				\
+} while (0)
+#else
+#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);
-MODULE_API void Dynarr_resize (void *dy, Elemcount size);
-MODULE_API void Dynarr_insert_many (void *d, const void *el, int len, int start);
-MODULE_API void Dynarr_delete_many (void *d, int start, int len);
 MODULE_API void Dynarr_free (void *d);
 #ifdef NEW_GC
 MODULE_API void *Dynarr_lisp_newf (Bytecount elsize,
 				   const struct lrecord_implementation
 ((dynarr_type *) Dynarr_lisp_newf (sizeof (type)), dynarr_imp, imp)
 #endif /* NEW_GC */
 #define Dynarr_new(type) ((type##_dynarr *) Dynarr_newf (sizeof (type)))
 #define Dynarr_new2(dynarr_type, type) \
 ((dynarr_type *) Dynarr_newf (sizeof (type)))
+/************* Dynarr access *************/
+#ifdef ERROR_CHECK_DYNARR
+#define Dynarr_at(d, pos) \
+((d)->base[Dynarr_verify_pos_at (d, pos, __FILE__, __LINE__)])
+#define Dynarr_atp_allow_end(d, pos) \
+(&((d)->base[Dynarr_verify_pos_atp_allow_end (d, pos, __FILE__, __LINE__)]))
+#define Dynarr_atp(d, pos) \
+(&((d)->base[Dynarr_verify_pos_atp (d, pos, __FILE__, __LINE__)]))
+#else
 #define Dynarr_at(d, pos) ((d)->base[pos])
 #define Dynarr_atp(d, pos) (&Dynarr_at (d, pos))
+#define Dynarr_atp_allow_end(d, pos) Dynarr_atp (d, pos)
+#endif
+/* Old #define Dynarr_atp(d, pos) (&Dynarr_at (d, pos)) */
 #define Dynarr_begin(d) Dynarr_atp (d, 0)
-#define Dynarr_end(d) Dynarr_atp (d, Dynarr_length (d) - 1)
+#define Dynarr_lastp(d) Dynarr_atp (d, Dynarr_length (d) - 1)
-#define Dynarr_sizeof(d) ((d)->cur * (d)->elsize)
+#define Dynarr_past_lastp(d) Dynarr_atp_allow_end (d, Dynarr_length (d))
-#ifdef ERROR_CHECK_STRUCTURES
-DECLARE_INLINE_HEADER (
+/************* Dynarr length/size retrieval and setting *************/
-Dynarr *
-Dynarr_verify_1 (void *d, const Ascbyte *file, int line)
+/* 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)
-Dynarr *dy = (Dynarr *) d;
+/* Retrieve the largest ever length seen of a Dynarr.  The `+ 0' is to
-assert_at_line (dy->cur >= 0 && dy->cur <= dy->largest &&
+ensure that this cannot be used as an lvalue. */
-		  dy->largest <= dy->max, file, line);
+#define Dynarr_largest(d) (Dynarr_verify (d)->largest_ + 0)
-return dy;
+/* 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)
-DECLARE_INLINE_HEADER (
+/* Retrieve the advertised memory usage of a Dynarr, i.e. the number of
-Dynarr *
+bytes occupied by the elements in the Dynarr, not counting any overhead. */
-Dynarr_verify_mod_1 (void *d, const Ascbyte *file, int line)
+#define Dynarr_sizeof(d) (Dynarr_length (d) * (d)->elsize)
-)
+/* Actually set the length of a Dynarr.  This is a low-level routine that
-{
+should not be directly used; use Dynarr_set_length() instead if you need
-Dynarr *dy = (Dynarr *) d;
+to, but be very careful when doing so! */
-assert_at_line (!dy->locked, file, line);
+#define Dynarr_set_length_1(d, n)					\
-assert_at_line (dy->cur >= 0 && dy->cur <= dy->largest &&
+do {									\
-		  dy->largest <= dy->max, file, line);
+Elemcount _dsl1_n = (n);						\
-return dy;
+dynarr_checking_assert (_dsl1_n >= 0 && _dsl1_n <= Dynarr_max (d));	\
-}
+(void) Dynarr_verify_mod (d);						\
+(d)->len_ = _dsl1_n;							\
-#define Dynarr_verify(d) Dynarr_verify_1 (d, __FILE__, __LINE__)
+/* Use the raw field references here otherwise we get a crash because	\
-#define Dynarr_verify_mod(d) Dynarr_verify_mod_1 (d, __FILE__, __LINE__)
+we've set the length but not yet fixed up the largest value. */	\
-#define Dynarr_lock(d) (Dynarr_verify_mod (d)->locked = 1)
+if ((d)->len_ > (d)->largest_)					\
-#define Dynarr_unlock(d) ((d)->locked = 0)
+(d)->largest_ = (d)->len_;						\
-#else
+(void) Dynarr_verify_mod (d);						\
-#define Dynarr_verify(d) (d)
+} while (0)
-#define Dynarr_verify_mod(d) (d)
-#define Dynarr_lock(d)
+/* The following two defines will get you into real trouble if you aren't
-#define Dynarr_unlock(d)
+careful.  But they can save a lot of execution time when used wisely. */
-#endif /* ERROR_CHECK_STRUCTURES */
+#define Dynarr_set_length(d, n)						\
+do {									\
-#define Dynarr_length(d) (Dynarr_verify (d)->cur)
+Elemcount _dsl_n = (n);						\
-#define Dynarr_largest(d) (Dynarr_verify (d)->largest)
+dynarr_checking_assert (_dsl_n >= 0 && _dsl_n <= Dynarr_largest (d)); \
-#define Dynarr_reset(d) (Dynarr_verify_mod (d)->cur = 0)
+Dynarr_set_length_1 (d, _dsl_n);					\
-#define Dynarr_add_many(d, el, len) Dynarr_insert_many (d, el, len, (d)->cur)
+} while (0)
+#define Dynarr_increment(d) \
+Dynarr_set_length (d, Dynarr_length (d) + 1)
+/* Reset the Dynarr's length to 0. */
+#define Dynarr_reset(d) Dynarr_set_length (d, 0)
+MODULE_API void Dynarr_resize (void *dy, Elemcount size);
+#define Dynarr_resize_if(d, numels)			\
+do {							\
+Elemcount _dri_numels = (numels);			\
+if (Dynarr_length (d) + _dri_numels > Dynarr_max (d))	\
+Dynarr_resize (d, Dynarr_length (d) + _dri_numels);	\
+} while (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 *************/
+#ifdef NEW_GC
+#define Dynarr_add(d, el)						\
+do {									\
+const struct lrecord_implementation *imp = (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);	\
+Dynarr_set_length_1 (d, Dynarr_length (d) + 1);			\
+(void) Dynarr_verify_mod (d);						\
+} while (0)
+#else /* not NEW_GC */
+#define Dynarr_add(d, el)				\
+do {							\
+(void) Dynarr_verify_mod (d);				\
+Dynarr_resize_if (d, 1);				\
+((d)->base)[Dynarr_length (d)] = (el);		\
+Dynarr_set_length_1 (d, Dynarr_length (d) + 1);	\
+(void) Dynarr_verify_mod (d);				\
+} while (0)
+#endif /* not NEW_GC */
+MODULE_API void Dynarr_insert_many (void *d, const void *el, int len,
+				    int start);
+MODULE_API void Dynarr_delete_many (void *d, int start, int len);
 #define Dynarr_insert_many_at_start(d, el, len)	\
 Dynarr_insert_many (d, el, len, 0)
 #define Dynarr_add_literal_string(d, s) Dynarr_add_many (d, s, sizeof (s) - 1)
 #define Dynarr_add_lisp_string(d, s, codesys)			\
 do {								\
 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)
-#ifdef NEW_GC
+/* Add LEN contiguous elements to a Dynarr */
-#define Dynarr_add(d, el)					\
-do {								\
+DECLARE_INLINE_HEADER (
-const struct lrecord_implementation *imp = (d)->lisp_imp;	\
+void
-if (Dynarr_verify_mod (d)->cur >= (d)->max)			\
+Dynarr_add_many (void *d, const void *el, int len)
-Dynarr_resize ((d), (d)->cur+1);				\
+)
-((d)->base)[(d)->cur] = (el);					\
+{
-								\
+/* This duplicates Dynarr_insert_many to some extent; but since it is
-if (imp)							\
+called so often, it seemed useful to remove the unnecessary stuff
-set_lheader_implementation					\
+from that function and to make it inline */
-((struct lrecord_header *)&(((d)->base)[(d)->cur]), imp);	\
+Dynarr *dy = Dynarr_verify_mod (d);
-								\
+Dynarr_resize_if (dy, len);
-(d)->cur++;							\
+/* Some functions call us with a value of 0 to mean "reserve space but
-if ((d)->cur > (d)->largest)					\
+don't write into it" */
-(d)->largest = (d)->cur;					\
+if (el)
-} while (0)
+memcpy ((char *) dy->base + Dynarr_sizeof (dy), el, len*dy->elsize);
-#else /* not NEW_GC */
+Dynarr_set_length_1 (dy, Dynarr_length (dy) + len);
-#define Dynarr_add(d, el) (						     \
+(void) Dynarr_verify_mod (dy);
-Dynarr_verify_mod (d)->cur >= (d)->max ? Dynarr_resize ((d), (d)->cur+1) : \
+}
-(void) 0,								     \
-((d)->base)[(d)->cur++] = (el),					     \
-(d)->cur > (d)->largest ? (d)->largest = (d)->cur : (int) 0)
-#endif /* not NEW_GC */
-/* The following defines will get you into real trouble if you aren't
-careful.  But they can save a lot of execution time when used wisely. */
-#define Dynarr_increment(d) (Dynarr_verify_mod (d)->cur++)
-#define Dynarr_set_size(d, n) (Dynarr_verify_mod (d)->cur = n)
 #define Dynarr_pop(d)					\
-(assert ((d)->cur > 0), Dynarr_verify_mod (d)->cur--,	\
+(dynarr_checking_assert (Dynarr_length (d) > 0),	\
-Dynarr_at (d, (d)->cur))
+Dynarr_verify_mod (d)->len_--,			\
+Dynarr_at (d, Dynarr_length (d)))
 #define Dynarr_delete(d, i) Dynarr_delete_many (d, i, 1)
 #define Dynarr_delete_by_pointer(d, p) \
 Dynarr_delete_many (d, (p) - ((d)->base), 1)
 #define Dynarr_delete_object(d, el)		\
 if (el == Dynarr_at (d, i))		\
 	Dynarr_delete_many (d, i, 1);		\
 }						\
 } while (0)
-#ifdef MEMORY_USAGE_STATS
+/************* Dynarr typedefs *************/
-struct overhead_stats;
-Bytecount Dynarr_memory_usage (void *d, struct overhead_stats *stats);
-#endif
-void *stack_like_malloc (Bytecount size);
-void stack_like_free (void *val);
-/* ------------------------------- */
-/*         Dynarr typedefs         */
-/* ------------------------------- */
 /* Dynarr typedefs -- basic types first */
 typedef struct
 {
 typedef unsigned long unsigned_long;
 typedef struct
 {
 Dynarr_declare (unsigned long);
 } unsigned_long_dynarr;
+typedef const Ascbyte *const_Ascbyte_ptr;
+typedef struct
+{
+Dynarr_declare (const Ascbyte *);
+} const_Ascbyte_ptr_dynarr;
+extern const struct sized_memory_description const_Ascbyte_ptr_description;
+extern const struct sized_memory_description const_Ascbyte_ptr_dynarr_description;
 typedef struct
 {
 Dynarr_declare (int);
 } int_dynarr;
 typedef struct
 {
 Dynarr_declare (Lisp_Object *);
 } Lisp_Object_ptr_dynarr;
+/************* Stack-like malloc/free: Another allocator *************/
+void *stack_like_malloc (Bytecount size);
+void stack_like_free (void *val);
+/************************************************************************/
+/**              Definitions of other basic Lisp objects               **/
+/************************************************************************/
 /*------------------------------ unbound -------------------------------*/
 /* Qunbound is a special Lisp_Object (actually of type
 symbol-value-forward), that can never be visible to
 #define DECLARE_INLINE_LISP_BIT_VECTOR(numbits) struct {	\
 LISP_OBJECT_HEADER lheader;				        \
 Elemcount size;						\
 unsigned long bits[BIT_VECTOR_LONG_STORAGE(numbits)];		\
 }
+/*---------------------- array, sequence -----------------------------*/
+#define ARRAYP(x) (VECTORP (x) || STRINGP (x) || BIT_VECTORP (x))
+#define CHECK_ARRAY(x) do {			\
+if (!ARRAYP (x))				\
+dead_wrong_type_argument (Qarrayp, x);	\
+} while (0)
+#define CONCHECK_ARRAY(x) do {			\
+if (!ARRAYP (x))				\
+x = wrong_type_argument (Qarrayp, x);	\
+} while (0)
+#define SEQUENCEP(x) (LISTP (x) || ARRAYP (x))
+#define CHECK_SEQUENCE(x) do {			\
+if (!SEQUENCEP (x))				\
+dead_wrong_type_argument (Qsequencep, x);	\
+} while (0)
+#define CONCHECK_SEQUENCE(x) do {		\
+if (!SEQUENCEP (x))				\
+x = wrong_type_argument (Qsequencep, x);	\
+} while (0)
 /*------------------------------ symbol --------------------------------*/
 typedef struct Lisp_Symbol Lisp_Symbol;
 struct Lisp_Symbol
 #define HASH6(a,b,c,d,e,f)       (GOOD_HASH * HASH5 (a,b,c,d,e)       + (f))
 #define HASH7(a,b,c,d,e,f,g)     (GOOD_HASH * HASH6 (a,b,c,d,e,f)     + (g))
 #define HASH8(a,b,c,d,e,f,g,h)   (GOOD_HASH * HASH7 (a,b,c,d,e,f,g)   + (h))
 #define HASH9(a,b,c,d,e,f,g,h,i) (GOOD_HASH * HASH8 (a,b,c,d,e,f,g,h) + (i))
-#define LISP_HASH(obj) ((unsigned long) LISP_TO_VOID (obj))
+#define LISP_HASH(obj) ((unsigned long) STORE_LISP_IN_VOID (obj))
 Hashcode memory_hash (const void *xv, Bytecount size);
 Hashcode internal_hash (Lisp_Object obj, int depth);
 Hashcode internal_array_hash (Lisp_Object *arr, int size, int depth);
 Fformat() should format the untranslated args[0] and return that,
 and also call Fgettext() on args[0] and, if that is different,
 format it and store it in the `string-translatable' property of the
 returned string.  See Fgettext().
-CGETTEXT() is the same as GETTEXT() but works with char * strings
+The variations IGETTEXT, CIGETTEXT and ASCGETTEXT operate on
-instead of Ibyte * strings.
+Ibyte *, CIbyte *, and Ascbyte * strings, respectively.  The
+ASCGETTEXT version has an assert check to verify that its string
-build_msg_string() is a shorthand for build_string (GETTEXT (x)).
+really is pure-ASCII.  Plain GETTEXT is defined as ASCGETTEXT, and
-build_msg_intstring() is a shorthand for build_intstring (GETTEXT (x)).
+so works the same way. (There are no versions that work for Extbyte *.
+Translate to internal format before working on it.)
+There are similar functions for building a Lisp string from a C
+string and translating in the process.  They again come in three
+variants: build_msg_istring(), build_msg_cistring(), and
+build_msg_ascstring().  Again, build_msg_ascstring() asserts that
+its text is pure-ASCII, and build_msg_string() is the same as
+build_msg_ascstring().
 */
-#define GETTEXT(x) (x)
+/* Return value NOT Ascbyte, because the result in general will have been
-#define CGETTEXT(x) (x)
+translated into a foreign language. */
-#define LISP_GETTEXT(x) (x)
+DECLARE_INLINE_HEADER (const CIbyte *ASCGETTEXT (const Ascbyte *s))
+{
-/* DEFER_GETTEXT is used to identify strings which are translated when
+ASSERT_ASCTEXT_ASCII (s);
-they are referenced instead of when they are defined.
+return s;
-These include Qerror_messages and initialized arrays of strings.
+}
+DECLARE_INLINE_HEADER (const Ibyte *IGETTEXT (const Ibyte *s))
+{
+return s;
+}
+DECLARE_INLINE_HEADER (const CIbyte *CIGETTEXT (const CIbyte *s))
+{
+return s;
+}
+DECLARE_INLINE_HEADER (Lisp_Object LISP_GETTEXT (Lisp_Object s))
+{
+return s;
+}
+#define GETTEXT ASCGETTEXT
+MODULE_API Lisp_Object build_msg_istring (const Ibyte *);
+MODULE_API Lisp_Object build_msg_cistring (const CIbyte *);
+MODULE_API Lisp_Object build_msg_ascstring (const Ascbyte *);
+#define build_msg_string build_msg_ascstring
+/* DEFER_GETTEXT() and variants are used to identify strings which are not
+meant to be translated immediately, but instead at some later time.
+This is used in strings that are stored somewhere at dump or
+initialization time, at a time when the current language environment is
+not set.  It is the duty of the user of the string to call GETTEXT or
+some variant at the appropriate time.  DEFER_GETTTEXT() serves only as a
+marker that the string is translatable, and will as a result be snarfed
+during message snarfing (see above).
+build_defer_string() and variants are the deferred equivalents of
+build_msg_string() and variants.  Similarly to DEFER_GETTEXT(), they
+don't actually do any translation, but serve as place markers for
+message snarfing.  However, they may do something more than just build
+a Lisp string -- in particular, they may store a string property
+indicating that the string is translatable (see discussion above about
+this property).
 */
-#define DEFER_GETTEXT(x) (x)
+DECLARE_INLINE_HEADER (const Ascbyte *DEFER_ASCGETTEXT (const Ascbyte *s))
+{
+ASSERT_ASCTEXT_ASCII (s);
+return s;
+}
+DECLARE_INLINE_HEADER (const Ibyte *DEFER_IGETTEXT (const Ibyte *s))
+{
+return s;
+}
+DECLARE_INLINE_HEADER (const CIbyte *DEFER_CIGETTEXT (const CIbyte *s))
+{
+return s;
+}
+#define DEFER_GETTEXT DEFER_ASCGETTEXT
+MODULE_API Lisp_Object build_defer_istring (const Ibyte *);
+MODULE_API Lisp_Object build_defer_cistring (const CIbyte *);
+MODULE_API Lisp_Object build_defer_ascstring (const Ascbyte *);
+#define build_defer_string build_defer_ascstring
+void write_msg_istring (Lisp_Object stream, const Ibyte *str);
+void write_msg_cistring (Lisp_Object stream, const CIbyte *str);
+void write_msg_ascstring (Lisp_Object stream, const Ascbyte *str);
+#define write_msg_string write_msg_ascstring
 /************************************************************************/
 /*		     Garbage collection / GC-protection			*/
 /************************************************************************/
 extern Lisp_Object_ptr_dynarr *staticpros_nodump;
 #ifdef DEBUG_XEMACS
 /* Help debug crashes gc-marking a staticpro'ed object. */
-MODULE_API void staticpro_1 (Lisp_Object *, Ascbyte *);
+MODULE_API void staticpro_1 (Lisp_Object *, const Ascbyte *);
-MODULE_API void staticpro_nodump_1 (Lisp_Object *, Ascbyte *);
+MODULE_API void staticpro_nodump_1 (Lisp_Object *, const Ascbyte *);
-/* g++ 4.3 complains about the conversion of const char to char.
+#define staticpro(ptr) staticpro_1 (ptr, #ptr)
-These end up in a dynarray, so we would need to define a whole new class
+#define staticpro_nodump(ptr) staticpro_nodump_1 (ptr, #ptr)
-of dynarray just to handle the const char stuff.
-####Check to see how hard this might be. */
-#define staticpro(ptr) staticpro_1 (ptr, (Ascbyte *) #ptr)
-#define staticpro_nodump(ptr) staticpro_nodump_1 (ptr, (Ascbyte *) #ptr)
 #ifdef HAVE_SHLIB
-MODULE_API void unstaticpro_nodump_1 (Lisp_Object *, Ascbyte *);
+MODULE_API void unstaticpro_nodump_1 (Lisp_Object *, const Ascbyte *);
-#define unstaticpro_nodump(ptr) unstaticpro_nodump_1 (ptr, (Ascbyte *) #ptr)
+#define unstaticpro_nodump(ptr) unstaticpro_nodump_1 (ptr, #ptr)
 #endif
 #else
 /* Call staticpro (&var) to protect static variable `var'. */
 MODULE_API void staticpro (Lisp_Object *);
+/* staticpro_1 (varptr, name) is used when we're not directly calling
+staticpro() on the address of a Lisp variable, but on a pointer we
+got from elsewhere.  In that case, NAME is a string describing the
+actual variable in question.  NAME is used only for debugging purposes,
+and hence when not DEBUG_XEMACS, staticpro_1() just calls staticpro().
+With DEBUG_XEMACS, however, it's the reverse -- staticpro() calls
+staticpro_1(), using the ANSI "stringize" operator to construct a string
+out of the variable name. */
+#define staticpro_1(ptr, name) staticpro (ptr)
 /* Call staticpro_nodump (&var) to protect static variable `var'. */
 /* var will not be saved at dump time */
 MODULE_API void staticpro_nodump (Lisp_Object *);
+#define staticpro_nodump_1(ptr, name) staticpro_nodump (ptr)
 #ifdef HAVE_SHLIB
 /* Call unstaticpro_nodump (&var) to stop protecting static variable `var'. */
 MODULE_API void unstaticpro_nodump (Lisp_Object *);
 #endif
 #ifdef NEW_GC
 extern Lisp_Object_dynarr *mcpros;
 #ifdef DEBUG_XEMACS
 /* Help debug crashes gc-marking a mcpro'ed object. */
-MODULE_API void mcpro_1 (Lisp_Object, char *);
+MODULE_API void mcpro_1 (Lisp_Object, const Ascbyte *);
 #define mcpro(ptr) mcpro_1 (ptr, #ptr)
 #else /* not DEBUG_XEMACS */
 /* Call mcpro (&var) to protect mc variable `var'. */
 MODULE_API void mcpro (Lisp_Object);
 #endif /* not DEBUG_XEMACS */
 /************************************************************************/
 /************************************************************************/
 /*		             Other numeric types      	                */
 /************************************************************************/
-#ifdef WITH_NUMBER_TYPES
 #include "number.h"
-#else
-#define make_integer(x) make_int(x)
-#endif
 /************************************************************************/
 /*                              prototypes                              */
 /************************************************************************/
 MODULE_API EXFUN (Fexpand_abbrev, 0);
 /* Defined in alloc.c */
 MODULE_API EXFUN (Fcons, 2);
 MODULE_API EXFUN (Flist, MANY);
+EXFUN (Fbit_vector, MANY);
 EXFUN (Fmake_byte_code, MANY);
 MODULE_API EXFUN (Fmake_list, 2);
 MODULE_API EXFUN (Fmake_string, 2);
+EXFUN (Fstring, MANY);
 MODULE_API EXFUN (Fmake_symbol, 1);
 MODULE_API EXFUN (Fmake_vector, 2);
 MODULE_API EXFUN (Fvector, MANY);
 #ifndef NEW_GC
 extern EMACS_INT gc_generation_number[1];
 #endif /* not NEW_GC */
 int c_readonly (Lisp_Object);
 int lisp_readonly (Lisp_Object);
 MODULE_API void copy_lisp_object (Lisp_Object dst, Lisp_Object src);
-MODULE_API Lisp_Object build_intstring (const Ibyte *);
+MODULE_API Lisp_Object build_istring (const Ibyte *);
-MODULE_API Lisp_Object build_string (const CIbyte *);
+MODULE_API Lisp_Object build_cistring (const CIbyte *);
-MODULE_API Lisp_Object build_ext_string (const Extbyte *, Lisp_Object);
+MODULE_API Lisp_Object build_ascstring (const Ascbyte *);
-MODULE_API Lisp_Object build_msg_intstring (const Ibyte *);
+MODULE_API Lisp_Object build_extstring (const Extbyte *, Lisp_Object);
-MODULE_API Lisp_Object build_msg_string (const CIbyte *);
 MODULE_API Lisp_Object make_string (const Ibyte *, Bytecount);
-MODULE_API Lisp_Object make_ext_string (const Extbyte *, EMACS_INT, Lisp_Object);
+MODULE_API Lisp_Object make_extstring (const Extbyte *, EMACS_INT, Lisp_Object);
 void init_string_ascii_begin (Lisp_Object string);
 Lisp_Object make_uninit_string (Bytecount);
 MODULE_API Lisp_Object make_float (double);
 Lisp_Object make_string_nocopy (const Ibyte *, Bytecount);
 void free_cons (Lisp_Object);
 /* Defined in bytecode.c */
 EXFUN (Fbyte_code, 3);
 DECLARE_DOESNT_RETURN (invalid_byte_code
-		       (const CIbyte *reason, Lisp_Object frob));
+		       (const Ascbyte *reason, Lisp_Object frob));
+extern Lisp_Object Qbyte_code, Qinvalid_byte_code;
 /* Defined in callint.c */
 EXFUN (Fcall_interactively, 3);
 EXFUN (Fprefix_numeric_value, 1);
 /* Defined in casefiddle.c */
 EXFUN (Fdowncase, 2);
+EXFUN (Fcanoncase, 2);
 EXFUN (Fupcase, 2);
 EXFUN (Fupcase_initials, 2);
 EXFUN (Fupcase_initials_region, 3);
 EXFUN (Fupcase_region, 3);
 /* Do NOT use word_to_lisp or wasteful_word_to_lisp to decode time_t's
 unless you KNOW arg is non-negative.  They cannot return negative
 values!  Use make_time.  */
 Lisp_Object word_to_lisp (unsigned int);
 unsigned int lisp_to_word (Lisp_Object);
+extern Lisp_Object Qarrayp, Qbitp, Qchar_or_string_p, Qcharacterp,
+Qerror_conditions, Qerror_message, Qinteger_char_or_marker_p,
+Qinteger_or_char_p, Qinteger_or_marker_p, Qlambda, Qlistp, Qnatnump,
+Qnonnegativep, Qnumber_char_or_marker_p, Qnumberp, Qquote, Qtrue_list_p;
+extern MODULE_API Lisp_Object Qintegerp;
+extern Lisp_Object Qarith_error, Qbeginning_of_buffer, Qbuffer_read_only,
+Qcircular_list, Qcircular_property_list, Qconversion_error,
+Qcyclic_variable_indirection, Qdomain_error, Qediting_error,
+Qend_of_buffer, Qend_of_file, Qerror, Qfile_error, Qinternal_error,
+Qinvalid_change, Qinvalid_constant, Qinvalid_function, Qinvalid_operation,
+Qinvalid_read_syntax, Qinvalid_state, Qio_error, Qlist_formation_error,
+Qmalformed_list, Qmalformed_property_list, Qno_catch, Qout_of_memory,
+Qoverflow_error, Qprinting_unreadable_object, Qquit, Qrange_error,
+Qsetting_constant, Qsingularity_error, Qstack_overflow,
+Qstructure_formation_error, Qtext_conversion_error, Qunderflow_error,
+Qvoid_function, Qvoid_variable, Qwrong_number_of_arguments,
+Qwrong_type_argument;
+extern MODULE_API Lisp_Object Qinvalid_argument, Qsyntax_error;
 /* Defined in dired.c */
 Lisp_Object make_directory_hash_table (const Ibyte *);
 Lisp_Object wasteful_word_to_lisp (unsigned int);
 extern int inhibit_non_essential_conversion_operations;
 extern int preparing_for_armageddon;
 extern Fixnum emacs_priority;
 extern int suppress_early_error_handler_backtrace;
 void debug_break (void);
-int debug_can_access_memory (void *ptr, Bytecount len);
+int debug_can_access_memory (const void *ptr, Bytecount len);
 DECLARE_DOESNT_RETURN (really_abort (void));
 void zero_out_command_line_status_vars (void);
 /* Defined in emodules.c */
 #ifdef HAVE_SHLIB
 Lisp_Object maybe_signal_continuable_ferror (Lisp_Object, Lisp_Object,
 					     Error_Behavior,
 					     const CIbyte *, ...)
 PRINTF_ARGS (4, 5);
-Lisp_Object build_error_data (const CIbyte *reason, Lisp_Object frob);
+Lisp_Object build_error_data (const Ascbyte *reason, Lisp_Object frob);
-DECLARE_DOESNT_RETURN (signal_error (Lisp_Object, const CIbyte *,
+DECLARE_DOESNT_RETURN (signal_error (Lisp_Object, const Ascbyte *,
 				     Lisp_Object));
-void maybe_signal_error (Lisp_Object, const CIbyte *, Lisp_Object,
+void maybe_signal_error (Lisp_Object, const Ascbyte *, Lisp_Object,
 			 Lisp_Object, Error_Behavior);
-Lisp_Object signal_continuable_error (Lisp_Object, const CIbyte *,
+Lisp_Object signal_continuable_error (Lisp_Object, const Ascbyte *,
 				      Lisp_Object);
-Lisp_Object maybe_signal_continuable_error (Lisp_Object, const CIbyte *,
+Lisp_Object maybe_signal_continuable_error (Lisp_Object, const Ascbyte *,
 					    Lisp_Object,
 					    Lisp_Object, Error_Behavior);
 DECLARE_DOESNT_RETURN (signal_ferror_with_frob (Lisp_Object, Lisp_Object,
-						const CIbyte *, ...))
+						const Ascbyte *, ...))
 PRINTF_ARGS(3, 4);
 void maybe_signal_ferror_with_frob (Lisp_Object, Lisp_Object, Lisp_Object,
 				    Error_Behavior,
-				    const CIbyte *, ...) PRINTF_ARGS (5, 6);
+				    const Ascbyte *, ...) PRINTF_ARGS (5, 6);
 Lisp_Object signal_continuable_ferror_with_frob (Lisp_Object, Lisp_Object,
-						 const CIbyte *,
+						 const Ascbyte *,
 						 ...) PRINTF_ARGS (3, 4);
 Lisp_Object maybe_signal_continuable_ferror_with_frob (Lisp_Object,
 						       Lisp_Object,
 						       Lisp_Object,
 						       Error_Behavior,
-						       const CIbyte *, ...)
+						       const Ascbyte *, ...)
 PRINTF_ARGS (5, 6);
-DECLARE_DOESNT_RETURN (signal_error_2 (Lisp_Object, const CIbyte *,
+DECLARE_DOESNT_RETURN (signal_error_2 (Lisp_Object, const Ascbyte *,
 				       Lisp_Object, Lisp_Object));
-void maybe_signal_error_2 (Lisp_Object, const CIbyte *, Lisp_Object,
+void maybe_signal_error_2 (Lisp_Object, const Ascbyte *, Lisp_Object,
 			   Lisp_Object, Lisp_Object, Error_Behavior);
-Lisp_Object signal_continuable_error_2 (Lisp_Object, const CIbyte *,
+Lisp_Object signal_continuable_error_2 (Lisp_Object, const Ascbyte *,
 					Lisp_Object, Lisp_Object);
-Lisp_Object maybe_signal_continuable_error_2 (Lisp_Object, const CIbyte *,
+Lisp_Object maybe_signal_continuable_error_2 (Lisp_Object, const Ascbyte *,
 					      Lisp_Object, Lisp_Object,
 					      Lisp_Object,
 					      Error_Behavior);
 				  (Lisp_Object));
 MODULE_API DECLARE_DOESNT_RETURN (signal_circular_list_error (Lisp_Object));
 MODULE_API DECLARE_DOESNT_RETURN (signal_circular_property_list_error
 				  (Lisp_Object));
-DECLARE_DOESNT_RETURN (syntax_error (const CIbyte *reason,
+DECLARE_DOESNT_RETURN (syntax_error (const Ascbyte *reason,
 				     Lisp_Object frob));
-DECLARE_DOESNT_RETURN (syntax_error_2 (const CIbyte *reason,
+DECLARE_DOESNT_RETURN (syntax_error_2 (const Ascbyte *reason,
 				       Lisp_Object frob1,
 				       Lisp_Object frob2));
-void maybe_syntax_error (const CIbyte *, Lisp_Object, Lisp_Object,
+void maybe_syntax_error (const Ascbyte *, Lisp_Object, Lisp_Object,
 			 Error_Behavior);
-DECLARE_DOESNT_RETURN (sferror (const CIbyte *reason, Lisp_Object frob));
+DECLARE_DOESNT_RETURN (sferror (const Ascbyte *reason, Lisp_Object frob));
-DECLARE_DOESNT_RETURN (sferror_2 (const CIbyte *reason, Lisp_Object frob1,
+DECLARE_DOESNT_RETURN (sferror_2 (const Ascbyte *reason, Lisp_Object frob1,
 				  Lisp_Object frob2));
-void maybe_sferror (const CIbyte *, Lisp_Object, Lisp_Object,
+void maybe_sferror (const Ascbyte *, Lisp_Object, Lisp_Object,
 		    Error_Behavior);
-MODULE_API DECLARE_DOESNT_RETURN (invalid_argument (const CIbyte *reason,
+MODULE_API DECLARE_DOESNT_RETURN (invalid_argument (const Ascbyte *reason,
 						    Lisp_Object frob));
-MODULE_API DECLARE_DOESNT_RETURN (invalid_argument_2 (const CIbyte *reason,
+MODULE_API DECLARE_DOESNT_RETURN (invalid_argument_2 (const Ascbyte *reason,
 						      Lisp_Object frob1,
 						      Lisp_Object frob2));
-void maybe_invalid_argument (const CIbyte *, Lisp_Object, Lisp_Object,
+void maybe_invalid_argument (const Ascbyte *, Lisp_Object, Lisp_Object,
 			     Error_Behavior);
-MODULE_API DECLARE_DOESNT_RETURN (invalid_operation (const CIbyte *reason,
+MODULE_API DECLARE_DOESNT_RETURN (invalid_operation (const Ascbyte *reason,
 						     Lisp_Object frob));
-MODULE_API DECLARE_DOESNT_RETURN (invalid_operation_2 (const CIbyte *reason,
+MODULE_API DECLARE_DOESNT_RETURN (invalid_operation_2 (const Ascbyte *reason,
 						       Lisp_Object frob1,
 						       Lisp_Object frob2));
-MODULE_API void maybe_invalid_operation (const CIbyte *, Lisp_Object,
+MODULE_API void maybe_invalid_operation (const Ascbyte *, Lisp_Object,
 					 Lisp_Object, Error_Behavior);
-DECLARE_DOESNT_RETURN (invalid_state (const CIbyte *reason,
+DECLARE_DOESNT_RETURN (invalid_state (const Ascbyte *reason,
 					 Lisp_Object frob));
-DECLARE_DOESNT_RETURN (invalid_state_2 (const CIbyte *reason,
+DECLARE_DOESNT_RETURN (invalid_state_2 (const Ascbyte *reason,
 					   Lisp_Object frob1,
 					   Lisp_Object frob2));
-void maybe_invalid_state (const CIbyte *, Lisp_Object, Lisp_Object,
+void maybe_invalid_state (const Ascbyte *, Lisp_Object, Lisp_Object,
 			  Error_Behavior);
-DECLARE_DOESNT_RETURN (invalid_change (const CIbyte *reason,
+DECLARE_DOESNT_RETURN (invalid_change (const Ascbyte *reason,
 					 Lisp_Object frob));
-DECLARE_DOESNT_RETURN (invalid_change_2 (const CIbyte *reason,
+DECLARE_DOESNT_RETURN (invalid_change_2 (const Ascbyte *reason,
 					   Lisp_Object frob1,
 					   Lisp_Object frob2));
-void maybe_invalid_change (const CIbyte *, Lisp_Object, Lisp_Object,
+void maybe_invalid_change (const Ascbyte *, Lisp_Object, Lisp_Object,
 			   Error_Behavior);
-MODULE_API DECLARE_DOESNT_RETURN (invalid_constant (const CIbyte *reason,
+MODULE_API DECLARE_DOESNT_RETURN (invalid_constant (const Ascbyte *reason,
 						    Lisp_Object frob));
-DECLARE_DOESNT_RETURN (invalid_constant_2 (const CIbyte *reason,
+DECLARE_DOESNT_RETURN (invalid_constant_2 (const Ascbyte *reason,
 					   Lisp_Object frob1,
 					   Lisp_Object frob2));
-void maybe_invalid_constant (const CIbyte *, Lisp_Object, Lisp_Object,
+void maybe_invalid_constant (const Ascbyte *, Lisp_Object, Lisp_Object,
 			     Error_Behavior);
-DECLARE_DOESNT_RETURN (wtaerror (const CIbyte *reason, Lisp_Object frob));
+DECLARE_DOESNT_RETURN (wtaerror (const Ascbyte *reason, Lisp_Object frob));
-MODULE_API DECLARE_DOESNT_RETURN (out_of_memory (const CIbyte *reason,
+MODULE_API DECLARE_DOESNT_RETURN (out_of_memory (const Ascbyte *reason,
 						 Lisp_Object frob));
-DECLARE_DOESNT_RETURN (stack_overflow (const CIbyte *reason,
+DECLARE_DOESNT_RETURN (stack_overflow (const Ascbyte *reason,
 				       Lisp_Object frob));
-MODULE_API DECLARE_DOESNT_RETURN (printing_unreadable_object (const CIbyte *,
-							      ...))
-PRINTF_ARGS (1, 2);
 Lisp_Object signal_void_function_error (Lisp_Object);
 Lisp_Object signal_invalid_function_error (Lisp_Object);
 Lisp_Object signal_wrong_number_of_arguments_error (Lisp_Object, int);
 int internal_bind_int (int *addr, int newval);
 int internal_bind_lisp_object (Lisp_Object *addr, Lisp_Object newval);
 void do_autoload (Lisp_Object, Lisp_Object); /* GCPROs both arguments */
 Lisp_Object un_autoload (Lisp_Object);
 void warn_when_safe_lispobj (Lisp_Object, Lisp_Object, Lisp_Object);
-MODULE_API void warn_when_safe (Lisp_Object, Lisp_Object, const CIbyte *,
+MODULE_API void warn_when_safe (Lisp_Object, Lisp_Object, const Ascbyte *,
 				...) PRINTF_ARGS (3, 4);
 extern int backtrace_with_internal_sections;
+extern Lisp_Object Vdebug_on_error;
 extern Lisp_Object Vstack_trace_on_error;
 /* Defined in event-stream.c */
 EXFUN (Faccept_process_output, 3);
 EXFUN (Fadd_timeout, 4);
 EXFUN (Fverify_visited_file_modtime, 1);
 void record_auto_save (void);
 void force_auto_save_soon (void);
 DECLARE_DOESNT_RETURN (report_error_with_errno (Lisp_Object errtype,
-						const CIbyte *string,
+						const Ascbyte *reason,
 						Lisp_Object data));
-DECLARE_DOESNT_RETURN (report_file_type_error (Lisp_Object errtype,
+DECLARE_DOESNT_RETURN (report_file_error (const Ascbyte *, Lisp_Object));
-					       Lisp_Object oserrmess,
-					       const CIbyte *string,
-					       Lisp_Object data));
-DECLARE_DOESNT_RETURN (report_file_error (const CIbyte *, Lisp_Object));
 Lisp_Object lisp_strerror (int);
 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object);
 int internal_delete_file (Lisp_Object);
 Ibyte *find_end_of_directory_component (const Ibyte *path,
 					Bytecount len);
 EXFUN (Fdelq, 2);
 EXFUN (Fdestructive_alist_to_plist, 1);
 EXFUN (Felt, 2);
 MODULE_API EXFUN (Fequal, 2);
 MODULE_API EXFUN (Fget, 3);
+MODULE_API EXFUN (Feqlsign, MANY);
+MODULE_API EXFUN (Fequalp, 2);
 EXFUN (Flast, 2);
 EXFUN (Flax_plist_get, 3);
 EXFUN (Flax_plist_remprop, 2);
 MODULE_API EXFUN (Flength, 1);
-EXFUN (Fmapcar, 2);
+EXFUN (FmapcarX, MANY);
 EXFUN (Fmember, 2);
 EXFUN (Fmemq, 2);
 EXFUN (Fnconc, MANY);
 MODULE_API EXFUN (Fnreverse, 1);
 EXFUN (Fnthcdr, 2);
 Lisp_Object delq_no_quit_and_free_cons (Lisp_Object, Lisp_Object);
 Lisp_Object remassoc_no_quit (Lisp_Object, Lisp_Object);
 Lisp_Object remassq_no_quit (Lisp_Object, Lisp_Object);
 Lisp_Object remrassq_no_quit (Lisp_Object, Lisp_Object);
-int plists_differ (Lisp_Object, Lisp_Object, int, int, int);
+int plists_differ (Lisp_Object, Lisp_Object, int, int, int, int);
 Lisp_Object internal_plist_get (Lisp_Object, Lisp_Object);
 void internal_plist_put (Lisp_Object *, Lisp_Object, Lisp_Object);
 int internal_remprop (Lisp_Object *, Lisp_Object);
 Lisp_Object external_plist_get (Lisp_Object *, Lisp_Object,
 				int, Error_Behavior);
 				      int retval,
 				      Lisp_Object obj1, Lisp_Object obj2,
 				      int depth);
 int internal_equal (Lisp_Object, Lisp_Object, int);
 int internal_equalp (Lisp_Object obj1, Lisp_Object obj2, int depth);
-Lisp_Object concat2 (Lisp_Object, Lisp_Object);
+Lisp_Object MODULE_API concat2 (Lisp_Object, Lisp_Object);
-Lisp_Object concat3 (Lisp_Object, Lisp_Object, Lisp_Object);
+Lisp_Object MODULE_API concat3 (Lisp_Object, Lisp_Object, Lisp_Object);
-Lisp_Object vconcat2 (Lisp_Object, Lisp_Object);
+Lisp_Object MODULE_API vconcat2 (Lisp_Object, Lisp_Object);
-Lisp_Object vconcat3 (Lisp_Object, Lisp_Object, Lisp_Object);
+Lisp_Object MODULE_API vconcat3 (Lisp_Object, Lisp_Object, Lisp_Object);
-Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
+Lisp_Object MODULE_API nconc2 (Lisp_Object, Lisp_Object);
+int internal_equal_0 (Lisp_Object, Lisp_Object, int, int);
 Lisp_Object bytecode_nconc2 (Lisp_Object *);
-void check_losing_bytecode (const char *, Lisp_Object);
+int bytecode_arithcompare (Lisp_Object obj1, Lisp_Object obj2);
+void check_losing_bytecode (const Ascbyte *, Lisp_Object);
 Lisp_Object add_suffix_to_symbol (Lisp_Object symbol,
 				  const Ascbyte *ascii_string);
 Lisp_Object add_prefix_to_symbol (const Ascbyte *ascii_string,
 				  Lisp_Object symbol);
 void debug_short_backtrace (int);
 void debug_backtrace (void);
 /* NOTE: Do not call this with the data of a Lisp_String.  Use princ.
 * Note: stream should be defaulted before calling
 *  (eg Qnil means stdout, not Vstandard_output, etc) */
-MODULE_API void write_c_string (Lisp_Object stream, const CIbyte *str);
+MODULE_API void write_istring (Lisp_Object stream, const Ibyte *str);
 /* Same goes for this function. */
-MODULE_API void write_string (Lisp_Object stream, const Ibyte *str);
+MODULE_API void write_cistring (Lisp_Object stream, const CIbyte *str);
+/* Same goes for this function. */
+MODULE_API void write_ascstring (Lisp_Object stream, const Ascbyte *str);
 /* Same goes for this function. */
 void write_string_1 (Lisp_Object stream, const Ibyte *str, Bytecount size);
 void write_eistring (Lisp_Object stream, const Eistring *ei);
 /* Higher-level (printf-style) ways to output data: */
 (((2410824 * sizeof (integral_type)) / 1000000) + 3)
 void long_to_string (char *, long);
 void ulong_to_bit_string (char *, unsigned long);
 extern int print_escape_newlines;
 extern MODULE_API int print_readably;
+extern int in_debug_print;
 Lisp_Object internal_with_output_to_temp_buffer (Lisp_Object,
 						 Lisp_Object (*) (Lisp_Object),
 						 Lisp_Object, Lisp_Object);
 void float_to_string (char *, double);
 void internal_object_printer (Lisp_Object obj, Lisp_Object printcharfun,
 			      int UNUSED (escapeflag));
 void external_object_printer (Lisp_Object obj, Lisp_Object printcharfun,
 			      int UNUSED (escapeflag));
+MODULE_API DECLARE_DOESNT_RETURN (printing_unreadable_object (const CIbyte *,
+							      ...))
+PRINTF_ARGS (1, 2);
+DECLARE_DOESNT_RETURN (printing_unreadable_lcrecord (Lisp_Object obj,
+						     const Ibyte *name));
 /* Defined in rangetab.c */
 EXFUN (Fclear_range_table, 1);
 EXFUN (Fget_range_table, 3);
 EXFUN (Fmake_range_table, 1);
 EXFUN (Fmatch_beginning, 1);
 EXFUN (Fmatch_end, 1);
 EXFUN (Fskip_chars_backward, 3);
 EXFUN (Fskip_chars_forward, 3);
 EXFUN (Fstring_match, 4);
+EXFUN (Fregexp_quote, 1);
 struct re_pattern_buffer;
 struct re_registers;
 Charbpos scan_buffer (struct buffer *, Ichar, Charbpos, Charbpos, EMACS_INT,
 		      EMACS_INT *, int);
 EXFUN (Fsymbol_name, 1);
 EXFUN (Fsymbol_plist, 1);
 EXFUN (Fsymbol_value, 1);
 unsigned int hash_string (const Ibyte *, Bytecount);
-Lisp_Object intern_int (const Ibyte *str);
+Lisp_Object intern_istring (const Ibyte *str);
 MODULE_API Lisp_Object intern (const CIbyte *str);
 Lisp_Object intern_converting_underscores_to_dashes (const CIbyte *str);
 Lisp_Object oblookup (Lisp_Object, const Ibyte *, Bytecount);
 void map_obarray (Lisp_Object, int (*) (Lisp_Object, void *), void *);
 Lisp_Object indirect_function (Lisp_Object, int);
 extern Lisp_Object Vcharset_latin_iso8859_2;
 extern Lisp_Object Vcharset_latin_iso8859_3;
 extern Lisp_Object Vcharset_latin_iso8859_4;
 extern Lisp_Object Vcharset_thai_tis620;
 extern Lisp_Object Vcharset_greek_iso8859_7;
+extern Lisp_Object Vcharset_arabic_iso8859_6;
 extern Lisp_Object Vcharset_hebrew_iso8859_8;
 extern Lisp_Object Vcharset_katakana_jisx0201;
 extern Lisp_Object Vcharset_latin_jisx0201;
 extern Lisp_Object Vcharset_cyrillic_iso8859_5;
 extern Lisp_Object Vcharset_latin_iso8859_9;
 int qxestrcasecmp (const Ibyte *s1, const Ibyte *s2);
 int qxestrcasecmp_ascii (const Ibyte *s1, const Ascbyte *s2);
 int qxestrcasecmp_i18n (const Ibyte *s1, const Ibyte *s2);
 int ascii_strcasecmp (const Ascbyte *s1, const Ascbyte *s2);
-int lisp_strcasecmp (Lisp_Object s1, Lisp_Object s2);
+int lisp_strcasecmp_ascii (Lisp_Object s1, Lisp_Object s2);
 int lisp_strcasecmp_i18n (Lisp_Object s1, Lisp_Object s2);
 int qxestrncasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len);
 int qxestrncasecmp_ascii (const Ibyte *s1, const Ascbyte *s2,
 			  Bytecount len);
 int qxestrncasecmp_i18n (const Ibyte *s1, const Ibyte *s2, Bytecount len);
 	  ;; finally terminate the last line.
 	  (princ ";\n"))))))
 */
-extern Lisp_Object Qactivate_menubar_hook, Qand_optional, Qand_rest;
+extern Lisp_Object Qactivate_menubar_hook, Qand_optional, Qand_rest, Qautoload,
-extern Lisp_Object Qarith_error, Qarrayp, Qautoload, Qbackground;
+Qbackground, Qbackground_pixmap, Qblinking, Qbuffer_glyph_p, Qbuffer_live_p,
-extern Lisp_Object Qbackground_pixmap, Qbeginning_of_buffer, Qbitp, Qblinking;
+Qcall_interactively, Qcategory_designator_p,
-extern Lisp_Object Qbuffer_glyph_p, Qbuffer_live_p, Qbuffer_read_only;
+Qcategory_table_value_p, Qcdr, Qcolor_pixmap_image_instance_p, Qcommandp,
-extern Lisp_Object Qbyte_code, Qcall_interactively, Qcategory_designator_p;
+Qcompletion_ignore_case, Qconsole_live_p, Qconst_specifier, Qcurrent_menubar,
-extern Lisp_Object Qcategory_table_value_p, Qcdr, Qchar_or_string_p;
+Qdefun, Qdevice_live_p, Qdim, Qdirection, Qdisabled, Qdisabled_command_hook,
-extern Lisp_Object Qcharacterp, Qcircular_list, Qcircular_property_list;
+Qdisplay_table, Qdll_error, Qend_open, Qerror_lacks_explanatory_string,
-extern Lisp_Object Qcolor_pixmap_image_instance_p, Qcommandp;
+Qevent_live_p, Qexit, Qextent_live_p, Qexternal_debugging_output, Qfeaturep,
-extern Lisp_Object Qcompletion_ignore_case, Qconsole_live_p, Qconst_specifier;
+Qfile_error, Qfile_name_sans_extension, Qfinal, Qforeground, Qformat,
-extern Lisp_Object Qconversion_error, Qcurrent_menubar;
+Qframe_live_p, Qgraphic, Qgui_error, Qicon_glyph_p, Qidentity, Qinhibit_quit,
-extern Lisp_Object Qcyclic_variable_indirection, Qdefun, Qdevice_live_p, Qdim;
+Qinhibit_read_only, Qinteractive, Qlayout, Qload, Qlong_name, Qmacro,
-extern Lisp_Object Qdirection, Qdisabled, Qdisabled_command_hook;
+Qmakunbound, Qmark, Qmodule, Qmono_pixmap_image_instance_p,
-extern Lisp_Object Qdisplay_table, Qdll_error, Qdomain_error, Qediting_error;
+Qmouse_leave_buffer_hook, Qnative_layout, Qnetwork_error,
-extern Lisp_Object Qend_of_buffer, Qend_of_file, Qend_open, Qerror;
+Qnothing_image_instance_p, Qpoint, Qpointer_glyph_p,
-extern Lisp_Object Qerror_conditions, Qerror_lacks_explanatory_string;
+Qpointer_image_instance_p, Qprint_length, Qprint_string_length, Qprogn,
-extern Lisp_Object Qerror_message, Qevent_live_p, Qexit, Qextent_live_p;
+Qread_char, Qread_from_minibuffer, Qreally_early_error_handler,
-extern Lisp_Object Qexternal_debugging_output, Qfeaturep, Qfile_error;
+Qregion_beginning, Qregion_end, Qregistries, Qreverse_direction_charset,
-extern Lisp_Object Qfile_name_sans_extension, Qfinal;
+Qrun_hooks, Qsans_modifiers, Qsave_buffers_kill_emacs, Qself_insert_command,
-extern Lisp_Object Qforeground, Qformat, Qframe_live_p, Qgraphic;
+Qself_insert_defer_undo, Qsequencep, Qset, Qshort_name, Qsound_error,
-extern Lisp_Object Qgui_error, Qicon_glyph_p, Qidentity, Qinhibit_quit;
+Qstandard_input, Qstandard_output, Qstart_open, Qstring_lessp, Qsubwindow,
-extern Lisp_Object Qinhibit_read_only, Qinteger_char_or_marker_p;
+Qsubwindow_image_instance_p, Qtext_image_instance_p, Qtop_level, Qunderline,
-extern Lisp_Object Qinteger_or_char_p, Qinteger_or_marker_p;
+Quser_files_and_directories, Qvalues, Qvariable_documentation,
-extern Lisp_Object Qinteractive, Qinternal_error;
+Qvariable_domain, Qwindow_live_p, Qyes_or_no_p;
-extern Lisp_Object Qinvalid_byte_code, Qinvalid_change, Qinvalid_constant;
-extern Lisp_Object Qinvalid_function, Qinvalid_operation;
+extern MODULE_API Lisp_Object Qprocess_error, Qt, Qunbound;
-extern Lisp_Object Qinvalid_read_syntax, Qinvalid_state, Qio_error, Qlambda;
-extern Lisp_Object Qlayout, Qlist_formation_error, Qlistp, Qload;
-extern Lisp_Object Qlong_name, Qmacro, Qmakunbound, Qmalformed_list;
-extern Lisp_Object Qmalformed_property_list, Qmark, Qmodule;
-extern Lisp_Object Qmono_pixmap_image_instance_p, Qmouse_leave_buffer_hook;
-extern Lisp_Object Qnative_layout, Qnatnump, Qnetwork_error, Qno_catch;
-extern Lisp_Object Qnonnegativep, Qnothing_image_instance_p;
-extern Lisp_Object Qnumber_char_or_marker_p, Qnumberp, Qout_of_memory;
-extern Lisp_Object Qoverflow_error, Qpoint, Qpointer_glyph_p;
-extern Lisp_Object Qpointer_image_instance_p, Qprint_length;
-extern Lisp_Object Qprint_string_length, Qprinting_unreadable_object;
-extern Lisp_Object Qprogn, Qquit, Qquote, Qrange_error;
-extern Lisp_Object Qread_char, Qread_from_minibuffer;
-extern Lisp_Object Qreally_early_error_handler, Qregion_beginning;
-extern Lisp_Object Qregion_end, Qregistries, Qreverse_direction_charset;
-extern Lisp_Object Qrun_hooks, Qsans_modifiers, Qsave_buffers_kill_emacs;
-extern Lisp_Object Qself_insert_command, Qself_insert_defer_undo, Qsequencep;
-extern Lisp_Object Qset, Qsetting_constant, Qshort_name, Qsingularity_error;
-extern Lisp_Object Qsound_error, Qstack_overflow, Qstandard_input;
-extern Lisp_Object Qstandard_output, Qstart_open, Qstring_lessp;
-extern Lisp_Object Qstructure_formation_error, Qsubwindow;
-extern Lisp_Object Qsubwindow_image_instance_p;
-extern Lisp_Object Qtext_conversion_error, Qtext_image_instance_p, Qtop_level;
-extern Lisp_Object Qtrue_list_p, Qunderflow_error, Qunderline;
-extern Lisp_Object Quser_files_and_directories, Qvalues;
-extern Lisp_Object Qvariable_documentation, Qvariable_domain, Qvoid_function;
-extern Lisp_Object Qvoid_variable, Qwindow_live_p, Qwrong_number_of_arguments;
-extern Lisp_Object Qwrong_type_argument, Qyes_or_no_p;
-extern MODULE_API Lisp_Object Qintegerp, Qinvalid_argument, Qprocess_error;
-extern MODULE_API Lisp_Object Qsyntax_error, Qt, Qunbound;
 #define SYMBOL(fou) extern Lisp_Object fou
 #define SYMBOL_MODULE_API(fou) extern MODULE_API Lisp_Object fou
 #define SYMBOL_KEYWORD(la_cle_est_fou) extern Lisp_Object la_cle_est_fou
 #define SYMBOL_GENERAL(tout_le_monde, est_fou) \
 extern Lisp_Object Vautoload_queue, Vblank_menubar;
 extern Lisp_Object Vcommand_history;
 extern Lisp_Object Vcommand_line_args, Vconfigure_info_directory;
 extern Lisp_Object Vconfigure_site_directory, Vconfigure_site_module_directory;
 extern Lisp_Object Vconsole_list, Vcontrolling_terminal;
-extern Lisp_Object Vcurrent_compiled_function_annotation, Vcurrent_load_list;
+extern Lisp_Object Vcurrent_load_list;
 extern Lisp_Object Vcurrent_mouse_event, Vcurrent_prefix_arg, Vdata_directory;
 extern Lisp_Object Vdirectory_sep_char, Vdisabled_command_hook;
 extern Lisp_Object Vdoc_directory, Vinternal_doc_file_name;
 extern Lisp_Object Vecho_area_buffer, Vemacs_major_version;
 extern Lisp_Object Vemacs_minor_version, Vexec_directory, Vexec_path;

Mercurial > hg > xemacs-beta

comparison src/lisp.h @ 5125:b5df3737028a ben-lisp-object