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