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