git.chise.org Git - chise/xemacs-chise.git.1/blob - src/lisp.h

   1 /* Fundamental definitions for XEmacs Lisp interpreter.
   2    Copyright (C) 1985-1987, 1992-1995 Free Software Foundation, Inc.
   3    Copyright (C) 1993-1996 Richard Mlynarik.
   4    Copyright (C) 1995, 1996, 2000 Ben Wing.
   5
   6 This file is part of XEmacs.
   7
   8 XEmacs is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with XEmacs; see the file COPYING.  If not, write to
  20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 /* Synched up with: FSF 19.30. */
  24
  25 #ifndef INCLUDED_lisp_h_
  26 #define INCLUDED_lisp_h_
  27
  28 /************************************************************************/
  29 /*                        general definitions                           */
  30 /************************************************************************/
  31
  32 /* ------------------------ include files ------------------- */
  33
  34 /* We include the following generally useful header files so that you
  35    don't have to worry about prototypes when using the standard C
  36    library functions and macros.  These files shouldn't be excessively
  37    large so they shouldn't cause that much of a slowdown. */
  38
  39 #include <stdlib.h>
  40 #include <string.h>             /* primarily for memcpy, etc. */
  41 #include <stdio.h>              /* NULL, etc. */
  42 #include <ctype.h>
  43 #include <stdarg.h>
  44 #include <stddef.h>             /* offsetof */
  45 #include <sys/types.h>
  46 #include <limits.h>
  47
  48 /* ------------------------ dynamic arrays ------------------- */
  49
  50 #define Dynarr_declare(type)    \
  51   type *base;                   \
  52   int elsize;                   \
  53   int cur;                      \
  54   int largest;                  \
  55   int max
  56
  57 typedef struct dynarr
  58 {
  59   Dynarr_declare (void);
  60 } Dynarr;
  61
  62 void *Dynarr_newf (int elsize);
  63 void Dynarr_resize (void *dy, int size);
  64 void Dynarr_insert_many (void *d, const void *el, int len, int start);
  65 void Dynarr_delete_many (void *d, int start, int len);
  66 void Dynarr_free (void *d);
  67
  68 #define Dynarr_new(type) ((type##_dynarr *) Dynarr_newf (sizeof (type)))
  69 #define Dynarr_new2(dynarr_type, type) \
  70   ((dynarr_type *) Dynarr_newf (sizeof (type)))
  71 #define Dynarr_at(d, pos) ((d)->base[pos])
  72 #define Dynarr_atp(d, pos) (&Dynarr_at (d, pos))
  73 #define Dynarr_begin(d) Dynarr_atp (d, 0)
  74 #define Dynarr_end(d) Dynarr_atp (d, Dynarr_length (d) - 1)
  75 #define Dynarr_sizeof(d) ((d)->cur * (d)->elsize)
  76 #define Dynarr_length(d) ((d)->cur)
  77 #define Dynarr_largest(d) ((d)->largest)
  78 #define Dynarr_reset(d) ((d)->cur = 0)
  79 #define Dynarr_add_many(d, el, len) Dynarr_insert_many (d, el, len, (d)->cur)
  80 #define Dynarr_insert_many_at_start(d, el, len) \
  81   Dynarr_insert_many (d, el, len, 0)
  82 #define Dynarr_add_literal_string(d, s) Dynarr_add_many (d, s, sizeof (s) - 1)
  83 #define Dynarr_add_lisp_string(d, s) do {               \
  84   Lisp_String *dyna_ls_s = XSTRING (s);                 \
  85   Dynarr_add_many (d, (char *) string_data (dyna_ls_s), \
  86                    string_length (dyna_ls_s));          \
  87 } while (0)
  88
  89 #define Dynarr_add(d, el) (                                             \
  90   (d)->cur >= (d)->max ? Dynarr_resize ((d), (d)->cur+1) : (void) 0,    \
  91   ((d)->base)[(d)->cur++] = (el),                                       \
  92   (d)->cur > (d)->largest ? (d)->largest = (d)->cur : (int) 0)
  93
  94 /* The following defines will get you into real trouble if you aren't
  95    careful.  But they can save a lot of execution time when used wisely. */
  96 #define Dynarr_increment(d) ((d)->cur++)
  97 #define Dynarr_set_size(d, n) ((d)->cur = n)
  98
  99 #ifdef MEMORY_USAGE_STATS
 100 struct overhead_stats;
 101 size_t Dynarr_memory_usage (void *d, struct overhead_stats *stats);
 102 #endif
 103
 104 /* Also define min() and max(). (Some compilers put them in strange
 105    places that won't be referenced by the above include files, such
 106    as 'macros.h' under Solaris.) */
 107
 108 #ifndef min
 109 #define min(a,b) (((a) <= (b)) ? (a) : (b))
 110 #endif
 111 #ifndef max
 112 #define max(a,b) (((a) > (b)) ? (a) : (b))
 113 #endif
 114
 115 /* Memory allocation */
 116 void malloc_warning (const char *);
 117 void *xmalloc (size_t size);
 118 void *xmalloc_and_zero (size_t size);
 119 void *xrealloc (void *, size_t size);
 120 char *xstrdup (const char *);
 121 /* generally useful */
 122 #define countof(x) ((int) (sizeof(x)/sizeof((x)[0])))
 123 #define xnew(type) ((type *) xmalloc (sizeof (type)))
 124 #define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type)))
 125 #define xnew_and_zero(type) ((type *) xmalloc_and_zero (sizeof (type)))
 126 #define xzero(lvalue) ((void) memset (&(lvalue), '\0', sizeof (lvalue)))
 127 #define xnew_array_and_zero(type, len) ((type *) xmalloc_and_zero ((len) * sizeof (type)))
 128 #define XREALLOC_ARRAY(ptr, type, len) ((void) (ptr = (type *) xrealloc (ptr, (len) * sizeof (type))))
 129 #define alloca_array(type, len) ((type *) alloca ((len) * sizeof (type)))
 130
 131 /* also generally useful if you want to avoid arbitrary size limits
 132    but don't need a full dynamic array.  Assumes that BASEVAR points
 133    to a malloced array of TYPE objects (or possibly a NULL pointer,
 134    if SIZEVAR is 0), with the total size stored in SIZEVAR.  This
 135    macro will realloc BASEVAR as necessary so that it can hold at
 136    least NEEDED_SIZE objects.  The reallocing is done by doubling,
 137    which ensures constant amortized time per element. */
 138 #define DO_REALLOC(basevar, sizevar, needed_size, type) do {    \
 139   EMACS_INT do_realloc_needed_size = (needed_size);             \
 140   if ((sizevar) < do_realloc_needed_size)                       \
 141     {                                                           \
 142       if ((sizevar) < 32)                                       \
 143         (sizevar) = 32;                                         \
 144       while ((sizevar) < do_realloc_needed_size)                \
 145         (sizevar) *= 2;                                         \
 146       XREALLOC_ARRAY (basevar, type, (sizevar));                \
 147     }                                                           \
 148 } while (0)
 149
 150 #ifdef ERROR_CHECK_MALLOC
 151 void xfree_1 (void *);
 152 #define xfree(lvalue) do                        \
 153 {                                               \
 154   void **xfree_ptr = (void **) &(lvalue);       \
 155   xfree_1 (*xfree_ptr);                         \
 156   *xfree_ptr = (void *) 0xDEADBEEF;             \
 157 } while (0)
 158 #else
 159 void xfree (void *);
 160 #endif /* ERROR_CHECK_MALLOC */
 161
 162 #ifndef PRINTF_ARGS
 163 # if defined (__GNUC__) && (__GNUC__ >= 2)
 164 #  define PRINTF_ARGS(string_index,first_to_check) \
 165           __attribute__ ((format (printf, string_index, first_to_check)))
 166 # else
 167 #  define PRINTF_ARGS(string_index,first_to_check)
 168 # endif /* GNUC */
 169 #endif
 170
 171 #ifndef DOESNT_RETURN
 172 # if defined __GNUC__
 173 #  if ((__GNUC__ > 2) || (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))
 174 #   define DOESNT_RETURN void
 175 #   define DECLARE_DOESNT_RETURN(decl) \
 176            extern void decl __attribute__ ((noreturn))
 177 #   define DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS(decl,str,idx) \
 178      /* Should be able to state multiple independent __attribute__s, but  \
 179         the losing syntax doesn't work that way, and screws losing cpp */ \
 180            extern void decl \
 181                   __attribute__ ((noreturn, format (printf, str, idx)))
 182 #  else
 183 #   define DOESNT_RETURN void volatile
 184 #   define DECLARE_DOESNT_RETURN(decl) extern void volatile decl
 185 #   define DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS(decl,str,idx) \
 186            extern void volatile decl PRINTF_ARGS(str,idx)
 187 #  endif /* GNUC 2.5 */
 188 # else
 189 #  define DOESNT_RETURN void
 190 #  define DECLARE_DOESNT_RETURN(decl) extern void decl
 191 #  define DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS(decl,str,idx) \
 192           extern void decl PRINTF_ARGS(str,idx)
 193 # endif /* GNUC */
 194 #endif
 195
 196 /* No type has a greater alignment requirement than max_align_t.
 197    (except perhaps for types we don't use, like long double) */
 198 typedef union
 199 {
 200   struct { long l; } l;
 201   struct { void *p; } p;
 202   struct { void (*f)(void); } f;
 203   struct { double d; } d;
 204 } max_align_t;
 205
 206 #ifndef ALIGNOF
 207 # if defined (__GNUC__) && (__GNUC__ >= 2)
 208 /* gcc has an extension that gives us exactly what we want. */
 209 #  define ALIGNOF(type) __alignof__ (type)
 210 # elif ! defined (__cplusplus)
 211 /* The following is mostly portable, except that:
 212    - it doesn't work for inside out declarations like void (*) (void).
 213      (so just call ALIGNOF with a typedef'ed name)
 214    - it doesn't work with C++.  The C++ committee has decided,
 215      in its infinite wisdom, that:
 216      "Types must be declared in declarations, not in expressions." */
 217 #  define ALIGNOF(type) offsetof (struct { char c; type member; }, member)
 218 # else
 219 /* C++ is annoying, but it has a big bag of tricks.
 220    The following doesn't have the "inside out" declaration bug C does. */
 221 template<typename T> struct alignment_trick { char c; T member; };
 222 #  define ALIGNOF(type) offsetof (alignment_trick<type>, member)
 223 # endif
 224 #endif /* ALIGNOF */
 225
 226 #define ALIGN_SIZE(len, unit) \
 227   ((((len) + (unit) - 1) / (unit)) * (unit))
 228
 229 /* #### Yuck, this is kind of evil */
 230 #define ALIGN_PTR(ptr, unit) \
 231   ((void *) ALIGN_SIZE ((size_t) (ptr), unit))
 232
 233 #ifndef DO_NOTHING
 234 #define DO_NOTHING do {} while (0)
 235 #endif
 236
 237 #ifndef DECLARE_NOTHING
 238 #define DECLARE_NOTHING struct nosuchstruct
 239 #endif
 240
 241 /* We define assert iff USE_ASSERTIONS or DEBUG_XEMACS is defined.
 242    Otherwise we define it to be empty.  Quantify has shown that the
 243    time the assert checks take is measurable so let's not include them
 244    in production binaries. */
 245
 246 #ifdef USE_ASSERTIONS
 247 /* Highly dubious kludge */
 248 /*   (thanks, Jamie, I feel better now -- ben) */
 249 void assert_failed (const char *, int, const char *);
 250 # define abort() (assert_failed (__FILE__, __LINE__, "abort()"))
 251 # define assert(x) ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, #x))
 252 #else
 253 # ifdef DEBUG_XEMACS
 254 #  define assert(x) ((x) ? (void) 0 : (void) abort ())
 255 # else
 256 #  define assert(x)
 257 # endif
 258 #endif
 259
 260 /*#ifdef DEBUG_XEMACS*/
 261 #define REGISTER
 262 #define register
 263 /*#else*/
 264 /*#define REGISTER register*/
 265 /*#endif*/
 266
 267
 268 /* EMACS_INT is the underlying integral type into which a Lisp_Object must fit.
 269    In particular, it must be large enough to contain a pointer.
 270    config.h can override this, e.g. to use `long long' for bigger lisp ints.
 271
 272    #### In point of fact, it would NOT be a good idea for config.h to mess
 273    with EMACS_INT.  A lot of code makes the basic assumption that EMACS_INT
 274    is the size of a pointer. */
 275
 276 #ifndef SIZEOF_EMACS_INT
 277 # define SIZEOF_EMACS_INT SIZEOF_VOID_P
 278 #endif
 279
 280 #ifndef EMACS_INT
 281 # if   SIZEOF_EMACS_INT == SIZEOF_LONG
 282 #  define EMACS_INT long
 283 # elif SIZEOF_EMACS_INT == SIZEOF_INT
 284 #  define EMACS_INT int
 285 # elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG
 286 #  define EMACS_INT long long
 287 # else
 288 #  error Unable to determine suitable type for EMACS_INT
 289 # endif
 290 #endif
 291
 292 #ifndef EMACS_UINT
 293 # define EMACS_UINT unsigned EMACS_INT
 294 #endif
 295
 296 #define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR)
 297
 298 \f
 299 /************************************************************************/
 300 /*                                typedefs                              */
 301 /************************************************************************/
 302
 303 /* We put typedefs here so that prototype declarations don't choke.
 304    Note that we don't actually declare the structures here (except
 305    maybe for simple structures like Dynarrs); that keeps them private
 306    to the routines that actually use them. */
 307
 308 /* ------------------------------- */
 309 /*     basic char/int typedefs     */
 310 /* ------------------------------- */
 311
 312 /* The definitions we put here use typedefs to attribute specific meaning
 313    to types that by themselves are pretty general.  Stuff pointed to by a
 314    char * or unsigned char * will nearly always be one of four types:
 315    a) pointer to internally-formatted text; b) pointer to text in some
 316    external format, which can be defined as all formats other than the
 317    internal one; c) pure ASCII text; d) binary data that is not meant to
 318    be interpreted as text. [A fifth possible type "e) a general pointer
 319    to memory" should be replaced with void *.]  Using these more specific
 320    types rather than the general ones helps avoid the confusions that
 321    occur when the semantics of a char * argument being studied are unclear. */
 322
 323 typedef unsigned char UChar;
 324
 325 /* The data representing the text in a buffer is logically a set
 326    of Bufbytes, declared as follows. */
 327
 328 typedef UChar Bufbyte;
 329
 330 /* Explicitly signed or unsigned versions: */
 331 typedef UChar UBufbyte;
 332 typedef char  SBufbyte;
 333
 334 /* The data representing a string in "external" format (binary or any
 335    external encoding) is logically a set of Extbytes, declared as
 336    follows.  Extbyte is guaranteed to be just a char, so for example
 337    strlen (Extbyte *) is OK.  Extbyte is only a documentation device
 338    for referring to external text. */
 339
 340 typedef char Extbyte;
 341
 342 /* A byte in a string in binary format: */
 343 typedef char Char_Binary;
 344 typedef UChar UChar_Binary;
 345
 346 /* A byte in a string in entirely US-ASCII format: (Nothing outside
 347  the range 00 - 7F) */
 348
 349 typedef char Char_ASCII;
 350 typedef UChar UChar_ASCII;
 351
 352
 353 /* To the user, a buffer is made up of characters, declared as follows.
 354    In the non-Mule world, characters and Bufbytes are equivalent.
 355    In the Mule world, a character requires (typically) 1 to 4
 356    Bufbytes for its representation in a buffer. */
 357
 358 typedef int Emchar;
 359
 360 /* Different ways of referring to a position in a buffer.  We use
 361    the typedefs in preference to 'EMACS_INT' to make it clearer what
 362    sort of position is being used.  See extents.c for a description
 363    of the different positions.  We put them here instead of in
 364    buffer.h (where they rightfully belong) to avoid syntax errors
 365    in function prototypes. */
 366
 367 typedef EMACS_INT Bufpos;
 368 typedef EMACS_INT Bytind;
 369 typedef EMACS_INT Memind;
 370
 371 /* Counts of bytes or chars */
 372
 373 typedef EMACS_INT Bytecount;
 374 typedef EMACS_INT Charcount;
 375
 376 /* Length in bytes of a string in external format */
 377 typedef EMACS_INT Extcount;
 378
 379 /* ------------------------------- */
 380 /*     structure/other typedefs    */
 381 /* ------------------------------- */
 382
 383 /* Counts of bytes or array elements */
 384 typedef EMACS_INT Memory_count;
 385 typedef EMACS_INT Element_count;
 386
 387 typedef struct lstream Lstream;
 388
 389 typedef unsigned int face_index;
 390
 391 typedef struct
 392 {
 393   Dynarr_declare (struct face_cachel);
 394 } face_cachel_dynarr;
 395
 396 typedef unsigned int glyph_index;
 397
 398 /* This is shared by process.h, events.h and others in future.
 399    See events.h for description */
 400 typedef unsigned int USID;
 401
 402 typedef struct
 403 {
 404   Dynarr_declare (struct glyph_cachel);
 405 } glyph_cachel_dynarr;
 406
 407 struct buffer;                  /* "buffer.h" */
 408 struct console;                 /* "console.h" */
 409 struct device;                  /* "device.h" */
 410 struct extent_fragment;
 411 struct extent;
 412 typedef struct extent *EXTENT;
 413 struct frame;                   /* "frame.h" */
 414 struct window;                  /* "window.h" */
 415 typedef struct Lisp_Event Lisp_Event; /* "events.h" */
 416 typedef struct Lisp_Face Lisp_Face;   /* "faces.h" */
 417 typedef struct Lisp_Process Lisp_Process; /* "procimpl.h" */
 418 struct stat;                    /* <sys/stat.h> */
 419 typedef struct Lisp_Color_Instance Lisp_Color_Instance;
 420 typedef struct Lisp_Font_Instance Lisp_Font_Instance;
 421 typedef struct Lisp_Image_Instance Lisp_Image_Instance;
 422 typedef struct Lisp_Gui_Item Lisp_Gui_Item;
 423 struct display_line;
 424 struct display_glyph_area;
 425 struct display_box;
 426 struct redisplay_info;
 427 struct window_mirror;
 428 struct scrollbar_instance;
 429 struct font_metric_info;
 430 struct face_cachel;
 431 struct console_type_entry;
 432
 433 typedef struct
 434 {
 435   Dynarr_declare (Bufbyte);
 436 } Bufbyte_dynarr;
 437
 438 typedef struct
 439 {
 440   Dynarr_declare (Extbyte);
 441 } Extbyte_dynarr;
 442
 443 typedef struct
 444 {
 445   Dynarr_declare (Emchar);
 446 } Emchar_dynarr;
 447
 448 typedef struct
 449 {
 450   Dynarr_declare (char);
 451 } char_dynarr;
 452
 453 typedef unsigned char unsigned_char;
 454 typedef struct
 455 {
 456   Dynarr_declare (unsigned char);
 457 } unsigned_char_dynarr;
 458
 459 typedef unsigned long unsigned_long;
 460 typedef struct
 461 {
 462   Dynarr_declare (unsigned long);
 463 } unsigned_long_dynarr;
 464
 465 typedef struct
 466 {
 467   Dynarr_declare (int);
 468 } int_dynarr;
 469
 470 typedef struct
 471 {
 472   Dynarr_declare (Bufpos);
 473 } Bufpos_dynarr;
 474
 475 typedef struct
 476 {
 477   Dynarr_declare (Bytind);
 478 } Bytind_dynarr;
 479
 480 typedef struct
 481 {
 482   Dynarr_declare (Charcount);
 483 } Charcount_dynarr;
 484
 485 typedef struct
 486 {
 487   Dynarr_declare (Bytecount);
 488 } Bytecount_dynarr;
 489
 490 typedef struct
 491 {
 492   Dynarr_declare (struct console_type_entry);
 493 } console_type_entry_dynarr;
 494
 495 enum run_hooks_condition
 496 {
 497   RUN_HOOKS_TO_COMPLETION,
 498   RUN_HOOKS_UNTIL_SUCCESS,
 499   RUN_HOOKS_UNTIL_FAILURE
 500 };
 501
 502 #ifdef HAVE_TOOLBARS
 503 enum toolbar_pos
 504 {
 505   TOP_TOOLBAR,
 506   BOTTOM_TOOLBAR,
 507   LEFT_TOOLBAR,
 508   RIGHT_TOOLBAR
 509 };
 510 #endif
 511
 512 enum edge_style
 513 {
 514   EDGE_ETCHED_IN,
 515   EDGE_ETCHED_OUT,
 516   EDGE_BEVEL_IN,
 517   EDGE_BEVEL_OUT
 518 };
 519
 520 #ifndef ERROR_CHECK_TYPECHECK
 521
 522 typedef enum error_behavior
 523 {
 524   ERROR_ME,
 525   ERROR_ME_NOT,
 526   ERROR_ME_WARN
 527 } Error_behavior;
 528
 529 #define ERRB_EQ(a, b) ((a) == (b))
 530
 531 #else
 532
 533 /* By defining it like this, we provide strict type-checking
 534    for code that lazily uses ints. */
 535
 536 typedef struct _error_behavior_struct_
 537 {
 538   int really_unlikely_name_to_have_accidentally_in_a_non_errb_structure;
 539 } Error_behavior;
 540
 541 extern Error_behavior ERROR_ME;
 542 extern Error_behavior ERROR_ME_NOT;
 543 extern Error_behavior ERROR_ME_WARN;
 544
 545 #define ERRB_EQ(a, b)                                                      \
 546  ((a).really_unlikely_name_to_have_accidentally_in_a_non_errb_structure == \
 547   (b).really_unlikely_name_to_have_accidentally_in_a_non_errb_structure)
 548
 549 #endif
 550
 551 enum munge_me_out_the_door
 552 {
 553   MUNGE_ME_FUNCTION_KEY,
 554   MUNGE_ME_KEY_TRANSLATION
 555 };
 556
 557 \f
 558 /************************************************************************/
 559 /*                   Definition of Lisp_Object data type                */
 560 /************************************************************************/
 561
 562 /* Define the fundamental Lisp data structures */
 563
 564 /* This is the set of Lisp data types */
 565
 566 enum Lisp_Type
 567 {
 568   Lisp_Type_Record,
 569   Lisp_Type_Int_Even,
 570   Lisp_Type_Char,
 571   Lisp_Type_Int_Odd
 572 };
 573
 574 #define POINTER_TYPE_P(type) ((type) == Lisp_Type_Record)
 575
 576 /* Overridden by m/next.h */
 577 #ifndef ASSERT_VALID_POINTER
 578 # define ASSERT_VALID_POINTER(pnt) (assert ((((EMACS_UINT) pnt) & 3) == 0))
 579 #endif
 580
 581 #define GCMARKBITS  0
 582 #define GCTYPEBITS  2
 583 #define GCBITS      2
 584 #define INT_GCBITS  1
 585
 586 #define INT_VALBITS (BITS_PER_EMACS_INT - INT_GCBITS)
 587 #define VALBITS (BITS_PER_EMACS_INT - GCBITS)
 588 #define EMACS_INT_MAX ((EMACS_INT) ((1UL << (INT_VALBITS - 1)) -1UL))
 589 #define EMACS_INT_MIN (-(EMACS_INT_MAX) - 1)
 590
 591 #ifdef USE_UNION_TYPE
 592 # include "lisp-union.h"
 593 #else /* !USE_UNION_TYPE */
 594 # include "lisp-disunion.h"
 595 #endif /* !USE_UNION_TYPE */
 596
 597 #define XPNTR(x) ((void *) XPNTRVAL(x))
 598
 599 /* WARNING WARNING WARNING.  You must ensure on your own that proper
 600    GC protection is provided for the elements in this array. */
 601 typedef struct
 602 {
 603   Dynarr_declare (Lisp_Object);
 604 } Lisp_Object_dynarr;
 605
 606 typedef struct
 607 {
 608   Dynarr_declare (Lisp_Object *);
 609 } Lisp_Object_ptr_dynarr;
 610
 611 /* Close your eyes now lest you vomit or spontaneously combust ... */
 612
 613 #define HACKEQ_UNSAFE(obj1, obj2)                               \
 614   (EQ (obj1, obj2) || (!POINTER_TYPE_P (XTYPE (obj1))           \
 615                        && !POINTER_TYPE_P (XTYPE (obj2))        \
 616                        && XCHAR_OR_INT (obj1) == XCHAR_OR_INT (obj2)))
 617
 618 #ifdef DEBUG_XEMACS
 619 extern int debug_issue_ebola_notices;
 620 int eq_with_ebola_notice (Lisp_Object, Lisp_Object);
 621 #define EQ_WITH_EBOLA_NOTICE(obj1, obj2)                                \
 622   (debug_issue_ebola_notices ? eq_with_ebola_notice (obj1, obj2)        \
 623    : EQ (obj1, obj2))
 624 #else
 625 #define EQ_WITH_EBOLA_NOTICE(obj1, obj2) EQ (obj1, obj2)
 626 #endif
 627
 628 /* OK, you can open them again */
 629
 630 \f
 631 /************************************************************************/
 632 /**                  Definitions of basic Lisp objects                 **/
 633 /************************************************************************/
 634
 635 #include "lrecord.h"
 636
 637 /*------------------------------ unbound -------------------------------*/
 638
 639 /* Qunbound is a special Lisp_Object (actually of type
 640    symbol-value-forward), that can never be visible to
 641    the Lisp caller and thus can be used in the C code
 642    to mean "no such value". */
 643
 644 #define UNBOUNDP(val) EQ (val, Qunbound)
 645
 646 /*------------------------------- cons ---------------------------------*/
 647
 648 /* In a cons, the markbit of the car is the gc mark bit */
 649
 650 struct Lisp_Cons
 651 {
 652   struct lrecord_header lheader;
 653   Lisp_Object car, cdr;
 654 };
 655 typedef struct Lisp_Cons Lisp_Cons;
 656
 657 #if 0 /* FSFmacs */
 658 /* Like a cons, but records info on where the text lives that it was read from */
 659 /* This is not really in use now */
 660
 661 struct Lisp_Buffer_Cons
 662 {
 663   Lisp_Object car, cdr;
 664   struct buffer *buffer;
 665   int bufpos;
 666 };
 667 #endif
 668
 669 DECLARE_LRECORD (cons, Lisp_Cons);
 670 #define XCONS(x) XRECORD (x, cons, Lisp_Cons)
 671 #define XSETCONS(x, p) XSETRECORD (x, p, cons)
 672 #define CONSP(x) RECORDP (x, cons)
 673 #define CHECK_CONS(x) CHECK_RECORD (x, cons)
 674 #define CONCHECK_CONS(x) CONCHECK_RECORD (x, cons)
 675
 676 #define CONS_MARKED_P(c) MARKED_RECORD_HEADER_P(&((c)->lheader))
 677 #define MARK_CONS(c) MARK_RECORD_HEADER (&((c)->lheader))
 678
 679 extern Lisp_Object Qnil;
 680
 681 #define NILP(x)  EQ (x, Qnil)
 682 #define XCAR(a) (XCONS (a)->car)
 683 #define XCDR(a) (XCONS (a)->cdr)
 684 #define LISTP(x) (CONSP(x) || NILP(x))
 685
 686 #define CHECK_LIST(x) do {                      \
 687   if (!LISTP (x))                               \
 688     dead_wrong_type_argument (Qlistp, x);       \
 689 } while (0)
 690
 691 #define CONCHECK_LIST(x) do {                   \
 692   if (!LISTP (x))                               \
 693     x = wrong_type_argument (Qlistp, x);        \
 694 } while (0)
 695
 696 /*---------------------- list traversal macros -------------------------*/
 697
 698 /* Note: These macros are for traversing through a list in some format,
 699    and executing code that you specify on each member of the list.
 700
 701    There are two kinds of macros, those requiring surrounding braces, and
 702    those not requiring this.  Which type of macro will be indicated.
 703    The general format for using a brace-requiring macro is
 704
 705    {
 706      LIST_LOOP_3 (elt, list, tail)
 707        execute_code_here;
 708    }
 709
 710    or
 711
 712    {
 713      LIST_LOOP_3 (elt, list, tail)
 714        {
 715          execute_code_here;
 716        }
 717    }
 718
 719    You can put variable declarations between the brace and beginning of
 720    macro, but NOTHING ELSE.
 721
 722    The brace-requiring macros typically declare themselves any arguments
 723    that are initialized and iterated by the macros.  If for some reason
 724    you need to declare these arguments yourself (e.g. to do something on
 725    them before the iteration starts, use the _NO_DECLARE versions of the
 726    macros.)
 727 */
 728
 729 /* There are two basic kinds of macros: those that handle "internal" lists
 730    that are known to be correctly structured (i.e. first element is a cons
 731    or nil, and the car of each cons is also a cons or nil, and there are
 732    no circularities), and those that handle "external" lists, where the
 733    list may have any sort of invalid formation.  This is reflected in
 734    the names: those with "EXTERNAL_" work with external lists, and those
 735    without this prefix work with internal lists.  The internal-list
 736    macros will hit an assertion failure if the structure is ill-formed;
 737    the external-list macros will signal an error in this case, either a
 738    malformed-list error or a circular-list error.
 739
 740    Note also that the simplest external list iterator, EXTERNAL_LIST_LOOP,
 741    does *NOT* check for circularities.  Therefore, make sure you call
 742    QUIT each iteration or so.  However, it's probably easier just to use
 743    EXTERNAL_LIST_LOOP_2, which is easier to use in any case.
 744 */
 745
 746 /* LIST_LOOP and EXTERNAL_LIST_LOOP are the simplest macros.  They don't
 747    require brace surrounding, and iterate through a list, which may or may
 748    not known to be syntactically correct.  EXTERNAL_LIST_LOOP is for those
 749    not known to be correct, and it detects and signals a malformed list
 750    error when encountering a problem.  Circularities, however, are not
 751    handled, and cause looping forever, so make sure to include a QUIT.
 752    These functions also accept two args, TAIL (set progressively to each
 753    cons starting with the first), and LIST, the list to iterate over.
 754    TAIL needs to be defined by the program.
 755
 756    In each iteration, you can retrieve the current list item using XCAR
 757    (tail), or destructively modify the list using XSETCAR (tail,
 758    ...). */
 759
 760 #define LIST_LOOP(tail, list)           \
 761   for (tail = list;                     \
 762        !NILP (tail);                    \
 763        tail = XCDR (tail))
 764
 765 #define EXTERNAL_LIST_LOOP(tail, list)                  \
 766   for (tail = list; !NILP (tail); tail = XCDR (tail))   \
 767      if (!CONSP (tail))                                 \
 768        signal_malformed_list_error (list);              \
 769      else
 770
 771 /* The following macros are the "core" macros for list traversal.
 772
 773    *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. ***
 774
 775    LIST_LOOP_2 and EXTERNAL_LIST_LOOP_2 are the standard, most-often used
 776    macros.  They take two arguments, an element variable ELT and the list
 777    LIST.  ELT is automatically declared, and set to each element in turn
 778    from LIST.
 779
 780    LIST_LOOP_3 and EXTERNAL_LIST_LOOP_3 are the same, but they have a third
 781    argument TAIL, another automatically-declared variable.  At each iteration,
 782    this one points to the cons cell for which ELT is the car.
 783
 784    EXTERNAL_LIST_LOOP_4 is like EXTERNAL_LIST_LOOP_3 but takes an additional
 785    LEN argument, again automatically declared, which counts the number of
 786    iterations gone by.  It is 0 during the first iteration.
 787
 788    EXTERNAL_LIST_LOOP_4_NO_DECLARE is like EXTERNAL_LIST_LOOP_4 but none
 789    of the variables are automatically declared, and so you need to declare
 790    them yourself. (ELT and TAIL are Lisp_Objects, and LEN is an EMACS_INT.)
 791 */
 792
 793 #define LIST_LOOP_2(elt, list)          \
 794   LIST_LOOP_3(elt, list, unused_tail_##elt)
 795
 796 #define LIST_LOOP_3(elt, list, tail)    \
 797   Lisp_Object elt, tail;                \
 798   for (tail = list;                     \
 799        NILP (tail) ?                    \
 800          0 : (elt = XCAR (tail), 1);    \
 801        tail = XCDR (tail))
 802
 803 /* The following macros are for traversing lisp lists.
 804    Signal an error if LIST is not properly acyclic and nil-terminated.
 805
 806    Use tortoise/hare algorithm to check for cycles, but only if it
 807    looks like the list is getting too long.  Not only is the hare
 808    faster than the tortoise; it even gets a head start! */
 809
 810 /* Optimized and safe macros for looping over external lists.  */
 811 #define CIRCULAR_LIST_SUSPICION_LENGTH 1024
 812
 813 #define EXTERNAL_LIST_LOOP_1(list)                                      \
 814 Lisp_Object ELL1_elt, ELL1_hare, ELL1_tortoise;                         \
 815 EMACS_INT ELL1_len;                                                     \
 816 PRIVATE_EXTERNAL_LIST_LOOP_6 (ELL1_elt, list, ELL1_len, ELL1_hare,      \
 817                       ELL1_tortoise, CIRCULAR_LIST_SUSPICION_LENGTH)
 818
 819 #define EXTERNAL_LIST_LOOP_2(elt, list)                                 \
 820 Lisp_Object elt, hare_##elt, tortoise_##elt;                            \
 821 EMACS_INT len_##elt;                                                    \
 822 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt,         \
 823                       tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
 824
 825 #define EXTERNAL_LIST_LOOP_3(elt, list, tail)                           \
 826 Lisp_Object elt, tail, tortoise_##elt;                                  \
 827 EMACS_INT len_##elt;                                                    \
 828 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, tail,               \
 829                       tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
 830
 831 #define EXTERNAL_LIST_LOOP_4_NO_DECLARE(elt, list, tail, len)           \
 832 Lisp_Object tortoise_##elt;                                             \
 833 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, tail,                     \
 834                       tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
 835
 836 #define EXTERNAL_LIST_LOOP_4(elt, list, tail, len)                      \
 837 Lisp_Object elt, tail, tortoise_##elt;                                  \
 838 EMACS_INT len;                                                          \
 839 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, tail,                     \
 840                       tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH)
 841
 842
 843 #define PRIVATE_EXTERNAL_LIST_LOOP_6(elt, list, len, hare,              \
 844                                      tortoise, suspicion_length)        \
 845   for (tortoise = hare = list, len = 0;                                 \
 846                                                                         \
 847        (CONSP (hare) ? ((elt = XCAR (hare)), 1) :                       \
 848         (NILP (hare) ? 0 :                                              \
 849          (signal_malformed_list_error (list), 0)));                     \
 850                                                                         \
 851        hare = XCDR (hare),                                              \
 852          (void)                                                         \
 853          ((++len > suspicion_length)                                    \
 854           &&                                                            \
 855           ((((len & 1) != 0) && (tortoise = XCDR (tortoise), 0)),       \
 856            (EQ (hare, tortoise) && (signal_circular_list_error (list), 0)))))
 857
 858 /* GET_LIST_LENGTH and GET_EXTERNAL_LIST_LENGTH:
 859
 860    These two macros return the length of LIST (either an internal or external
 861    list, according to which macro is used), stored into LEN (which must
 862    be declared by the caller).  Circularities are trapped in external lists
 863    (and cause errors).  Neither macro need be declared inside brackets. */
 864
 865 #define GET_LIST_LENGTH(list, len) do {         \
 866   Lisp_Object GLL_tail;                         \
 867   for (GLL_tail = list, len = 0;                \
 868        !NILP (GLL_tail);                        \
 869        GLL_tail = XCDR (GLL_tail), ++len)       \
 870     DO_NOTHING;                                 \
 871 } while (0)
 872
 873 #define GET_EXTERNAL_LIST_LENGTH(list, len)                             \
 874 do {                                                                    \
 875   Lisp_Object GELL_elt, GELL_tail;                                      \
 876   EXTERNAL_LIST_LOOP_4_NO_DECLARE (GELL_elt, list, GELL_tail, len)      \
 877     ;                                                                   \
 878 } while (0)
 879
 880 /* For a list that's known to be in valid list format, where we may
 881    be deleting the current element out of the list --
 882    will abort() if the list is not in valid format */
 883 #define LIST_LOOP_DELETING(consvar, nextconsvar, list)          \
 884   for (consvar = list;                                          \
 885        !NILP (consvar) ? (nextconsvar = XCDR (consvar), 1) :0;  \
 886        consvar = nextconsvar)
 887
 888 /* LIST_LOOP_DELETE_IF and EXTERNAL_LIST_LOOP_DELETE_IF:
 889
 890    These two macros delete all elements of LIST (either an internal or
 891    external list, according to which macro is used) satisfying
 892    CONDITION, a C expression referring to variable ELT.  ELT is
 893    automatically declared.  Circularities are trapped in external
 894    lists (and cause errors).  Neither macro need be declared inside
 895    brackets. */
 896
 897 #define LIST_LOOP_DELETE_IF(elt, list, condition) do {          \
 898   /* Do not use ##list when creating new variables because      \
 899      that may not be just a variable name. */                   \
 900   Lisp_Object prev_tail_##elt = Qnil;                           \
 901   LIST_LOOP_3 (elt, list, tail_##elt)                           \
 902     {                                                           \
 903       if (condition)                                            \
 904         {                                                       \
 905           if (NILP (prev_tail_##elt))                           \
 906             list = XCDR (tail_##elt);                           \
 907           else                                                  \
 908             XCDR (prev_tail_##elt) = XCDR (tail_##elt); \
 909         }                                                       \
 910       else                                                      \
 911         prev_tail_##elt = tail_##elt;                           \
 912     }                                                           \
 913 } while (0)
 914
 915 #define EXTERNAL_LIST_LOOP_DELETE_IF(elt, list, condition) do { \
 916   Lisp_Object prev_tail_##elt = Qnil;                           \
 917   EXTERNAL_LIST_LOOP_4 (elt, list, tail_##elt, len_##elt)       \
 918     {                                                           \
 919       if (condition)                                            \
 920         {                                                       \
 921           if (NILP (prev_tail_##elt))                           \
 922             list = XCDR (tail_##elt);                           \
 923           else                                                  \
 924             XCDR (prev_tail_##elt) = XCDR (tail_##elt);         \
 925           /* Keep tortoise from ever passing hare. */           \
 926           len_##elt = 0;                                        \
 927         }                                                       \
 928       else                                                      \
 929         prev_tail_##elt = tail_##elt;                           \
 930     }                                                           \
 931 } while (0)
 932
 933
 934 /* Macros for looping over external alists.
 935
 936    *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. ***
 937
 938    EXTERNAL_ALIST_LOOP_4 is similar to EXTERNAL_LIST_LOOP_2, but it
 939    assumes the elements are aconses (the elements in an alist) and
 940    sets two additional argument variables ELT_CAR and ELT_CDR to the
 941    car and cdr of the acons.  All of the variables ELT, ELT_CAR and
 942    ELT_CDR are automatically declared.
 943
 944    EXTERNAL_ALIST_LOOP_5 adds a TAIL argument to EXTERNAL_ALIST_LOOP_4,
 945    just like EXTERNAL_LIST_LOOP_3 does, and again TAIL is automatically
 946    declared.
 947
 948    EXTERNAL_ALIST_LOOP_6 adds a LEN argument to EXTERNAL_ALIST_LOOP_5,
 949    just like EXTERNAL_LIST_LOOP_4 does, and again LEN is automatically
 950    declared.
 951
 952    EXTERNAL_ALIST_LOOP_6_NO_DECLARE does not declare any of its arguments,
 953    just like EXTERNAL_LIST_LOOP_4_NO_DECLARE, and so these must be declared
 954    manually.
 955  */
 956
 957 /* Optimized and safe macros for looping over external alists. */
 958 #define EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, list)      \
 959 Lisp_Object elt, elt_car, elt_cdr;                              \
 960 Lisp_Object hare_##elt, tortoise_##elt;                         \
 961 EMACS_INT len_##elt;                                            \
 962 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list,     \
 963                        len_##elt, hare_##elt, tortoise_##elt,   \
 964                        CIRCULAR_LIST_SUSPICION_LENGTH)
 965
 966 #define EXTERNAL_ALIST_LOOP_5(elt, elt_car, elt_cdr, list, tail)        \
 967 Lisp_Object elt, elt_car, elt_cdr, tail;                                \
 968 Lisp_Object tortoise_##elt;                                             \
 969 EMACS_INT len_##elt;                                                    \
 970 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list,             \
 971                        len_##elt, tail, tortoise_##elt,                 \
 972                        CIRCULAR_LIST_SUSPICION_LENGTH)                  \
 973
 974 #define EXTERNAL_ALIST_LOOP_6(elt, elt_car, elt_cdr, list, tail, len)   \
 975 Lisp_Object elt, elt_car, elt_cdr, tail;                                \
 976 EMACS_INT len;                                                          \
 977 Lisp_Object tortoise_##elt;                                             \
 978 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list,             \
 979                        len, tail, tortoise_##elt,                       \
 980                        CIRCULAR_LIST_SUSPICION_LENGTH)
 981
 982 #define EXTERNAL_ALIST_LOOP_6_NO_DECLARE(elt, elt_car, elt_cdr, list,   \
 983                                          tail, len)                     \
 984 Lisp_Object tortoise_##elt;                                             \
 985 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list,             \
 986                        len, tail, tortoise_##elt,                       \
 987                        CIRCULAR_LIST_SUSPICION_LENGTH)
 988
 989
 990 #define PRIVATE_EXTERNAL_ALIST_LOOP_8(elt, elt_car, elt_cdr, list, len, \
 991                                       hare, tortoise, suspicion_length) \
 992 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, hare, tortoise,           \
 993                               suspicion_length)                         \
 994   if (CONSP (elt) ? (elt_car = XCAR (elt), elt_cdr = XCDR (elt), 0) :1) \
 995     continue;                                                           \
 996   else
 997
 998 /* Macros for looping over external property lists.
 999
1000    *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. ***
1001
1002    EXTERNAL_PROPERTY_LIST_LOOP_3 maps over an external list assumed to
1003    be a property list, consisting of alternating pairs of keys
1004    (typically symbols or keywords) and values.  Each iteration
1005    processes one such pair out of LIST, assigning the two elements to
1006    KEY and VALUE respectively.  Malformed lists and circularities are
1007    trapped as usual, and in addition, property lists with an odd number
1008    of elements also signal an error.
1009
1010    EXTERNAL_PROPERTY_LIST_LOOP_4 adds a TAIL argument to
1011    EXTERNAL_PROPERTY_LIST_LOOP_3, just like EXTERNAL_LIST_LOOP_3 does,
1012    and again TAIL is automatically declared.
1013
1014    EXTERNAL_PROPERTY_LIST_LOOP_5 adds a LEN argument to
1015    EXTERNAL_PROPERTY_LIST_LOOP_4, just like EXTERNAL_LIST_LOOP_4 does,
1016    and again LEN is automatically declared.  Note that in this case,
1017    LEN counts the iterations, NOT the total number of list elements
1018    processed, which is 2 * LEN.
1019
1020    EXTERNAL_PROPERTY_LIST_LOOP_5_NO_DECLARE does not declare any of its
1021    arguments, just like EXTERNAL_LIST_LOOP_4_NO_DECLARE, and so these
1022    must be declared manually.  */
1023
1024 /* Optimized and safe macros for looping over external property lists. */
1025 #define EXTERNAL_PROPERTY_LIST_LOOP_3(key, value, list)                 \
1026 Lisp_Object key, value, hare_##key, tortoise_##key;                     \
1027 EMACS_INT len_##key;                                                    \
1028 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, hare_##key, \
1029                      tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH)
1030
1031 #define EXTERNAL_PROPERTY_LIST_LOOP_4(key, value, list, tail)           \
1032 Lisp_Object key, value, tail, tortoise_##key;                           \
1033 EMACS_INT len_##key;                                                    \
1034 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, tail,       \
1035                      tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH)
1036
1037 #define EXTERNAL_PROPERTY_LIST_LOOP_5(key, value, list, tail, len)      \
1038 Lisp_Object key, value, tail, tortoise_##key;                           \
1039 EMACS_INT len;                                                          \
1040 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail,             \
1041                      tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH)
1042
1043 #define EXTERNAL_PROPERTY_LIST_LOOP_5_NO_DECLARE(key, value, list,      \
1044                                                  tail, len)             \
1045 Lisp_Object tortoise_##key;                                             \
1046 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail,             \
1047                      tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH)
1048
1049
1050 #define EXTERNAL_PROPERTY_LIST_LOOP_7(key, value, list, len, hare,      \
1051                              tortoise, suspicion_length)                \
1052   for (tortoise = hare = list, len = 0;                                 \
1053                                                                         \
1054        ((CONSP (hare) &&                                                \
1055          (key = XCAR (hare),                                            \
1056           hare = XCDR (hare),                                           \
1057           (CONSP (hare) ? 1 :                                           \
1058            (signal_malformed_property_list_error (list), 0)))) ?        \
1059         (value = XCAR (hare), 1) :                                      \
1060         (NILP (hare) ? 0 :                                              \
1061          (signal_malformed_property_list_error (list), 0)));            \
1062                                                                         \
1063        hare = XCDR (hare),                                              \
1064          ((++len < suspicion_length) ?                                  \
1065           ((void) 0) :                                                  \
1066           (((len & 1) ?                                                 \
1067             ((void) (tortoise = XCDR (XCDR (tortoise)))) :              \
1068             ((void) 0))                                                 \
1069            ,                                                            \
1070            (EQ (hare, tortoise) ?                                       \
1071             ((void) signal_circular_property_list_error (list)) :       \
1072             ((void) 0)))))
1073
1074 /* For a property list (alternating keywords/values) that may not be
1075    in valid list format -- will signal an error if the list is not in
1076    valid format.  CONSVAR is used to keep track of the iterations
1077    without modifying PLIST.
1078
1079    We have to be tricky to still keep the same C format.*/
1080 #define EXTERNAL_PROPERTY_LIST_LOOP(tail, key, value, plist)    \
1081   for (tail = plist;                                            \
1082        (CONSP (tail) && CONSP (XCDR (tail)) ?                   \
1083         (key = XCAR (tail), value = XCAR (XCDR (tail))) :       \
1084         (key = Qunbound,    value = Qunbound)),                 \
1085        !NILP (tail);                                            \
1086        tail = XCDR (XCDR (tail)))                               \
1087     if (UNBOUNDP (key))                                         \
1088       Fsignal (Qmalformed_property_list, list1 (plist));        \
1089     else
1090
1091 #define PROPERTY_LIST_LOOP(tail, key, value, plist)     \
1092   for (tail = plist;                                    \
1093        NILP (tail) ? 0 :                                \
1094          (key   = XCAR (tail), tail = XCDR (tail),      \
1095           value = XCAR (tail), tail = XCDR (tail), 1);  \
1096        )
1097
1098 /* Return 1 if LIST is properly acyclic and nil-terminated, else 0. */
1099 INLINE_HEADER int TRUE_LIST_P (Lisp_Object object);
1100 INLINE_HEADER int
1101 TRUE_LIST_P (Lisp_Object object)
1102 {
1103   Lisp_Object hare, tortoise;
1104   EMACS_INT len;
1105
1106   for (hare = tortoise = object, len = 0;
1107        CONSP (hare);
1108        hare = XCDR (hare), len++)
1109     {
1110       if (len < CIRCULAR_LIST_SUSPICION_LENGTH)
1111         continue;
1112
1113       if (len & 1)
1114         tortoise = XCDR (tortoise);
1115       else if (EQ (hare, tortoise))
1116         return 0;
1117     }
1118
1119   return NILP (hare);
1120 }
1121
1122 /* Signal an error if LIST is not properly acyclic and nil-terminated. */
1123 #define CHECK_TRUE_LIST(list) do {                      \
1124   Lisp_Object CTL_list = (list);                        \
1125   Lisp_Object CTL_hare, CTL_tortoise;                   \
1126   EMACS_INT CTL_len;                                    \
1127                                                         \
1128   for (CTL_hare = CTL_tortoise = CTL_list, CTL_len = 0; \
1129        CONSP (CTL_hare);                                \
1130        CTL_hare = XCDR (CTL_hare), CTL_len++)           \
1131     {                                                   \
1132       if (CTL_len < CIRCULAR_LIST_SUSPICION_LENGTH)     \
1133         continue;                                       \
1134                                                         \
1135       if (CTL_len & 1)                                  \
1136         CTL_tortoise = XCDR (CTL_tortoise);             \
1137       else if (EQ (CTL_hare, CTL_tortoise))             \
1138         Fsignal (Qcircular_list, list1 (CTL_list));     \
1139     }                                                   \
1140                                                         \
1141   if (! NILP (CTL_hare))                                \
1142     signal_malformed_list_error (CTL_list);             \
1143 } while (0)
1144
1145 /*------------------------------ string --------------------------------*/
1146
1147 struct Lisp_String
1148 {
1149   struct lrecord_header lheader;
1150   Bytecount size;
1151   Bufbyte *data;
1152   Lisp_Object plist;
1153 };
1154 typedef struct Lisp_String Lisp_String;
1155
1156 DECLARE_LRECORD (string, Lisp_String);
1157 #define XSTRING(x) XRECORD (x, string, Lisp_String)
1158 #define XSETSTRING(x, p) XSETRECORD (x, p, string)
1159 #define STRINGP(x) RECORDP (x, string)
1160 #define CHECK_STRING(x) CHECK_RECORD (x, string)
1161 #define CONCHECK_STRING(x) CONCHECK_RECORD (x, string)
1162
1163 #ifdef MULE
1164
1165 Charcount bytecount_to_charcount (const Bufbyte *ptr, Bytecount len);
1166 Bytecount charcount_to_bytecount (const Bufbyte *ptr, Charcount len);
1167
1168 #else /* not MULE */
1169
1170 # define bytecount_to_charcount(ptr, len) (len)
1171 # define charcount_to_bytecount(ptr, len) (len)
1172
1173 #endif /* not MULE */
1174
1175 #define string_length(s) ((s)->size)
1176 #define XSTRING_LENGTH(s) string_length (XSTRING (s))
1177 #define XSTRING_CHAR_LENGTH(s) string_char_length (XSTRING (s))
1178 #define string_data(s) ((s)->data + 0)
1179 #define XSTRING_DATA(s) string_data (XSTRING (s))
1180 #define string_byte(s, i) ((s)->data[i] + 0)
1181 #define XSTRING_BYTE(s, i) string_byte (XSTRING (s), i)
1182 #define string_byte_addr(s, i) (&((s)->data[i]))
1183 #define set_string_length(s, len) ((void) ((s)->size = (len)))
1184 #define set_string_data(s, ptr) ((void) ((s)->data = (ptr)))
1185 #define set_string_byte(s, i, b) ((void) ((s)->data[i] = (b)))
1186
1187 void resize_string (Lisp_String *s, Bytecount pos, Bytecount delta);
1188
1189 #ifdef MULE
1190
1191 INLINE_HEADER Charcount string_char_length (Lisp_String *s);
1192 INLINE_HEADER Charcount
1193 string_char_length (Lisp_String *s)
1194 {
1195   return bytecount_to_charcount (string_data (s), string_length (s));
1196 }
1197
1198 # define string_char(s, i) charptr_emchar_n (string_data (s), i)
1199 # define string_char_addr(s, i) charptr_n_addr (string_data (s), i)
1200 void set_string_char (Lisp_String *s, Charcount i, Emchar c);
1201
1202 #else /* not MULE */
1203
1204 # define string_char_length(s) string_length (s)
1205 # define string_char(s, i) ((Emchar) string_byte (s, i))
1206 # define string_char_addr(s, i) string_byte_addr (s, i)
1207 # define set_string_char(s, i, c) set_string_byte (s, i, (Bufbyte)c)
1208
1209 #endif /* not MULE */
1210
1211 /* Return the true aligned size of a struct whose last member is a
1212    variable-length array field.  (this is known as the "struct hack") */
1213 /* Implementation: in practice, structtype and fieldtype usually have
1214    the same alignment, but we can't be sure.  We need to use
1215    ALIGN_SIZE to be absolutely sure of getting the correct alignment.
1216    To help the compiler's optimizer, we use a ternary expression that
1217    only a very stupid compiler would fail to correctly simplify. */
1218 #define FLEXIBLE_ARRAY_STRUCT_SIZEOF(structtype,        \
1219                                      fieldtype,         \
1220                                      fieldname,         \
1221                                      array_length)      \
1222 (ALIGNOF (structtype) == ALIGNOF (fieldtype)            \
1223  ? (offsetof (structtype, fieldname) +                  \
1224     (offsetof (structtype, fieldname[1]) -              \
1225      offsetof (structtype, fieldname[0])) *             \
1226     (array_length))                                     \
1227  : (ALIGN_SIZE                                          \
1228     ((offsetof (structtype, fieldname) +                \
1229       (offsetof (structtype, fieldname[1]) -            \
1230        offsetof (structtype, fieldname[0])) *           \
1231       (array_length)),                                  \
1232      ALIGNOF (structtype))))
1233
1234 /*------------------------------ vector --------------------------------*/
1235
1236 struct Lisp_Vector
1237 {
1238   struct lcrecord_header header;
1239   long size;
1240   /* next is now chained through v->contents[size], terminated by Qzero.
1241      This means that pure vectors don't need a "next" */
1242   /* struct Lisp_Vector *next; */
1243   Lisp_Object contents[1];
1244 };
1245 typedef struct Lisp_Vector Lisp_Vector;
1246
1247 DECLARE_LRECORD (vector, Lisp_Vector);
1248 #define XVECTOR(x) XRECORD (x, vector, Lisp_Vector)
1249 #define XSETVECTOR(x, p) XSETRECORD (x, p, vector)
1250 #define VECTORP(x) RECORDP (x, vector)
1251 #define CHECK_VECTOR(x) CHECK_RECORD (x, vector)
1252 #define CONCHECK_VECTOR(x) CONCHECK_RECORD (x, vector)
1253
1254 #define vector_length(v) ((v)->size)
1255 #define XVECTOR_LENGTH(s) vector_length (XVECTOR (s))
1256 #define vector_data(v) ((v)->contents)
1257 #define XVECTOR_DATA(s) vector_data (XVECTOR (s))
1258
1259 /*---------------------------- bit vectors -----------------------------*/
1260
1261 #if (LONGBITS < 16)
1262 #error What the hell?!
1263 #elif (LONGBITS < 32)
1264 # define LONGBITS_LOG2 4
1265 # define LONGBITS_POWER_OF_2 16
1266 #elif (LONGBITS < 64)
1267 # define LONGBITS_LOG2 5
1268 # define LONGBITS_POWER_OF_2 32
1269 #elif (LONGBITS < 128)
1270 # define LONGBITS_LOG2 6
1271 # define LONGBITS_POWER_OF_2 64
1272 #else
1273 #error You really have 128-bit integers?!
1274 #endif
1275
1276 struct Lisp_Bit_Vector
1277 {
1278   struct lrecord_header lheader;
1279   Lisp_Object next;
1280   EMACS_INT size;
1281   unsigned long bits[1];
1282 };
1283 typedef struct Lisp_Bit_Vector Lisp_Bit_Vector;
1284
1285 DECLARE_LRECORD (bit_vector, Lisp_Bit_Vector);
1286 #define XBIT_VECTOR(x) XRECORD (x, bit_vector, Lisp_Bit_Vector)
1287 #define XSETBIT_VECTOR(x, p) XSETRECORD (x, p, bit_vector)
1288 #define BIT_VECTORP(x) RECORDP (x, bit_vector)
1289 #define CHECK_BIT_VECTOR(x) CHECK_RECORD (x, bit_vector)
1290 #define CONCHECK_BIT_VECTOR(x) CONCHECK_RECORD (x, bit_vector)
1291
1292 #define BITP(x) (INTP (x) && (XINT (x) == 0 || XINT (x) == 1))
1293
1294 #define CHECK_BIT(x) do {               \
1295   if (!BITP (x))                        \
1296     dead_wrong_type_argument (Qbitp, x);\
1297 } while (0)
1298
1299 #define CONCHECK_BIT(x) do {            \
1300   if (!BITP (x))                        \
1301     x = wrong_type_argument (Qbitp, x); \
1302 } while (0)
1303
1304 #define bit_vector_length(v) ((v)->size)
1305 #define bit_vector_next(v) ((v)->next)
1306
1307 INLINE_HEADER int bit_vector_bit (Lisp_Bit_Vector *v, size_t n);
1308 INLINE_HEADER int
1309 bit_vector_bit (Lisp_Bit_Vector *v, size_t n)
1310 {
1311   return ((v->bits[n >> LONGBITS_LOG2] >> (n & (LONGBITS_POWER_OF_2 - 1)))
1312           & 1);
1313 }
1314
1315 INLINE_HEADER void set_bit_vector_bit (Lisp_Bit_Vector *v, size_t n, int value);
1316 INLINE_HEADER void
1317 set_bit_vector_bit (Lisp_Bit_Vector *v, size_t n, int value)
1318 {
1319   if (value)
1320     v->bits[n >> LONGBITS_LOG2] |= (1UL << (n & (LONGBITS_POWER_OF_2 - 1)));
1321   else
1322     v->bits[n >> LONGBITS_LOG2] &= ~(1UL << (n & (LONGBITS_POWER_OF_2 - 1)));
1323 }
1324
1325 /* Number of longs required to hold LEN bits */
1326 #define BIT_VECTOR_LONG_STORAGE(len) \
1327   (((len) + LONGBITS_POWER_OF_2 - 1) >> LONGBITS_LOG2)
1328
1329 /*------------------------------ symbol --------------------------------*/
1330
1331 typedef struct Lisp_Symbol Lisp_Symbol;
1332 struct Lisp_Symbol
1333 {
1334   struct lrecord_header lheader;
1335   /* next symbol in this obarray bucket */
1336   Lisp_Symbol *next;
1337   Lisp_String *name;
1338   Lisp_Object value;
1339   Lisp_Object function;
1340   Lisp_Object plist;
1341 };
1342
1343 #define SYMBOL_IS_KEYWORD(sym)                                          \
1344   ((string_byte (symbol_name (XSYMBOL (sym)), 0) == ':')                \
1345    && EQ (sym, oblookup (Vobarray,                                      \
1346                          string_data (symbol_name (XSYMBOL (sym))),     \
1347                          string_length (symbol_name (XSYMBOL (sym))))))
1348 #define KEYWORDP(obj) (SYMBOLP (obj) && SYMBOL_IS_KEYWORD (obj))
1349
1350 DECLARE_LRECORD (symbol, Lisp_Symbol);
1351 #define XSYMBOL(x) XRECORD (x, symbol, Lisp_Symbol)
1352 #define XSETSYMBOL(x, p) XSETRECORD (x, p, symbol)
1353 #define SYMBOLP(x) RECORDP (x, symbol)
1354 #define CHECK_SYMBOL(x) CHECK_RECORD (x, symbol)
1355 #define CONCHECK_SYMBOL(x) CONCHECK_RECORD (x, symbol)
1356
1357 #define symbol_next(s) ((s)->next)
1358 #define symbol_name(s) ((s)->name)
1359 #define symbol_value(s) ((s)->value)
1360 #define symbol_function(s) ((s)->function)
1361 #define symbol_plist(s) ((s)->plist)
1362
1363 /*------------------------------- subr ---------------------------------*/
1364
1365 typedef Lisp_Object (*lisp_fn_t) (void);
1366
1367 struct Lisp_Subr
1368 {
1369   struct lrecord_header lheader;
1370   short min_args;
1371   short max_args;
1372   const char *prompt;
1373   const char *doc;
1374   const char *name;
1375   lisp_fn_t subr_fn;
1376 };
1377 typedef struct Lisp_Subr Lisp_Subr;
1378
1379 DECLARE_LRECORD (subr, Lisp_Subr);
1380 #define XSUBR(x) XRECORD (x, subr, Lisp_Subr)
1381 #define XSETSUBR(x, p) XSETRECORD (x, p, subr)
1382 #define SUBRP(x) RECORDP (x, subr)
1383 #define CHECK_SUBR(x) CHECK_RECORD (x, subr)
1384 #define CONCHECK_SUBR(x) CONCHECK_RECORD (x, subr)
1385
1386 #define subr_function(subr) ((subr)->subr_fn)
1387 #define SUBR_FUNCTION(subr,max_args) \
1388   ((Lisp_Object (*) (EXFUN_##max_args)) (subr)->subr_fn)
1389 #define subr_name(subr) ((subr)->name)
1390
1391 /*------------------------------ marker --------------------------------*/
1392
1393
1394 typedef struct Lisp_Marker Lisp_Marker;
1395 struct Lisp_Marker
1396 {
1397   struct lrecord_header lheader;
1398   Lisp_Marker *next;
1399   Lisp_Marker *prev;
1400   struct buffer *buffer;
1401   Memind memind;
1402   char insertion_type;
1403 };
1404
1405 DECLARE_LRECORD (marker, Lisp_Marker);
1406 #define XMARKER(x) XRECORD (x, marker, Lisp_Marker)
1407 #define XSETMARKER(x, p) XSETRECORD (x, p, marker)
1408 #define MARKERP(x) RECORDP (x, marker)
1409 #define CHECK_MARKER(x) CHECK_RECORD (x, marker)
1410 #define CONCHECK_MARKER(x) CONCHECK_RECORD (x, marker)
1411
1412 /* The second check was looking for GCed markers still in use */
1413 /* if (INTP (XMARKER (x)->lheader.next.v)) abort (); */
1414
1415 #define marker_next(m) ((m)->next)
1416 #define marker_prev(m) ((m)->prev)
1417
1418 /*------------------------------- char ---------------------------------*/
1419
1420 #define CHARP(x) (XTYPE (x) == Lisp_Type_Char)
1421
1422 #ifdef ERROR_CHECK_TYPECHECK
1423
1424 INLINE_HEADER Emchar XCHAR (Lisp_Object obj);
1425 INLINE_HEADER Emchar
1426 XCHAR (Lisp_Object obj)
1427 {
1428   assert (CHARP (obj));
1429   return XCHARVAL (obj);
1430 }
1431
1432 #else
1433
1434 #define XCHAR(x) ((Emchar)XCHARVAL (x))
1435
1436 #endif
1437
1438 #define CHECK_CHAR(x) CHECK_NONRECORD (x, Lisp_Type_Char, Qcharacterp)
1439 #define CONCHECK_CHAR(x) CONCHECK_NONRECORD (x, Lisp_Type_Char, Qcharacterp)
1440
1441
1442 /*------------------------------ float ---------------------------------*/
1443
1444 #ifdef LISP_FLOAT_TYPE
1445
1446 /* Note: the 'unused_next_' field exists only to ensure that the
1447    `next' pointer fits within the structure, for the purposes of the
1448    free list.  This makes a difference in the unlikely case of
1449    sizeof(double) being smaller than sizeof(void *). */
1450
1451 struct Lisp_Float
1452 {
1453   struct lrecord_header lheader;
1454   union { double d; struct Lisp_Float *unused_next_; } data;
1455 };
1456 typedef struct Lisp_Float Lisp_Float;
1457
1458 DECLARE_LRECORD (float, Lisp_Float);
1459 #define XFLOAT(x) XRECORD (x, float, Lisp_Float)
1460 #define XSETFLOAT(x, p) XSETRECORD (x, p, float)
1461 #define FLOATP(x) RECORDP (x, float)
1462 #define CHECK_FLOAT(x) CHECK_RECORD (x, float)
1463 #define CONCHECK_FLOAT(x) CONCHECK_RECORD (x, float)
1464
1465 #define float_data(f) ((f)->data.d)
1466 #define XFLOAT_DATA(x) float_data (XFLOAT (x))
1467
1468 #define XFLOATINT(n) extract_float (n)
1469
1470 #define CHECK_INT_OR_FLOAT(x) do {              \
1471   if (!INT_OR_FLOATP (x))                       \
1472     dead_wrong_type_argument (Qnumberp, x);     \
1473 } while (0)
1474
1475 #define CONCHECK_INT_OR_FLOAT(x) do {           \
1476   if (!INT_OR_FLOATP (x))                       \
1477     x = wrong_type_argument (Qnumberp, x);      \
1478 } while (0)
1479
1480 # define INT_OR_FLOATP(x) (INTP (x) || FLOATP (x))
1481
1482 #else /* not LISP_FLOAT_TYPE */
1483
1484 #define XFLOAT(x) --- error!  No float support. ---
1485 #define XSETFLOAT(x, p) --- error!  No float support. ---
1486 #define FLOATP(x) 0
1487 #define CHECK_FLOAT(x) --- error!  No float support. ---
1488 #define CONCHECK_FLOAT(x) --- error!  No float support. ---
1489
1490 #define XFLOATINT(n) XINT(n)
1491 #define CHECK_INT_OR_FLOAT CHECK_INT
1492 #define CONCHECK_INT_OR_FLOAT CONCHECK_INT
1493 #define INT_OR_FLOATP(x) INTP (x)
1494
1495 #endif /* not LISP_FLOAT_TYPE */
1496
1497 /*-------------------------------- int ---------------------------------*/
1498
1499 #define ZEROP(x) EQ (x, Qzero)
1500
1501 #ifdef ERROR_CHECK_TYPECHECK
1502
1503 INLINE_HEADER EMACS_INT XINT (Lisp_Object obj);
1504 INLINE_HEADER EMACS_INT
1505 XINT (Lisp_Object obj)
1506 {
1507   assert (INTP (obj));
1508   return XREALINT (obj);
1509 }
1510
1511 INLINE_HEADER EMACS_INT XCHAR_OR_INT (Lisp_Object obj);
1512 INLINE_HEADER EMACS_INT
1513 XCHAR_OR_INT (Lisp_Object obj)
1514 {
1515   assert (INTP (obj) || CHARP (obj));
1516   return CHARP (obj) ? XCHAR (obj) : XINT (obj);
1517 }
1518
1519 #else /* no error checking */
1520
1521 #define XINT(obj) XREALINT (obj)
1522 #define XCHAR_OR_INT(obj) (CHARP (obj) ? XCHAR (obj) : XINT (obj))
1523
1524 #endif /* no error checking */
1525
1526 #define CHECK_INT(x) do {                       \
1527   if (!INTP (x))                                \
1528     dead_wrong_type_argument (Qintegerp, x);    \
1529 } while (0)
1530
1531 #define CONCHECK_INT(x) do {                    \
1532   if (!INTP (x))                                \
1533     x = wrong_type_argument (Qintegerp, x);     \
1534 } while (0)
1535
1536 #define NATNUMP(x) (INTP (x) && XINT (x) >= 0)
1537
1538 #define CHECK_NATNUM(x) do {                    \
1539   if (!NATNUMP (x))                             \
1540     dead_wrong_type_argument (Qnatnump, x);     \
1541 } while (0)
1542
1543 #define CONCHECK_NATNUM(x) do {                 \
1544   if (!NATNUMP (x))                             \
1545     x = wrong_type_argument (Qnatnump, x);      \
1546 } while (0)
1547
1548 /* next three always continuable because they coerce their arguments. */
1549 #define CHECK_INT_COERCE_CHAR(x) do {                   \
1550   if (INTP (x))                                         \
1551     ;                                                   \
1552   else if (CHARP (x))                                   \
1553     x = make_int (XCHAR (x));                           \
1554   else                                                  \
1555     x = wrong_type_argument (Qinteger_or_char_p, x);    \
1556 } while (0)
1557
1558 #define CHECK_INT_COERCE_MARKER(x) do {                 \
1559   if (INTP (x))                                         \
1560     ;                                                   \
1561   else if (MARKERP (x))                                 \
1562     x = make_int (marker_position (x));                 \
1563   else                                                  \
1564     x = wrong_type_argument (Qinteger_or_marker_p, x);  \
1565 } while (0)
1566
1567 #define CHECK_INT_COERCE_CHAR_OR_MARKER(x) do {                 \
1568   if (INTP (x))                                                 \
1569     ;                                                           \
1570   else if (CHARP (x))                                           \
1571     x = make_int (XCHAR (x));                                   \
1572   else if (MARKERP (x))                                         \
1573     x = make_int (marker_position (x));                         \
1574   else                                                          \
1575     x = wrong_type_argument (Qinteger_char_or_marker_p, x);     \
1576 } while (0)
1577
1578
1579 /*--------------------------- readonly objects -------------------------*/
1580
1581 #define CHECK_C_WRITEABLE(obj)                                  \
1582   do { if (c_readonly (obj)) c_write_error (obj); } while (0)
1583
1584 #define CHECK_LISP_WRITEABLE(obj)                                       \
1585   do { if (lisp_readonly (obj)) lisp_write_error (obj); } while (0)
1586
1587 #define C_READONLY(obj) (C_READONLY_RECORD_HEADER_P(XRECORD_LHEADER (obj)))
1588 #define LISP_READONLY(obj) (LISP_READONLY_RECORD_HEADER_P(XRECORD_LHEADER (obj)))
1589
1590 /*----------------------------- structures -----------------------------*/
1591
1592 typedef struct structure_keyword_entry structure_keyword_entry;
1593 struct structure_keyword_entry
1594 {
1595   Lisp_Object keyword;
1596   int (*validate) (Lisp_Object keyword, Lisp_Object value,
1597                    Error_behavior errb);
1598 };
1599
1600 typedef struct
1601 {
1602   Dynarr_declare (structure_keyword_entry);
1603 } structure_keyword_entry_dynarr;
1604
1605 typedef struct structure_type structure_type;
1606 struct structure_type
1607 {
1608   Lisp_Object type;
1609   structure_keyword_entry_dynarr *keywords;
1610   int (*validate) (Lisp_Object data, Error_behavior errb);
1611   Lisp_Object (*instantiate) (Lisp_Object data);
1612 };
1613
1614 typedef struct
1615 {
1616   Dynarr_declare (structure_type);
1617 } structure_type_dynarr;
1618
1619 struct structure_type *define_structure_type (Lisp_Object type,
1620                                               int (*validate)
1621                                               (Lisp_Object data,
1622                                                Error_behavior errb),
1623                                               Lisp_Object (*instantiate)
1624                                               (Lisp_Object data));
1625 void define_structure_type_keyword (struct structure_type *st,
1626                                     Lisp_Object keyword,
1627                                     int (*validate) (Lisp_Object keyword,
1628                                                      Lisp_Object value,
1629                                                      Error_behavior errb));
1630
1631 /*---------------------------- weak lists ------------------------------*/
1632
1633 enum weak_list_type
1634 {
1635   /* element disappears if it's unmarked. */
1636   WEAK_LIST_SIMPLE,
1637   /* element disappears if it's a cons and either its car or
1638      cdr is unmarked. */
1639   WEAK_LIST_ASSOC,
1640   /* element disappears if it's a cons and its car is unmarked. */
1641   WEAK_LIST_KEY_ASSOC,
1642   /* element disappears if it's a cons and its cdr is unmarked. */
1643   WEAK_LIST_VALUE_ASSOC,
1644   /* element disappears if it's a cons and neither its car nor
1645      its cdr is marked. */
1646   WEAK_LIST_FULL_ASSOC
1647 };
1648
1649 struct weak_list
1650 {
1651   struct lcrecord_header header;
1652   Lisp_Object list; /* don't mark through this! */
1653   enum weak_list_type type;
1654   Lisp_Object next_weak; /* don't mark through this! */
1655 };
1656
1657 DECLARE_LRECORD (weak_list, struct weak_list);
1658 #define XWEAK_LIST(x) XRECORD (x, weak_list, struct weak_list)
1659 #define XSETWEAK_LIST(x, p) XSETRECORD (x, p, weak_list)
1660 #define WEAK_LISTP(x) RECORDP (x, weak_list)
1661 #define CHECK_WEAK_LIST(x) CHECK_RECORD (x, weak_list)
1662 #define CONCHECK_WEAK_LIST(x) CONCHECK_RECORD (x, weak_list)
1663
1664 #define weak_list_list(w) ((w)->list)
1665 #define XWEAK_LIST_LIST(w) (XWEAK_LIST (w)->list)
1666
1667 Lisp_Object make_weak_list (enum weak_list_type type);
1668 /* The following two are only called by the garbage collector */
1669 int finish_marking_weak_lists (void);
1670 void prune_weak_lists (void);
1671
1672 /*-------------------------- lcrecord-list -----------------------------*/
1673
1674 struct lcrecord_list
1675 {
1676   struct lcrecord_header header;
1677   Lisp_Object free;
1678   size_t size;
1679   const struct lrecord_implementation *implementation;
1680 };
1681
1682 DECLARE_LRECORD (lcrecord_list, struct lcrecord_list);
1683 #define XLCRECORD_LIST(x) XRECORD (x, lcrecord_list, struct lcrecord_list)
1684 #define XSETLCRECORD_LIST(x, p) XSETRECORD (x, p, lcrecord_list)
1685 #define LCRECORD_LISTP(x) RECORDP (x, lcrecord_list)
1686 /* #define CHECK_LCRECORD_LIST(x) CHECK_RECORD (x, lcrecord_list)
1687    Lcrecord lists should never escape to the Lisp level, so
1688    functions should not be doing this. */
1689
1690 Lisp_Object make_lcrecord_list (size_t size,
1691                                 const struct lrecord_implementation
1692                                 *implementation);
1693 Lisp_Object allocate_managed_lcrecord (Lisp_Object lcrecord_list);
1694 void free_managed_lcrecord (Lisp_Object lcrecord_list, Lisp_Object lcrecord);
1695
1696 \f
1697 /************************************************************************/
1698 /*         Definitions of primitive Lisp functions and variables        */
1699 /************************************************************************/
1700
1701
1702 /* DEFUN - Define a built-in Lisp-visible C function or `subr'.
1703  `lname' should be the name to give the function in Lisp,
1704     as a null-terminated C string.
1705  `Fname' should be the C equivalent of `lname', using only characters
1706     valid in a C identifier, with an "F" prepended.
1707     The name of the C constant structure that records information
1708     on this function for internal use is "S" concatenated with Fname.
1709  `min_args' should be a number, the minimum number of arguments allowed.
1710  `max_args' should be a number, the maximum number of arguments allowed,
1711     or else MANY or UNEVALLED.
1712     MANY means pass a vector of evaluated arguments,
1713          in the form of an integer number-of-arguments
1714          followed by the address of a vector of Lisp_Objects
1715          which contains the argument values.
1716     UNEVALLED means pass the list of unevaluated arguments.
1717  `prompt' says how to read arguments for an interactive call.
1718     See the doc string for `interactive'.
1719     A null string means call interactively with no arguments.
1720  `arglist' are the comma-separated arguments (always Lisp_Objects) for
1721     the function.
1722   The docstring for the function is placed as a "C" comment between
1723     the prompt and the `args' argument.  make-docfile reads the
1724     comment and creates the DOC file from it.
1725 */
1726
1727 #define EXFUN_0 void
1728 #define EXFUN_1 Lisp_Object
1729 #define EXFUN_2 Lisp_Object,Lisp_Object
1730 #define EXFUN_3 Lisp_Object,Lisp_Object,Lisp_Object
1731 #define EXFUN_4 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object
1732 #define EXFUN_5 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object
1733 #define EXFUN_6 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \
1734 Lisp_Object
1735 #define EXFUN_7 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \
1736 Lisp_Object,Lisp_Object
1737 #define EXFUN_8 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \
1738 Lisp_Object,Lisp_Object,Lisp_Object
1739 #define EXFUN_MANY int, Lisp_Object*
1740 #define EXFUN_UNEVALLED Lisp_Object
1741 #define EXFUN(sym, max_args) Lisp_Object sym (EXFUN_##max_args)
1742
1743 #define SUBR_MAX_ARGS 8
1744 #define MANY -2
1745 #define UNEVALLED -1
1746
1747 /* Can't be const, because then subr->doc is read-only and
1748    Snarf_documentation chokes */
1749
1750 #define DEFUN(lname, Fname, min_args, max_args, prompt, arglist)        \
1751   Lisp_Object Fname (EXFUN_##max_args);                                 \
1752   static struct Lisp_Subr S##Fname =                                    \
1753   {                                                                     \
1754     { /* struct lrecord_header */                                       \
1755       lrecord_type_subr, /* lrecord_type_index */                       \
1756       1, /* mark bit */                                                 \
1757       1, /* c_readonly bit */                                           \
1758       1  /* lisp_readonly bit */                                        \
1759     },                                                                  \
1760     min_args,                                                           \
1761     max_args,                                                           \
1762     prompt,                                                             \
1763     0,  /* doc string */                                                \
1764     lname,                                                              \
1765     (lisp_fn_t) Fname                                                   \
1766   };                                                                    \
1767   Lisp_Object Fname (DEFUN_##max_args arglist)
1768
1769 /* Heavy ANSI C preprocessor hackery to get DEFUN to declare a
1770    prototype that matches max_args, and add the obligatory
1771    `Lisp_Object' type declaration to the formal C arguments.  */
1772
1773 #define DEFUN_MANY(named_int, named_Lisp_Object) named_int, named_Lisp_Object
1774 #define DEFUN_UNEVALLED(args) Lisp_Object args
1775 #define DEFUN_0() void
1776 #define DEFUN_1(a)                                      Lisp_Object a
1777 #define DEFUN_2(a,b)             DEFUN_1(a),            Lisp_Object b
1778 #define DEFUN_3(a,b,c)           DEFUN_2(a,b),          Lisp_Object c
1779 #define DEFUN_4(a,b,c,d)         DEFUN_3(a,b,c),        Lisp_Object d
1780 #define DEFUN_5(a,b,c,d,e)       DEFUN_4(a,b,c,d),      Lisp_Object e
1781 #define DEFUN_6(a,b,c,d,e,f)     DEFUN_5(a,b,c,d,e),    Lisp_Object f
1782 #define DEFUN_7(a,b,c,d,e,f,g)   DEFUN_6(a,b,c,d,e,f),  Lisp_Object g
1783 #define DEFUN_8(a,b,c,d,e,f,g,h) DEFUN_7(a,b,c,d,e,f,g),Lisp_Object h
1784
1785 /* WARNING: If you add defines here for higher values of max_args,
1786    make sure to also fix the clauses in PRIMITIVE_FUNCALL(),
1787    and change the define of SUBR_MAX_ARGS above.  */
1788
1789 #include "symeval.h"
1790
1791 /* `specpdl' is the special binding/unwind-protect stack.
1792
1793    Knuth says (see the Jargon File):
1794    At MIT, `pdl' [abbreviation for `Push Down List'] used to
1795    be a more common synonym for `stack'.
1796    Everywhere else `stack' seems to be the preferred term.
1797
1798    specpdl_depth is the current depth of `specpdl'.
1799    Save this for use later as arg to `unbind_to'.  */
1800 extern int specpdl_depth_counter;
1801 #define specpdl_depth() specpdl_depth_counter
1802
1803
1804 #define CHECK_FUNCTION(fun) do {                \
1805  while (NILP (Ffunctionp (fun)))                \
1806    signal_invalid_function_error (fun);         \
1807  } while (0)
1808
1809 \f
1810 /************************************************************************/
1811 /*                         Checking for QUIT                            */
1812 /************************************************************************/
1813
1814 /* Asynchronous events set something_happened, and then are processed
1815    within the QUIT macro.  At this point, we are guaranteed to not be in
1816    any sensitive code. */
1817
1818 extern volatile int something_happened;
1819 int check_what_happened (void);
1820
1821 extern volatile int quit_check_signal_happened;
1822 extern volatile int quit_check_signal_tick_count;
1823 int check_quit (void);
1824
1825 void signal_quit (void);
1826
1827 /* Nonzero if ought to quit now.  */
1828 #define QUITP                                                   \
1829   ((quit_check_signal_happened ? check_quit () : 0),            \
1830    (!NILP (Vquit_flag) && (NILP (Vinhibit_quit)                 \
1831                            || EQ (Vquit_flag, Qcritical))))
1832
1833 /* QUIT used to call QUITP, but there are some places where QUITP
1834    is called directly, and check_what_happened() should only be called
1835    when Emacs is actually ready to quit because it could do things
1836    like switch threads. */
1837 #define INTERNAL_QUITP                                          \
1838   ((something_happened ? check_what_happened () : 0),           \
1839    (!NILP (Vquit_flag) &&                                       \
1840     (NILP (Vinhibit_quit) || EQ (Vquit_flag, Qcritical))))
1841
1842 #define INTERNAL_REALLY_QUITP                                   \
1843   (check_what_happened (),                                      \
1844    (!NILP (Vquit_flag) &&                                       \
1845     (NILP (Vinhibit_quit) || EQ (Vquit_flag, Qcritical))))
1846
1847 /* Check quit-flag and quit if it is non-nil.  Also do any other things
1848    that might have gotten queued until it was safe. */
1849 #define QUIT do { if (INTERNAL_QUITP) signal_quit (); } while (0)
1850
1851 #define REALLY_QUIT do { if (INTERNAL_REALLY_QUITP) signal_quit (); } while (0)
1852
1853 \f
1854 /************************************************************************/
1855 /*                               hashing                                */
1856 /************************************************************************/
1857
1858 /* #### for a 64-bit machine, we should substitute a prime just over 2^32 */
1859 #define GOOD_HASH 65599 /* prime number just over 2^16; Dragon book, p. 435 */
1860 #define HASH2(a,b)               (GOOD_HASH * (a)                     + (b))
1861 #define HASH3(a,b,c)             (GOOD_HASH * HASH2 (a,b)             + (c))
1862 #define HASH4(a,b,c,d)           (GOOD_HASH * HASH3 (a,b,c)           + (d))
1863 #define HASH5(a,b,c,d,e)         (GOOD_HASH * HASH4 (a,b,c,d)         + (e))
1864 #define HASH6(a,b,c,d,e,f)       (GOOD_HASH * HASH5 (a,b,c,d,e)       + (f))
1865 #define HASH7(a,b,c,d,e,f,g)     (GOOD_HASH * HASH6 (a,b,c,d,e,f)     + (g))
1866 #define HASH8(a,b,c,d,e,f,g,h)   (GOOD_HASH * HASH7 (a,b,c,d,e,f,g)   + (h))
1867 #define HASH9(a,b,c,d,e,f,g,h,i) (GOOD_HASH * HASH8 (a,b,c,d,e,f,g,h) + (i))
1868
1869 #define LISP_HASH(obj) ((unsigned long) LISP_TO_VOID (obj))
1870 unsigned long string_hash (const char *xv);
1871 unsigned long memory_hash (const void *xv, size_t size);
1872 unsigned long internal_hash (Lisp_Object obj, int depth);
1873 unsigned long internal_array_hash (Lisp_Object *arr, int size, int depth);
1874
1875 \f
1876 /************************************************************************/
1877 /*                       String translation                             */
1878 /************************************************************************/
1879
1880 #ifdef I18N3
1881 #ifdef HAVE_LIBINTL_H
1882 #include <libintl.h>
1883 #else
1884 char *dgettext       (const char *, const char *);
1885 char *gettext        (const char *);
1886 char *textdomain     (const char *);
1887 char *bindtextdomain (const char *, const char *);
1888 #endif /* HAVE_LIBINTL_H */
1889
1890 #define GETTEXT(x)  gettext(x)
1891 #define LISP_GETTEXT(x)  Fgettext (x)
1892 #else /* !I18N3 */
1893 #define GETTEXT(x)  (x)
1894 #define LISP_GETTEXT(x)  (x)
1895 #endif /* !I18N3 */
1896
1897 /* DEFER_GETTEXT is used to identify strings which are translated when
1898    they are referenced instead of when they are defined.
1899    These include Qerror_messages and initialized arrays of strings.
1900 */
1901 #define DEFER_GETTEXT(x) (x)
1902
1903 \f
1904 /************************************************************************/
1905 /*                   Garbage collection / GC-protection                 */
1906 /************************************************************************/
1907
1908 /* number of bytes of structure consed since last GC */
1909
1910 extern EMACS_INT consing_since_gc;
1911
1912 /* threshold for doing another gc */
1913
1914 extern Fixnum gc_cons_threshold;
1915
1916 /* Structure for recording stack slots that need marking */
1917
1918 /* This is a chain of structures, each of which points at a Lisp_Object
1919    variable whose value should be marked in garbage collection.
1920    Normally every link of the chain is an automatic variable of a function,
1921    and its `val' points to some argument or local variable of the function.
1922    On exit to the function, the chain is set back to the value it had on
1923    entry.  This way, no link remains in the chain when the stack frame
1924    containing the link disappears.
1925
1926    Every function that can call Feval must protect in this fashion all
1927    Lisp_Object variables whose contents will be used again. */
1928
1929 extern struct gcpro *gcprolist;
1930
1931 struct gcpro
1932 {
1933   struct gcpro *next;
1934   Lisp_Object *var;             /* Address of first protected variable */
1935   int nvars;                    /* Number of consecutive protected variables */
1936 };
1937
1938 /* Normally, you declare variables gcpro1, gcpro2, ... and use the
1939    GCPROn() macros.  However, if you need to have nested gcpro's,
1940    declare ngcpro1, ngcpro2, ... and use NGCPROn().  If you need
1941    to nest another level, use nngcpro1, nngcpro2, ... and use
1942    NNGCPROn().  If you need to nest yet another level, create
1943    the appropriate macros. */
1944
1945 #ifdef DEBUG_GCPRO
1946
1947 void debug_gcpro1 (char *, int, struct gcpro *, Lisp_Object *);
1948 void debug_gcpro2 (char *, int, struct gcpro *, struct gcpro *,
1949                    Lisp_Object *, Lisp_Object *);
1950 void debug_gcpro3 (char *, int, struct gcpro *, struct gcpro *, struct gcpro *,
1951                    Lisp_Object *, Lisp_Object *, Lisp_Object *);
1952 void debug_gcpro4 (char *, int, struct gcpro *, struct gcpro *, struct gcpro *,
1953                    struct gcpro *, Lisp_Object *, Lisp_Object *, Lisp_Object *,
1954                    Lisp_Object *);
1955 void debug_gcpro5 (char *, int, struct gcpro *, struct gcpro *, struct gcpro *,
1956                    struct gcpro *, struct gcpro *, Lisp_Object *, Lisp_Object *,
1957                    Lisp_Object *, Lisp_Object *, Lisp_Object *);
1958 void debug_ungcpro(char *, int, struct gcpro *);
1959
1960 #define GCPRO1(v) \
1961  debug_gcpro1 (__FILE__, __LINE__,&gcpro1,&v)
1962 #define GCPRO2(v1,v2) \
1963  debug_gcpro2 (__FILE__, __LINE__,&gcpro1,&gcpro2,&v1,&v2)
1964 #define GCPRO3(v1,v2,v3) \
1965  debug_gcpro3 (__FILE__, __LINE__,&gcpro1,&gcpro2,&gcpro3,&v1,&v2,&v3)
1966 #define GCPRO4(v1,v2,v3,v4) \
1967  debug_gcpro4 (__FILE__, __LINE__,&gcpro1,&gcpro2,&gcpro3,&gcpro4,\
1968                &v1,&v2,&v3,&v4)
1969 #define GCPRO5(v1,v2,v3,v4,v5) \
1970  debug_gcpro5 (__FILE__, __LINE__,&gcpro1,&gcpro2,&gcpro3,&gcpro4,&gcpro5,\
1971                &v1,&v2,&v3,&v4,&v5)
1972 #define UNGCPRO \
1973  debug_ungcpro(__FILE__, __LINE__,&gcpro1)
1974
1975 #define NGCPRO1(v) \
1976  debug_gcpro1 (__FILE__, __LINE__,&ngcpro1,&v)
1977 #define NGCPRO2(v1,v2) \
1978  debug_gcpro2 (__FILE__, __LINE__,&ngcpro1,&ngcpro2,&v1,&v2)
1979 #define NGCPRO3(v1,v2,v3) \
1980  debug_gcpro3 (__FILE__, __LINE__,&ngcpro1,&ngcpro2,&ngcpro3,&v1,&v2,&v3)
1981 #define NGCPRO4(v1,v2,v3,v4) \
1982  debug_gcpro4 (__FILE__, __LINE__,&ngcpro1,&ngcpro2,&ngcpro3,&ngcpro4,\
1983                &v1,&v2,&v3,&v4)
1984 #define NGCPRO5(v1,v2,v3,v4,v5) \
1985  debug_gcpro5 (__FILE__, __LINE__,&ngcpro1,&ngcpro2,&ngcpro3,&ngcpro4,\
1986                &ngcpro5,&v1,&v2,&v3,&v4,&v5)
1987 #define NUNGCPRO \
1988  debug_ungcpro(__FILE__, __LINE__,&ngcpro1)
1989
1990 #define NNGCPRO1(v) \
1991  debug_gcpro1 (__FILE__, __LINE__,&nngcpro1,&v)
1992 #define NNGCPRO2(v1,v2) \
1993  debug_gcpro2 (__FILE__, __LINE__,&nngcpro1,&nngcpro2,&v1,&v2)
1994 #define NNGCPRO3(v1,v2,v3) \
1995  debug_gcpro3 (__FILE__, __LINE__,&nngcpro1,&nngcpro2,&nngcpro3,&v1,&v2,&v3)
1996 #define NNGCPRO4(v1,v2,v3,v4) \
1997  debug_gcpro4 (__FILE__, __LINE__,&nngcpro1,&nngcpro2,&nngcpro3,&nngcpro4,\
1998                &v1,&v2,&v3,&v4)
1999 #define NNGCPRO5(v1,v2,v3,v4,v5) \
2000  debug_gcpro5 (__FILE__, __LINE__,&nngcpro1,&nngcpro2,&nngcpro3,&nngcpro4,\
2001                &nngcpro5,&v1,&v2,&v3,&v4,&v5)
2002 #define NNUNGCPRO \
2003  debug_ungcpro(__FILE__, __LINE__,&nngcpro1)
2004
2005 #else /* ! DEBUG_GCPRO */
2006
2007 #define GCPRO1(var1) ((void) (                                          \
2008   gcpro1.next = gcprolist, gcpro1.var = &var1, gcpro1.nvars = 1,        \
2009   gcprolist = &gcpro1 ))
2010
2011 #define GCPRO2(var1, var2) ((void) (                                    \
2012   gcpro1.next = gcprolist, gcpro1.var = &var1, gcpro1.nvars = 1,        \
2013   gcpro2.next = &gcpro1,   gcpro2.var = &var2, gcpro2.nvars = 1,        \
2014   gcprolist = &gcpro2 ))
2015
2016 #define GCPRO3(var1, var2, var3) ((void) (                              \
2017   gcpro1.next = gcprolist, gcpro1.var = &var1, gcpro1.nvars = 1,        \
2018   gcpro2.next = &gcpro1,   gcpro2.var = &var2, gcpro2.nvars = 1,        \
2019   gcpro3.next = &gcpro2,   gcpro3.var = &var3, gcpro3.nvars = 1,        \
2020   gcprolist = &gcpro3 ))
2021
2022 #define GCPRO4(var1, var2, var3, var4) ((void) (                        \
2023   gcpro1.next = gcprolist, gcpro1.var = &var1, gcpro1.nvars = 1,        \
2024   gcpro2.next = &gcpro1,   gcpro2.var = &var2, gcpro2.nvars = 1,        \
2025   gcpro3.next = &gcpro2,   gcpro3.var = &var3, gcpro3.nvars = 1,        \
2026   gcpro4.next = &gcpro3,   gcpro4.var = &var4, gcpro4.nvars = 1,        \
2027   gcprolist = &gcpro4 ))
2028
2029 #define GCPRO5(var1, var2, var3, var4, var5) ((void) (                  \
2030   gcpro1.next = gcprolist, gcpro1.var = &var1, gcpro1.nvars = 1,        \
2031   gcpro2.next = &gcpro1,   gcpro2.var = &var2, gcpro2.nvars = 1,        \
2032   gcpro3.next = &gcpro2,   gcpro3.var = &var3, gcpro3.nvars = 1,        \
2033   gcpro4.next = &gcpro3,   gcpro4.var = &var4, gcpro4.nvars = 1,        \
2034   gcpro5.next = &gcpro4,   gcpro5.var = &var5, gcpro5.nvars = 1,        \
2035   gcprolist = &gcpro5 ))
2036
2037 #define UNGCPRO ((void) (gcprolist = gcpro1.next))
2038
2039 #define NGCPRO1(var1) ((void) (                                         \
2040   ngcpro1.next = gcprolist, ngcpro1.var = &var1, ngcpro1.nvars = 1,     \
2041   gcprolist = &ngcpro1 ))
2042
2043 #define NGCPRO2(var1, var2) ((void) (                                   \
2044   ngcpro1.next = gcprolist, ngcpro1.var = &var1, ngcpro1.nvars = 1,     \
2045   ngcpro2.next = &ngcpro1,  ngcpro2.var = &var2, ngcpro2.nvars = 1,     \
2046   gcprolist = &ngcpro2 ))
2047
2048 #define NGCPRO3(var1, var2, var3) ((void) (                             \
2049   ngcpro1.next = gcprolist, ngcpro1.var = &var1, ngcpro1.nvars = 1,     \
2050   ngcpro2.next = &ngcpro1,  ngcpro2.var = &var2, ngcpro2.nvars = 1,     \
2051   ngcpro3.next = &ngcpro2,  ngcpro3.var = &var3, ngcpro3.nvars = 1,     \
2052   gcprolist = &ngcpro3 ))
2053
2054 #define NGCPRO4(var1, var2, var3, var4) ((void) (                       \
2055   ngcpro1.next = gcprolist, ngcpro1.var = &var1, ngcpro1.nvars = 1,     \
2056   ngcpro2.next = &ngcpro1,  ngcpro2.var = &var2, ngcpro2.nvars = 1,     \
2057   ngcpro3.next = &ngcpro2,  ngcpro3.var = &var3, ngcpro3.nvars = 1,     \
2058   ngcpro4.next = &ngcpro3,  ngcpro4.var = &var4, ngcpro4.nvars = 1,     \
2059   gcprolist = &ngcpro4 ))
2060
2061 #define NGCPRO5(var1, var2, var3, var4, var5) ((void) (                 \
2062   ngcpro1.next = gcprolist, ngcpro1.var = &var1, ngcpro1.nvars = 1,     \
2063   ngcpro2.next = &ngcpro1,  ngcpro2.var = &var2, ngcpro2.nvars = 1,     \
2064   ngcpro3.next = &ngcpro2,  ngcpro3.var = &var3, ngcpro3.nvars = 1,     \
2065   ngcpro4.next = &ngcpro3,  ngcpro4.var = &var4, ngcpro4.nvars = 1,     \
2066   ngcpro5.next = &ngcpro4,  ngcpro5.var = &var5, ngcpro5.nvars = 1,     \
2067   gcprolist = &ngcpro5 ))
2068
2069 #define NUNGCPRO ((void) (gcprolist = ngcpro1.next))
2070
2071 #define NNGCPRO1(var1) ((void) (                                        \
2072   nngcpro1.next = gcprolist, nngcpro1.var = &var1, nngcpro1.nvars = 1,  \
2073   gcprolist = &nngcpro1 ))
2074
2075 #define NNGCPRO2(var1, var2) ((void) (                                  \
2076   nngcpro1.next = gcprolist, nngcpro1.var = &var1, nngcpro1.nvars = 1,  \
2077   nngcpro2.next = &nngcpro1, nngcpro2.var = &var2, nngcpro2.nvars = 1,  \
2078   gcprolist = &nngcpro2 ))
2079
2080 #define NNGCPRO3(var1, var2, var3) ((void) (                            \
2081   nngcpro1.next = gcprolist, nngcpro1.var = &var1, nngcpro1.nvars = 1,  \
2082   nngcpro2.next = &nngcpro1, nngcpro2.var = &var2, nngcpro2.nvars = 1,  \
2083   nngcpro3.next = &nngcpro2, nngcpro3.var = &var3, nngcpro3.nvars = 1,  \
2084   gcprolist = &nngcpro3 ))
2085
2086 #define NNGCPRO4(var1, var2, var3, var4)  ((void) (                     \
2087   nngcpro1.next = gcprolist, nngcpro1.var = &var1, nngcpro1.nvars = 1,  \
2088   nngcpro2.next = &nngcpro1, nngcpro2.var = &var2, nngcpro2.nvars = 1,  \
2089   nngcpro3.next = &nngcpro2, nngcpro3.var = &var3, nngcpro3.nvars = 1,  \
2090   nngcpro4.next = &nngcpro3, nngcpro4.var = &var4, nngcpro4.nvars = 1,  \
2091   gcprolist = &nngcpro4 ))
2092
2093 #define NNGCPRO5(var1, var2, var3, var4, var5) ((void) (                \
2094   nngcpro1.next = gcprolist, nngcpro1.var = &var1, nngcpro1.nvars = 1,  \
2095   nngcpro2.next = &nngcpro1, nngcpro2.var = &var2, nngcpro2.nvars = 1,  \
2096   nngcpro3.next = &nngcpro2, nngcpro3.var = &var3, nngcpro3.nvars = 1,  \
2097   nngcpro4.next = &nngcpro3, nngcpro4.var = &var4, nngcpro4.nvars = 1,  \
2098   nngcpro5.next = &nngcpro4, nngcpro5.var = &var5, nngcpro5.nvars = 1,  \
2099   gcprolist = &nngcpro5 ))
2100
2101 #define NNUNGCPRO ((void) (gcprolist = nngcpro1.next))
2102
2103 #endif /* ! DEBUG_GCPRO */
2104
2105 /* Another try to fix SunPro C compiler warnings */
2106 /* "end-of-loop code not reached" */
2107 /* "statement not reached */
2108 #if defined __SUNPRO_C || defined __USLC__
2109 #define RETURN_SANS_WARNINGS if (1) return
2110 #define RETURN_NOT_REACHED(value)
2111 #else
2112 #define RETURN_SANS_WARNINGS return
2113 #define RETURN_NOT_REACHED(value) return value;
2114 #endif
2115
2116 /* Evaluate expr, UNGCPRO, and then return the value of expr.  */
2117 #define RETURN_UNGCPRO(expr) do         \
2118 {                                       \
2119   Lisp_Object ret_ungc_val = (expr);    \
2120   UNGCPRO;                              \
2121   RETURN_SANS_WARNINGS ret_ungc_val;    \
2122 } while (0)
2123
2124 /* Evaluate expr, NUNGCPRO, UNGCPRO, and then return the value of expr.  */
2125 #define RETURN_NUNGCPRO(expr) do        \
2126 {                                       \
2127   Lisp_Object ret_ungc_val = (expr);    \
2128   NUNGCPRO;                             \
2129   UNGCPRO;                              \
2130   RETURN_SANS_WARNINGS ret_ungc_val;    \
2131 } while (0)
2132
2133 /* Evaluate expr, NNUNGCPRO, NUNGCPRO, UNGCPRO, and then return the
2134    value of expr.  */
2135 #define RETURN_NNUNGCPRO(expr) do       \
2136 {                                       \
2137   Lisp_Object ret_ungc_val = (expr);    \
2138   NNUNGCPRO;                            \
2139   NUNGCPRO;                             \
2140   UNGCPRO;                              \
2141   RETURN_SANS_WARNINGS ret_ungc_val;    \
2142 } while (0)
2143
2144 /* Evaluate expr, return it if it's not Qunbound. */
2145 #define RETURN_IF_NOT_UNBOUND(expr) do  \
2146 {                                       \
2147   Lisp_Object ret_nunb_val = (expr);    \
2148   if (!UNBOUNDP (ret_nunb_val))         \
2149     RETURN_SANS_WARNINGS ret_nunb_val;  \
2150 } while (0)
2151
2152 extern Lisp_Object_ptr_dynarr *staticpros;
2153
2154 void register_post_gc_action (void (*fun) (void *), void *arg);
2155
2156 /* Call staticpro (&var) to protect static variable `var'. */
2157 void staticpro (Lisp_Object *);
2158
2159 /* Call staticpro_nodump (&var) to protect static variable `var'. */
2160 /* var will not be saved at dump time */
2161 void staticpro_nodump (Lisp_Object *);
2162
2163 /* dump_add_root_struct_ptr (&var, &desc) dumps the structure pointed to by `var'. */
2164 #ifdef PDUMP
2165 void dump_add_root_struct_ptr (void *, const struct struct_description *);
2166 #else
2167 #define dump_add_root_struct_ptr(varaddr,descaddr) DO_NOTHING
2168 #endif
2169
2170 /* dump_add_opaque (&var, size) dumps the opaque static structure `var'. */
2171 #ifdef PDUMP
2172 void dump_add_opaque (void *, size_t);
2173 #else
2174 #define dump_add_opaque(varaddr,size) DO_NOTHING
2175 #endif
2176
2177 /* Call dump_add_opaque_int (&int_var) to dump `int_var', of type `int'. */
2178 #ifdef PDUMP
2179 #define dump_add_opaque_int(int_varaddr) do {   \
2180   int *dao_ = (int_varaddr); /* type check */   \
2181   dump_add_opaque (dao_, sizeof (*dao_));       \
2182 } while (0)
2183 #else
2184 #define dump_add_opaque_int(int_varaddr) DO_NOTHING
2185 #endif
2186
2187 /* Call dump_add_opaque_fixnum (&fixnum_var) to dump `fixnum_var', of type `Fixnum'. */
2188 #ifdef PDUMP
2189 #define dump_add_opaque_fixnum(fixnum_varaddr) do {     \
2190   Fixnum *dao_ = (fixnum_varaddr); /* type check */     \
2191   dump_add_opaque (dao_, sizeof (*dao_));               \
2192 } while (0)
2193 #else
2194 #define dump_add_opaque_fixnum(fixnum_varaddr) DO_NOTHING
2195 #endif
2196
2197 /* Call dump_add_root_object (&var) to ensure that var is properly updated after pdump. */
2198 #ifdef PDUMP
2199 void dump_add_root_object (Lisp_Object *);
2200 #else
2201 #define dump_add_root_object(varaddr) DO_NOTHING
2202 #endif
2203
2204 /* Call dump_add_root_object (&var) to ensure that var is properly updated after
2205    pdump.  var must point to a linked list of objects out of which
2206    some may not be dumped */
2207 #ifdef PDUMP
2208 void dump_add_weak_object_chain (Lisp_Object *);
2209 #else
2210 #define dump_add_weak_object_chain(varaddr) DO_NOTHING
2211 #endif
2212
2213 /* Nonzero means Emacs has already been initialized.
2214    Used during startup to detect startup of dumped Emacs.  */
2215 extern int initialized;
2216
2217 #ifdef MEMORY_USAGE_STATS
2218
2219 /* This structure is used to keep statistics on the amount of memory
2220    in use.
2221
2222    WAS_REQUESTED stores the actual amount of memory that was requested
2223    of the allocation function.  The *_OVERHEAD fields store the
2224    additional amount of memory that was grabbed by the functions to
2225    facilitate allocation, reallocation, etc.  MALLOC_OVERHEAD is for
2226    memory allocated with malloc(); DYNARR_OVERHEAD is for dynamic
2227    arrays; GAP_OVERHEAD is for gap arrays.  Note that for (e.g.)
2228    dynamic arrays, there is both MALLOC_OVERHEAD and DYNARR_OVERHEAD
2229    memory: The dynamic array allocates memory above and beyond what
2230    was asked of it, and when it in turns allocates memory using
2231    malloc(), malloc() allocates memory beyond what it was asked
2232    to allocate.
2233
2234    Functions that accept a structure of this sort do not initialize
2235    the fields to 0, and add any existing values to whatever was there
2236    before; this way, you can get a cumulative effect. */
2237
2238 struct overhead_stats
2239 {
2240   int was_requested;
2241   int malloc_overhead;
2242   int dynarr_overhead;
2243   int gap_overhead;
2244 };
2245
2246 #endif /* MEMORY_USAGE_STATS */
2247
2248 #ifndef DIRECTORY_SEP
2249 #define DIRECTORY_SEP '/'
2250 #endif
2251 #ifndef IS_DIRECTORY_SEP
2252 #define IS_DIRECTORY_SEP(c) ((c) == DIRECTORY_SEP)
2253 #endif
2254 #ifndef IS_DEVICE_SEP
2255 #ifndef DEVICE_SEP
2256 #define IS_DEVICE_SEP(c) 0
2257 #else
2258 #define IS_DEVICE_SEP(c) ((c) == DEVICE_SEP)
2259 #endif
2260 #endif
2261 #ifndef IS_ANY_SEP
2262 #define IS_ANY_SEP(c) IS_DIRECTORY_SEP (c)
2263 #endif
2264
2265 #ifdef HAVE_INTTYPES_H
2266 #include <inttypes.h>
2267 #elif defined(INTPTR_T_IN_CYGWIN_TYPES_H)
2268 /* Recent Cygwin defines these types in <cygwin/types.h>
2269    We can hope that if they ever get inttypes.h, they won't define twice */
2270 #elif SIZEOF_VOID_P == SIZEOF_INT
2271 typedef int intptr_t;
2272 typedef unsigned int uintptr_t;
2273 #elif SIZEOF_VOID_P == SIZEOF_LONG
2274 typedef long intptr_t;
2275 typedef unsigned long uintptr_t;
2276 #elif defined(SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG
2277 typedef long long intptr_t;
2278 typedef unsigned long long uintptr_t;
2279 #else
2280 /* Just pray. May break, may not. */
2281 typedef long intptr_t;
2282 typedef unsigned long uintptr_t;
2283 #endif
2284
2285 \f
2286 /************************************************************************/
2287 /*                              prototypes                              */
2288 /************************************************************************/
2289
2290 /* NOTE: Prototypes should go HERE, not in various header files, unless
2291    they specifically reference a type that's not defined in lisp.h.
2292    (And even then, you might consider adding the type to lisp.h.)
2293
2294    The idea is that header files typically contain the innards of objects,
2295    and we want to minimize the number of "dependencies" of one file on
2296    the specifics of such objects.  Putting prototypes here minimizes the
2297    number of header files that need to be included -- good for a number
2298    of reasons. --ben */
2299
2300 /*--------------- prototypes for various public c functions ------------*/
2301
2302 /* Prototypes for all init/syms_of/vars_of initialization functions. */
2303 #include "symsinit.h"
2304
2305 /* Defined in alloc.c */
2306 void release_breathing_space (void);
2307 Lisp_Object noseeum_cons (Lisp_Object, Lisp_Object);
2308 Lisp_Object make_vector (size_t, Lisp_Object);
2309 Lisp_Object vector1 (Lisp_Object);
2310 Lisp_Object vector2 (Lisp_Object, Lisp_Object);
2311 Lisp_Object vector3 (Lisp_Object, Lisp_Object, Lisp_Object);
2312 Lisp_Object make_bit_vector (size_t, Lisp_Object);
2313 Lisp_Object make_bit_vector_from_byte_vector (unsigned char *, size_t);
2314 Lisp_Object noseeum_make_marker (void);
2315 void garbage_collect_1 (void);
2316 Lisp_Object acons (Lisp_Object, Lisp_Object, Lisp_Object);
2317 Lisp_Object cons3 (Lisp_Object, Lisp_Object, Lisp_Object);
2318 Lisp_Object list1 (Lisp_Object);
2319 Lisp_Object list2 (Lisp_Object, Lisp_Object);
2320 Lisp_Object list3 (Lisp_Object, Lisp_Object, Lisp_Object);
2321 Lisp_Object list4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
2322 Lisp_Object list5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
2323                    Lisp_Object);
2324 Lisp_Object list6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
2325                    Lisp_Object, Lisp_Object);
2326 DECLARE_DOESNT_RETURN (memory_full (void));
2327 void disksave_object_finalization (void);
2328 extern int purify_flag;
2329 extern int gc_currently_forbidden;
2330 Lisp_Object restore_gc_inhibit (Lisp_Object);
2331 extern EMACS_INT gc_generation_number[1];
2332 int c_readonly (Lisp_Object);
2333 int lisp_readonly (Lisp_Object);
2334 Lisp_Object build_string (const char *);
2335 Lisp_Object build_ext_string (const char *, Lisp_Object);
2336 Lisp_Object build_translated_string (const char *);
2337 Lisp_Object make_string (const Bufbyte *, Bytecount);
2338 Lisp_Object make_ext_string (const Extbyte *, EMACS_INT, Lisp_Object);
2339 Lisp_Object make_uninit_string (Bytecount);
2340 Lisp_Object make_float (double);
2341 Lisp_Object make_string_nocopy (const Bufbyte *, Bytecount);
2342 void free_cons (Lisp_Cons *);
2343 void free_list (Lisp_Object);
2344 void free_alist (Lisp_Object);
2345 void mark_conses_in_list (Lisp_Object);
2346 void free_marker (Lisp_Marker *);
2347 int object_dead_p (Lisp_Object);
2348 void mark_object (Lisp_Object obj);
2349 int marked_p (Lisp_Object obj);
2350
2351 #ifdef MEMORY_USAGE_STATS
2352 size_t malloced_storage_size (void *, size_t, struct overhead_stats *);
2353 size_t fixed_type_block_overhead (size_t);
2354 #endif
2355 #ifdef PDUMP
2356 void pdump (void);
2357 int pdump_load (const char *);
2358
2359 extern char *pdump_start, *pdump_end;
2360 #define DUMPEDP(adr) ((((char *)(adr)) < pdump_end) && (((char *)(adr)) >= pdump_start))
2361 #else
2362 #define DUMPEDP(adr) 0
2363 #endif
2364
2365 /* Defined in buffer.c */
2366 Lisp_Object make_buffer (struct buffer *);
2367 Lisp_Object get_truename_buffer (Lisp_Object);
2368 void switch_to_buffer (Lisp_Object, Lisp_Object);
2369 extern int find_file_compare_truenames;
2370 extern int find_file_use_truenames;
2371
2372 /* Defined in callproc.c */
2373 char *egetenv (const char *);
2374
2375 /* Defined in console.c */
2376 void stuff_buffered_input (Lisp_Object);
2377
2378 /* Defined in console-msw.c */
2379 EXFUN (Fmswindows_message_box, 3);
2380 extern int mswindows_message_outputted;
2381
2382 /* Defined in data.c */
2383 DECLARE_DOESNT_RETURN (c_write_error (Lisp_Object));
2384 DECLARE_DOESNT_RETURN (lisp_write_error (Lisp_Object));
2385 DECLARE_DOESNT_RETURN (args_out_of_range (Lisp_Object, Lisp_Object));
2386 DECLARE_DOESNT_RETURN (args_out_of_range_3 (Lisp_Object, Lisp_Object,
2387                                             Lisp_Object));
2388 Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object);
2389 DECLARE_DOESNT_RETURN (dead_wrong_type_argument (Lisp_Object, Lisp_Object));
2390 void check_int_range (EMACS_INT, EMACS_INT, EMACS_INT);
2391
2392 enum arith_comparison {
2393   arith_equal,
2394   arith_notequal,
2395   arith_less,
2396   arith_grtr,
2397   arith_less_or_equal,
2398   arith_grtr_or_equal };
2399 Lisp_Object arithcompare (Lisp_Object, Lisp_Object, enum arith_comparison);
2400
2401 /* Do NOT use word_to_lisp or wasteful_word_to_lisp to decode time_t's
2402    unless you KNOW arg is non-negative.  They cannot return negative
2403    values!  Use make_time.  */
2404 Lisp_Object word_to_lisp (unsigned int);
2405 unsigned int lisp_to_word (Lisp_Object);
2406
2407 /* Defined in dired.c */
2408 Lisp_Object make_directory_hash_table (const char *);
2409 Lisp_Object wasteful_word_to_lisp (unsigned int);
2410
2411 /* Defined in doc.c */
2412 Lisp_Object unparesseuxify_doc_string (int, EMACS_INT, char *, Lisp_Object);
2413 Lisp_Object read_doc_string (Lisp_Object);
2414
2415 /* Defined in doprnt.c */
2416 Bytecount emacs_doprnt_c (Lisp_Object, const Bufbyte *, Lisp_Object,
2417                           Bytecount, ...);
2418 Bytecount emacs_doprnt_va (Lisp_Object, const Bufbyte *, Lisp_Object,
2419                            Bytecount, va_list);
2420 Bytecount emacs_doprnt_lisp (Lisp_Object, const Bufbyte *, Lisp_Object,
2421                              Bytecount, int, const Lisp_Object *);
2422 Bytecount emacs_doprnt_lisp_2 (Lisp_Object, const Bufbyte *, Lisp_Object,
2423                                Bytecount, int, ...);
2424 Lisp_Object emacs_doprnt_string_c (const Bufbyte *, Lisp_Object,
2425                                    Bytecount, ...);
2426 Lisp_Object emacs_doprnt_string_va (const Bufbyte *, Lisp_Object,
2427                                     Bytecount, va_list);
2428 Lisp_Object emacs_doprnt_string_lisp (const Bufbyte *, Lisp_Object,
2429                                       Bytecount, int, const Lisp_Object *);
2430 Lisp_Object emacs_doprnt_string_lisp_2 (const Bufbyte *, Lisp_Object,
2431                                         Bytecount, int, ...);
2432
2433 /* Defined in editfns.c */
2434 void uncache_home_directory (void);
2435 Extbyte *get_home_directory (void);
2436 char *user_login_name (uid_t *);
2437 Bufpos bufpos_clip_to_bounds (Bufpos, Bufpos, Bufpos);
2438 Bytind bytind_clip_to_bounds (Bytind, Bytind, Bytind);
2439 void buffer_insert1 (struct buffer *, Lisp_Object);
2440 Lisp_Object make_string_from_buffer (struct buffer *, Bufpos, Charcount);
2441 Lisp_Object make_string_from_buffer_no_extents (struct buffer *, Bufpos, Charcount);
2442 Lisp_Object make_time (time_t);
2443 Lisp_Object save_excursion_save (void);
2444 Lisp_Object save_restriction_save (void);
2445 Lisp_Object save_excursion_restore (Lisp_Object);
2446 Lisp_Object save_restriction_restore (Lisp_Object);
2447
2448 /* Defined in emacsfns.c */
2449 Lisp_Object save_current_buffer_restore (Lisp_Object);
2450
2451 /* Defined in emacs.c */
2452 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (fatal (const char *,
2453                                                            ...), 1, 2);
2454 int stderr_out (const char *, ...) PRINTF_ARGS (1, 2);
2455 int stdout_out (const char *, ...) PRINTF_ARGS (1, 2);
2456 SIGTYPE fatal_error_signal (int);
2457 Lisp_Object make_arg_list (int, Extbyte **);
2458 void make_argc_argv (Lisp_Object, int *, Extbyte ***);
2459 void free_argc_argv (Extbyte **);
2460 Lisp_Object decode_env_path (const char *, const char *);
2461 Lisp_Object decode_path (const char *);
2462 /* Nonzero means don't do interactive redisplay and don't change tty modes */
2463 extern int noninteractive, noninteractive1;
2464 extern int fatal_error_in_progress;
2465 extern int inhibit_non_essential_printing_operations;
2466 extern int preparing_for_armageddon;
2467 extern Fixnum emacs_priority;
2468 extern int running_asynch_code;
2469 extern int suppress_early_error_handler_backtrace;
2470 void debug_break (void);
2471 int debug_can_access_memory (void *ptr, Bytecount len);
2472
2473 /* Defined in eval.c */
2474 DECLARE_DOESNT_RETURN (signal_error (Lisp_Object, Lisp_Object));
2475 void maybe_signal_error (Lisp_Object, Lisp_Object, Lisp_Object,
2476                          Error_behavior);
2477 Lisp_Object maybe_signal_continuable_error (Lisp_Object, Lisp_Object,
2478                                             Lisp_Object, Error_behavior);
2479 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (type_error (Lisp_Object,
2480                                                               const char *,
2481                                                               ...), 2, 3);
2482 void maybe_type_error (Lisp_Object, Lisp_Object, Error_behavior, const char *,
2483                        ...) PRINTF_ARGS (4, 5);
2484 Lisp_Object continuable_type_error (Lisp_Object, const char *, ...)
2485      PRINTF_ARGS (2, 3);
2486 Lisp_Object maybe_continuable_type_error (Lisp_Object, Lisp_Object,
2487                                           Error_behavior,
2488                                           const char *, ...)
2489      PRINTF_ARGS (4, 5);
2490 DECLARE_DOESNT_RETURN (signal_type_error (Lisp_Object, const char *,
2491                                           Lisp_Object));
2492 void maybe_signal_type_error (Lisp_Object, const char *, Lisp_Object,
2493                               Lisp_Object, Error_behavior);
2494 Lisp_Object signal_type_continuable_error (Lisp_Object, const char *,
2495                                            Lisp_Object);
2496 Lisp_Object maybe_signal_type_continuable_error (Lisp_Object, const char *,
2497                                                  Lisp_Object,
2498                                                  Lisp_Object, Error_behavior);
2499 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (type_error_with_frob
2500                                                   (Lisp_Object, Lisp_Object,
2501                                                    const char *,
2502                                                    ...), 3, 4);
2503 void maybe_type_error_with_frob (Lisp_Object, Lisp_Object, Lisp_Object,
2504                                  Error_behavior,
2505                                  const char *, ...) PRINTF_ARGS (5, 6);
2506 Lisp_Object continuable_type_error_with_frob (Lisp_Object, Lisp_Object,
2507                                               const char *,
2508                                               ...) PRINTF_ARGS (3, 4);
2509 Lisp_Object maybe_continuable_type_error_with_frob
2510 (Lisp_Object, Lisp_Object, Lisp_Object, Error_behavior, const char *, ...)
2511      PRINTF_ARGS (5, 6);
2512 DECLARE_DOESNT_RETURN (signal_type_error_2 (Lisp_Object, const char *,
2513                                             Lisp_Object, Lisp_Object));
2514 void maybe_signal_type_error_2 (Lisp_Object, const char *, Lisp_Object,
2515                                 Lisp_Object, Lisp_Object, Error_behavior);
2516 Lisp_Object signal_type_continuable_error_2 (Lisp_Object, const char *,
2517                                              Lisp_Object, Lisp_Object);
2518 Lisp_Object maybe_signal_type_continuable_error_2 (Lisp_Object, const char *,
2519                                                    Lisp_Object, Lisp_Object,
2520                                                    Lisp_Object,
2521                                                    Error_behavior);
2522 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (error (const char *,
2523                                                            ...), 1, 2);
2524 void maybe_error (Lisp_Object, Error_behavior, const char *,
2525                   ...) PRINTF_ARGS (3, 4);
2526 Lisp_Object continuable_error (const char *, ...) PRINTF_ARGS (1, 2);
2527 Lisp_Object maybe_continuable_error (Lisp_Object, Error_behavior,
2528                                      const char *, ...) PRINTF_ARGS (3, 4);
2529 DECLARE_DOESNT_RETURN (signal_simple_error (const char *, Lisp_Object));
2530 void maybe_signal_simple_error (const char *, Lisp_Object,
2531                                 Lisp_Object, Error_behavior);
2532 Lisp_Object signal_simple_continuable_error (const char *, Lisp_Object);
2533 Lisp_Object maybe_signal_simple_continuable_error (const char *, Lisp_Object,
2534                                                    Lisp_Object, Error_behavior);
2535 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (error_with_frob
2536                                                     (Lisp_Object, const char *,
2537                                                      ...), 2, 3);
2538 void maybe_error_with_frob (Lisp_Object, Lisp_Object, Error_behavior,
2539                             const char *, ...) PRINTF_ARGS (4, 5);
2540 Lisp_Object continuable_error_with_frob (Lisp_Object, const char *,
2541                                          ...) PRINTF_ARGS (2, 3);
2542 Lisp_Object maybe_continuable_error_with_frob
2543 (Lisp_Object, Lisp_Object, Error_behavior, const char *, ...) PRINTF_ARGS (4, 5);
2544 DECLARE_DOESNT_RETURN (signal_simple_error_2 (const char *,
2545                                               Lisp_Object, Lisp_Object));
2546 void maybe_signal_simple_error_2 (const char *, Lisp_Object, Lisp_Object,
2547                                   Lisp_Object, Error_behavior);
2548 Lisp_Object signal_simple_continuable_error_2 (const char *,
2549                                                Lisp_Object, Lisp_Object);
2550 Lisp_Object maybe_signal_simple_continuable_error_2 (const char *, Lisp_Object,
2551                                                      Lisp_Object, Lisp_Object,
2552                                                      Error_behavior);
2553 DECLARE_DOESNT_RETURN (signal_malformed_list_error (Lisp_Object));
2554 DECLARE_DOESNT_RETURN (signal_malformed_property_list_error (Lisp_Object));
2555 DECLARE_DOESNT_RETURN (signal_circular_list_error (Lisp_Object));
2556 DECLARE_DOESNT_RETURN (signal_circular_property_list_error (Lisp_Object));
2557
2558 DECLARE_DOESNT_RETURN (syntax_error (const char *reason, Lisp_Object frob));
2559 DECLARE_DOESNT_RETURN (syntax_error_2 (const char *reason, Lisp_Object frob1,
2560                                        Lisp_Object frob2));
2561 DECLARE_DOESNT_RETURN (invalid_argument (const char *reason,
2562                                          Lisp_Object frob));
2563 DECLARE_DOESNT_RETURN (invalid_argument_2 (const char *reason,
2564                                            Lisp_Object frob1,
2565                                            Lisp_Object frob2));
2566 DECLARE_DOESNT_RETURN (invalid_operation (const char *reason,
2567                                           Lisp_Object frob));
2568 DECLARE_DOESNT_RETURN (invalid_operation_2 (const char *reason,
2569                                             Lisp_Object frob1,
2570                                             Lisp_Object frob2));
2571 DECLARE_DOESNT_RETURN (invalid_change (const char *reason,
2572                                        Lisp_Object frob));
2573 DECLARE_DOESNT_RETURN (invalid_change_2 (const char *reason,
2574                                          Lisp_Object frob1,
2575                                          Lisp_Object frob2));
2576
2577 Lisp_Object signal_void_function_error (Lisp_Object);
2578 Lisp_Object signal_invalid_function_error (Lisp_Object);
2579 Lisp_Object signal_wrong_number_of_arguments_error (Lisp_Object, int);
2580
2581 Lisp_Object run_hook_with_args_in_buffer (struct buffer *, int, Lisp_Object *,
2582                                           enum run_hooks_condition);
2583 Lisp_Object run_hook_with_args (int, Lisp_Object *, enum run_hooks_condition);
2584 void va_run_hook_with_args (Lisp_Object, int, ...);
2585 void va_run_hook_with_args_in_buffer (struct buffer *, Lisp_Object, int, ...);
2586 Lisp_Object run_hook (Lisp_Object);
2587 Lisp_Object apply1 (Lisp_Object, Lisp_Object);
2588 Lisp_Object call0 (Lisp_Object);
2589 Lisp_Object call1 (Lisp_Object, Lisp_Object);
2590 Lisp_Object call2 (Lisp_Object, Lisp_Object, Lisp_Object);
2591 Lisp_Object call3 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
2592 Lisp_Object call4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
2593                    Lisp_Object);
2594 Lisp_Object call5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
2595                    Lisp_Object, Lisp_Object);
2596 Lisp_Object call6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
2597                    Lisp_Object, Lisp_Object, Lisp_Object);
2598 Lisp_Object call7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
2599                    Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
2600 Lisp_Object call8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
2601                    Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
2602                    Lisp_Object);
2603 Lisp_Object call0_in_buffer (struct buffer *, Lisp_Object);
2604 Lisp_Object call1_in_buffer (struct buffer *, Lisp_Object, Lisp_Object);
2605 Lisp_Object call2_in_buffer (struct buffer *, Lisp_Object, Lisp_Object,
2606                              Lisp_Object);
2607 Lisp_Object call3_in_buffer (struct buffer *, Lisp_Object, Lisp_Object,
2608                              Lisp_Object, Lisp_Object);
2609 Lisp_Object call4_in_buffer (struct buffer *, Lisp_Object, Lisp_Object,
2610                              Lisp_Object, Lisp_Object, Lisp_Object);
2611 Lisp_Object call5_in_buffer (struct buffer *, Lisp_Object, Lisp_Object,
2612                              Lisp_Object, Lisp_Object, Lisp_Object,
2613                              Lisp_Object);
2614 Lisp_Object call6_in_buffer (struct buffer *, Lisp_Object, Lisp_Object,
2615                              Lisp_Object, Lisp_Object, Lisp_Object,
2616                              Lisp_Object, Lisp_Object);
2617 Lisp_Object eval_in_buffer (struct buffer *, Lisp_Object);
2618 Lisp_Object call0_with_handler (Lisp_Object, Lisp_Object);
2619 Lisp_Object call1_with_handler (Lisp_Object, Lisp_Object, Lisp_Object);
2620 Lisp_Object eval_in_buffer_trapping_errors (const char *, struct buffer *,
2621                                             Lisp_Object);
2622 Lisp_Object run_hook_trapping_errors (const char *, Lisp_Object);
2623 Lisp_Object safe_run_hook_trapping_errors (const char *, Lisp_Object, int);
2624 Lisp_Object call0_trapping_errors (const char *, Lisp_Object);
2625 Lisp_Object call1_trapping_errors (const char *, Lisp_Object, Lisp_Object);
2626 Lisp_Object call2_trapping_errors (const char *,
2627                                    Lisp_Object, Lisp_Object, Lisp_Object);
2628 Lisp_Object call_with_suspended_errors (lisp_fn_t, volatile Lisp_Object, Lisp_Object,
2629                                         Error_behavior, int, ...);
2630 /* C Code should be using internal_catch, record_unwind_p, condition_case_1 */
2631 Lisp_Object internal_catch (Lisp_Object, Lisp_Object (*) (Lisp_Object),
2632                             Lisp_Object, int * volatile);
2633 Lisp_Object condition_case_1 (Lisp_Object,
2634                               Lisp_Object (*) (Lisp_Object),
2635                               Lisp_Object,
2636                               Lisp_Object (*) (Lisp_Object, Lisp_Object),
2637                               Lisp_Object);
2638 Lisp_Object condition_case_3 (Lisp_Object, Lisp_Object, Lisp_Object);
2639 Lisp_Object unbind_to (int, Lisp_Object);
2640 void specbind (Lisp_Object, Lisp_Object);
2641 void record_unwind_protect (Lisp_Object (*) (Lisp_Object), Lisp_Object);
2642 void do_autoload (Lisp_Object, Lisp_Object);
2643 Lisp_Object un_autoload (Lisp_Object);
2644 void warn_when_safe_lispobj (Lisp_Object, Lisp_Object, Lisp_Object);
2645 void warn_when_safe (Lisp_Object, Lisp_Object, const char *,
2646                      ...) PRINTF_ARGS (3, 4);
2647
2648
2649 /* Defined in event-stream.c */
2650 void wait_delaying_user_input (int (*) (void *), void *);
2651 int detect_input_pending (void);
2652 void reset_this_command_keys (Lisp_Object, int);
2653 Lisp_Object enqueue_misc_user_event (Lisp_Object, Lisp_Object, Lisp_Object);
2654 Lisp_Object enqueue_misc_user_event_pos (Lisp_Object, Lisp_Object,
2655                                          Lisp_Object, int, int, int, int);
2656 extern int modifier_keys_are_sticky;
2657
2658 /* Defined in event-Xt.c */
2659 void enqueue_Xt_dispatch_event (Lisp_Object event);
2660 void signal_special_Xt_user_event (Lisp_Object, Lisp_Object, Lisp_Object);
2661
2662
2663 /* Defined in events.c */
2664 void clear_event_resource (void);
2665 Lisp_Object allocate_event (void);
2666
2667 /* Defined in fileio.c */
2668 void record_auto_save (void);
2669 void force_auto_save_soon (void);
2670 DECLARE_DOESNT_RETURN (report_file_error (const char *, Lisp_Object));
2671 void maybe_report_file_error (const char *, Lisp_Object,
2672                               Lisp_Object, Error_behavior);
2673 DECLARE_DOESNT_RETURN (signal_file_error (const char *, Lisp_Object));
2674 void maybe_signal_file_error (const char *, Lisp_Object,
2675                               Lisp_Object, Error_behavior);
2676 DECLARE_DOESNT_RETURN (signal_double_file_error (const char *, const char *,
2677                                                  Lisp_Object));
2678 void maybe_signal_double_file_error (const char *, const char *,
2679                                      Lisp_Object, Lisp_Object, Error_behavior);
2680 DECLARE_DOESNT_RETURN (signal_double_file_error_2 (const char *, const char *,
2681                                                    Lisp_Object, Lisp_Object));
2682 void maybe_signal_double_file_error_2 (const char *, const char *,
2683                                        Lisp_Object, Lisp_Object, Lisp_Object,
2684                                        Error_behavior);
2685 Lisp_Object lisp_strerror (int);
2686 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object);
2687 ssize_t read_allowing_quit (int, void *, size_t);
2688 ssize_t write_allowing_quit (int, const void *, size_t);
2689 int internal_delete_file (Lisp_Object);
2690
2691 /* Defined in filelock.c */
2692 void lock_file (Lisp_Object);
2693 void unlock_file (Lisp_Object);
2694 void unlock_all_files (void);
2695 void unlock_buffer (struct buffer *);
2696
2697 /* Defined in filemode.c */
2698 void filemodestring (struct stat *, char *);
2699
2700 /* Defined in floatfns.c */
2701 double extract_float (Lisp_Object);
2702
2703 /* Defined in fns.c */
2704 Lisp_Object list_sort (Lisp_Object, Lisp_Object,
2705                        int (*) (Lisp_Object, Lisp_Object, Lisp_Object));
2706 Lisp_Object merge (Lisp_Object, Lisp_Object, Lisp_Object);
2707
2708 void bump_string_modiff (Lisp_Object);
2709 Lisp_Object memq_no_quit (Lisp_Object, Lisp_Object);
2710 Lisp_Object assoc_no_quit (Lisp_Object, Lisp_Object);
2711 Lisp_Object assq_no_quit (Lisp_Object, Lisp_Object);
2712 Lisp_Object rassq_no_quit (Lisp_Object, Lisp_Object);
2713 Lisp_Object delq_no_quit (Lisp_Object, Lisp_Object);
2714 Lisp_Object delq_no_quit_and_free_cons (Lisp_Object, Lisp_Object);
2715 Lisp_Object remassoc_no_quit (Lisp_Object, Lisp_Object);
2716 Lisp_Object remassq_no_quit (Lisp_Object, Lisp_Object);
2717 Lisp_Object remrassq_no_quit (Lisp_Object, Lisp_Object);
2718
2719 int plists_differ (Lisp_Object, Lisp_Object, int, int, int);
2720 Lisp_Object internal_plist_get (Lisp_Object, Lisp_Object);
2721 void internal_plist_put (Lisp_Object *, Lisp_Object, Lisp_Object);
2722 int internal_remprop (Lisp_Object *, Lisp_Object);
2723 Lisp_Object external_plist_get (Lisp_Object *, Lisp_Object,
2724                                 int, Error_behavior);
2725 void external_plist_put (Lisp_Object *, Lisp_Object,
2726                          Lisp_Object, int, Error_behavior);
2727 int external_remprop (Lisp_Object *, Lisp_Object, int, Error_behavior);
2728 int internal_equal (Lisp_Object, Lisp_Object, int);
2729 Lisp_Object concat2 (Lisp_Object, Lisp_Object);
2730 Lisp_Object concat3 (Lisp_Object, Lisp_Object, Lisp_Object);
2731 Lisp_Object vconcat2 (Lisp_Object, Lisp_Object);
2732 Lisp_Object vconcat3 (Lisp_Object, Lisp_Object, Lisp_Object);
2733 Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
2734 Lisp_Object bytecode_nconc2 (Lisp_Object *);
2735 void check_losing_bytecode (const char *, Lisp_Object);
2736
2737 /* Defined in glyphs.c */
2738 Error_behavior decode_error_behavior_flag (Lisp_Object);
2739 Lisp_Object encode_error_behavior_flag (Error_behavior);
2740
2741 /* Defined in indent.c */
2742 int bi_spaces_at_point (struct buffer *, Bytind);
2743 int column_at_point (struct buffer *, Bufpos, int);
2744 int string_column_at_point (Lisp_String *, Bufpos, int);
2745 int current_column (struct buffer *);
2746 void invalidate_current_column (void);
2747 Bufpos vmotion (struct window *, Bufpos, int, int *);
2748 Bufpos vmotion_pixels (Lisp_Object, Bufpos, int, int, int *);
2749
2750 /* Defined in keymap.c */
2751 void where_is_to_char (Lisp_Object, char *);
2752
2753 /* Defined in lread.c */
2754 void ebolify_bytecode_constants (Lisp_Object);
2755 void close_load_descs (void);
2756 int locate_file (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object *, int);
2757 EXFUN (Flocate_file_clear_hashing, 1);
2758 int isfloat_string (const char *);
2759
2760 /* Well, I've decided to enable this. -- ben */
2761 /* And I've decided to make it work right.  -- sb */
2762 #define LOADHIST
2763 /* Define the following symbol to enable load history of dumped files */
2764 #define LOADHIST_DUMPED
2765 /* Define the following symbol to enable load history of C source */
2766 #define LOADHIST_BUILTIN
2767
2768 #ifdef LOADHIST /* this is just a stupid idea */
2769 #define LOADHIST_ATTACH(x) \
2770  do { if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list); } \
2771  while (0)
2772 #else /*! LOADHIST */
2773 # define LOADHIST_ATTACH(x)
2774 #endif /*! LOADHIST */
2775
2776 /* Defined in marker.c */
2777 Bytind bi_marker_position (Lisp_Object);
2778 Bufpos marker_position (Lisp_Object);
2779 void set_bi_marker_position (Lisp_Object, Bytind);
2780 void set_marker_position (Lisp_Object, Bufpos);
2781 void unchain_marker (Lisp_Object);
2782 Lisp_Object noseeum_copy_marker (Lisp_Object, Lisp_Object);
2783 Lisp_Object set_marker_restricted (Lisp_Object, Lisp_Object, Lisp_Object);
2784 #ifdef MEMORY_USAGE_STATS
2785 int compute_buffer_marker_usage (struct buffer *, struct overhead_stats *);
2786 #endif
2787
2788 /* Defined in menubar.c */
2789 extern int popup_menu_up_p;
2790 extern int menubar_show_keybindings;
2791 extern int popup_menu_titles;
2792
2793 /* Defined in minibuf.c */
2794 extern int minibuf_level;
2795 Charcount scmp_1 (const Bufbyte *, const Bufbyte *, Charcount, int);
2796 #define scmp(s1, s2, len) scmp_1 (s1, s2, len, completion_ignore_case)
2797 extern int completion_ignore_case;
2798 int regexp_ignore_completion_p (const Bufbyte *, Lisp_Object,
2799                                 Bytecount, Bytecount);
2800 Lisp_Object clear_echo_area (struct frame *, Lisp_Object, int);
2801 Lisp_Object clear_echo_area_from_print (struct frame *, Lisp_Object, int);
2802 void echo_area_append (struct frame *, const Bufbyte *, Lisp_Object,
2803                        Bytecount, Bytecount, Lisp_Object);
2804 void echo_area_message (struct frame *, const Bufbyte *, Lisp_Object,
2805                         Bytecount, Bytecount, Lisp_Object);
2806 Lisp_Object echo_area_status (struct frame *);
2807 int echo_area_active (struct frame *);
2808 Lisp_Object echo_area_contents (struct frame *);
2809 void message_internal (const Bufbyte *, Lisp_Object, Bytecount, Bytecount);
2810 void message_append_internal (const Bufbyte *, Lisp_Object,
2811                               Bytecount, Bytecount);
2812 void message (const char *, ...) PRINTF_ARGS (1, 2);
2813 void message_append (const char *, ...) PRINTF_ARGS (1, 2);
2814 void message_no_translate (const char *, ...) PRINTF_ARGS (1, 2);
2815 void clear_message (void);
2816
2817 /* Defined in print.c */
2818 void write_string_to_stdio_stream (FILE *, struct console *,
2819                                    const Bufbyte *, Bytecount, Bytecount,
2820                                    Lisp_Object, int);
2821 void debug_print (Lisp_Object);
2822 void debug_short_backtrace (int);
2823 void temp_output_buffer_setup (Lisp_Object);
2824 void temp_output_buffer_show (Lisp_Object, Lisp_Object);
2825 /* NOTE: Do not call this with the data of a Lisp_String.  Use princ.
2826  * Note: stream should be defaulted before calling
2827  *  (eg Qnil means stdout, not Vstandard_output, etc) */
2828 void write_c_string (const char *, Lisp_Object);
2829 /* Same goes for this function. */
2830 void write_string_1 (const Bufbyte *, Bytecount, Lisp_Object);
2831 void print_cons (Lisp_Object, Lisp_Object, int);
2832 void print_vector (Lisp_Object, Lisp_Object, int);
2833 void print_string (Lisp_Object, Lisp_Object, int);
2834 char *long_to_string (char *, long);
2835 void print_internal (Lisp_Object, Lisp_Object, int);
2836 void print_symbol (Lisp_Object, Lisp_Object, int);
2837 void print_float (Lisp_Object, Lisp_Object, int);
2838 extern int print_escape_newlines;
2839 extern int print_readably;
2840 Lisp_Object internal_with_output_to_temp_buffer (Lisp_Object,
2841                                                  Lisp_Object (*) (Lisp_Object),
2842                                                  Lisp_Object, Lisp_Object);
2843 void float_to_string (char *, double);
2844 void internal_object_printer (Lisp_Object, Lisp_Object, int);
2845
2846 /* Defined in profile.c */
2847 void mark_profiling_info (void);
2848 void profile_increase_call_count (Lisp_Object);
2849 extern int profiling_active;
2850 extern int profiling_redisplay_flag;
2851
2852 /* Defined in rangetab.c */
2853 void put_range_table (Lisp_Object, EMACS_INT, EMACS_INT, Lisp_Object);
2854 int unified_range_table_bytes_needed (Lisp_Object);
2855 int unified_range_table_bytes_used (void *);
2856 void unified_range_table_copy_data (Lisp_Object, void *);
2857 Lisp_Object unified_range_table_lookup (void *, EMACS_INT, Lisp_Object);
2858 int unified_range_table_nentries (void *);
2859 void unified_range_table_get_range (void *, int, EMACS_INT *, EMACS_INT *,
2860                                     Lisp_Object *);
2861
2862 /* Defined in search.c */
2863 struct re_pattern_buffer;
2864 struct re_registers;
2865 Bufpos scan_buffer (struct buffer *, Emchar, Bufpos, Bufpos, EMACS_INT, EMACS_INT *, int);
2866 Bufpos find_next_newline (struct buffer *, Bufpos, int);
2867 Bufpos find_next_newline_no_quit (struct buffer *, Bufpos, int);
2868 Bytind bi_find_next_newline_no_quit (struct buffer *, Bytind, int);
2869 Bytind bi_find_next_emchar_in_string (Lisp_String*, Emchar, Bytind, EMACS_INT);
2870 Bufpos find_before_next_newline (struct buffer *, Bufpos, Bufpos, int);
2871 struct re_pattern_buffer *compile_pattern (Lisp_Object, struct re_registers *,
2872                                            Lisp_Object, int, Error_behavior);
2873 Bytecount fast_string_match (Lisp_Object,  const Bufbyte *,
2874                              Lisp_Object, Bytecount,
2875                              Bytecount, int, Error_behavior, int);
2876 Bytecount fast_lisp_string_match (Lisp_Object, Lisp_Object);
2877 void restore_match_data (void);
2878
2879 /* Defined in signal.c */
2880 void init_interrupts_late (void);
2881 extern int dont_check_for_quit;
2882 void begin_dont_check_for_quit (void);
2883 void emacs_sleep (int);
2884
2885 /* Defined in sound.c */
2886 void init_device_sound (struct device *);
2887
2888 /* Defined in specifier.c */
2889 Lisp_Object specifier_instance (Lisp_Object, Lisp_Object, Lisp_Object,
2890                                 Error_behavior, int, int, Lisp_Object);
2891 Lisp_Object specifier_instance_no_quit (Lisp_Object, Lisp_Object, Lisp_Object,
2892                                         Error_behavior, int, Lisp_Object);
2893
2894 /* Defined in symbols.c */
2895 int hash_string (const Bufbyte *, Bytecount);
2896 Lisp_Object intern (const char *);
2897 Lisp_Object oblookup (Lisp_Object, const Bufbyte *, Bytecount);
2898 void map_obarray (Lisp_Object, int (*) (Lisp_Object, void *), void *);
2899 Lisp_Object indirect_function (Lisp_Object, int);
2900 Lisp_Object symbol_value_in_buffer (Lisp_Object, Lisp_Object);
2901 void kill_buffer_local_variables (struct buffer *);
2902 int symbol_value_buffer_local_info (Lisp_Object, struct buffer *);
2903 Lisp_Object find_symbol_value (Lisp_Object);
2904 Lisp_Object find_symbol_value_quickly (Lisp_Object, int);
2905 Lisp_Object top_level_value (Lisp_Object);
2906 void reject_constant_symbols (Lisp_Object sym, Lisp_Object newval,
2907                               int function_p,
2908                               Lisp_Object follow_past_lisp_magic);
2909
2910 /* Defined in syntax.c */
2911 Bufpos scan_words (struct buffer *, Bufpos, int);
2912
2913 /* Defined in undo.c */
2914 Lisp_Object truncate_undo_list (Lisp_Object, int, int);
2915 void record_extent (Lisp_Object, int);
2916 void record_insert (struct buffer *, Bufpos, Charcount);
2917 void record_delete (struct buffer *, Bufpos, Charcount);
2918 void record_change (struct buffer *, Bufpos, Charcount);
2919
2920 /* Defined in unex*.c */
2921 int unexec (char *, char *, uintptr_t, uintptr_t, uintptr_t);
2922 #ifdef RUN_TIME_REMAP
2923 int run_time_remap (char *);
2924 #endif
2925
2926 /* Defined in vm-limit.c */
2927 void memory_warnings (void *, void (*) (const char *));
2928
2929 /* Defined in window.c */
2930 Lisp_Object save_window_excursion_unwind (Lisp_Object);
2931 Lisp_Object display_buffer (Lisp_Object, Lisp_Object, Lisp_Object);
2932
2933 /*--------------- prototypes for Lisp primitives in C ------------*/
2934
2935 /* The following were machine generated 19980312 */
2936
2937 EXFUN (Faccept_process_output, 3);
2938 EXFUN (Fadd1, 1);
2939 EXFUN (Fadd_spec_to_specifier, 5);
2940 EXFUN (Fadd_timeout, 4);
2941 EXFUN (Fappend, MANY);
2942 EXFUN (Fapply, MANY);
2943 EXFUN (Faref, 2);
2944 EXFUN (Faset, 3);
2945 EXFUN (Fassoc, 2);
2946 EXFUN (Fassq, 2);
2947 EXFUN (Fbacktrace, 2);
2948 EXFUN (Fbeginning_of_line, 2);
2949 EXFUN (Fbobp, 1);
2950 EXFUN (Fbolp, 1);
2951 EXFUN (Fboundp, 1);
2952 EXFUN (Fbuffer_substring, 3);
2953 EXFUN (Fbuilt_in_variable_type, 1);
2954 EXFUN (Fbyte_code, 3);
2955 EXFUN (Fcall_interactively, 3);
2956 EXFUN (Fcanonicalize_lax_plist, 2);
2957 EXFUN (Fcanonicalize_plist, 2);
2958 EXFUN (Fcar, 1);
2959 EXFUN (Fcar_safe, 1);
2960 EXFUN (Fcdr, 1);
2961 EXFUN (Fchar_after, 2);
2962 EXFUN (Fchar_ref_p, 1);
2963 EXFUN (Fchar_to_string, 1);
2964 EXFUN (Fcheck_valid_plist, 1);
2965 EXFUN (Fvalid_plist_p, 1);
2966 EXFUN (Fclear_range_table, 1);
2967 EXFUN (Fcoding_category_list, 0);
2968 EXFUN (Fcoding_category_system, 1);
2969 EXFUN (Fcoding_priority_list, 0);
2970 EXFUN (Fcoding_system_charset, 2);
2971 EXFUN (Fcoding_system_doc_string, 1);
2972 EXFUN (Fcoding_system_list, 0);
2973 EXFUN (Fcoding_system_name, 1);
2974 EXFUN (Fcoding_system_p, 1);
2975 EXFUN (Fcoding_system_property, 2);
2976 EXFUN (Fcoding_system_type, 1);
2977 EXFUN (Fcommand_execute, 3);
2978 EXFUN (Fcommandp, 1);
2979 EXFUN (Fconcat, MANY);
2980 EXFUN (Fcons, 2);
2981 EXFUN (Fcopy_alist, 1);
2982 EXFUN (Fcopy_coding_system, 2);
2983 EXFUN (Fcopy_event, 2);
2984 EXFUN (Fcopy_list, 1);
2985 EXFUN (Fcopy_marker, 2);
2986 EXFUN (Fcopy_sequence, 1);
2987 EXFUN (Fcopy_tree, 2);
2988 EXFUN (Fcurrent_window_configuration, 1);
2989 EXFUN (Fdecode_big5_char, 1);
2990 EXFUN (Fdecode_coding_region, 4);
2991 EXFUN (Fdecode_shift_jis_char, 1);
2992 EXFUN (Fdefault_boundp, 1);
2993 EXFUN (Fdefault_value, 1);
2994 EXFUN (Fdefine_key, 3);
2995 EXFUN (Fdelete, 2);
2996 EXFUN (Fdelete_region, 3);
2997 EXFUN (Fdelete_process, 1);
2998 EXFUN (Fdelq, 2);
2999 EXFUN (Fdestructive_alist_to_plist, 1);
3000 EXFUN (Fdetect_coding_region, 3);
3001 EXFUN (Fdgettext, 2);
3002 EXFUN (Fding, 3);
3003 EXFUN (Fdirectory_file_name, 1);
3004 EXFUN (Fdisable_timeout, 1);
3005 EXFUN (Fdiscard_input, 0);
3006 EXFUN (Fdispatch_event, 1);
3007 EXFUN (Fdisplay_error, 2);
3008 EXFUN (Fdo_auto_save, 2);
3009 EXFUN (Fdowncase, 2);
3010 EXFUN (Felt, 2);
3011 EXFUN (Fencode_big5_char, 1);
3012 EXFUN (Fencode_coding_region, 4);
3013 EXFUN (Fencode_shift_jis_char, 1);
3014 EXFUN (Fend_of_line, 2);
3015 EXFUN (Fenqueue_eval_event, 2);
3016 EXFUN (Feobp, 1);
3017 EXFUN (Feolp, 1);
3018 EXFUN (Fequal, 2);
3019 EXFUN (Ferror_message_string, 1);
3020 EXFUN (Feval, 1);
3021 EXFUN (Fevent_to_character, 4);
3022 EXFUN (Fexecute_kbd_macro, 2);
3023 EXFUN (Fexpand_abbrev, 0);
3024 EXFUN (Fexpand_file_name, 2);
3025 EXFUN (Fextent_at, 5);
3026 EXFUN (Fextent_property, 3);
3027 EXFUN (Ffboundp, 1);
3028 EXFUN (Ffile_accessible_directory_p, 1);
3029 EXFUN (Ffile_directory_p, 1);
3030 EXFUN (Ffile_executable_p, 1);
3031 EXFUN (Ffile_exists_p, 1);
3032 EXFUN (Ffile_name_absolute_p, 1);
3033 EXFUN (Ffile_name_as_directory, 1);
3034 EXFUN (Ffile_name_directory, 1);
3035 EXFUN (Ffile_name_nondirectory, 1);
3036 EXFUN (Ffile_readable_p, 1);
3037 EXFUN (Ffile_symlink_p, 1);
3038 EXFUN (Ffile_truename, 2);
3039 EXFUN (Ffind_coding_system, 1);
3040 EXFUN (Ffind_file_name_handler, 2);
3041 EXFUN (Ffollowing_char, 1);
3042 EXFUN (Fformat, MANY);
3043 EXFUN (Fforward_char, 2);
3044 EXFUN (Fforward_line, 2);
3045 EXFUN (Ffset, 2);
3046 EXFUN (Ffuncall, MANY);
3047 EXFUN (Ffunctionp, 1);
3048 EXFUN (Fgeq, MANY);
3049 EXFUN (Fget, 3);
3050 EXFUN (Fget_buffer_process, 1);
3051 EXFUN (Fget_coding_system, 1);
3052 EXFUN (Fget_process, 1);
3053 EXFUN (Fget_range_table, 3);
3054 EXFUN (Fgettext, 1);
3055 EXFUN (Fgoto_char, 2);
3056 EXFUN (Fgtr, MANY);
3057 EXFUN (Findent_to, 3);
3058 EXFUN (Findirect_function, 1);
3059 EXFUN (Finsert, MANY);
3060 EXFUN (Finsert_buffer_substring, 3);
3061 EXFUN (Finsert_char, 4);
3062 EXFUN (Finsert_file_contents_internal, 7);
3063 EXFUN (Finteractive_p, 0);
3064 EXFUN (Fintern, 2);
3065 EXFUN (Fintern_soft, 2);
3066 EXFUN (Fkey_description, 1);
3067 EXFUN (Fkill_emacs, 1);
3068 EXFUN (Fkill_local_variable, 1);
3069 EXFUN (Flast, 2);
3070 EXFUN (Flax_plist_get, 3);
3071 EXFUN (Flax_plist_remprop, 2);
3072 EXFUN (Flength, 1);
3073 EXFUN (Fleq, MANY);
3074 EXFUN (Flist, MANY);
3075 EXFUN (Flistp, 1);
3076 EXFUN (Flist_modules, 0);
3077 EXFUN (Fload_module, 3);
3078 EXFUN (Flookup_key, 3);
3079 EXFUN (Flss, MANY);
3080 EXFUN (Fmake_byte_code, MANY);
3081 EXFUN (Fmake_coding_system, 4);
3082 EXFUN (Fmake_glyph_internal, 1);
3083 EXFUN (Fmake_list, 2);
3084 EXFUN (Fmake_marker, 0);
3085 EXFUN (Fmake_range_table, 0);
3086 EXFUN (Fmake_sparse_keymap, 1);
3087 EXFUN (Fmake_string, 2);
3088 EXFUN (Fmake_symbol, 1);
3089 EXFUN (Fmake_vector, 2);
3090 EXFUN (Fmapcar, 2);
3091 EXFUN (Fmarker_buffer, 1);
3092 EXFUN (Fmarker_position, 1);
3093 EXFUN (Fmatch_beginning, 1);
3094 EXFUN (Fmatch_end, 1);
3095 EXFUN (Fmax, MANY);
3096 EXFUN (Fmember, 2);
3097 EXFUN (Fmemq, 2);
3098 EXFUN (Fmin, MANY);
3099 EXFUN (Fminus, MANY);
3100 EXFUN (Fnarrow_to_region, 3);
3101 EXFUN (Fnconc, MANY);
3102 EXFUN (Fnext_event, 2);
3103 EXFUN (Fnreverse, 1);
3104 EXFUN (Fnthcdr, 2);
3105 EXFUN (Fnumber_to_string, 1);
3106 EXFUN (Fold_assq, 2);
3107 EXFUN (Fold_equal, 2);
3108 EXFUN (Fold_member, 2);
3109 EXFUN (Fold_memq, 2);
3110 EXFUN (Fplist_get, 3);
3111 EXFUN (Fplist_member, 2);
3112 EXFUN (Fplist_put, 3);
3113 EXFUN (Fplus, MANY);
3114 EXFUN (Fpoint, 1);
3115 EXFUN (Fpoint_marker, 2);
3116 EXFUN (Fpoint_max, 1);
3117 EXFUN (Fpoint_min, 1);
3118 EXFUN (Fpreceding_char, 1);
3119 EXFUN (Fprefix_numeric_value, 1);
3120 EXFUN (Fprin1, 2);
3121 EXFUN (Fprin1_to_string, 2);
3122 EXFUN (Fprinc, 2);
3123 EXFUN (Fprint, 2);
3124 EXFUN (Fprocess_status, 1);
3125 EXFUN (Fprogn, UNEVALLED);
3126 EXFUN (Fprovide, 1);
3127 EXFUN (Fput, 3);
3128 EXFUN (Fput_range_table, 4);
3129 EXFUN (Fput_text_property, 5);
3130 EXFUN (Fquo, MANY);
3131 EXFUN (Frassq, 2);
3132 EXFUN (Fread, 1);
3133 EXFUN (Fread_key_sequence, 3);
3134 EXFUN (Freally_free, 1);
3135 EXFUN (Frem, 2);
3136 EXFUN (Fremassq, 2);
3137 EXFUN (Freplace_list, 2);
3138 EXFUN (Fselected_frame, 1);
3139 EXFUN (Fset, 2);
3140 EXFUN (Fset_coding_category_system, 2);
3141 EXFUN (Fset_coding_priority_list, 1);
3142 EXFUN (Fset_default, 2);
3143 EXFUN (Fset_marker, 3);
3144 EXFUN (Fset_standard_case_table, 1);
3145 EXFUN (Fsetcar, 2);
3146 EXFUN (Fsetcdr, 2);
3147 EXFUN (Fsignal, 2);
3148 EXFUN (Fsit_for, 2);
3149 EXFUN (Fskip_chars_backward, 3);
3150 EXFUN (Fskip_chars_forward, 3);
3151 EXFUN (Fsleep_for, 1);
3152 EXFUN (Fsort, 2);
3153 EXFUN (Fspecifier_spec_list, 4);
3154 EXFUN (Fstring_equal, 2);
3155 EXFUN (Fstring_lessp, 2);
3156 EXFUN (Fstring_match, 4);
3157 EXFUN (Fstring_to_number, 2);
3158 EXFUN (Fsub1, 1);
3159 EXFUN (Fsubr_max_args, 1);
3160 EXFUN (Fsubr_min_args, 1);
3161 EXFUN (Fsubsidiary_coding_system, 2);
3162 EXFUN (Fsubstitute_command_keys, 1);
3163 EXFUN (Fsubstitute_in_file_name, 1);
3164 EXFUN (Fsubstring, 3);
3165 EXFUN (Fsymbol_function, 1);
3166 EXFUN (Fsymbol_name, 1);
3167 EXFUN (Fsymbol_plist, 1);
3168 EXFUN (Fsymbol_value, 1);
3169 EXFUN (Fsystem_name, 0);
3170 EXFUN (Fthrow, 2);
3171 EXFUN (Ftimes, MANY);
3172 EXFUN (Ftruncate, 1);
3173 EXFUN (Fundo_boundary, 0);
3174 EXFUN (Funhandled_file_name_directory, 1);
3175 EXFUN (Funlock_buffer, 0);
3176 EXFUN (Fupcase, 2);
3177 EXFUN (Fupcase_initials, 2);
3178 EXFUN (Fupcase_initials_region, 3);
3179 EXFUN (Fupcase_region, 3);
3180 EXFUN (Fuser_home_directory, 0);
3181 EXFUN (Fuser_login_name, 1);
3182 EXFUN (Fvector, MANY);
3183 EXFUN (Fverify_visited_file_modtime, 1);
3184 EXFUN (Fvertical_motion, 3);
3185 EXFUN (Fwiden, 1);
3186
3187 /*--------------- prototypes for constant symbols  ------------*/
3188
3189 extern Lisp_Object Q_style;
3190 extern Lisp_Object Qactivate_menubar_hook;
3191 extern Lisp_Object Qarith_error;
3192 extern Lisp_Object Qarrayp, Qautoload;
3193 extern Lisp_Object Qbackground, Qbackground_pixmap;
3194 extern Lisp_Object Qbeginning_of_buffer, Qbig5;
3195 extern Lisp_Object Qbitp, Qblinking;
3196 extern Lisp_Object Qbuffer_glyph_p, Qbuffer_live_p, Qbuffer_read_only;
3197 extern Lisp_Object Qbyte_code, Qcall_interactively;
3198 extern Lisp_Object Qcategory_designator_p, Qcategory_table_value_p, Qccl, Qcdr;
3199 extern Lisp_Object Qchar_or_string_p, Qcharacterp;
3200 extern Lisp_Object Qcharset_g0, Qcharset_g1, Qcharset_g2, Qcharset_g3;
3201 extern Lisp_Object Qcircular_list, Qcircular_property_list;
3202 extern Lisp_Object Qcoding_system_error;
3203 extern Lisp_Object Qcolor_pixmap_image_instance_p;
3204 extern Lisp_Object Qcommandp, Qcompletion_ignore_case;
3205 extern Lisp_Object Qconsole_live_p, Qconst_specifier, Qcr;
3206 extern Lisp_Object Qcrlf, Qcurrent_menubar, Qctext;
3207 extern Lisp_Object Qcyclic_variable_indirection, Qdecode;
3208 extern Lisp_Object Qdefun, Qdevice_live_p;
3209 extern Lisp_Object Qdim, Qdisabled, Qdisplay_table;
3210 extern Lisp_Object Qdomain_error;
3211 extern Lisp_Object Qediting_error;
3212 extern Lisp_Object Qencode, Qend_of_buffer, Qend_of_file, Qend_open;
3213 extern Lisp_Object Qeol_cr, Qeol_crlf, Qeol_lf, Qeol_type;
3214 extern Lisp_Object Qerror, Qerror_conditions, Qerror_message, Qescape_quoted;
3215 extern Lisp_Object Qevent_live_p, Qexit, Qextent_live_p;
3216 extern Lisp_Object Qexternal_debugging_output, Qfeaturep;
3217 extern Lisp_Object Qfile_error;
3218 extern Lisp_Object Qforce_g0_on_output, Qforce_g1_on_output;
3219 extern Lisp_Object Qforce_g2_on_output, Qforce_g3_on_output, Qforeground;
3220 extern Lisp_Object Qformat, Qframe_live_p;
3221 extern Lisp_Object Qicon_glyph_p, Qidentity;
3222 extern Lisp_Object Qinhibit_quit, Qinhibit_read_only;
3223 extern Lisp_Object Qinput_charset_conversion;
3224 extern Lisp_Object Qinteger_char_or_marker_p, Qinteger_or_char_p;
3225 extern Lisp_Object Qinteger_or_marker_p, Qintegerp, Qinteractive;
3226 extern Lisp_Object Qinternal_error, Qinvalid_argument;
3227 extern Lisp_Object Qinvalid_change, Qinvalid_function, Qinvalid_operation;
3228 extern Lisp_Object Qinvalid_read_syntax, Qinvalid_state;
3229 extern Lisp_Object Qio_error;
3230 extern Lisp_Object Qiso2022;
3231 extern Lisp_Object Qlambda, Qlayout;
3232 extern Lisp_Object Qlf;
3233 extern Lisp_Object Qlist_formation_error;
3234 extern Lisp_Object Qlistp, Qload, Qlock_shift, Qmacro;
3235 extern Lisp_Object Qmakunbound, Qmalformed_list, Qmalformed_property_list;
3236 extern Lisp_Object Qmark;
3237 extern Lisp_Object Qmnemonic;
3238 extern Lisp_Object Qmono_pixmap_image_instance_p;
3239 extern Lisp_Object Qmouse_leave_buffer_hook;
3240 extern Lisp_Object Qnas, Qnatnump, Qnative_layout;
3241 extern Lisp_Object Qno_ascii_cntl, Qno_ascii_eol, Qno_catch;
3242 extern Lisp_Object Qno_conversion, Qno_iso6429;
3243 extern Lisp_Object Qnothing_image_instance_p;
3244 extern Lisp_Object Qnumber_char_or_marker_p, Qnumberp;
3245 extern Lisp_Object Qoutput_charset_conversion;
3246 extern Lisp_Object Qoverflow_error, Qpoint, Qpointer_glyph_p;
3247 extern Lisp_Object Qpointer_image_instance_p, Qpost_read_conversion;
3248 extern Lisp_Object Qpre_write_conversion, Qprint_length;
3249 extern Lisp_Object Qprint_string_length, Qprogn, Qquit;
3250 extern Lisp_Object Qquote, Qrange_error, Qread_char;
3251 extern Lisp_Object Qread_from_minibuffer, Qreally_early_error_handler;
3252 extern Lisp_Object Qregion_beginning, Qregion_end;
3253 extern Lisp_Object Qrun_hooks, Qsans_modifiers;
3254 extern Lisp_Object Qsave_buffers_kill_emacs;
3255 extern Lisp_Object Qself_insert_command, Qself_insert_defer_undo;
3256 extern Lisp_Object Qsequencep, Qset, Qsetting_constant;
3257 extern Lisp_Object Qseven, Qshift_jis, Qshort;
3258 extern Lisp_Object Qsingularity_error;
3259 extern Lisp_Object Qstandard_input, Qstandard_output;
3260 extern Lisp_Object Qstart_open;
3261 extern Lisp_Object Qstring_lessp, Qsubwindow;
3262 extern Lisp_Object Qsubwindow_image_instance_p;
3263 extern Lisp_Object Qsyntax_error, Qt;
3264 extern Lisp_Object Qtext_image_instance_p;
3265 extern Lisp_Object Qtop_level;
3266 extern Lisp_Object Qtrue_list_p;
3267 extern Lisp_Object Qunbound, Qunderflow_error;
3268 #ifdef UTF2000
3269 extern Lisp_Object Qunloaded;
3270 #endif
3271 extern Lisp_Object Qunderline, Quser_files_and_directories;
3272 extern Lisp_Object Qvalues;
3273 extern Lisp_Object Qvariable_documentation, Qvariable_domain;
3274 extern Lisp_Object Qvoid_function, Qvoid_variable;
3275 extern Lisp_Object Qwindow_live_p, Qwrong_number_of_arguments;
3276 extern Lisp_Object Qwrong_type_argument, Qyes_or_no_p;
3277 extern Lisp_Object Qgtk;
3278
3279 #define SYMBOL(fou) extern Lisp_Object fou
3280 #define SYMBOL_KEYWORD(la_cle_est_fou) extern Lisp_Object la_cle_est_fou
3281 #define SYMBOL_GENERAL(tout_le_monde, est_fou) \
3282   extern Lisp_Object tout_le_monde
3283
3284 #include "general-slots.h"
3285
3286 #undef SYMBOL
3287 #undef SYMBOL_KEYWORD
3288 #undef SYMBOL_GENERAL
3289
3290 /*--------------- prototypes for variables of type Lisp_Object  ------------*/
3291
3292 extern Lisp_Object Vactivate_menubar_hook;
3293 extern Lisp_Object Vautoload_queue, Vblank_menubar;
3294 extern Lisp_Object Vcharset_ascii, Vcharset_composite, Vcharset_control_1;
3295 extern Lisp_Object Vcharset_latin_iso8859_1, Vcharset_greek_iso8859_7;
3296 extern Lisp_Object Vcharset_cyrillic_iso8859_5, Vcharset_hebrew_iso8859_8;
3297 extern Lisp_Object Vcharset_thai_tis620, Vcharset_katakana_jisx0201;
3298 extern Lisp_Object Vcoding_system_for_read, Vcoding_system_for_write;
3299 extern Lisp_Object Vcoding_system_hash_table, Vcommand_history;
3300 extern Lisp_Object Vcommand_line_args, Vconfigure_info_directory;
3301 extern Lisp_Object Vconfigure_site_directory, Vconfigure_site_module_directory;
3302 extern Lisp_Object Vconsole_list, Vcontrolling_terminal;
3303 extern Lisp_Object Vcurrent_compiled_function_annotation, Vcurrent_load_list;
3304 extern Lisp_Object Vcurrent_mouse_event, Vcurrent_prefix_arg, Vdata_directory;
3305 extern Lisp_Object Vdirectory_sep_char, Vdisabled_command_hook;
3306 extern Lisp_Object Vdoc_directory, Vinternal_doc_file_name;
3307 extern Lisp_Object Vecho_area_buffer, Vemacs_major_version;
3308 extern Lisp_Object Vemacs_minor_version, Vexec_directory, Vexec_path;
3309 extern Lisp_Object Vexecuting_macro, Vfeatures, Vfile_domain;
3310 extern Lisp_Object Vfile_name_coding_system, Vinhibit_quit;
3311 extern Lisp_Object Vinvocation_directory, Vinvocation_name;
3312 extern Lisp_Object Vkeyboard_coding_system, Vlast_command, Vlast_command_char;
3313 extern Lisp_Object Vlast_command_event, Vlast_input_event;
3314 extern Lisp_Object Vload_file_name_internal;
3315 extern Lisp_Object Vload_file_name_internal_the_purecopy, Vload_history;
3316 extern Lisp_Object Vload_path, Vmark_even_if_inactive, Vmenubar_configuration;
3317 extern Lisp_Object Vminibuf_preprompt, Vminibuf_prompt, Vminibuffer_zero;
3318 extern Lisp_Object Vmodule_directory, Vmswindows_downcase_file_names;
3319 extern Lisp_Object Vmswindows_get_true_file_attributes, Vobarray;
3320 extern Lisp_Object Vprint_length, Vprint_level, Vprocess_environment;
3321 extern Lisp_Object Vquit_flag;
3322 extern Lisp_Object Vrecent_keys_ring, Vshell_file_name, Vsite_directory;
3323 extern Lisp_Object Vsite_module_directory;
3324 extern Lisp_Object Vstandard_input, Vstandard_output, Vstdio_str;
3325 extern Lisp_Object Vsynchronous_sounds, Vsystem_name, Vterminal_coding_system;
3326 extern Lisp_Object Vthis_command_keys, Vunread_command_event;
3327 extern Lisp_Object Vx_initial_argv_list;
3328
3329 #endif /* INCLUDED_lisp_h_ */