--- a/src/lisp.h	Mon Aug 13 11:19:22 2007 +0200
+++ b/src/lisp.h	Mon Aug 13 11:20:41 2007 +0200
@@ -22,8 +22,8 @@
 
 /* Synched up with: FSF 19.30. */
 
-#ifndef INCLUDED_lisp_h_
-#define INCLUDED_lisp_h_
+#ifndef _XEMACS_LISP_H_
+#define _XEMACS_LISP_H_
 
 /************************************************************************/
 /*			  general definitions				*/
@@ -39,9 +39,10 @@
 #include <stdio.h>		/* NULL, etc. */
 #include <ctype.h>
 #include <stdarg.h>
-#include <stddef.h>		/* offsetof */
-#include <sys/types.h>
-#include <limits.h>
+
+#ifdef __lucid
+# include <sysent.h>
+#endif
 
 /* ---- Dynamic arrays ---- */
 
@@ -59,13 +60,11 @@
 
 void *Dynarr_newf (int elsize);
 void Dynarr_resize (void *dy, int size);
-void Dynarr_insert_many (void *d, const void *el, int len, int start);
+void Dynarr_insert_many (void *d, CONST void *el, int len, int start);
 void Dynarr_delete_many (void *d, int start, int len);
 void Dynarr_free (void *d);
 
-#define Dynarr_new(type) ((type##_dynarr *) Dynarr_newf (sizeof (type)))
-#define Dynarr_new2(dynarr_type, type) \
-  ((dynarr_type *) Dynarr_newf (sizeof (type)))
+#define Dynarr_new(type) ((type##_dynarr *) Dynarr_newf (sizeof(type)))
 #define Dynarr_at(d, pos) ((d)->base[pos])
 #define Dynarr_atp(d, pos) (&Dynarr_at (d, pos))
 #define Dynarr_length(d) ((d)->cur)
@@ -74,9 +73,9 @@
 #define Dynarr_add_many(d, el, len) Dynarr_insert_many (d, el, len, (d)->cur)
 #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_literal_string(d, s) Dynarr_add_many (d, s, sizeof(s) - 1)
 #define Dynarr_add_lisp_string(d, s) do {		\
-  Lisp_String *dyna_ls_s = XSTRING (s);			\
+  struct Lisp_String *dyna_ls_s = XSTRING (s);		\
   Dynarr_add_many (d, (char *) string_data (dyna_ls_s),	\
 		   string_length (dyna_ls_s));		\
 } while (0)
@@ -91,6 +90,9 @@
 #define Dynarr_increment(d) ((d)->cur++)
 #define Dynarr_set_size(d, n) ((d)->cur = n)
 
+/* Minimum size in elements for dynamic array when resized; default is 32 */
+extern int Dynarr_min_size;
+
 #ifdef MEMORY_USAGE_STATS
 struct overhead_stats;
 size_t Dynarr_memory_usage (void *d, struct overhead_stats *stats);
@@ -110,17 +112,19 @@
 #endif
 
 /* Memory allocation */
-void malloc_warning (const char *);
+void malloc_warning (CONST char *);
 void *xmalloc (size_t size);
 void *xmalloc_and_zero (size_t size);
 void *xrealloc (void *, size_t size);
-char *xstrdup (const char *);
+char *xstrdup (CONST char *);
 /* generally useful */
-#define countof(x) ((int) (sizeof(x)/sizeof((x)[0])))
+#define countof(x) ((int) (sizeof(x)/sizeof(x[0])))
+#define slot_offset(type, slot_name) \
+  ((unsigned) (((char *) (&(((type *)0)->slot_name))) - ((char *)0)))
 #define xnew(type) ((type *) xmalloc (sizeof (type)))
 #define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type)))
 #define xnew_and_zero(type) ((type *) xmalloc_and_zero (sizeof (type)))
-#define xzero(lvalue) ((void) memset (&(lvalue), '\0', sizeof (lvalue)))
+#define xzero(lvalue) ((void) memset (&(lvalue), 0, sizeof (lvalue)))
 #define xnew_array_and_zero(type, len) ((type *) xmalloc_and_zero ((len) * sizeof (type)))
 #define XREALLOC_ARRAY(ptr, type, len) ((void) (ptr = (type *) xrealloc (ptr, (len) * sizeof (type))))
 #define alloca_array(type, len) ((type *) alloca ((len) * sizeof (type)))
@@ -132,16 +136,21 @@
    macro will realloc BASEVAR as necessary so that it can hold at
    least NEEDED_SIZE objects.  The reallocing is done by doubling,
    which ensures constant amortized time per element. */
-#define DO_REALLOC(basevar, sizevar, needed_size, type)	do {	\
+#define DO_REALLOC(basevar, sizevar, needed_size, type)	do	\
+{								\
+  /* Avoid side-effectualness. */				\
+  /* Dammit! Macros suffer from dynamic scope! */		\
+  /* We demand inline functions! */				\
   size_t do_realloc_needed_size = (needed_size);		\
-  if ((sizevar) < do_realloc_needed_size)			\
-    {								\
-      if ((sizevar) < 32)					\
-	(sizevar) = 32;						\
-      while ((sizevar) < do_realloc_needed_size)		\
-	(sizevar) *= 2;						\
-      XREALLOC_ARRAY (basevar, type, (sizevar));		\
-    }								\
+  size_t do_realloc_newsize = 0;				\
+  while ((sizevar) < (do_realloc_needed_size)) {		\
+    do_realloc_newsize = 2*(sizevar);				\
+    if (do_realloc_newsize < 32)				\
+      do_realloc_newsize = 32;					\
+    (sizevar) = do_realloc_newsize;				\
+  }								\
+  if (do_realloc_newsize)					\
+    XREALLOC_ARRAY (basevar, type, do_realloc_newsize);		\
 } while (0)
 
 #ifdef ERROR_CHECK_MALLOC
@@ -154,6 +163,7 @@
 } while (0)
 #else
 void xfree (void *);
+#define xfree_1 xfree
 #endif /* ERROR_CHECK_MALLOC */
 
 #ifndef PRINTF_ARGS
@@ -168,13 +178,13 @@
 #ifndef DOESNT_RETURN
 # if defined __GNUC__
 #  if ((__GNUC__ > 2) || (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))
-#   define DOESNT_RETURN void
+#   define DOESNT_RETURN void volatile
 #   define DECLARE_DOESNT_RETURN(decl) \
-           extern void decl __attribute__ ((noreturn))
+           extern void volatile decl __attribute__ ((noreturn))
 #   define DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS(decl,str,idx) \
      /* Should be able to state multiple independent __attribute__s, but  \
         the losing syntax doesn't work that way, and screws losing cpp */ \
-           extern void decl \
+           extern void volatile decl \
                   __attribute__ ((noreturn, format (printf, str, idx)))
 #  else
 #   define DOESNT_RETURN void volatile
@@ -192,7 +202,7 @@
 
 #ifndef ALIGNOF
 # if defined (__GNUC__) && (__GNUC__ >= 2)
-#  define ALIGNOF(x) __alignof__ (x)
+#  define ALIGNOF(x) __alignof (x)
 # else
 #  define ALIGNOF(x) sizeof (x)
 # endif
@@ -221,7 +231,7 @@
 #ifdef USE_ASSERTIONS
 /* Highly dubious kludge */
 /*   (thanks, Jamie, I feel better now -- ben) */
-void assert_failed (const char *, int, const char *);
+DECLARE_DOESNT_RETURN (assert_failed (CONST char *, int, CONST char *));
 # define abort() (assert_failed (__FILE__, __LINE__, "abort()"))
 # define assert(x) ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, #x))
 #else
@@ -239,33 +249,6 @@
 /*#define REGISTER register*/
 /*#endif*/
 
-
-/* EMACS_INT is the underlying integral type into which a Lisp_Object must fit.
-   In particular, it must be large enough to contain a pointer.
-   config.h can override this, e.g. to use `long long' for bigger lisp ints. */
-
-#ifndef SIZEOF_EMACS_INT
-# define SIZEOF_EMACS_INT SIZEOF_VOID_P
-#endif
-
-#ifndef EMACS_INT
-# if   SIZEOF_EMACS_INT == SIZEOF_LONG
-#  define EMACS_INT long
-# elif SIZEOF_EMACS_INT == SIZEOF_INT
-#  define EMACS_INT int
-# elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG
-#  define EMACS_INT long long
-# else
-#  error Unable to determine suitable type for EMACS_INT
-# endif
-#endif
-
-#ifndef EMACS_UINT
-# define EMACS_UINT unsigned EMACS_INT
-#endif
-
-#define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR)
-
 
 /************************************************************************/
 /*				  typedefs				*/
@@ -300,17 +283,17 @@
    buffer.h (where they rightfully belong) to avoid syntax errors
    in function prototypes. */
 
-typedef EMACS_INT Bufpos;
-typedef EMACS_INT Bytind;
-typedef EMACS_INT Memind;
+typedef int Bufpos;
+typedef int Bytind;
+typedef int Memind;
 
 /* Counts of bytes or chars */
 
-typedef EMACS_INT Bytecount;
-typedef EMACS_INT Charcount;
+typedef int Bytecount;
+typedef int Charcount;
 
 /* Length in bytes of a string in external format */
-typedef EMACS_INT Extcount;
+typedef int Extcount;
 
 typedef struct lstream Lstream;
 
@@ -340,17 +323,20 @@
 typedef struct extent *EXTENT;
 struct frame;			/* "frame.h" */
 struct window;                  /* "window.h" */
-typedef struct Lisp_Event Lisp_Event; /* "events.h" */
-typedef struct Lisp_Face Lisp_Face;   /* "faces.h" */
-typedef struct Lisp_Process Lisp_Process; /* "procimpl.h" */
+struct Lisp_Event;              /* "events.h" */
+typedef struct Lisp_Event Lisp_Event;
+struct Lisp_Face;
+typedef struct Lisp_Face Lisp_Face;
+struct Lisp_Process;            /* "process.c" */
+typedef struct Lisp_Process Lisp_Process;
 struct stat;                    /* <sys/stat.h> */
+struct Lisp_Color_Instance;
 typedef struct Lisp_Color_Instance Lisp_Color_Instance;
+struct Lisp_Font_Instance;
 typedef struct Lisp_Font_Instance Lisp_Font_Instance;
+struct Lisp_Image_Instance;
 typedef struct Lisp_Image_Instance Lisp_Image_Instance;
-typedef struct Lisp_Gui_Item Lisp_Gui_Item;
 struct display_line;
-struct display_glyph_area;
-struct display_box;
 struct redisplay_info;
 struct window_mirror;
 struct scrollbar_instance;
@@ -420,6 +406,47 @@
   Dynarr_declare (struct console_type_entry);
 } console_type_entry_dynarr;
 
+/* Need to declare this here. */
+enum external_data_format
+{
+  /* Binary format.  This is the simplest format and is what we
+     use in the absence of a more appropriate format.  This converts
+     according to the `binary' coding system:
+
+     a) On input, bytes 0 - 255 are converted into characters 0 - 255.
+     b) On output, characters 0 - 255 are converted into bytes 0 - 255
+        and other characters are converted into `X'.
+   */
+  FORMAT_BINARY,
+
+  /* Format used for filenames.  In the original Mule, this is
+     user-definable with the `pathname-coding-system' variable.
+     For the moment, we just use the `binary' coding system. */
+  FORMAT_FILENAME,
+
+  /* Format used for output to the terminal.  This should be controlled
+     by the `terminal-coding-system' variable.  Under kterm, this will
+     be some ISO2022 system.  On some DOS machines, this is Shift-JIS. */
+  FORMAT_TERMINAL,
+
+  /* Format used for input from the terminal.  This should be controlled
+     by the `keyboard-coding-system' variable. */
+  FORMAT_KEYBOARD,
+
+  /* Format used for the external Unix environment -- argv[], stuff
+     from getenv(), stuff from the /etc/passwd file, etc.
+
+     Perhaps should be the same as FORMAT_FILENAME. */
+  FORMAT_OS,
+
+  /* Compound-text format.  This is the standard X format used for
+     data stored in properties, selections, and the like.  This is
+     an 8-bit no-lock-shift ISO2022 coding system. */
+  FORMAT_CTEXT
+};
+
+#define FORMAT_NATIVE FORMAT_FILENAME
+
 enum run_hooks_condition
 {
   RUN_HOOKS_TO_COMPLETION,
@@ -437,14 +464,6 @@
 };
 #endif
 
-enum edge_style
-{
-  EDGE_ETCHED_IN,
-  EDGE_ETCHED_OUT,
-  EDGE_BEVEL_IN,
-  EDGE_BEVEL_OUT
-};
-
 #ifndef ERROR_CHECK_TYPECHECK
 
 typedef enum error_behavior
@@ -501,6 +520,32 @@
 
 #define POINTER_TYPE_P(type) ((type) == Lisp_Type_Record)
 
+/* EMACS_INT is the underlying integral type into which a Lisp_Object must fit.
+   In particular, it must be large enough to contain a pointer.
+   config.h can override this, e.g. to use `long long' for bigger lisp ints. */
+
+#ifndef SIZEOF_EMACS_INT
+# define SIZEOF_EMACS_INT SIZEOF_VOID_P
+#endif
+
+#ifndef EMACS_INT
+# if   SIZEOF_EMACS_INT == SIZEOF_LONG
+#  define EMACS_INT long
+# elif SIZEOF_EMACS_INT == SIZEOF_INT
+#  define EMACS_INT int
+# elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG
+#  define EMACS_INT long long
+# else
+#  error Unable to determine suitable type for EMACS_INT
+# endif
+#endif
+
+#ifndef EMACS_UINT
+# define EMACS_UINT unsigned EMACS_INT
+#endif
+
+#define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR)
+
 /* Overridden by m/next.h */
 #ifndef ASSERT_VALID_POINTER
 # define ASSERT_VALID_POINTER(pnt) (assert ((((EMACS_UINT) pnt) & 3) == 0))
@@ -513,8 +558,7 @@
 
 #define INT_VALBITS (BITS_PER_EMACS_INT - INT_GCBITS)
 #define VALBITS (BITS_PER_EMACS_INT - GCBITS)
-#define EMACS_INT_MAX ((EMACS_INT) ((1UL << INT_VALBITS) -1UL))
-#define EMACS_INT_MIN (-(EMACS_INT_MAX) - 1)
+#define EMACS_INT_MAX ((1UL << INT_VALBITS) -1UL)
 
 #ifdef USE_UNION_TYPE
 # include "lisp-union.h"
@@ -522,7 +566,7 @@
 # include "lisp-disunion.h"
 #endif /* !USE_UNION_TYPE */
 
-#define XPNTR(x) ((void *) XPNTRVAL(x))
+#define XPNTR(x) ((void *) (XPNTRVAL(x)))
 
 /* WARNING WARNING WARNING.  You must ensure on your own that proper
    GC protection is provided for the elements in this array. */
@@ -534,8 +578,8 @@
 /* Close your eyes now lest you vomit or spontaneously combust ... */
 
 #define HACKEQ_UNSAFE(obj1, obj2)				\
-  (EQ (obj1, obj2) || (!POINTER_TYPE_P (XTYPE (obj1))		\
-		       && !POINTER_TYPE_P (XTYPE (obj2))	\
+  (EQ (obj1, obj2) || (!POINTER_TYPE_P (XGCTYPE (obj1))		\
+		       && !POINTER_TYPE_P (XGCTYPE (obj2))	\
 		       && XCHAR_OR_INT (obj1) == XCHAR_OR_INT (obj2)))
 
 #ifdef DEBUG_XEMACS
@@ -565,6 +609,7 @@
    to mean "no such value". */
 
 #define UNBOUNDP(val) EQ (val, Qunbound)
+#define GC_UNBOUNDP(val) GC_EQ (val, Qunbound)
 
 /*********** cons ***********/
 
@@ -593,6 +638,7 @@
 #define XCONS(x) XRECORD (x, cons, Lisp_Cons)
 #define XSETCONS(x, p) XSETRECORD (x, p, cons)
 #define CONSP(x) RECORDP (x, cons)
+#define GC_CONSP(x) GC_RECORDP (x, cons)
 #define CHECK_CONS(x) CHECK_RECORD (x, cons)
 #define CONCHECK_CONS(x) CONCHECK_RECORD (x, cons)
 
@@ -602,6 +648,7 @@
 extern Lisp_Object Qnil;
 
 #define NILP(x)  EQ (x, Qnil)
+#define GC_NILP(x)  GC_EQ (x, Qnil)
 #define XCAR(a) (XCONS (a)->car)
 #define XCDR(a) (XCONS (a)->cdr)
 #define LISTP(x) (CONSP(x) || NILP(x))
@@ -661,7 +708,7 @@
 #define EXTERNAL_LIST_LOOP_DELETE_IF(elt, list, condition) do {	\
   Lisp_Object prev_tail_##list = Qnil;				\
   Lisp_Object tail_##list;					\
-  EMACS_INT len_##list;						\
+  int len_##list;						\
   EXTERNAL_LIST_LOOP_4 (elt, list, tail_##list, len_##list)	\
     {								\
       if (condition)						\
@@ -718,26 +765,26 @@
 
 #define EXTERNAL_LIST_LOOP_1(list)					\
 Lisp_Object ELL1_elt, ELL1_hare, ELL1_tortoise;				\
-EMACS_INT ELL1_len;							\
-EXTERNAL_LIST_LOOP_6 (ELL1_elt, list, ELL1_len, ELL1_hare,		\
-		      ELL1_tortoise, CIRCULAR_LIST_SUSPICION_LENGTH)
+int ELL1_len;								\
+EXTERNAL_LIST_LOOP_6(ELL1_elt, list, ELL1_len, ELL1_hare,		\
+		     ELL1_tortoise, CIRCULAR_LIST_SUSPICION_LENGTH)
 
 #define EXTERNAL_LIST_LOOP_2(elt, list)					\
 Lisp_Object hare_##elt, tortoise_##elt;					\
-EMACS_INT len_##elt;							\
-EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt,			\
-		      tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
+int len_##elt;								\
+EXTERNAL_LIST_LOOP_6(elt, list, len_##elt, hare_##elt,			\
+		     tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
 
 #define EXTERNAL_LIST_LOOP_3(elt, list, tail)				\
 Lisp_Object tortoise_##elt;						\
-EMACS_INT len_##elt;							\
-EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, tail,			\
-		      tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
+int len_##elt;								\
+EXTERNAL_LIST_LOOP_6(elt, list, len_##elt, tail,			\
+		     tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
 
 #define EXTERNAL_LIST_LOOP_4(elt, list, tail, len)			\
 Lisp_Object tortoise_##elt;						\
-EXTERNAL_LIST_LOOP_6 (elt, list, len, tail,				\
-		      tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
+EXTERNAL_LIST_LOOP_6(elt, list, len, tail,				\
+		     tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
 
 
 #define EXTERNAL_LIST_LOOP_6(elt, list, len, hare,		\
@@ -762,30 +809,30 @@
 
 
 /* Optimized and safe macros for looping over external alists. */
-#define EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, list)	\
-Lisp_Object hare_##elt, tortoise_##elt;				\
-EMACS_INT len_##elt;						\
-EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list,		\
-		       len_##elt, hare_##elt, tortoise_##elt,	\
+#define EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, list)		\
+Lisp_Object hare_##elt, tortoise_##elt;					\
+int len_##elt;								\
+EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list,			\
+		       len_##elt, hare_##elt, tortoise_##elt,		\
 		       CIRCULAR_LIST_SUSPICION_LENGTH)
 
 #define EXTERNAL_ALIST_LOOP_5(elt, elt_car, elt_cdr, list, tail)	\
 Lisp_Object tortoise_##elt;						\
-EMACS_INT len_##elt;							\
-EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list,			\
-		       len_##elt, tail, tortoise_##elt,			\
-		       CIRCULAR_LIST_SUSPICION_LENGTH)			\
+int len_##elt;								\
+EXTERNAL_ALIST_LOOP_8(elt, elt_car, elt_cdr, list,			\
+		      len_##elt, tail, tortoise_##elt,			\
+		      CIRCULAR_LIST_SUSPICION_LENGTH)
 
 #define EXTERNAL_ALIST_LOOP_6(elt, elt_car, elt_cdr, list, tail, len)	\
 Lisp_Object tortoise_##elt;						\
-EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list,			\
-		       len, tail, tortoise_##elt,			\
-		       CIRCULAR_LIST_SUSPICION_LENGTH)
+EXTERNAL_ALIST_LOOP_8(elt, elt_car, elt_cdr, list,			\
+		      len, tail, tortoise_##elt,			\
+		      CIRCULAR_LIST_SUSPICION_LENGTH)
 
 
 #define EXTERNAL_ALIST_LOOP_8(elt, elt_car, elt_cdr, list, len, hare,	\
                              tortoise, suspicion_length)		\
-EXTERNAL_LIST_LOOP_6 (elt, list, len, hare, tortoise, suspicion_length)	\
+EXTERNAL_LIST_LOOP_6(elt, list, len, hare, tortoise, suspicion_length)	\
   if (CONSP (elt) ? (elt_car = XCAR (elt), elt_cdr = XCDR (elt), 0) :1)	\
     continue;								\
   else
@@ -794,20 +841,20 @@
 /* Optimized and safe macros for looping over external property lists. */
 #define EXTERNAL_PROPERTY_LIST_LOOP_3(key, value, list)			\
 Lisp_Object key, value, hare_##key, tortoise_##key;			\
-EMACS_INT len_##key;							\
-EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, hare_##key,	\
+int len_##key;								\
+EXTERNAL_PROPERTY_LIST_LOOP_7(key, value, list, len_##key, hare_##key,\
 		     tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH)
 
 #define EXTERNAL_PROPERTY_LIST_LOOP_4(key, value, list, tail)		\
 Lisp_Object key, value, tail, tortoise_##key;				\
-EMACS_INT len_##key;							\
-EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, tail,	\
+int len_##key;								\
+EXTERNAL_PROPERTY_LIST_LOOP_7(key, value, list, len_##key, tail,	\
 		     tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH)
 
 #define EXTERNAL_PROPERTY_LIST_LOOP_5(key, value, list, tail, len)	\
 Lisp_Object key, value, tail, tortoise_##key;				\
-EMACS_INT len;								\
-EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail,		\
+int len;								\
+EXTERNAL_PROPERTY_LIST_LOOP_7(key, value, list, len, tail,		\
 		     tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH)
 
 
@@ -859,12 +906,12 @@
        )
 
 /* Return 1 if LIST is properly acyclic and nil-terminated, else 0. */
-INLINE_HEADER int TRUE_LIST_P (Lisp_Object object);
-INLINE_HEADER int
+INLINE int TRUE_LIST_P (Lisp_Object object);
+INLINE int
 TRUE_LIST_P (Lisp_Object object)
 {
   Lisp_Object hare, tortoise;
-  EMACS_INT len;
+  int len;
 
   for (hare = tortoise = object, len = 0;
        CONSP (hare);
@@ -886,7 +933,7 @@
 #define CHECK_TRUE_LIST(list) do {			\
   Lisp_Object CTL_list = (list);			\
   Lisp_Object CTL_hare, CTL_tortoise;			\
-  EMACS_INT CTL_len;					\
+  int CTL_len;						\
 							\
   for (CTL_hare = CTL_tortoise = CTL_list, CTL_len = 0;	\
        CONSP (CTL_hare);				\
@@ -920,13 +967,14 @@
 #define XSTRING(x) XRECORD (x, string, Lisp_String)
 #define XSETSTRING(x, p) XSETRECORD (x, p, string)
 #define STRINGP(x) RECORDP (x, string)
+#define GC_STRINGP(x) GC_RECORDP (x, string)
 #define CHECK_STRING(x) CHECK_RECORD (x, string)
 #define CONCHECK_STRING(x) CONCHECK_RECORD (x, string)
 
 #ifdef MULE
 
-Charcount bytecount_to_charcount (const Bufbyte *ptr, Bytecount len);
-Bytecount charcount_to_bytecount (const Bufbyte *ptr, Charcount len);
+Charcount bytecount_to_charcount (CONST Bufbyte *ptr, Bytecount len);
+Bytecount charcount_to_bytecount (CONST Bufbyte *ptr, Charcount len);
 
 #else /* not MULE */
 
@@ -945,14 +993,14 @@
 #define string_byte_addr(s, i) (&((s)->data[i]))
 #define set_string_length(s, len) ((void) ((s)->size = (len)))
 #define set_string_data(s, ptr) ((void) ((s)->data = (ptr)))
-#define set_string_byte(s, i, b) ((void) ((s)->data[i] = (b)))
+#define set_string_byte(s, i, c) ((void) ((s)->data[i] = (c)))
 
 void resize_string (Lisp_String *s, Bytecount pos, Bytecount delta);
 
 #ifdef MULE
 
-INLINE_HEADER Charcount string_char_length (Lisp_String *s);
-INLINE_HEADER Charcount
+INLINE Charcount string_char_length (Lisp_String *s);
+INLINE Charcount
 string_char_length (Lisp_String *s)
 {
   return bytecount_to_charcount (string_data (s), string_length (s));
@@ -967,19 +1015,10 @@
 # define string_char_length(s) string_length (s)
 # define string_char(s, i) ((Emchar) string_byte (s, i))
 # define string_char_addr(s, i) string_byte_addr (s, i)
-# define set_string_char(s, i, c) set_string_byte (s, i, (Bufbyte)c)
+# define set_string_char(s, i, c) set_string_byte (s, i, c)
 
 #endif /* not MULE */
 
-/* Return the true size of a struct with a variable-length array field.  */
-#define FLEXIBLE_ARRAY_STRUCT_SIZEOF(flexible_array_structtype,		\
-				     flexible_array_field,		\
-				     flexible_array_length)		\
-  (offsetof (flexible_array_structtype, flexible_array_field) +		\
-   (offsetof (flexible_array_structtype, flexible_array_field[1]) -	\
-    offsetof (flexible_array_structtype, flexible_array_field[0])) *	\
-   (flexible_array_length))
-
 /*********** vector ***********/
 
 struct Lisp_Vector
@@ -997,6 +1036,7 @@
 #define XVECTOR(x) XRECORD (x, vector, Lisp_Vector)
 #define XSETVECTOR(x, p) XSETRECORD (x, p, vector)
 #define VECTORP(x) RECORDP (x, vector)
+#define GC_VECTORP(x) GC_RECORDP (x, vector)
 #define CHECK_VECTOR(x) CHECK_RECORD (x, vector)
 #define CONCHECK_VECTOR(x) CONCHECK_RECORD (x, vector)
 
@@ -1035,10 +1075,12 @@
 #define XBIT_VECTOR(x) XRECORD (x, bit_vector, Lisp_Bit_Vector)
 #define XSETBIT_VECTOR(x, p) XSETRECORD (x, p, bit_vector)
 #define BIT_VECTORP(x) RECORDP (x, bit_vector)
+#define GC_BIT_VECTORP(x) GC_RECORDP (x, bit_vector)
 #define CHECK_BIT_VECTOR(x) CHECK_RECORD (x, bit_vector)
 #define CONCHECK_BIT_VECTOR(x) CONCHECK_RECORD (x, bit_vector)
 
 #define BITP(x) (INTP (x) && (XINT (x) == 0 || XINT (x) == 1))
+#define GC_BITP(x) (GC_INTP (x) && (XINT (x) == 0 || XINT (x) == 1))
 
 #define CHECK_BIT(x) do {		\
   if (!BITP (x))			\
@@ -1053,42 +1095,45 @@
 #define bit_vector_length(v) ((v)->size)
 #define bit_vector_next(v) ((v)->next)
 
-INLINE_HEADER int bit_vector_bit (Lisp_Bit_Vector *v, size_t n);
-INLINE_HEADER int
-bit_vector_bit (Lisp_Bit_Vector *v, size_t n)
+INLINE int bit_vector_bit (Lisp_Bit_Vector *v, int i);
+INLINE int
+bit_vector_bit (Lisp_Bit_Vector *v, int i)
 {
-  return ((v->bits[n >> LONGBITS_LOG2] >> (n & (LONGBITS_POWER_OF_2 - 1)))
+  unsigned int ui = (unsigned int) i;
+
+  return (((v)->bits[ui >> LONGBITS_LOG2] >> (ui & (LONGBITS_POWER_OF_2 - 1)))
 	  & 1);
 }
 
-INLINE_HEADER void set_bit_vector_bit (Lisp_Bit_Vector *v, size_t n, int value);
-INLINE_HEADER void
-set_bit_vector_bit (Lisp_Bit_Vector *v, size_t n, int value)
+INLINE void set_bit_vector_bit (Lisp_Bit_Vector *v, int i, int value);
+INLINE void
+set_bit_vector_bit (Lisp_Bit_Vector *v, int i, int value)
 {
+  unsigned int ui = (unsigned int) i;
   if (value)
-    v->bits[n >> LONGBITS_LOG2] |= (1UL << (n & (LONGBITS_POWER_OF_2 - 1)));
+    (v)->bits[ui >> LONGBITS_LOG2] |= (1U << (ui & (LONGBITS_POWER_OF_2 - 1)));
   else
-    v->bits[n >> LONGBITS_LOG2] &= ~(1UL << (n & (LONGBITS_POWER_OF_2 - 1)));
+    (v)->bits[ui >> LONGBITS_LOG2] &= ~(1U << (ui & (LONGBITS_POWER_OF_2 - 1)));
 }
 
 /* Number of longs required to hold LEN bits */
 #define BIT_VECTOR_LONG_STORAGE(len) \
-  (((len) + LONGBITS_POWER_OF_2 - 1) >> LONGBITS_LOG2)
+  ((len + LONGBITS_POWER_OF_2 - 1) >> LONGBITS_LOG2)
 
 
 /*********** symbol ***********/
 
-typedef struct Lisp_Symbol Lisp_Symbol;
 struct Lisp_Symbol
 {
   struct lrecord_header lheader;
   /* next symbol in this obarray bucket */
-  Lisp_Symbol *next;
-  Lisp_String *name;
+  struct Lisp_Symbol *next;
+  struct Lisp_String *name;
   Lisp_Object value;
   Lisp_Object function;
   Lisp_Object plist;
 };
+typedef struct Lisp_Symbol Lisp_Symbol;
 
 #define SYMBOL_IS_KEYWORD(sym)						\
   ((string_byte (symbol_name (XSYMBOL (sym)), 0) == ':')		\
@@ -1101,6 +1146,7 @@
 #define XSYMBOL(x) XRECORD (x, symbol, Lisp_Symbol)
 #define XSETSYMBOL(x, p) XSETRECORD (x, p, symbol)
 #define SYMBOLP(x) RECORDP (x, symbol)
+#define GC_SYMBOLP(x) GC_RECORDP (x, symbol)
 #define CHECK_SYMBOL(x) CHECK_RECORD (x, symbol)
 #define CONCHECK_SYMBOL(x) CONCHECK_RECORD (x, symbol)
 
@@ -1117,11 +1163,10 @@
 struct Lisp_Subr
 {
   struct lrecord_header lheader;
-  short min_args;
-  short max_args;
-  const char *prompt;
-  const char *doc;
-  const char *name;
+  short min_args, max_args;
+  CONST char *prompt;
+  CONST char *doc;
+  CONST char *name;
   lisp_fn_t subr_fn;
 };
 typedef struct Lisp_Subr Lisp_Subr;
@@ -1130,31 +1175,30 @@
 #define XSUBR(x) XRECORD (x, subr, Lisp_Subr)
 #define XSETSUBR(x, p) XSETRECORD (x, p, subr)
 #define SUBRP(x) RECORDP (x, subr)
+#define GC_SUBRP(x) GC_RECORDP (x, subr)
 #define CHECK_SUBR(x) CHECK_RECORD (x, subr)
 #define CONCHECK_SUBR(x) CONCHECK_RECORD (x, subr)
 
-#define subr_function(subr) ((subr)->subr_fn)
-#define SUBR_FUNCTION(subr,max_args) \
-  ((Lisp_Object (*) (EXFUN_##max_args)) (subr)->subr_fn)
-#define subr_name(subr) ((subr)->name)
+#define subr_function(subr) (subr)->subr_fn
+#define subr_name(subr) (subr)->name
 
 /*********** marker ***********/
 
-typedef struct Lisp_Marker Lisp_Marker;
 struct Lisp_Marker
 {
   struct lrecord_header lheader;
-  Lisp_Marker *next;
-  Lisp_Marker *prev;
+  struct Lisp_Marker *next, *prev;
   struct buffer *buffer;
   Memind memind;
   char insertion_type;
 };
+typedef struct Lisp_Marker Lisp_Marker;
 
 DECLARE_LRECORD (marker, Lisp_Marker);
 #define XMARKER(x) XRECORD (x, marker, Lisp_Marker)
 #define XSETMARKER(x, p) XSETRECORD (x, p, marker)
 #define MARKERP(x) RECORDP (x, marker)
+#define GC_MARKERP(x) GC_RECORDP (x, marker)
 #define CHECK_MARKER(x) CHECK_RECORD (x, marker)
 #define CONCHECK_MARKER(x) CONCHECK_RECORD (x, marker)
 
@@ -1167,11 +1211,12 @@
 /*********** char ***********/
 
 #define CHARP(x) (XTYPE (x) == Lisp_Type_Char)
+#define GC_CHARP(x) (XGCTYPE (x) == Lisp_Type_Char)
 
 #ifdef ERROR_CHECK_TYPECHECK
 
-INLINE_HEADER Emchar XCHAR (Lisp_Object obj);
-INLINE_HEADER Emchar
+INLINE Emchar XCHAR (Lisp_Object obj);
+INLINE Emchar
 XCHAR (Lisp_Object obj)
 {
   assert (CHARP (obj));
@@ -1180,7 +1225,7 @@
 
 #else
 
-#define XCHAR(x) ((Emchar)XCHARVAL (x))
+#define XCHAR(x) XCHARVAL (x)
 
 #endif
 
@@ -1208,6 +1253,7 @@
 #define XFLOAT(x) XRECORD (x, float, Lisp_Float)
 #define XSETFLOAT(x, p) XSETRECORD (x, p, float)
 #define FLOATP(x) RECORDP (x, float)
+#define GC_FLOATP(x) GC_RECORDP (x, float)
 #define CHECK_FLOAT(x) CHECK_RECORD (x, float)
 #define CONCHECK_FLOAT(x) CONCHECK_RECORD (x, float)
 
@@ -1227,38 +1273,44 @@
 } while (0)
 
 # define INT_OR_FLOATP(x) (INTP (x) || FLOATP (x))
+# define GC_INT_OR_FLOATP(x) (GC_INTP (x) || GC_FLOATP (x))
 
 #else /* not LISP_FLOAT_TYPE */
 
 #define XFLOAT(x) --- error!  No float support. ---
 #define XSETFLOAT(x, p) --- error!  No float support. ---
 #define FLOATP(x) 0
+#define GC_FLOATP(x) 0
 #define CHECK_FLOAT(x) --- error!  No float support. ---
 #define CONCHECK_FLOAT(x) --- error!  No float support. ---
 
 #define XFLOATINT(n) XINT(n)
 #define CHECK_INT_OR_FLOAT CHECK_INT
 #define CONCHECK_INT_OR_FLOAT CONCHECK_INT
-#define INT_OR_FLOATP(x) INTP (x)
+#define INT_OR_FLOATP(x) (INTP (x))
+# define GC_INT_OR_FLOATP(x) (GC_INTP (x))
 
 #endif /* not LISP_FLOAT_TYPE */
 
 /*********** int ***********/
 
+#define GC_INTP(x) INTP (x)
+
 #define ZEROP(x) EQ (x, Qzero)
+#define GC_ZEROP(x) GC_EQ (x, Qzero)
 
 #ifdef ERROR_CHECK_TYPECHECK
 
-INLINE_HEADER EMACS_INT XINT (Lisp_Object obj);
-INLINE_HEADER EMACS_INT
+INLINE EMACS_INT XINT (Lisp_Object obj);
+INLINE EMACS_INT
 XINT (Lisp_Object obj)
 {
   assert (INTP (obj));
   return XREALINT (obj);
 }
 
-INLINE_HEADER EMACS_INT XCHAR_OR_INT (Lisp_Object obj);
-INLINE_HEADER EMACS_INT
+INLINE EMACS_INT XCHAR_OR_INT (Lisp_Object obj);
+INLINE EMACS_INT
 XCHAR_OR_INT (Lisp_Object obj)
 {
   assert (INTP (obj) || CHARP (obj));
@@ -1283,6 +1335,7 @@
 } while (0)
 
 #define NATNUMP(x) (INTP (x) && XINT (x) >= 0)
+#define GC_NATNUMP(x) (GC_INTP (x) && XINT (x) >= 0)
 
 #define CHECK_NATNUM(x) do {			\
   if (!NATNUMP (x))				\
@@ -1326,7 +1379,7 @@
 
 
 /*********** readonly objects ***********/
-
+    
 #define CHECK_C_WRITEABLE(obj)					\
   do { if (c_readonly (obj)) c_write_error (obj); } while (0)
 
@@ -1389,10 +1442,7 @@
   /* element disappears if it's a cons and its car is unmarked. */
   WEAK_LIST_KEY_ASSOC,
   /* element disappears if it's a cons and its cdr is unmarked. */
-  WEAK_LIST_VALUE_ASSOC,
-  /* element disappears if it's a cons and neither its car nor
-     its cdr is marked. */
-  WEAK_LIST_FULL_ASSOC
+  WEAK_LIST_VALUE_ASSOC
 };
 
 struct weak_list
@@ -1407,6 +1457,7 @@
 #define XWEAK_LIST(x) XRECORD (x, weak_list, struct weak_list)
 #define XSETWEAK_LIST(x, p) XSETRECORD (x, p, weak_list)
 #define WEAK_LISTP(x) RECORDP (x, weak_list)
+#define GC_WEAK_LISTP(x) GC_RECORDP (x, weak_list)
 #define CHECK_WEAK_LIST(x) CHECK_RECORD (x, weak_list)
 #define CONCHECK_WEAK_LIST(x) CONCHECK_RECORD (x, weak_list)
 
@@ -1415,8 +1466,9 @@
 
 Lisp_Object make_weak_list (enum weak_list_type type);
 /* The following two are only called by the garbage collector */
-int finish_marking_weak_lists (void);
-void prune_weak_lists (void);
+int finish_marking_weak_lists (int (*obj_marked_p) (Lisp_Object),
+			       void (*markobj) (Lisp_Object));
+void prune_weak_lists (int (*obj_marked_p) (Lisp_Object));
 
 /*********** lcrecord lists ***********/
 
@@ -1425,19 +1477,20 @@
   struct lcrecord_header header;
   Lisp_Object free;
   size_t size;
-  const struct lrecord_implementation *implementation;
+  CONST struct lrecord_implementation *implementation;
 };
 
 DECLARE_LRECORD (lcrecord_list, struct lcrecord_list);
 #define XLCRECORD_LIST(x) XRECORD (x, lcrecord_list, struct lcrecord_list)
 #define XSETLCRECORD_LIST(x, p) XSETRECORD (x, p, lcrecord_list)
 #define LCRECORD_LISTP(x) RECORDP (x, lcrecord_list)
+#define GC_LCRECORD_LISTP(x) GC_RECORDP (x, lcrecord_list)
 /* #define CHECK_LCRECORD_LIST(x) CHECK_RECORD (x, lcrecord_list)
    Lcrecord lists should never escape to the Lisp level, so
    functions should not be doing this. */
 
 Lisp_Object make_lcrecord_list (size_t size,
-				const struct lrecord_implementation
+				CONST struct lrecord_implementation
 				*implementation);
 Lisp_Object allocate_managed_lcrecord (Lisp_Object lcrecord_list);
 void free_managed_lcrecord (Lisp_Object lcrecord_list, Lisp_Object lcrecord);
@@ -1496,23 +1549,12 @@
 /* Can't be const, because then subr->doc is read-only and
    Snarf_documentation chokes */
 
+#define subr_lheader_initializer { 0, { 0, 0, 0 } }
+
 #define DEFUN(lname, Fname, min_args, max_args, prompt, arglist)	\
   Lisp_Object Fname (EXFUN_##max_args);					\
-  static struct Lisp_Subr S##Fname =					\
-  {									\
-    { /* struct lrecord_header */					\
-      lrecord_type_subr, /* lrecord_type_index */			\
-      1, /* mark bit */							\
-      1, /* c_readonly bit */						\
-      1  /* lisp_readonly bit */					\
-    },									\
-    min_args,								\
-    max_args,								\
-    prompt,								\
-    0,	/* doc string */						\
-    lname,								\
-    (lisp_fn_t) Fname							\
-  };									\
+  static struct Lisp_Subr S##Fname = { subr_lheader_initializer,	\
+	min_args, max_args, prompt, 0, lname, (lisp_fn_t) Fname };	\
   Lisp_Object Fname (DEFUN_##max_args arglist)
 
 /* Heavy ANSI C preprocessor hackery to get DEFUN to declare a
@@ -1549,12 +1591,6 @@
 extern int specpdl_depth_counter;
 #define specpdl_depth() specpdl_depth_counter
 
-
-#define CHECK_FUNCTION(fun) do {		\
- while (NILP (Ffunctionp (fun)))		\
-   signal_invalid_function_error (fun);		\
- } while (0)
-
 
 /************************************************************************/
 /*			   Checking for QUIT				*/
@@ -1616,8 +1652,8 @@
 #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))
-unsigned long string_hash (const char *xv);
-unsigned long memory_hash (const void *xv, size_t size);
+unsigned long string_hash (CONST void *xv);
+unsigned long memory_hash (CONST void *xv, size_t size);
 unsigned long internal_hash (Lisp_Object obj, int depth);
 unsigned long internal_array_hash (Lisp_Object *arr, int size, int depth);
 
@@ -1630,10 +1666,10 @@
 #ifdef HAVE_LIBINTL_H
 #include <libintl.h>
 #else
-char *dgettext       (const char *, const char *);
-char *gettext        (const char *);
-char *textdomain     (const char *);
-char *bindtextdomain (const char *, const char *);
+char *dgettext       (CONST char *, CONST char *);
+char *gettext        (CONST char *);
+char *textdomain     (CONST char *);
+char *bindtextdomain (CONST char *, CONST char *);
 #endif /* HAVE_LIBINTL_H */
 
 #define GETTEXT(x)  gettext(x)
@@ -1775,7 +1811,8 @@
   gcpro4.next = &gcpro3,   gcpro4.var = &var4, gcpro4.nvars = 1,	\
   gcprolist = &gcpro4 ))
 
-#define GCPRO5(var1, var2, var3, var4, var5) ((void) (			\
+#define GCPRO5(var1, var2, var3, var4, var5)				\
+  ((void) (								\
   gcpro1.next = gcprolist, gcpro1.var = &var1, gcpro1.nvars = 1,	\
   gcpro2.next = &gcpro1,   gcpro2.var = &var2, gcpro2.nvars = 1,	\
   gcpro3.next = &gcpro2,   gcpro3.var = &var3, gcpro3.nvars = 1,	\
@@ -1807,7 +1844,8 @@
   ngcpro4.next = &ngcpro3,  ngcpro4.var = &var4, ngcpro4.nvars = 1,	\
   gcprolist = &ngcpro4 ))
 
-#define NGCPRO5(var1, var2, var3, var4, var5) ((void) (			\
+#define NGCPRO5(var1, var2, var3, var4, var5)				\
+  ((void) (								\
   ngcpro1.next = gcprolist, ngcpro1.var = &var1, ngcpro1.nvars = 1,	\
   ngcpro2.next = &ngcpro1,  ngcpro2.var = &var2, ngcpro2.nvars = 1,	\
   ngcpro3.next = &ngcpro2,  ngcpro3.var = &var3, ngcpro3.nvars = 1,	\
@@ -1839,7 +1877,8 @@
   nngcpro4.next = &nngcpro3, nngcpro4.var = &var4, nngcpro4.nvars = 1,	\
   gcprolist = &nngcpro4 ))
 
-#define NNGCPRO5(var1, var2, var3, var4, var5) ((void) (		\
+#define NNGCPRO5(var1, var2, var3, var4, var5)				\
+  ((void) (								\
   nngcpro1.next = gcprolist, nngcpro1.var = &var1, nngcpro1.nvars = 1,	\
   nngcpro2.next = &nngcpro1, nngcpro2.var = &var2, nngcpro2.nvars = 1,	\
   nngcpro3.next = &nngcpro2, nngcpro3.var = &var3, nngcpro3.nvars = 1,	\
@@ -1901,24 +1940,6 @@
 /* Call staticpro (&var) to protect static variable `var'. */
 void staticpro (Lisp_Object *);
 
-/* Call staticpro_nodump (&var) to protect static variable `var'. */
-/* var will not be saved at dump time */
-void staticpro_nodump (Lisp_Object *);
-
-/* Call dumpstruct(&var, &desc) to dump the structure pointed to by `var'. */
-void dumpstruct (void *, const struct struct_description *);
-
-/* Call dumpopaque(&var, size) to dump the opaque static structure `var'. */
-void dumpopaque (void *, size_t);
-
-/* Call pdump_wire(&var) to ensure that var is properly updated after pdump. */
-void pdump_wire (Lisp_Object *);
-
-/* Call pdump_wire(&var) to ensure that var  is properly updated after
-   pdump.  var  must point to  a linked list  of  objects out of which
-   some may not be dumped */
-void pdump_wire_list (Lisp_Object *);
-
 /* Nonzero means Emacs has already been initialized.
    Used during startup to detect startup of dumped Emacs.  */
 extern int initialized;
@@ -1968,7 +1989,7 @@
 #endif
 #endif
 #ifndef IS_ANY_SEP
-#define IS_ANY_SEP(c) IS_DIRECTORY_SEP (c)
+#define IS_ANY_SEP(c) (IS_DIRECTORY_SEP (c))
 #endif
 
 #ifdef HAVE_INTTYPES_H
@@ -2017,36 +2038,26 @@
 extern EMACS_INT gc_generation_number[1];
 int c_readonly (Lisp_Object);
 int lisp_readonly (Lisp_Object);
-Lisp_Object build_string (const char *);
-Lisp_Object build_ext_string (const char *, Lisp_Object);
-Lisp_Object build_translated_string (const char *);
-Lisp_Object make_string (const Bufbyte *, Bytecount);
-Lisp_Object make_ext_string (const Extbyte *, EMACS_INT, Lisp_Object);
+Lisp_Object build_string (CONST char *);
+Lisp_Object build_ext_string (CONST char *, enum external_data_format);
+Lisp_Object build_translated_string (CONST char *);
+Lisp_Object make_string (CONST Bufbyte *, Bytecount);
+Lisp_Object make_ext_string (CONST Extbyte *, EMACS_INT,
+			     enum external_data_format);
 Lisp_Object make_uninit_string (Bytecount);
 Lisp_Object make_float (double);
-Lisp_Object make_string_nocopy (const Bufbyte *, Bytecount);
+Lisp_Object make_string_nocopy (CONST Bufbyte *, Bytecount);
 void free_cons (Lisp_Cons *);
 void free_list (Lisp_Object);
 void free_alist (Lisp_Object);
 void mark_conses_in_list (Lisp_Object);
 void free_marker (Lisp_Marker *);
 int object_dead_p (Lisp_Object);
-void mark_object (Lisp_Object obj);
-int marked_p (Lisp_Object obj);
 
 #ifdef MEMORY_USAGE_STATS
 size_t malloced_storage_size (void *, size_t, struct overhead_stats *);
 size_t fixed_type_block_overhead (size_t);
 #endif
-#ifdef PDUMP
-void pdump (void);
-int pdump_load (const char *);
-
-extern char *pdump_start, *pdump_end;
-#define DUMPEDP(adr) ((((char *)(adr)) < pdump_end) && (((char *)(adr)) >= pdump_start))
-#else
-#define DUMPEDP(adr) 0
-#endif
 
 /* Defined in buffer.c */
 Lisp_Object make_buffer (struct buffer *);
@@ -2056,15 +2067,11 @@
 extern int find_file_use_truenames;
 
 /* Defined in callproc.c */
-char *egetenv (const char *);
+char *egetenv (CONST char *);
 
 /* Defined in console.c */
 void stuff_buffered_input (Lisp_Object);
 
-/* Defined in console-msw.c */
-EXFUN (Fmswindows_message_box, 3);
-extern int mswindows_message_outputted;
-
 /* Defined in data.c */
 DECLARE_DOESNT_RETURN (c_write_error (Lisp_Object));
 DECLARE_DOESNT_RETURN (lisp_write_error (Lisp_Object));
@@ -2073,7 +2080,7 @@
 					    Lisp_Object));
 Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object);
 DECLARE_DOESNT_RETURN (dead_wrong_type_argument (Lisp_Object, Lisp_Object));
-void check_int_range (EMACS_INT, EMACS_INT, EMACS_INT);
+void check_int_range (int, int, int);
 
 enum arith_comparison {
   arith_equal,
@@ -2088,7 +2095,7 @@
 unsigned int lisp_to_word (Lisp_Object);
 
 /* Defined in dired.c */
-Lisp_Object make_directory_hash_table (const char *);
+Lisp_Object make_directory_hash_table (CONST char *);
 Lisp_Object wasteful_word_to_lisp (unsigned int);
 
 /* Defined in doc.c */
@@ -2096,32 +2103,32 @@
 Lisp_Object read_doc_string (Lisp_Object);
 
 /* Defined in doprnt.c */
-Bytecount emacs_doprnt_c (Lisp_Object, const Bufbyte *, Lisp_Object,
+Bytecount emacs_doprnt_c (Lisp_Object, CONST Bufbyte *, Lisp_Object,
 			  Bytecount, ...);
-Bytecount emacs_doprnt_va (Lisp_Object, const Bufbyte *, Lisp_Object,
+Bytecount emacs_doprnt_va (Lisp_Object, CONST Bufbyte *, Lisp_Object,
 			   Bytecount, va_list);
-Bytecount emacs_doprnt_lisp (Lisp_Object, const Bufbyte *, Lisp_Object,
-			     Bytecount, int, const Lisp_Object *);
-Bytecount emacs_doprnt_lisp_2 (Lisp_Object, const Bufbyte *, Lisp_Object,
+Bytecount emacs_doprnt_lisp (Lisp_Object, CONST Bufbyte *, Lisp_Object,
+			     Bytecount, int, CONST Lisp_Object *);
+Bytecount emacs_doprnt_lisp_2 (Lisp_Object, CONST Bufbyte *, Lisp_Object,
 			       Bytecount, int, ...);
-Lisp_Object emacs_doprnt_string_c (const Bufbyte *, Lisp_Object,
+Lisp_Object emacs_doprnt_string_c (CONST Bufbyte *, Lisp_Object,
 				   Bytecount, ...);
-Lisp_Object emacs_doprnt_string_va (const Bufbyte *, Lisp_Object,
+Lisp_Object emacs_doprnt_string_va (CONST Bufbyte *, Lisp_Object,
 				    Bytecount, va_list);
-Lisp_Object emacs_doprnt_string_lisp (const Bufbyte *, Lisp_Object,
-				      Bytecount, int, const Lisp_Object *);
-Lisp_Object emacs_doprnt_string_lisp_2 (const Bufbyte *, Lisp_Object,
+Lisp_Object emacs_doprnt_string_lisp (CONST Bufbyte *, Lisp_Object,
+				      Bytecount, int, CONST Lisp_Object *);
+Lisp_Object emacs_doprnt_string_lisp_2 (CONST Bufbyte *, Lisp_Object,
 					Bytecount, int, ...);
 
 /* Defined in editfns.c */
 void uncache_home_directory (void);
-Extbyte *get_home_directory (void);
-char *user_login_name (uid_t *);
+char *get_home_directory (void);
+char *user_login_name (int *);
 Bufpos bufpos_clip_to_bounds (Bufpos, Bufpos, Bufpos);
 Bytind bytind_clip_to_bounds (Bytind, Bytind, Bytind);
 void buffer_insert1 (struct buffer *, Lisp_Object);
-Lisp_Object make_string_from_buffer (struct buffer *, Bufpos, Charcount);
-Lisp_Object make_string_from_buffer_no_extents (struct buffer *, Bufpos, Charcount);
+Lisp_Object make_string_from_buffer (struct buffer *, int, int);
+Lisp_Object make_string_from_buffer_no_extents (struct buffer *, int, int);
 Lisp_Object save_excursion_save (void);
 Lisp_Object save_restriction_save (void);
 Lisp_Object save_excursion_restore (Lisp_Object);
@@ -2131,19 +2138,18 @@
 Lisp_Object save_current_buffer_restore (Lisp_Object);
 
 /* Defined in emacs.c */
-DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (fatal (const char *,
+DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (fatal (CONST char *,
 							   ...), 1, 2);
-int stderr_out (const char *, ...) PRINTF_ARGS (1, 2);
-int stdout_out (const char *, ...) PRINTF_ARGS (1, 2);
+int stderr_out (CONST char *, ...) PRINTF_ARGS (1, 2);
+int stdout_out (CONST char *, ...) PRINTF_ARGS (1, 2);
 SIGTYPE fatal_error_signal (int);
 Lisp_Object make_arg_list (int, char **);
 void make_argc_argv (Lisp_Object, int *, char ***);
 void free_argc_argv (char **);
-Lisp_Object decode_env_path (const char *, const char *);
-Lisp_Object decode_path (const char *);
+Lisp_Object decode_env_path (CONST char *, CONST char *);
+Lisp_Object decode_path (CONST char *);
 /* Nonzero means don't do interactive redisplay and don't change tty modes */
-extern int noninteractive, noninteractive1;
-extern int fatal_error_in_progress;
+extern int noninteractive;
 extern int preparing_for_armageddon;
 extern int emacs_priority;
 extern int running_asynch_code;
@@ -2154,46 +2160,42 @@
 void maybe_signal_error (Lisp_Object, Lisp_Object, Lisp_Object, Error_behavior);
 Lisp_Object maybe_signal_continuable_error (Lisp_Object, Lisp_Object,
 					    Lisp_Object, Error_behavior);
-DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (error (const char *,
+DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (error (CONST char *,
 							   ...), 1, 2);
-void maybe_error (Lisp_Object, Error_behavior, const char *,
+void maybe_error (Lisp_Object, Error_behavior, CONST char *,
 		  ...) PRINTF_ARGS (3, 4);
-Lisp_Object continuable_error (const char *, ...) PRINTF_ARGS (1, 2);
+Lisp_Object continuable_error (CONST char *, ...) PRINTF_ARGS (1, 2);
 Lisp_Object maybe_continuable_error (Lisp_Object, Error_behavior,
-				     const char *, ...) PRINTF_ARGS (3, 4);
-DECLARE_DOESNT_RETURN (signal_simple_error (const char *, Lisp_Object));
-void maybe_signal_simple_error (const char *, Lisp_Object,
+				     CONST char *, ...) PRINTF_ARGS (3, 4);
+DECLARE_DOESNT_RETURN (signal_simple_error (CONST char *, Lisp_Object));
+void maybe_signal_simple_error (CONST char *, Lisp_Object,
 				Lisp_Object, Error_behavior);
-Lisp_Object signal_simple_continuable_error (const char *, Lisp_Object);
-Lisp_Object maybe_signal_simple_continuable_error (const char *, Lisp_Object,
+Lisp_Object signal_simple_continuable_error (CONST char *, Lisp_Object);
+Lisp_Object maybe_signal_simple_continuable_error (CONST char *, Lisp_Object,
 						   Lisp_Object, Error_behavior);
 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (error_with_frob
-						    (Lisp_Object, const char *,
+						    (Lisp_Object, CONST char *,
 						     ...), 2, 3);
 void maybe_error_with_frob (Lisp_Object, Lisp_Object, Error_behavior,
-			    const char *, ...) PRINTF_ARGS (4, 5);
-Lisp_Object continuable_error_with_frob (Lisp_Object, const char *,
+			    CONST char *, ...) PRINTF_ARGS (4, 5);
+Lisp_Object continuable_error_with_frob (Lisp_Object, CONST char *,
 					 ...) PRINTF_ARGS (2, 3);
 Lisp_Object maybe_continuable_error_with_frob
-(Lisp_Object, Lisp_Object, Error_behavior, const char *, ...) PRINTF_ARGS (4, 5);
-DECLARE_DOESNT_RETURN (signal_simple_error_2 (const char *,
+(Lisp_Object, Lisp_Object, Error_behavior, CONST char *, ...) PRINTF_ARGS (4, 5);
+DECLARE_DOESNT_RETURN (signal_simple_error_2 (CONST char *,
 					      Lisp_Object, Lisp_Object));
-void maybe_signal_simple_error_2 (const char *, Lisp_Object, Lisp_Object,
+void maybe_signal_simple_error_2 (CONST char *, Lisp_Object, Lisp_Object,
 				  Lisp_Object, Error_behavior);
-Lisp_Object signal_simple_continuable_error_2 (const char *,
+Lisp_Object signal_simple_continuable_error_2 (CONST char *,
 					       Lisp_Object, Lisp_Object);
-Lisp_Object maybe_signal_simple_continuable_error_2 (const char *, Lisp_Object,
+Lisp_Object maybe_signal_simple_continuable_error_2 (CONST char *, Lisp_Object,
 						     Lisp_Object, Lisp_Object,
 						     Error_behavior);
-DECLARE_DOESNT_RETURN (signal_malformed_list_error (Lisp_Object));
-DECLARE_DOESNT_RETURN (signal_malformed_property_list_error (Lisp_Object));
-DECLARE_DOESNT_RETURN (signal_circular_list_error (Lisp_Object));
-DECLARE_DOESNT_RETURN (signal_circular_property_list_error (Lisp_Object));
-
-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);
-
+void signal_malformed_list_error (Lisp_Object);
+void signal_malformed_property_list_error (Lisp_Object);
+void signal_circular_list_error (Lisp_Object);
+void signal_circular_property_list_error (Lisp_Object);
+void signal_void_function_error (Lisp_Object);
 Lisp_Object run_hook_with_args_in_buffer (struct buffer *, int, Lisp_Object *,
 					  enum run_hooks_condition);
 Lisp_Object run_hook_with_args (int, Lisp_Object *, enum run_hooks_condition);
@@ -2233,13 +2235,13 @@
 Lisp_Object eval_in_buffer (struct buffer *, Lisp_Object);
 Lisp_Object call0_with_handler (Lisp_Object, Lisp_Object);
 Lisp_Object call1_with_handler (Lisp_Object, Lisp_Object, Lisp_Object);
-Lisp_Object eval_in_buffer_trapping_errors (const char *, struct buffer *,
+Lisp_Object eval_in_buffer_trapping_errors (CONST char *, struct buffer *,
 					    Lisp_Object);
-Lisp_Object run_hook_trapping_errors (const char *, Lisp_Object);
-Lisp_Object safe_run_hook_trapping_errors (const char *, Lisp_Object, int);
-Lisp_Object call0_trapping_errors (const char *, Lisp_Object);
-Lisp_Object call1_trapping_errors (const char *, Lisp_Object, Lisp_Object);
-Lisp_Object call2_trapping_errors (const char *,
+Lisp_Object run_hook_trapping_errors (CONST char *, Lisp_Object);
+Lisp_Object safe_run_hook_trapping_errors (CONST char *, Lisp_Object, int);
+Lisp_Object call0_trapping_errors (CONST char *, Lisp_Object);
+Lisp_Object call1_trapping_errors (CONST char *, Lisp_Object, Lisp_Object);
+Lisp_Object call2_trapping_errors (CONST char *,
 				   Lisp_Object, Lisp_Object, Lisp_Object);
 Lisp_Object call_with_suspended_errors (lisp_fn_t, volatile Lisp_Object, Lisp_Object,
 					Error_behavior, int, ...);
@@ -2258,7 +2260,7 @@
 void do_autoload (Lisp_Object, Lisp_Object);
 Lisp_Object un_autoload (Lisp_Object);
 void warn_when_safe_lispobj (Lisp_Object, Lisp_Object, Lisp_Object);
-void warn_when_safe (Lisp_Object, Lisp_Object, const char *,
+void warn_when_safe (Lisp_Object, Lisp_Object, CONST char *,
 		     ...) PRINTF_ARGS (3, 4);
 
 
@@ -2269,39 +2271,38 @@
 Lisp_Object enqueue_misc_user_event (Lisp_Object, Lisp_Object, Lisp_Object);
 Lisp_Object enqueue_misc_user_event_pos (Lisp_Object, Lisp_Object,
 					 Lisp_Object, int, int, int, int);
-extern int modifier_keys_are_sticky;
 
 /* Defined in event-Xt.c */
-void enqueue_Xt_dispatch_event (Lisp_Object event);
 void signal_special_Xt_user_event (Lisp_Object, Lisp_Object, Lisp_Object);
 
 
 /* Defined in events.c */
 void clear_event_resource (void);
 Lisp_Object allocate_event (void);
+int event_to_character (Lisp_Event *, int, int, int);
 
 /* Defined in fileio.c */
 void record_auto_save (void);
 void force_auto_save_soon (void);
-DECLARE_DOESNT_RETURN (report_file_error (const char *, Lisp_Object));
-void maybe_report_file_error (const char *, Lisp_Object,
+DECLARE_DOESNT_RETURN (report_file_error (CONST char *, Lisp_Object));
+void maybe_report_file_error (CONST char *, Lisp_Object,
 			      Lisp_Object, Error_behavior);
-DECLARE_DOESNT_RETURN (signal_file_error (const char *, Lisp_Object));
-void maybe_signal_file_error (const char *, Lisp_Object,
+DECLARE_DOESNT_RETURN (signal_file_error (CONST char *, Lisp_Object));
+void maybe_signal_file_error (CONST char *, Lisp_Object,
 			      Lisp_Object, Error_behavior);
-DECLARE_DOESNT_RETURN (signal_double_file_error (const char *, const char *,
+DECLARE_DOESNT_RETURN (signal_double_file_error (CONST char *, CONST char *,
 						 Lisp_Object));
-void maybe_signal_double_file_error (const char *, const char *,
+void maybe_signal_double_file_error (CONST char *, CONST char *,
 				     Lisp_Object, Lisp_Object, Error_behavior);
-DECLARE_DOESNT_RETURN (signal_double_file_error_2 (const char *, const char *,
+DECLARE_DOESNT_RETURN (signal_double_file_error_2 (CONST char *, CONST char *,
 						   Lisp_Object, Lisp_Object));
-void maybe_signal_double_file_error_2 (const char *, const char *,
+void maybe_signal_double_file_error_2 (CONST char *, CONST char *,
 				       Lisp_Object, Lisp_Object, Lisp_Object,
 				       Error_behavior);
 Lisp_Object lisp_strerror (int);
 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object);
-ssize_t read_allowing_quit (int, void *, size_t);
-ssize_t write_allowing_quit (int, const void *, size_t);
+int read_allowing_quit (int, void *, size_t);
+int write_allowing_quit (int, CONST void *, size_t);
 int internal_delete_file (Lisp_Object);
 
 /* Defined in filelock.c */
@@ -2332,6 +2333,7 @@
 Lisp_Object remassq_no_quit (Lisp_Object, Lisp_Object);
 Lisp_Object remrassq_no_quit (Lisp_Object, Lisp_Object);
 
+void pure_put (Lisp_Object, Lisp_Object, Lisp_Object);
 int plists_differ (Lisp_Object, Lisp_Object, int, int, int);
 Lisp_Object internal_plist_get (Lisp_Object, Lisp_Object);
 void internal_plist_put (Lisp_Object *, Lisp_Object, Lisp_Object);
@@ -2348,7 +2350,7 @@
 Lisp_Object vconcat3 (Lisp_Object, Lisp_Object, Lisp_Object);
 Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
 Lisp_Object bytecode_nconc2 (Lisp_Object *);
-void check_losing_bytecode (const char *, Lisp_Object);
+void check_losing_bytecode (CONST char *, Lisp_Object);
 
 /* Defined in getloadavg.c */
 int getloadavg (double[], int);
@@ -2360,7 +2362,6 @@
 /* Defined in indent.c */
 int bi_spaces_at_point (struct buffer *, Bytind);
 int column_at_point (struct buffer *, Bufpos, int);
-int string_column_at_point (Lisp_String *, Bufpos, int);
 int current_column (struct buffer *);
 void invalidate_current_column (void);
 Bufpos vmotion (struct window *, Bufpos, int, int *);
@@ -2374,7 +2375,7 @@
 void close_load_descs (void);
 int locate_file (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object *, int);
 EXFUN (Flocate_file_clear_hashing, 1);
-int isfloat_string (const char *);
+int isfloat_string (CONST char *);
 
 /* Well, I've decided to enable this. -- ben */
 /* And I've decided to make it work right.  -- sb */
@@ -2411,32 +2412,32 @@
 
 /* Defined in minibuf.c */
 extern int minibuf_level;
-Charcount scmp_1 (const Bufbyte *, const Bufbyte *, Charcount, int);
+Charcount scmp_1 (CONST Bufbyte *, CONST Bufbyte *, Charcount, int);
 #define scmp(s1, s2, len) scmp_1 (s1, s2, len, completion_ignore_case)
 extern int completion_ignore_case;
-int regexp_ignore_completion_p (const Bufbyte *, Lisp_Object,
+int regexp_ignore_completion_p (CONST Bufbyte *, Lisp_Object,
 				Bytecount, Bytecount);
 Lisp_Object clear_echo_area (struct frame *, Lisp_Object, int);
 Lisp_Object clear_echo_area_from_print (struct frame *, Lisp_Object, int);
-void echo_area_append (struct frame *, const Bufbyte *, Lisp_Object,
+void echo_area_append (struct frame *, CONST Bufbyte *, Lisp_Object,
 		       Bytecount, Bytecount, Lisp_Object);
-void echo_area_message (struct frame *, const Bufbyte *, Lisp_Object,
+void echo_area_message (struct frame *, CONST Bufbyte *, Lisp_Object,
 			Bytecount, Bytecount, Lisp_Object);
 Lisp_Object echo_area_status (struct frame *);
 int echo_area_active (struct frame *);
 Lisp_Object echo_area_contents (struct frame *);
-void message_internal (const Bufbyte *, Lisp_Object, Bytecount, Bytecount);
-void message_append_internal (const Bufbyte *, Lisp_Object,
+void message_internal (CONST Bufbyte *, Lisp_Object, Bytecount, Bytecount);
+void message_append_internal (CONST Bufbyte *, Lisp_Object,
 			      Bytecount, Bytecount);
-void message (const char *, ...) PRINTF_ARGS (1, 2);
-void message_append (const char *, ...) PRINTF_ARGS (1, 2);
-void message_no_translate (const char *, ...) PRINTF_ARGS (1, 2);
+void message (CONST char *, ...) PRINTF_ARGS (1, 2);
+void message_append (CONST char *, ...) PRINTF_ARGS (1, 2);
+void message_no_translate (CONST char *, ...) PRINTF_ARGS (1, 2);
 void clear_message (void);
 
 /* Defined in print.c */
 void write_string_to_stdio_stream (FILE *, struct console *,
-				   const Bufbyte *, Bytecount, Bytecount,
-				   Lisp_Object, int);
+				   CONST Bufbyte *, Bytecount, Bytecount,
+				   enum external_data_format);
 void debug_print (Lisp_Object);
 void debug_short_backtrace (int);
 void temp_output_buffer_setup (Lisp_Object);
@@ -2444,9 +2445,9 @@
 /* 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) */
-void write_c_string (const char *, Lisp_Object);
+void write_c_string (CONST char *, Lisp_Object);
 /* Same goes for this function. */
-void write_string_1 (const Bufbyte *, Bytecount, Lisp_Object);
+void write_string_1 (CONST Bufbyte *, Bytecount, Lisp_Object);
 void print_cons (Lisp_Object, Lisp_Object, int);
 void print_vector (Lisp_Object, Lisp_Object, int);
 void print_string (Lisp_Object, Lisp_Object, int);
@@ -2463,7 +2464,7 @@
 void internal_object_printer (Lisp_Object, Lisp_Object, int);
 
 /* Defined in profile.c */
-void mark_profiling_info (void);
+void mark_profiling_info (void (*) (Lisp_Object));
 void profile_increase_call_count (Lisp_Object);
 extern int profiling_active;
 extern int profiling_redisplay_flag;
@@ -2485,11 +2486,10 @@
 Bufpos find_next_newline (struct buffer *, Bufpos, int);
 Bufpos find_next_newline_no_quit (struct buffer *, Bufpos, int);
 Bytind bi_find_next_newline_no_quit (struct buffer *, Bytind, int);
-Bytind bi_find_next_emchar_in_string (Lisp_String*, Emchar, Bytind, EMACS_INT);
 Bufpos find_before_next_newline (struct buffer *, Bufpos, Bufpos, int);
 struct re_pattern_buffer *compile_pattern (Lisp_Object, struct re_registers *,
 					   char *, int, Error_behavior);
-Bytecount fast_string_match (Lisp_Object,  const Bufbyte *,
+Bytecount fast_string_match (Lisp_Object,  CONST Bufbyte *,
 			     Lisp_Object, Bytecount,
 			     Bytecount, int, Error_behavior, int);
 Bytecount fast_lisp_string_match (Lisp_Object, Lisp_Object);
@@ -2511,9 +2511,9 @@
 					Error_behavior, int, Lisp_Object);
 
 /* Defined in symbols.c */
-int hash_string (const Bufbyte *, Bytecount);
-Lisp_Object intern (const char *);
-Lisp_Object oblookup (Lisp_Object, const Bufbyte *, Bytecount);
+int hash_string (CONST Bufbyte *, Bytecount);
+Lisp_Object intern (CONST char *);
+Lisp_Object oblookup (Lisp_Object, CONST Bufbyte *, Bytecount);
 void map_obarray (Lisp_Object, int (*) (Lisp_Object, void *), void *);
 Lisp_Object indirect_function (Lisp_Object, int);
 Lisp_Object symbol_value_in_buffer (Lisp_Object, Lisp_Object);
@@ -2527,7 +2527,7 @@
 			      Lisp_Object follow_past_lisp_magic);
 
 /* Defined in syntax.c */
-Bufpos scan_words (struct buffer *, Bufpos, int);
+int scan_words (struct buffer *, int, int);
 
 /* Defined in undo.c */
 Lisp_Object truncate_undo_list (Lisp_Object, int, int);
@@ -2543,7 +2543,7 @@
 #endif
 
 /* Defined in vm-limit.c */
-void memory_warnings (void *, void (*) (const char *));
+void memory_warnings (void *, void (*) (CONST char *));
 
 /* Defined in window.c */
 Lisp_Object save_window_excursion_unwind (Lisp_Object);
@@ -2579,7 +2579,6 @@
 EXFUN (Fchar_after, 2);
 EXFUN (Fchar_to_string, 1);
 EXFUN (Fcheck_valid_plist, 1);
-EXFUN (Fvalid_plist_p, 1);
 EXFUN (Fclear_range_table, 1);
 EXFUN (Fcoding_category_list, 0);
 EXFUN (Fcoding_category_system, 1);
@@ -2610,7 +2609,6 @@
 EXFUN (Fdefault_value, 1);
 EXFUN (Fdefine_key, 3);
 EXFUN (Fdelete_region, 3);
-EXFUN (Fdelete_process, 1);
 EXFUN (Fdelq, 2);
 EXFUN (Fdestructive_alist_to_plist, 1);
 EXFUN (Fdetect_coding_region, 3);
@@ -2660,7 +2658,6 @@
 EXFUN (Fforward_line, 2);
 EXFUN (Ffset, 2);
 EXFUN (Ffuncall, MANY);
-EXFUN (Ffunctionp, 1);
 EXFUN (Fgeq, MANY);
 EXFUN (Fget, 3);
 EXFUN (Fget_buffer_process, 1);
@@ -2688,9 +2685,10 @@
 EXFUN (Fleq, MANY);
 EXFUN (Flist, MANY);
 EXFUN (Flistp, 1);
+#ifdef HAVE_SHLIB
 EXFUN (Flist_modules, 0);
 EXFUN (Fload_module, 3);
-EXFUN (Flookup_key, 3);
+#endif
 EXFUN (Flss, MANY);
 EXFUN (Fmake_byte_code, MANY);
 EXFUN (Fmake_coding_system, 4);
@@ -2739,6 +2737,7 @@
 EXFUN (Fprocess_status, 1);
 EXFUN (Fprogn, UNEVALLED);
 EXFUN (Fprovide, 1);
+EXFUN (Fpurecopy, 1);
 EXFUN (Fput, 3);
 EXFUN (Fput_range_table, 4);
 EXFUN (Fput_text_property, 5);
@@ -2749,7 +2748,6 @@
 EXFUN (Freally_free, 1);
 EXFUN (Frem, 2);
 EXFUN (Fremassq, 2);
-EXFUN (Freplace_list, 2);
 EXFUN (Fselected_frame, 1);
 EXFUN (Fset, 2);
 EXFUN (Fset_coding_category_system, 2);
@@ -2799,100 +2797,82 @@
 EXFUN (Fwiden, 1);
 
 
-extern Lisp_Object Q_style, Qabort, Qactually_requested;
-extern Lisp_Object Qactivate_menubar_hook;
-extern Lisp_Object Qafter, Qall, Qand, Qappend;
+extern Lisp_Object Q_style, Qactually_requested, Qactivate_menubar_hook;
+extern Lisp_Object Qafter, Qall, Qand;
 extern Lisp_Object Qarith_error, Qarrayp, Qassoc, Qat, Qautodetect, Qautoload;
 extern Lisp_Object Qbackground, Qbackground_pixmap, Qbad_variable, Qbefore;
-extern Lisp_Object Qbeginning_of_buffer, Qbig5, Qbinary;
-extern Lisp_Object Qbitmap, Qbitp, Qblinking;
-extern Lisp_Object Qboolean, Qbottom, Qbottom_margin, Qbuffer;
+extern Lisp_Object Qbeginning_of_buffer, Qbig5, Qbinary, Qbitmap, Qbitp, Qblinking;
+extern Lisp_Object Qboolean, Qbottom, Qbuffer, Qbuffer_file_coding_system;
 extern Lisp_Object Qbuffer_glyph_p, Qbuffer_live_p, Qbuffer_read_only, Qbutton;
-extern Lisp_Object Qbyte_code, Qcall_interactively, Qcancel, Qcategory;
+extern Lisp_Object Qbyte_code, Qcall_interactively, Qcategory;
 extern Lisp_Object Qcategory_designator_p, Qcategory_table_value_p, Qccl, Qcdr;
 extern Lisp_Object Qchannel, Qchar, Qchar_or_string_p, Qcharacter, Qcharacterp;
 extern Lisp_Object Qchars, Qcharset_g0, Qcharset_g1, Qcharset_g2, Qcharset_g3;
-extern Lisp_Object Qcenter, Qcircular_list, Qcircular_property_list;
-extern Lisp_Object Qcoding_system_error;
+extern Lisp_Object Qcircular_list, Qcircular_property_list;
+extern Lisp_Object Qcoding_system_error, Qcoding_system_p;
 extern Lisp_Object Qcolor, Qcolor_pixmap_image_instance_p;
 extern Lisp_Object Qcolumns, Qcommand, Qcommandp, Qcompletion_ignore_case;
-extern Lisp_Object Qconsole, Qconsole_live_p, Qconst_specifier, Qcopies, Qcr;
-extern Lisp_Object Qcritical, Qcrlf, Qctext, Qcurrent_menubar, Qctext, Qcursor;
+extern Lisp_Object Qconsole, Qconsole_live_p, Qconst_specifier, Qcr, Qcritical;
+extern Lisp_Object Qcrlf, Qctext, Qcurrent_menubar, Qcursor;
 extern Lisp_Object Qcyclic_variable_indirection, Qdata, Qdead, Qdecode;
 extern Lisp_Object Qdefault, Qdefun, Qdelete, Qdelq, Qdevice, Qdevice_live_p;
-extern Lisp_Object Qdialog;
 extern Lisp_Object Qdim, Qdimension, Qdisabled, Qdisplay, Qdisplay_table;
-extern Lisp_Object Qdoc_string, Qdomain_error, Qduplex, Qdynarr_overhead;
+extern Lisp_Object Qdoc_string, Qdomain_error, Qdynarr_overhead;
 extern Lisp_Object Qempty, Qencode, Qend_of_buffer, Qend_of_file, Qend_open;
 extern Lisp_Object Qeol_cr, Qeol_crlf, Qeol_lf, Qeol_type, Qeq, Qeql, Qequal;
 extern Lisp_Object Qerror, Qerror_conditions, Qerror_message, Qescape_quoted;
 extern Lisp_Object Qeval, Qevent_live_p, Qexit, Qextent_live_p, Qextents;
-extern Lisp_Object Qexternal_debugging_output, Qface, Qfeaturep;
-extern Lisp_Object Qfile_name, Qfile_error;
+extern Lisp_Object Qexternal_debugging_output, Qface, Qfeaturep, Qfile_error;
 extern Lisp_Object Qfont, Qforce_g0_on_output, Qforce_g1_on_output;
 extern Lisp_Object Qforce_g2_on_output, Qforce_g3_on_output, Qforeground;
-extern Lisp_Object Qformat, Qframe, Qframe_live_p, Qfrom_page, Qfull_assoc;
-extern Lisp_Object Qfuncall, Qfunction;
-extern Lisp_Object Qgap_overhead, Qgeneric, Qgeometry, Qglobal, Qheight;
-extern Lisp_Object Qhelp, Qhighlight, Qhorizontal, Qicon;
-extern Lisp_Object Qicon_glyph_p, Qid, Qidentity, Qignore, Qimage, Qinfo;
-extern Lisp_Object Qinherit;
+extern Lisp_Object Qformat, Qframe, Qframe_live_p, Qfunction, Qgap_overhead;
+extern Lisp_Object Qgeneric, Qgeometry, Qglobal, Qheight, Qhighlight, Qicon;
+extern Lisp_Object Qicon_glyph_p, Qid, Qidentity, Qimage, Qinfo, Qinherit;
 extern Lisp_Object Qinhibit_quit, Qinhibit_read_only;
 extern Lisp_Object Qinput_charset_conversion, Qinteger;
 extern Lisp_Object Qinteger_char_or_marker_p, Qinteger_or_char_p;
 extern Lisp_Object Qinteger_or_marker_p, Qintegerp, Qinteractive, Qinternal;
 extern Lisp_Object Qinvalid_function, Qinvalid_read_syntax, Qio_error;
-extern Lisp_Object Qiso2022, Qkey, Qkey_assoc, Qkeyboard, Qkeymap;
-extern Lisp_Object Qlambda, Qlast_command, Qlayout, Qlandscape;
-extern Lisp_Object Qleft, Qleft_margin, Qlet, Qlf;
+extern Lisp_Object Qiso2022, Qkey, Qkey_assoc, Qkeymap, Qlambda, Qleft, Qlf;
 extern Lisp_Object Qlist, Qlistp, Qload, Qlock_shift, Qmacro, Qmagic;
-extern Lisp_Object Qmakunbound, Qmalformed_list, Qmalformed_property_list;
+extern Lisp_Object Qmalformed_list, Qmalformed_property_list;
 extern Lisp_Object Qmalloc_overhead, Qmark, Qmarkers;
-extern Lisp_Object Qmenubar;
 extern Lisp_Object Qmax, Qmemory, Qmessage, Qminus, Qmnemonic, Qmodifiers;
 extern Lisp_Object Qmono_pixmap_image_instance_p, Qmotion;
-extern Lisp_Object Qmouse_leave_buffer_hook, Qmsprinter, Qmswindows;
-extern Lisp_Object Qname, Qnas, Qnatnump, Qnative_layout;
-extern Lisp_Object Qno, Qno_ascii_cntl, Qno_ascii_eol, Qno_catch;
+extern Lisp_Object Qmouse_leave_buffer_hook, Qmswindows, Qname, Qnas, Qnatnump;
+extern Lisp_Object Qno_ascii_cntl, Qno_ascii_eol, Qno_catch;
 extern Lisp_Object Qno_conversion, Qno_iso6429, Qnone, Qnot, Qnothing;
 extern Lisp_Object Qnothing_image_instance_p, Qnotice;
-extern Lisp_Object Qnumber_char_or_marker_p, Qnumberp;
-extern Lisp_Object Qobject, Qok, Qold_assoc, Qold_delete, Qold_delq;
-extern Lisp_Object Qold_rassoc;
-extern Lisp_Object Qold_rassq, Qonly, Qor, Qother;
-extern Lisp_Object Qorientation, Qoutput_charset_conversion;
-extern Lisp_Object Qoverflow_error, Qpoint, Qpointer, Qpointer_glyph_p;
-extern Lisp_Object Qpointer_image_instance_p, Qportrait, Qpost_read_conversion;
-extern Lisp_Object Qpre_write_conversion, Qprint, Qprinter, Qprint_length;
+extern Lisp_Object Qnumber_char_or_marker_p, Qnumber_or_marker_p, Qnumberp;
+extern Lisp_Object Qobject, Qold_assoc, Qold_delete, Qold_delq, Qold_rassoc;
+extern Lisp_Object Qold_rassq, Qonly, Qor, Qother, Qoutput_charset_conversion;
+extern Lisp_Object Qoverflow_error, Qpath, Qpoint, Qpointer, Qpointer_glyph_p;
+extern Lisp_Object Qpointer_image_instance_p, Qpost_read_conversion;
+extern Lisp_Object Qpre_write_conversion, Qprint, Qprint_length;
 extern Lisp_Object Qprint_string_length, Qprocess, Qprogn, Qprovide, Qquit;
 extern Lisp_Object Qquote, Qrange_error, Qrassoc, Qrassq, Qread_char;
 extern Lisp_Object Qread_from_minibuffer, Qreally_early_error_handler;
 extern Lisp_Object Qregion_beginning, Qregion_end, Qrequire, Qresource;
-extern Lisp_Object Qretry, Qreturn, Qreverse, Qright, Qright_margin;
-extern Lisp_Object Qrun_hooks, Qsans_modifiers;
-extern Lisp_Object Qsave_buffers_kill_emacs, Qsearch, Qselected;
-extern Lisp_Object Qself_insert_command, Qself_insert_defer_undo;
-extern Lisp_Object Qsequencep, Qset, Qsetting_constant;
-extern Lisp_Object Qseven, Qshift_jis, Qshort;
+extern Lisp_Object Qreturn, Qreverse, Qright, Qrun_hooks, Qsans_modifiers;
+extern Lisp_Object Qsave_buffers_kill_emacs, Qsearch, Qselected, Qself_insert_command;
+extern Lisp_Object Qsequencep, Qsetting_constant, Qseven, Qshift_jis, Qshort;
 extern Lisp_Object Qsignal, Qsimple, Qsingularity_error, Qsize, Qspace;
 extern Lisp_Object Qspecifier, Qstandard_input, Qstandard_output, Qstart_open;
 extern Lisp_Object Qstream, Qstring, Qstring_lessp, Qsubwindow;
-extern Lisp_Object Qsubwindow_image_instance_p;
-extern Lisp_Object Qsymbol, Qsyntax, Qt, Qterminal, Qtest;
-extern Lisp_Object Qtext, Qtext_image_instance_p, Qthis_command, Qtimeout;
-extern Lisp_Object Qtimestamp, Qtoolbar, Qtop, Qtop_margin, Qtop_level;
-extern Lisp_Object Qto_page, Qtrue_list_p, Qtty, Qtype;
+extern Lisp_Object Qsubwindow_image_instance_p, Qsymbol, Qsyntax, Qt, Qtest;
+extern Lisp_Object Qtext, Qtext_image_instance_p, Qtimeout, Qtimestamp;
+extern Lisp_Object Qtoolbar, Qtop, Qtop_level, Qtrue_list_p, Qtty, Qtype;
 extern Lisp_Object Qunbound, Qundecided, Qundefined, Qunderflow_error;
 extern Lisp_Object Qunderline, Qunimplemented, Quser_files_and_directories;
 extern Lisp_Object Qvalue_assoc, Qvalues;
-extern Lisp_Object Qvariable_documentation, Qvariable_domain, Qvertical;
-extern Lisp_Object Qvoid_function, Qvoid_variable, Qwarning;
-extern Lisp_Object Qwidth, Qwidget, Qwindow;
+extern Lisp_Object Qvariable_documentation, Qvariable_domain, Qvector;
+extern Lisp_Object Qvoid_function, Qvoid_variable, Qwarning, Qwidth, Qwidget, Qwindow;
 extern Lisp_Object Qwindow_live_p, Qwindow_system, Qwrong_number_of_arguments;
-extern Lisp_Object Qwrong_type_argument, Qx, Qy, Qyes, Qyes_or_no_p;
+extern Lisp_Object Qwrong_type_argument, Qx, Qy, Qyes_or_no_p;
 extern Lisp_Object Vactivate_menubar_hook, Vascii_canon_table;
 extern Lisp_Object Vascii_downcase_table, Vascii_eqv_table;
-extern Lisp_Object Vascii_upcase_table, Vautoload_queue, Vblank_menubar;
+extern Lisp_Object Vascii_upcase_table, Vautoload_queue, Vbinary_process_input;
+extern Lisp_Object Vbinary_process_output, Vblank_menubar;
 extern Lisp_Object Vcharset_ascii, Vcharset_composite, Vcharset_control_1;
 extern Lisp_Object Vcoding_system_for_read, Vcoding_system_for_write;
 extern Lisp_Object Vcoding_system_hash_table, Vcommand_history;
@@ -2901,8 +2881,7 @@
 extern Lisp_Object Vconsole_list, Vcontrolling_terminal;
 extern Lisp_Object Vcurrent_compiled_function_annotation, 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 Vdisabled_command_hook, 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;
 extern Lisp_Object Vexecuting_macro, Vfeatures, Vfile_domain;
@@ -2925,6 +2904,9 @@
 extern Lisp_Object Vstandard_input, Vstandard_output, Vstdio_str;
 extern Lisp_Object Vsynchronous_sounds, Vsystem_name, Vterminal_coding_system;
 extern Lisp_Object Vthis_command_keys, Vunread_command_event;
+extern Lisp_Object Vwin32_generate_fake_inodes, Vwin32_pipe_read_delay;
 extern Lisp_Object Vx_initial_argv_list;
 
-#endif /* INCLUDED_lisp_h_ */
+extern Lisp_Object Qmakunbound, Qset;
+
+#endif /* _XEMACS_LISP_H_ */