src/lisp.h

   1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
   2    Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
   3                  2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.  */
  21
  22 #ifndef EMACS_LISP_H
  23 #define EMACS_LISP_H
  24
  25 /* Declare the prototype for a general external function.  */
  26 #if defined (PROTOTYPES) || defined (WINDOWSNT)
  27 #define P_(proto) proto
  28 #else
  29 #define P_(proto) ()
  30 #endif
  31
  32 #if 0
  33 /* Define this temporarily to hunt a bug.  If defined, the size of
  34    strings is redundantly recorded in sdata structures so that it can
  35    be compared to the sizes recorded in Lisp strings.  */
  36
  37 #define GC_CHECK_STRING_BYTES 1
  38
  39 /* Define this to check for short string overrun.  */
  40
  41 #define GC_CHECK_STRING_OVERRUN 1
  42
  43 /* Define this to check the string free list.  */
  44
  45 #define GC_CHECK_STRING_FREE_LIST 1
  46
  47 /* Define this to check for malloc buffer overrun.  */
  48
  49 #define XMALLOC_OVERRUN_CHECK 1
  50
  51 /* Define this to check for errors in cons list.  */
  52 /* #define GC_CHECK_CONS_LIST 1 */
  53
  54 #endif /* 0 */
  55
  56 #ifdef GC_CHECK_CONS_LIST
  57 #define CHECK_CONS_LIST() check_cons_list()
  58 #else
  59 #define CHECK_CONS_LIST() 0
  60 #endif
  61
  62 /* These are default choices for the types to use.  */
  63 #ifdef _LP64
  64 #ifndef EMACS_INT
  65 #define EMACS_INT long
  66 #define BITS_PER_EMACS_INT BITS_PER_LONG
  67 #endif
  68 #ifndef EMACS_UINT
  69 #define EMACS_UINT unsigned long
  70 #endif
  71 #else /* not _LP64 */
  72 #ifndef EMACS_INT
  73 #define EMACS_INT int
  74 #define BITS_PER_EMACS_INT BITS_PER_INT
  75 #endif
  76 #ifndef EMACS_UINT
  77 #define EMACS_UINT unsigned int
  78 #endif
  79 #endif
  80
  81 /* Extra internal type checking?  */
  82 extern int suppress_checking;
  83 extern void die P_((const char *, const char *, int)) NO_RETURN;
  84
  85 #ifdef ENABLE_CHECKING
  86
  87 #define CHECK(check,msg) (((check) || suppress_checking         \
  88                            ? (void) 0                           \
  89                            : die ((msg), __FILE__, __LINE__)),  \
  90                           0)
  91 #else
  92
  93 /* Produce same side effects and result, but don't complain.  */
  94 #define CHECK(check,msg) ((check),0)
  95
  96 #endif
  97
  98 /* Used for making sure that Emacs is compilable in all
  99    configurations.  */
 100
 101 #ifdef USE_LISP_UNION_TYPE
 102 #undef NO_UNION_TYPE
 103 #endif
 104
 105 /* Define an Emacs version of "assert", since some system ones are
 106    flaky.  */
 107 #ifndef ENABLE_CHECKING
 108 #define eassert(X)      (void) 0
 109 #else /* ENABLE_CHECKING */
 110 #if defined (__GNUC__) && __GNUC__ >= 2 && defined (__STDC__)
 111 #define eassert(cond) CHECK(cond,"assertion failed: " #cond)
 112 #else
 113 #define eassert(cond) CHECK(cond,"assertion failed")
 114 #endif
 115 #endif /* ENABLE_CHECKING */
 116
 117 /* Define the fundamental Lisp data structures.  */
 118
 119 /* This is the set of Lisp data types.  */
 120
 121 enum Lisp_Type
 122   {
 123     /* Integer.  XINT (obj) is the integer value.  */
 124     Lisp_Int,
 125
 126     /* Symbol.  XSYMBOL (object) points to a struct Lisp_Symbol.  */
 127     Lisp_Symbol,
 128
 129     /* Miscellaneous.  XMISC (object) points to a union Lisp_Misc,
 130        whose first member indicates the subtype.  */
 131     Lisp_Misc,
 132
 133     /* String.  XSTRING (object) points to a struct Lisp_String.
 134        The length of the string, and its contents, are stored therein.  */
 135     Lisp_String,
 136
 137     /* Vector of Lisp objects, or something resembling it.
 138        XVECTOR (object) points to a struct Lisp_Vector, which contains
 139        the size and contents.  The size field also contains the type
 140        information, if it's not a real vector object.  */
 141     Lisp_Vectorlike,
 142
 143     /* Cons.  XCONS (object) points to a struct Lisp_Cons.  */
 144     Lisp_Cons,
 145
 146     Lisp_Float,
 147
 148     /* This is not a type code.  It is for range checking.  */
 149     Lisp_Type_Limit
 150   };
 151
 152 /* This is the set of data types that share a common structure.
 153    The first member of the structure is a type code from this set.
 154    The enum values are arbitrary, but we'll use large numbers to make it
 155    more likely that we'll spot the error if a random word in memory is
 156    mistakenly interpreted as a Lisp_Misc.  */
 157 enum Lisp_Misc_Type
 158   {
 159     Lisp_Misc_Free = 0x5eab,
 160     Lisp_Misc_Marker,
 161     Lisp_Misc_Intfwd,
 162     Lisp_Misc_Boolfwd,
 163     Lisp_Misc_Objfwd,
 164     Lisp_Misc_Buffer_Objfwd,
 165     Lisp_Misc_Buffer_Local_Value,
 166     Lisp_Misc_Some_Buffer_Local_Value,
 167     Lisp_Misc_Overlay,
 168     Lisp_Misc_Kboard_Objfwd,
 169     Lisp_Misc_Save_Value,
 170     /* Currently floats are not a misc type,
 171        but let's define this in case we want to change that.  */
 172     Lisp_Misc_Float,
 173     /* This is not a type code.  It is for range checking.  */
 174     Lisp_Misc_Limit
 175   };
 176
 177 #ifndef GCTYPEBITS
 178 #define GCTYPEBITS 3
 179 #endif
 180
 181 /* These values are overridden by the m- file on some machines.  */
 182 #ifndef VALBITS
 183 #define VALBITS (BITS_PER_EMACS_INT - GCTYPEBITS)
 184 #endif
 185
 186 #ifndef NO_UNION_TYPE
 187
 188 #ifndef WORDS_BIG_ENDIAN
 189
 190 /* Definition of Lisp_Object for little-endian machines.  */
 191
 192 typedef
 193 union Lisp_Object
 194   {
 195     /* Used for comparing two Lisp_Objects;
 196        also, positive integers can be accessed fast this way.  */
 197     EMACS_INT i;
 198
 199     struct
 200       {
 201         EMACS_INT val  : VALBITS;
 202         enum Lisp_Type type : GCTYPEBITS;
 203       } s;
 204     struct
 205       {
 206         EMACS_UINT val : VALBITS;
 207         enum Lisp_Type type : GCTYPEBITS;
 208       } u;
 209   }
 210 Lisp_Object;
 211
 212 #else /* If WORDS_BIG_ENDIAN */
 213
 214 typedef
 215 union Lisp_Object
 216   {
 217     /* Used for comparing two Lisp_Objects;
 218        also, positive integers can be accessed fast this way.  */
 219     EMACS_INT i;
 220
 221     struct
 222       {
 223         enum Lisp_Type type : GCTYPEBITS;
 224         EMACS_INT val  : VALBITS;
 225       } s;
 226     struct
 227       {
 228         enum Lisp_Type type : GCTYPEBITS;
 229         EMACS_UINT val : VALBITS;
 230       } u;
 231   }
 232 Lisp_Object;
 233
 234 #endif /* WORDS_BIG_ENDIAN */
 235
 236 #ifdef __GNUC__
 237 static __inline__ Lisp_Object
 238 LISP_MAKE_RVALUE (Lisp_Object o)
 239 {
 240     return o;
 241 }
 242 #else
 243 /* This isn't quite right - it keeps the argument as an lvalue.
 244    Making it const via casting would help avoid code actually
 245    modifying the location in question, but the casting could cover
 246    other type-related bugs.  */
 247 #define LISP_MAKE_RVALUE(o) (o)
 248 #endif
 249
 250 #endif /* NO_UNION_TYPE */
 251
 252
 253 /* If union type is not wanted, define Lisp_Object as just a number.  */
 254
 255 #ifdef NO_UNION_TYPE
 256 typedef EMACS_INT Lisp_Object;
 257 #define LISP_MAKE_RVALUE(o) (0+(o))
 258 #endif /* NO_UNION_TYPE */
 259
 260 /* Two flags that are set during GC.  On some machines, these flags
 261    are defined differently by the m- file.  */
 262
 263 /* In the size word of a vector, this bit means the vector has been marked.  */
 264
 265 #ifndef ARRAY_MARK_FLAG
 266 #define ARRAY_MARK_FLAG ((EMACS_INT) ((EMACS_UINT) 1 << (VALBITS + GCTYPEBITS - 1)))
 267 #endif /* no ARRAY_MARK_FLAG */
 268
 269 /* In the size word of a struct Lisp_Vector, this bit means it's really
 270    some other vector-like object.  */
 271 #ifndef PSEUDOVECTOR_FLAG
 272 #define PSEUDOVECTOR_FLAG ((ARRAY_MARK_FLAG >> 1) & ~ARRAY_MARK_FLAG)
 273 #endif
 274
 275 /* In a pseudovector, the size field actually contains a word with one
 276    PSEUDOVECTOR_FLAG bit set, and exactly one of the following bits to
 277    indicate the actual type.  */
 278 enum pvec_type
 279 {
 280   PVEC_NORMAL_VECTOR = 0,
 281   PVEC_PROCESS = 0x200,
 282   PVEC_FRAME = 0x400,
 283   PVEC_COMPILED = 0x800,
 284   PVEC_WINDOW = 0x1000,
 285   PVEC_WINDOW_CONFIGURATION = 0x2000,
 286   PVEC_SUBR = 0x4000,
 287   PVEC_CHAR_TABLE = 0x8000,
 288   PVEC_BOOL_VECTOR = 0x10000,
 289   PVEC_BUFFER = 0x20000,
 290   PVEC_HASH_TABLE = 0x40000,
 291   PVEC_TYPE_MASK = 0x7fe00
 292
 293 #if 0 /* This is used to make the value of PSEUDOVECTOR_FLAG available to
 294          GDB.  It doesn't work on OS Alpha.  Moved to a variable in
 295          emacs.c.  */
 296   PVEC_FLAG = PSEUDOVECTOR_FLAG
 297 #endif
 298 };
 299
 300 /* For convenience, we also store the number of elements in these bits.
 301    Note that this size is not necessarily the memory-footprint size, but
 302    only the number of Lisp_Object fields (that need to be traced by the GC).
 303    The distinction is used e.g. by Lisp_Process which places extra
 304    non-Lisp_Object fields at the end of the structure.  */
 305 #define PSEUDOVECTOR_SIZE_MASK 0x1ff
 306
 307 /* Number of bits to put in each character in the internal representation
 308    of bool vectors.  This should not vary across implementations.  */
 309 #define BOOL_VECTOR_BITS_PER_CHAR 8
 310 \f
 311 /***** Select the tagging scheme.  *****/
 312 /* There are basically two options that control the tagging scheme:
 313    - NO_UNION_TYPE says that Lisp_Object should be an integer instead
 314      of a union.
 315    - USE_LSB_TAG means that we can assume the least 3 bits of pointers are
 316      always 0, and we can thus use them to hold tag bits, without
 317      restricting our addressing space.
 318
 319    If USE_LSB_TAG is not set, then we use the top 3 bits for tagging, thus
 320    restricting our possible address range.  Currently USE_LSB_TAG is not
 321    allowed together with a union.  This is not due to any fundamental
 322    technical (or political ;-) problem: nobody wrote the code to do it yet.
 323
 324    USE_LSB_TAG not only requires the least 3 bits of pointers returned by
 325    malloc to be 0 but also needs to be able to impose a mult-of-8 alignment
 326    on the few static Lisp_Objects used: all the defsubr as well
 327    as the two special buffers buffer_defaults and buffer_local_symbols.  */
 328
 329 /* First, try and define DECL_ALIGN(type,var) which declares a static
 330    variable VAR of type TYPE with the added requirement that it be
 331    TYPEBITS-aligned. */
 332 #ifndef NO_DECL_ALIGN
 333 # ifndef DECL_ALIGN
 334 /* What compiler directive should we use for non-gcc compilers?  -stef  */
 335 #  if defined (__GNUC__)
 336 #   define DECL_ALIGN(type, var) \
 337      type __attribute__ ((__aligned__ (1 << GCTYPEBITS))) var
 338 #  endif
 339 # endif
 340 #endif
 341
 342 /* Let's USE_LSB_TAG on systems where we know malloc returns mult-of-8.  */
 343 #if defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ || defined MAC_OSX
 344 /* We also need to be able to specify mult-of-8 alignment on static vars.  */
 345 # if defined DECL_ALIGN
 346 /* We currently do not support USE_LSB_TAG with a union Lisp_Object.  */
 347 #  if defined NO_UNION_TYPE
 348 #   define USE_LSB_TAG
 349 #  endif
 350 # endif
 351 #endif
 352
 353 /* If we cannot use 8-byte alignment, make DECL_ALIGN a no-op.  */
 354 #ifndef DECL_ALIGN
 355 # ifdef USE_LSB_TAG
 356 #  error "USE_LSB_TAG used without defining DECL_ALIGN"
 357 # endif
 358 # define DECL_ALIGN(type, var) type var
 359 #endif
 360
 361 \f
 362 /* These macros extract various sorts of values from a Lisp_Object.
 363  For example, if tem is a Lisp_Object whose type is Lisp_Cons,
 364  XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons.  */
 365
 366 #ifdef NO_UNION_TYPE
 367
 368 #ifdef USE_LSB_TAG
 369
 370 #define TYPEMASK ((((EMACS_INT) 1) << GCTYPEBITS) - 1)
 371 #define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) & TYPEMASK))
 372 #define XINT(a) (((EMACS_INT) (a)) >> GCTYPEBITS)
 373 #define XUINT(a) (((EMACS_UINT) (a)) >> GCTYPEBITS)
 374 #define XSET(var, type, ptr)                                    \
 375     (eassert (XTYPE (ptr) == 0), /* Check alignment.  */        \
 376      (var) = ((EMACS_INT) (type)) | ((EMACS_INT) (ptr)))
 377 #define make_number(N) (((EMACS_INT) (N)) << GCTYPEBITS)
 378
 379 /* XFASTINT and XSETFASTINT are for use when the integer is known to be
 380    positive, in which case the implementation can sometimes be faster
 381    depending on the tagging scheme.  With USE_LSB_TAG, there's no benefit.  */
 382 #define XFASTINT(a) XINT (a)
 383 #define XSETFASTINT(a, b) ((a) = make_number (b))
 384
 385 #define XPNTR(a) ((EMACS_INT) ((a) & ~TYPEMASK))
 386
 387 #else  /* not USE_LSB_TAG */
 388
 389 #define VALMASK ((((EMACS_INT) 1) << VALBITS) - 1)
 390
 391 /* One need to override this if there must be high bits set in data space
 392    (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
 393     on all machines, but would penalize machines which don't need it)
 394  */
 395 #define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) >> VALBITS))
 396
 397 /* For integers known to be positive, XFASTINT provides fast retrieval
 398    and XSETFASTINT provides fast storage.  This takes advantage of the
 399    fact that Lisp_Int is 0.  */
 400 #define XFASTINT(a) ((a) + 0)
 401 #define XSETFASTINT(a, b) ((a) = (b))
 402
 403 /* Extract the value of a Lisp_Object as a signed integer.  */
 404
 405 #ifndef XINT   /* Some machines need to do this differently.  */
 406 #define XINT(a) ((((EMACS_INT) (a)) << (BITS_PER_EMACS_INT - VALBITS))  \
 407                  >> (BITS_PER_EMACS_INT - VALBITS))
 408 #endif
 409
 410 /* Extract the value as an unsigned integer.  This is a basis
 411    for extracting it as a pointer to a structure in storage.  */
 412
 413 #ifndef XUINT
 414 #define XUINT(a) ((EMACS_UINT) ((a) & VALMASK))
 415 #endif
 416
 417 #ifndef XSET
 418 #define XSET(var, type, ptr) \
 419    ((var) = ((EMACS_INT)(type) << VALBITS) + ((EMACS_INT) (ptr) & VALMASK))
 420 #endif
 421
 422 /* Convert a C integer into a Lisp_Object integer.  */
 423
 424 #define make_number(N)          \
 425   ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
 426
 427 #endif /* not USE_LSB_TAG */
 428
 429 #define EQ(x, y) ((x) == (y))
 430
 431 #else /* not NO_UNION_TYPE */
 432
 433 #define XTYPE(a) ((enum Lisp_Type) (a).u.type)
 434
 435 /* For integers known to be positive, XFASTINT provides fast retrieval
 436    and XSETFASTINT provides fast storage.  This takes advantage of the
 437    fact that Lisp_Int is 0.  */
 438 #define XFASTINT(a) ((a).i + 0)
 439 #define XSETFASTINT(a, b) ((a).i = (b))
 440
 441 #ifdef EXPLICIT_SIGN_EXTEND
 442 /* Make sure we sign-extend; compilers have been known to fail to do so.  */
 443 #define XINT(a) (((a).s.val << (BITS_PER_EMACS_INT - VALBITS)) \
 444                  >> (BITS_PER_EMACS_INT - VALBITS))
 445 #else
 446 #define XINT(a) ((a).s.val)
 447 #endif /* EXPLICIT_SIGN_EXTEND */
 448
 449 #define XUINT(a) ((a).u.val)
 450
 451 #define XSET(var, vartype, ptr) \
 452    (((var).s.val = ((EMACS_INT) (ptr))), ((var).s.type = ((char) (vartype))))
 453
 454 #if __GNUC__ >= 2 && defined (__OPTIMIZE__)
 455 #define make_number(N) \
 456   (__extension__ ({ Lisp_Object _l; _l.s.val = (N); _l.s.type = Lisp_Int; _l; }))
 457 #else
 458 extern Lisp_Object make_number P_ ((EMACS_INT));
 459 #endif
 460
 461 #define EQ(x, y) ((x).i == (y).i)
 462
 463 #endif /* NO_UNION_TYPE */
 464
 465 /* During garbage collection, XGCTYPE must be used for extracting types
 466  so that the mark bit is ignored.  XMARKBIT accesses the markbit.
 467  Markbits are used only in particular slots of particular structure types.
 468  Other markbits are always zero.
 469  Outside of garbage collection, all mark bits are always zero.  */
 470
 471 #ifndef XGCTYPE
 472 /* The distinction does not exist now that the MARKBIT has been eliminated.  */
 473 #define XGCTYPE(a) XTYPE (a)
 474 #endif
 475
 476 #ifndef XPNTR
 477 #ifdef HAVE_SHM
 478 /* In this representation, data is found in two widely separated segments.  */
 479 extern size_t pure_size;
 480 #define XPNTR(a) \
 481   (XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
 482 #else /* not HAVE_SHM */
 483 #ifdef DATA_SEG_BITS
 484 /* This case is used for the rt-pc.
 485    In the diffs I was given, it checked for ptr = 0
 486    and did not adjust it in that case.
 487    But I don't think that zero should ever be found
 488    in a Lisp object whose data type says it points to something.  */
 489 #define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
 490 #else
 491 /* Some versions of gcc seem to consider the bitfield width when
 492    issuing the "cast to pointer from integer of different size"
 493    warning, so the cast is here to widen the value back to its natural
 494    size.  */
 495 #define XPNTR(a) ((EMACS_INT) XUINT (a))
 496 #endif
 497 #endif /* not HAVE_SHM */
 498 #endif /* no XPNTR */
 499
 500 /* Largest and smallest representable fixnum values.  These are the C
 501    values.  */
 502
 503 #define MOST_NEGATIVE_FIXNUM    - ((EMACS_INT) 1 << (VALBITS - 1))
 504 #define MOST_POSITIVE_FIXNUM    (((EMACS_INT) 1 << (VALBITS - 1)) - 1)
 505 /* Mask indicating the significant bits of a Lisp_Int.
 506    I.e. (x & INTMASK) == XUINT (make_number (x)).  */
 507 #define INTMASK ((((EMACS_INT) 1) << VALBITS) - 1)
 508
 509 /* Value is non-zero if C integer I doesn't fit into a Lisp fixnum.  */
 510
 511 #define FIXNUM_OVERFLOW_P(i) \
 512   ((EMACS_INT)(i) > MOST_POSITIVE_FIXNUM \
 513    || (EMACS_INT) (i) < MOST_NEGATIVE_FIXNUM)
 514
 515 /* Extract a value or address from a Lisp_Object.  */
 516
 517 #define XCONS(a) (eassert (GC_CONSP(a)),(struct Lisp_Cons *) XPNTR(a))
 518 #define XVECTOR(a) (eassert (GC_VECTORLIKEP(a)),(struct Lisp_Vector *) XPNTR(a))
 519 #define XSTRING(a) (eassert (GC_STRINGP(a)),(struct Lisp_String *) XPNTR(a))
 520 #define XSYMBOL(a) (eassert (GC_SYMBOLP(a)),(struct Lisp_Symbol *) XPNTR(a))
 521 #define XFLOAT(a) (eassert (GC_FLOATP(a)),(struct Lisp_Float *) XPNTR(a))
 522
 523 /* Misc types.  */
 524
 525 #define XMISC(a)   ((union Lisp_Misc *) XPNTR(a))
 526 #define XMISCTYPE(a)   (XMARKER (a)->type)
 527 #define XMARKER(a) (&(XMISC(a)->u_marker))
 528 #define XINTFWD(a) (&(XMISC(a)->u_intfwd))
 529 #define XBOOLFWD(a) (&(XMISC(a)->u_boolfwd))
 530 #define XOBJFWD(a) (&(XMISC(a)->u_objfwd))
 531 #define XBUFFER_OBJFWD(a) (&(XMISC(a)->u_buffer_objfwd))
 532 #define XBUFFER_LOCAL_VALUE(a) (&(XMISC(a)->u_buffer_local_value))
 533 #define XOVERLAY(a) (&(XMISC(a)->u_overlay))
 534 #define XKBOARD_OBJFWD(a) (&(XMISC(a)->u_kboard_objfwd))
 535 #define XSAVE_VALUE(a) (&(XMISC(a)->u_save_value))
 536
 537 /* Pseudovector types.  */
 538
 539 #define XPROCESS(a) (eassert (GC_PROCESSP(a)),(struct Lisp_Process *) XPNTR(a))
 540 #define XWINDOW(a) (eassert (GC_WINDOWP(a)),(struct window *) XPNTR(a))
 541 #define XSUBR(a) (eassert (GC_SUBRP(a)),(struct Lisp_Subr *) XPNTR(a))
 542 #define XBUFFER(a) (eassert (GC_BUFFERP(a)),(struct buffer *) XPNTR(a))
 543 #define XCHAR_TABLE(a) ((struct Lisp_Char_Table *) XPNTR(a))
 544 #define XBOOL_VECTOR(a) ((struct Lisp_Bool_Vector *) XPNTR(a))
 545
 546 /* Construct a Lisp_Object from a value or address.  */
 547
 548 #define XSETINT(a, b) (a) = make_number (b)
 549 #define XSETCONS(a, b) XSET (a, Lisp_Cons, b)
 550 #define XSETVECTOR(a, b) XSET (a, Lisp_Vectorlike, b)
 551 #define XSETSTRING(a, b) XSET (a, Lisp_String, b)
 552 #define XSETSYMBOL(a, b) XSET (a, Lisp_Symbol, b)
 553 #define XSETFLOAT(a, b) XSET (a, Lisp_Float, b)
 554
 555 /* Misc types.  */
 556
 557 #define XSETMISC(a, b) XSET (a, Lisp_Misc, b)
 558 #define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
 559
 560 /* Pseudovector types.  */
 561
 562 #define XSETPSEUDOVECTOR(a, b, code) \
 563   (XSETVECTOR (a, b), XVECTOR (a)->size |= PSEUDOVECTOR_FLAG | (code))
 564 #define XSETWINDOW_CONFIGURATION(a, b) \
 565   (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
 566 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
 567 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
 568 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
 569 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
 570 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
 571 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
 572 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
 573
 574 /* Convenience macros for dealing with Lisp arrays.  */
 575
 576 #define AREF(ARRAY, IDX)        XVECTOR ((ARRAY))->contents[IDX]
 577 #define ASET(ARRAY, IDX, VAL)   (AREF ((ARRAY), (IDX)) = (VAL))
 578 #define ASIZE(ARRAY)            XVECTOR ((ARRAY))->size
 579
 580 /* Convenience macros for dealing with Lisp strings.  */
 581
 582 #define SREF(string, index)     (XSTRING (string)->data[index] + 0)
 583 #define SSET(string, index, new) (XSTRING (string)->data[index] = (new))
 584 #define SDATA(string)           (XSTRING (string)->data + 0)
 585 #define SCHARS(string)          (XSTRING (string)->size + 0)
 586 #define SBYTES(string)          (STRING_BYTES (XSTRING (string)) + 0)
 587
 588 #define STRING_SET_CHARS(string, newsize) \
 589     (XSTRING (string)->size = (newsize))
 590
 591 #define STRING_COPYIN(string, index, new, count) \
 592     bcopy (new, XSTRING (string)->data + index, count)
 593
 594 /* Type checking.  */
 595
 596 #define CHECK_TYPE(ok, Qxxxp, x) \
 597   do { if (!(ok)) wrong_type_argument (Qxxxp, (x)); } while (0)
 598
 599
 600 \f
 601 /* See the macros in intervals.h.  */
 602
 603 typedef struct interval *INTERVAL;
 604
 605 /* Complain if object is not string or buffer type */
 606 #define CHECK_STRING_OR_BUFFER(x) \
 607   CHECK_TYPE (STRINGP (x) || BUFFERP (x), Qbuffer_or_string_p, x)
 608
 609 \f
 610 /* In a cons, the markbit of the car is the gc mark bit */
 611
 612 struct Lisp_Cons
 613   {
 614     /* Please do not use the names of these elements in code other
 615        than the core lisp implementation.  Use XCAR and XCDR below.  */
 616 #ifdef HIDE_LISP_IMPLEMENTATION
 617     Lisp_Object car_;
 618     union
 619     {
 620       Lisp_Object cdr_;
 621       struct Lisp_Cons *chain;
 622     } u;
 623 #else
 624     Lisp_Object car;
 625     union
 626     {
 627       Lisp_Object cdr;
 628       struct Lisp_Cons *chain;
 629     } u;
 630 #endif
 631   };
 632
 633 /* Take the car or cdr of something known to be a cons cell.  */
 634 /* The _AS_LVALUE macros shouldn't be used outside of the minimal set
 635    of code that has to know what a cons cell looks like.  Other code not
 636    part of the basic lisp implementation should assume that the car and cdr
 637    fields are not accessible as lvalues.  (What if we want to switch to
 638    a copying collector someday?  Cached cons cell field addresses may be
 639    invalidated at arbitrary points.)  */
 640 #ifdef HIDE_LISP_IMPLEMENTATION
 641 #define XCAR_AS_LVALUE(c) (XCONS ((c))->car_)
 642 #define XCDR_AS_LVALUE(c) (XCONS ((c))->u.cdr_)
 643 #else
 644 #define XCAR_AS_LVALUE(c) (XCONS ((c))->car)
 645 #define XCDR_AS_LVALUE(c) (XCONS ((c))->u.cdr)
 646 #endif
 647
 648 /* Use these from normal code.  */
 649 #define XCAR(c) LISP_MAKE_RVALUE(XCAR_AS_LVALUE(c))
 650 #define XCDR(c) LISP_MAKE_RVALUE(XCDR_AS_LVALUE(c))
 651
 652 /* Use these to set the fields of a cons cell.
 653
 654    Note that both arguments may refer to the same object, so 'n'
 655    should not be read after 'c' is first modified.  Also, neither
 656    argument should be evaluated more than once; side effects are
 657    especially common in the second argument.  */
 658 #define XSETCAR(c,n) (XCAR_AS_LVALUE(c) = (n))
 659 #define XSETCDR(c,n) (XCDR_AS_LVALUE(c) = (n))
 660
 661 /* For performance: Fast storage of positive integers into the
 662    fields of a cons cell.  See above caveats.  */
 663 #define XSETCARFASTINT(c,n)  XSETFASTINT(XCAR_AS_LVALUE(c),(n))
 664 #define XSETCDRFASTINT(c,n)  XSETFASTINT(XCDR_AS_LVALUE(c),(n))
 665
 666 /* Take the car or cdr of something whose type is not known.  */
 667 #define CAR(c)                                  \
 668  (CONSP ((c)) ? XCAR ((c))                      \
 669   : NILP ((c)) ? Qnil                           \
 670   : wrong_type_argument (Qlistp, (c)))
 671
 672 #define CDR(c)                                  \
 673  (CONSP ((c)) ? XCDR ((c))                      \
 674   : NILP ((c)) ? Qnil                           \
 675   : wrong_type_argument (Qlistp, (c)))
 676
 677 /* Take the car or cdr of something whose type is not known.  */
 678 #define CAR_SAFE(c)                             \
 679   (CONSP ((c)) ? XCAR ((c)) : Qnil)
 680
 681 #define CDR_SAFE(c)                             \
 682   (CONSP ((c)) ? XCDR ((c)) : Qnil)
 683
 684 /* Nonzero if STR is a multibyte string.  */
 685 #define STRING_MULTIBYTE(STR)  \
 686   (XSTRING (STR)->size_byte >= 0)
 687
 688 /* Return the length in bytes of STR.  */
 689
 690 #ifdef GC_CHECK_STRING_BYTES
 691
 692 struct Lisp_String;
 693 extern int string_bytes P_ ((struct Lisp_String *));
 694 #define STRING_BYTES(S) string_bytes ((S))
 695
 696 #else /* not GC_CHECK_STRING_BYTES */
 697
 698 #define STRING_BYTES(STR)  \
 699   ((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte)
 700
 701 #endif /* not GC_CHECK_STRING_BYTES */
 702
 703 /* Mark STR as a unibyte string.  */
 704 #define STRING_SET_UNIBYTE(STR)  \
 705   do { if (EQ (STR, empty_multibyte_string))  \
 706       (STR) = empty_unibyte_string;  \
 707     else XSTRING (STR)->size_byte = -1; } while (0)
 708
 709 /* Get text properties.  */
 710 #define STRING_INTERVALS(STR)  (XSTRING (STR)->intervals + 0)
 711
 712 /* Set text properties.  */
 713 #define STRING_SET_INTERVALS(STR, INT) (XSTRING (STR)->intervals = (INT))
 714
 715 /* In a string or vector, the sign bit of the `size' is the gc mark bit */
 716
 717 struct Lisp_String
 718   {
 719     EMACS_INT size;
 720     EMACS_INT size_byte;
 721     INTERVAL intervals;         /* text properties in this string */
 722     unsigned char *data;
 723   };
 724
 725 #ifdef offsetof
 726 #define OFFSETOF(type,field) offsetof(type,field)
 727 #else
 728 #define OFFSETOF(type,field) \
 729   ((int)((char*)&((type*)0)->field - (char*)0))
 730 #endif
 731
 732 struct Lisp_Vector
 733   {
 734     EMACS_INT size;
 735     struct Lisp_Vector *next;
 736     Lisp_Object contents[1];
 737   };
 738
 739 /* If a struct is made to look like a vector, this macro returns the length
 740    of the shortest vector that would hold that struct.  */
 741 #define VECSIZE(type) ((sizeof (type)                                     \
 742                         - OFFSETOF (struct Lisp_Vector, contents[0])      \
 743                         + sizeof(Lisp_Object) - 1) /* round up */         \
 744                        / sizeof (Lisp_Object))
 745
 746 /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields
 747    at the end and we need to compute the number of Lisp_Object fields (the
 748    ones that the GC needs to trace).  */
 749 #define PSEUDOVECSIZE(type, nonlispfield) \
 750   ((OFFSETOF(type, nonlispfield) - OFFSETOF(struct Lisp_Vector, contents[0])) \
 751    / sizeof (Lisp_Object))
 752
 753 /* A char table is a kind of vectorlike, with contents are like a
 754    vector but with a few other slots.  For some purposes, it makes
 755    sense to handle a chartable with type struct Lisp_Vector.  An
 756    element of a char table can be any Lisp objects, but if it is a sub
 757    char-table, we treat it a table that contains information of a
 758    group of characters of the same charsets or a specific character of
 759    a charset.  A sub char-table has the same structure as a char table
 760    except for that the former omits several slots at the tail.  A sub
 761    char table appears only in an element of a char table, and there's
 762    no way to access it directly from Emacs Lisp program.  */
 763
 764 /* This is the number of slots that apply to characters or character
 765    sets.  The first 128 are for ASCII, the next 128 are for 8-bit
 766    European characters, and the last 128 are for multibyte characters.
 767    The first 256 are indexed by the code itself, but the last 128 are
 768    indexed by (charset-id + 128).  */
 769 #define CHAR_TABLE_ORDINARY_SLOTS 384
 770
 771 /* These are the slot of the default values for single byte
 772    characters.  As 0x9A is never be a charset-id, it is safe to use
 773    that slot for ASCII.  0x9E and 0x80 are charset-ids of
 774    eight-bit-control and eight-bit-graphic respectively.  */
 775 #define CHAR_TABLE_DEFAULT_SLOT_ASCII (0x9A + 128)
 776 #define CHAR_TABLE_DEFAULT_SLOT_8_BIT_CONTROL (0x9E + 128)
 777 #define CHAR_TABLE_DEFAULT_SLOT_8_BIT_GRAPHIC (0x80 + 128)
 778
 779 /* This is the number of slots that apply to characters of ASCII and
 780    8-bit Europeans only.  */
 781 #define CHAR_TABLE_SINGLE_BYTE_SLOTS 256
 782
 783 /* This is the number of slots that every char table must have.  This
 784    counts the ordinary slots and the top, defalt, parent, and purpose
 785    slots.  */
 786 #define CHAR_TABLE_STANDARD_SLOTS (CHAR_TABLE_ORDINARY_SLOTS + 4)
 787
 788 /* This is the number of slots that apply to position-code-1 and
 789    position-code-2 of a multibyte character at the 2nd and 3rd level
 790    sub char tables respectively.  */
 791 #define SUB_CHAR_TABLE_ORDINARY_SLOTS 128
 792
 793 /* This is the number of slots that every sub char table must have.
 794    This counts the ordinary slots and the top and defalt slot.  */
 795 #define SUB_CHAR_TABLE_STANDARD_SLOTS (SUB_CHAR_TABLE_ORDINARY_SLOTS + 2)
 796
 797 /* Return the number of "extra" slots in the char table CT.  */
 798
 799 #define CHAR_TABLE_EXTRA_SLOTS(CT)      \
 800   (((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
 801
 802 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
 803    and 8-bit Europeans characters.  For these characters, do not check
 804    validity of CT.  Do not follow parent.  */
 805 #define CHAR_TABLE_REF(CT, IDX)                         \
 806   ((IDX) >= 0 && (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS   \
 807    ? (!NILP (XCHAR_TABLE (CT)->contents[IDX])           \
 808       ? XCHAR_TABLE (CT)->contents[IDX]                 \
 809       : XCHAR_TABLE (CT)->defalt)                       \
 810    : Faref (CT, make_number (IDX)))
 811
 812 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
 813    and 8-bit Europeans characters.  However, if the result is nil,
 814    return IDX.
 815
 816    For these characters, do not check validity of CT
 817    and do not follow parent.  */
 818 #define CHAR_TABLE_TRANSLATE(CT, IDX)                   \
 819   ((IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS                 \
 820    ? (!NILP (XCHAR_TABLE (CT)->contents[IDX])           \
 821       ? XINT (XCHAR_TABLE (CT)->contents[IDX])          \
 822       : IDX)                                            \
 823    : char_table_translate (CT, IDX))
 824
 825 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
 826    8-bit Europeans characters.  Do not check validity of CT.  */
 827 #define CHAR_TABLE_SET(CT, IDX, VAL)                    \
 828   do {                                                  \
 829     if (XFASTINT (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS)  \
 830       XCHAR_TABLE (CT)->contents[XFASTINT (IDX)] = VAL; \
 831     else                                                \
 832       Faset (CT, IDX, VAL);                             \
 833   } while (0)
 834
 835 struct Lisp_Char_Table
 836   {
 837     /* This is the vector's size field, which also holds the
 838        pseudovector type information.  It holds the size, too.
 839        The size counts the top, defalt, purpose, and parent slots.
 840        The last three are not counted if this is a sub char table.  */
 841     EMACS_INT size;
 842     struct Lisp_Vector *next;
 843     /* This holds a flag to tell if this is a top level char table (t)
 844        or a sub char table (nil).  */
 845     Lisp_Object top;
 846     /* This holds a default value,
 847        which is used whenever the value for a specific character is nil.  */
 848     Lisp_Object defalt;
 849     /* This holds an actual value of each element.  A sub char table
 850        has only SUB_CHAR_TABLE_ORDINARY_SLOTS number of elements.  */
 851     Lisp_Object contents[CHAR_TABLE_ORDINARY_SLOTS];
 852
 853     /* A sub char table doesn't has the following slots.  */
 854
 855     /* This points to another char table, which we inherit from
 856        when the value for a specific character is nil.
 857        The `defalt' slot takes precedence over this.  */
 858     Lisp_Object parent;
 859     /* This should be a symbol which says what kind of use
 860        this char-table is meant for.
 861        Typically now the values can be `syntax-table' and `display-table'.  */
 862     Lisp_Object purpose;
 863     /* These hold additional data.  */
 864     Lisp_Object extras[1];
 865   };
 866
 867 /* A boolvector is a kind of vectorlike, with contents are like a string.  */
 868 struct Lisp_Bool_Vector
 869   {
 870     /* This is the vector's size field.  It doesn't have the real size,
 871        just the subtype information.  */
 872     EMACS_INT vector_size;
 873     struct Lisp_Vector *next;
 874     /* This is the size in bits.  */
 875     EMACS_INT size;
 876     /* This contains the actual bits, packed into bytes.  */
 877     unsigned char data[1];
 878   };
 879
 880 /* This structure describes a built-in function.
 881    It is generated by the DEFUN macro only.
 882    defsubr makes it into a Lisp object.
 883
 884    This type is treated in most respects as a pseudovector,
 885    but since we never dynamically allocate or free them,
 886    we don't need a next-vector field.  */
 887
 888 struct Lisp_Subr
 889   {
 890     EMACS_INT size;
 891     Lisp_Object (*function) ();
 892     short min_args, max_args;
 893     char *symbol_name;
 894     char *prompt;
 895     char *doc;
 896   };
 897
 898 \f
 899 /***********************************************************************
 900                                Symbols
 901  ***********************************************************************/
 902
 903 /* Interned state of a symbol.  */
 904
 905 enum symbol_interned
 906 {
 907   SYMBOL_UNINTERNED = 0,
 908   SYMBOL_INTERNED = 1,
 909   SYMBOL_INTERNED_IN_INITIAL_OBARRAY = 2
 910 };
 911
 912 /* In a symbol, the markbit of the plist is used as the gc mark bit */
 913
 914 struct Lisp_Symbol
 915 {
 916   unsigned gcmarkbit : 1;
 917
 918   /* Non-zero means symbol serves as a variable alias.  The symbol
 919      holding the real value is found in the value slot.  */
 920   unsigned indirect_variable : 1;
 921
 922   /* Non-zero means symbol is constant, i.e. changing its value
 923      should signal an error.  */
 924   unsigned constant : 1;
 925
 926   /* Interned state of the symbol.  This is an enumerator from
 927      enum symbol_interned.  */
 928   unsigned interned : 2;
 929
 930   /* The symbol's name, as a Lisp string.
 931
 932      The name "xname" is used to intentionally break code referring to
 933      the old field "name" of type pointer to struct Lisp_String.  */
 934   Lisp_Object xname;
 935
 936   /* Value of the symbol or Qunbound if unbound.  If this symbol is a
 937      defvaralias, `value' contains the symbol for which it is an
 938      alias.  Use the SYMBOL_VALUE and SET_SYMBOL_VALUE macros to get
 939      and set a symbol's value, to take defvaralias into account.  */
 940   Lisp_Object value;
 941
 942   /* Function value of the symbol or Qunbound if not fboundp.  */
 943   Lisp_Object function;
 944
 945   /* The symbol's property list.  */
 946   Lisp_Object plist;
 947
 948   /* Next symbol in obarray bucket, if the symbol is interned.  */
 949   struct Lisp_Symbol *next;
 950 };
 951
 952 /* Value is name of symbol.  */
 953
 954 #define SYMBOL_NAME(sym)  \
 955      LISP_MAKE_RVALUE (XSYMBOL (sym)->xname)
 956
 957 /* Value is non-zero if SYM is an interned symbol.  */
 958
 959 #define SYMBOL_INTERNED_P(sym)  \
 960      (XSYMBOL (sym)->interned != SYMBOL_UNINTERNED)
 961
 962 /* Value is non-zero if SYM is interned in initial_obarray.  */
 963
 964 #define SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P(sym) \
 965      (XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY)
 966
 967 /* Value is non-zero if symbol is considered a constant, i.e. its
 968    value cannot be changed (there is an exception for keyword symbols,
 969    whose value can be set to the keyword symbol itself).  */
 970
 971 #define SYMBOL_CONSTANT_P(sym)   XSYMBOL (sym)->constant
 972
 973 /* Value is the value of SYM, with defvaralias taken into
 974    account.  */
 975
 976 #define SYMBOL_VALUE(sym)                       \
 977    (XSYMBOL (sym)->indirect_variable            \
 978     ? XSYMBOL (indirect_variable (sym))->value  \
 979     : XSYMBOL (sym)->value)
 980
 981 /* Set SYM's value to VAL, taking defvaralias into account.  */
 982
 983 #define SET_SYMBOL_VALUE(sym, val)                              \
 984      do {                                                       \
 985        if (XSYMBOL (sym)->indirect_variable)                    \
 986          XSYMBOL (indirect_variable ((sym)))->value = (val);    \
 987        else                                                     \
 988          XSYMBOL (sym)->value = (val);                          \
 989      } while (0)
 990
 991 \f
 992 /***********************************************************************
 993                              Hash Tables
 994  ***********************************************************************/
 995
 996 /* The structure of a Lisp hash table.  */
 997
 998 struct Lisp_Hash_Table
 999 {
1000   /* Vector fields.  The hash table code doesn't refer to these.  */
1001   EMACS_INT size;
1002   struct Lisp_Vector *vec_next;
1003
1004   /* Function used to compare keys.  */
1005   Lisp_Object test;
1006
1007   /* Nil if table is non-weak.  Otherwise a symbol describing the
1008      weakness of the table.  */
1009   Lisp_Object weak;
1010
1011   /* When the table is resized, and this is an integer, compute the
1012      new size by adding this to the old size.  If a float, compute the
1013      new size by multiplying the old size with this factor.  */
1014   Lisp_Object rehash_size;
1015
1016   /* Resize hash table when number of entries/ table size is >= this
1017      ratio, a float.  */
1018   Lisp_Object rehash_threshold;
1019
1020   /* Number of key/value entries in the table.  */
1021   Lisp_Object count;
1022
1023   /* Vector of keys and values.  The key of item I is found at index
1024      2 * I, the value is found at index 2 * I + 1.  */
1025   Lisp_Object key_and_value;
1026
1027   /* Vector of hash codes.. If hash[I] is nil, this means that that
1028      entry I is unused.  */
1029   Lisp_Object hash;
1030
1031   /* Vector used to chain entries.  If entry I is free, next[I] is the
1032      entry number of the next free item.  If entry I is non-free,
1033      next[I] is the index of the next entry in the collision chain.  */
1034   Lisp_Object next;
1035
1036   /* Index of first free entry in free list.  */
1037   Lisp_Object next_free;
1038
1039   /* Bucket vector.  A non-nil entry is the index of the first item in
1040      a collision chain.  This vector's size can be larger than the
1041      hash table size to reduce collisions.  */
1042   Lisp_Object index;
1043
1044   /* Next weak hash table if this is a weak hash table.  The head
1045      of the list is in Vweak_hash_tables.  */
1046   Lisp_Object next_weak;
1047
1048   /* User-supplied hash function, or nil.  */
1049   Lisp_Object user_hash_function;
1050
1051   /* User-supplied key comparison function, or nil.  */
1052   Lisp_Object user_cmp_function;
1053
1054   /* C function to compare two keys.  */
1055   int (* cmpfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object,
1056                      unsigned, Lisp_Object, unsigned));
1057
1058   /* C function to compute hash code.  */
1059   unsigned (* hashfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object));
1060 };
1061
1062
1063 #define XHASH_TABLE(OBJ) \
1064      ((struct Lisp_Hash_Table *) XPNTR (OBJ))
1065
1066 #define XSET_HASH_TABLE(VAR, PTR) \
1067      (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
1068
1069 #define HASH_TABLE_P(OBJ)  PSEUDOVECTORP (OBJ, PVEC_HASH_TABLE)
1070 #define GC_HASH_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_HASH_TABLE)
1071
1072 #define CHECK_HASH_TABLE(x) \
1073   CHECK_TYPE (HASH_TABLE_P (x), Qhash_table_p, x)
1074
1075 /* Value is the key part of entry IDX in hash table H.  */
1076
1077 #define HASH_KEY(H, IDX)   AREF ((H)->key_and_value, 2 * (IDX))
1078
1079 /* Value is the value part of entry IDX in hash table H.  */
1080
1081 #define HASH_VALUE(H, IDX) AREF ((H)->key_and_value, 2 * (IDX) + 1)
1082
1083 /* Value is the index of the next entry following the one at IDX
1084    in hash table H.  */
1085
1086 #define HASH_NEXT(H, IDX)  AREF ((H)->next, (IDX))
1087
1088 /* Value is the hash code computed for entry IDX in hash table H.  */
1089
1090 #define HASH_HASH(H, IDX)  AREF ((H)->hash, (IDX))
1091
1092 /* Value is the index of the element in hash table H that is the
1093    start of the collision list at index IDX in the index vector of H.  */
1094
1095 #define HASH_INDEX(H, IDX)  AREF ((H)->index, (IDX))
1096
1097 /* Value is the size of hash table H.  */
1098
1099 #define HASH_TABLE_SIZE(H) XVECTOR ((H)->next)->size
1100
1101 /* Default size for hash tables if not specified.  */
1102
1103 #define DEFAULT_HASH_SIZE 65
1104
1105 /* Default threshold specifying when to resize a hash table.  The
1106    value gives the ratio of current entries in the hash table and the
1107    size of the hash table.  */
1108
1109 #define DEFAULT_REHASH_THRESHOLD 0.8
1110
1111 /* Default factor by which to increase the size of a hash table.  */
1112
1113 #define DEFAULT_REHASH_SIZE 1.5
1114
1115 \f
1116 /* These structures are used for various misc types.  */
1117
1118 struct Lisp_Marker
1119 {
1120   int type : 16;                /* = Lisp_Misc_Marker */
1121   unsigned gcmarkbit : 1;
1122   int spacer : 14;
1123   /* 1 means normal insertion at the marker's position
1124      leaves the marker after the inserted text.  */
1125   unsigned int insertion_type : 1;
1126   /* This is the buffer that the marker points into,
1127      or 0 if it points nowhere.  */
1128   struct buffer *buffer;
1129
1130   /* The remaining fields are meaningless in a marker that
1131      does not point anywhere.  */
1132
1133   /* For markers that point somewhere,
1134      this is used to chain of all the markers in a given buffer.  */
1135   struct Lisp_Marker *next;
1136   /* This is the char position where the marker points.  */
1137   EMACS_INT charpos;
1138   /* This is the byte position.  */
1139   EMACS_INT bytepos;
1140 };
1141
1142 /* Forwarding pointer to an int variable.
1143    This is allowed only in the value cell of a symbol,
1144    and it means that the symbol's value really lives in the
1145    specified int variable.  */
1146 struct Lisp_Intfwd
1147   {
1148     int type : 16;      /* = Lisp_Misc_Intfwd */
1149     unsigned gcmarkbit : 1;
1150     int spacer : 15;
1151     EMACS_INT *intvar;
1152   };
1153
1154 /* Boolean forwarding pointer to an int variable.
1155    This is like Lisp_Intfwd except that the ostensible
1156    "value" of the symbol is t if the int variable is nonzero,
1157    nil if it is zero.  */
1158 struct Lisp_Boolfwd
1159   {
1160     int type : 16;      /* = Lisp_Misc_Boolfwd */
1161     unsigned gcmarkbit : 1;
1162     int spacer : 15;
1163     int *boolvar;
1164   };
1165
1166 /* Forwarding pointer to a Lisp_Object variable.
1167    This is allowed only in the value cell of a symbol,
1168    and it means that the symbol's value really lives in the
1169    specified variable.  */
1170 struct Lisp_Objfwd
1171   {
1172     int type : 16;      /* = Lisp_Misc_Objfwd */
1173     unsigned gcmarkbit : 1;
1174     int spacer : 15;
1175     Lisp_Object *objvar;
1176   };
1177
1178 /* Like Lisp_Objfwd except that value lives in a slot in the
1179    current buffer.  Value is byte index of slot within buffer.  */
1180 struct Lisp_Buffer_Objfwd
1181   {
1182     int type : 16;      /* = Lisp_Misc_Buffer_Objfwd */
1183     unsigned gcmarkbit : 1;
1184     int spacer : 15;
1185     int offset;
1186   };
1187
1188 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
1189    the symbol has buffer-local or frame-local bindings.  (Exception:
1190    some buffer-local variables are built-in, with their values stored
1191    in the buffer structure itself.  They are handled differently,
1192    using struct Lisp_Buffer_Objfwd.)
1193
1194    The `realvalue' slot holds the variable's current value, or a
1195    forwarding pointer to where that value is kept.  This value is the
1196    one that corresponds to the loaded binding.  To read or set the
1197    variable, you must first make sure the right binding is loaded;
1198    then you can access the value in (or through) `realvalue'.
1199
1200    `buffer' and `frame' are the buffer and frame for which the loaded
1201    binding was found.  If those have changed, to make sure the right
1202    binding is loaded it is necessary to find which binding goes with
1203    the current buffer and selected frame, then load it.  To load it,
1204    first unload the previous binding, then copy the value of the new
1205    binding into `realvalue' (or through it).  Also update
1206    LOADED-BINDING to point to the newly loaded binding.
1207
1208    Lisp_Misc_Buffer_Local_Value and Lisp_Misc_Some_Buffer_Local_Value
1209    both use this kind of structure.  With the former, merely setting
1210    the variable creates a local binding for the current buffer.  With
1211    the latter, setting the variable does not do that; only
1212    make-local-variable does that.  */
1213
1214 struct Lisp_Buffer_Local_Value
1215   {
1216     int type : 16;      /* = Lisp_Misc_Buffer_Local_Value
1217                            or Lisp_Misc_Some_Buffer_Local_Value */
1218     unsigned gcmarkbit : 1;
1219     int spacer : 12;
1220
1221     /* 1 means this variable is allowed to have frame-local bindings,
1222        so check for them when looking for the proper binding.  */
1223     unsigned int check_frame : 1;
1224     /* 1 means that the binding now loaded was found
1225        as a local binding for the buffer in the `buffer' slot.  */
1226     unsigned int found_for_buffer : 1;
1227     /* 1 means that the binding now loaded was found
1228        as a local binding for the frame in the `frame' slot.  */
1229     unsigned int found_for_frame : 1;
1230     Lisp_Object realvalue;
1231     /* The buffer and frame for which the loaded binding was found.  */
1232     Lisp_Object buffer, frame;
1233
1234     /* A cons cell, (LOADED-BINDING . DEFAULT-VALUE).
1235
1236        LOADED-BINDING is the binding now loaded.  It is a cons cell
1237        whose cdr is the binding's value.  The cons cell may be an
1238        element of a buffer's local-variable alist, or an element of a
1239        frame's parameter alist, or it may be this cons cell.
1240
1241        DEFAULT-VALUE is the variable's default value, seen when the
1242        current buffer and selected frame do not have their own
1243        bindings for the variable.  When the default binding is loaded,
1244        LOADED-BINDING is actually this very cons cell; thus, its car
1245        points to itself.  */
1246     Lisp_Object cdr;
1247   };
1248
1249 /* START and END are markers in the overlay's buffer, and
1250    PLIST is the overlay's property list.  */
1251 struct Lisp_Overlay
1252   {
1253     int type : 16;      /* = Lisp_Misc_Overlay */
1254     unsigned gcmarkbit : 1;
1255     int spacer : 15;
1256     struct Lisp_Overlay *next;
1257     Lisp_Object start, end, plist;
1258   };
1259
1260 /* Like Lisp_Objfwd except that value lives in a slot in the
1261    current kboard.  */
1262 struct Lisp_Kboard_Objfwd
1263   {
1264     int type : 16;      /* = Lisp_Misc_Kboard_Objfwd */
1265     unsigned gcmarkbit : 1;
1266     int spacer : 15;
1267     int offset;
1268   };
1269
1270 /* Hold a C pointer for later use.
1271    This type of object is used in the arg to record_unwind_protect.  */
1272 struct Lisp_Save_Value
1273   {
1274     int type : 16;      /* = Lisp_Misc_Save_Value */
1275     unsigned gcmarkbit : 1;
1276     int spacer : 14;
1277     /* If DOGC is set, POINTER is the address of a memory
1278        area containing INTEGER potential Lisp_Objects.  */
1279     unsigned int dogc : 1;
1280     void *pointer;
1281     int integer;
1282   };
1283
1284
1285 /* A miscellaneous object, when it's on the free list.  */
1286 struct Lisp_Free
1287   {
1288     int type : 16;      /* = Lisp_Misc_Free */
1289     unsigned gcmarkbit : 1;
1290     int spacer : 15;
1291     union Lisp_Misc *chain;
1292 #ifdef USE_LSB_TAG
1293     /* Try to make sure that sizeof(Lisp_Misc) preserves TYPEBITS-alignment.
1294        This assumes that Lisp_Marker is the largest of the alternatives and
1295        that Lisp_Intfwd has the same size as "Lisp_Free w/o padding".  */
1296     char padding[((((sizeof (struct Lisp_Marker) - 1) >> GCTYPEBITS) + 1)
1297                   << GCTYPEBITS) - sizeof (struct Lisp_Intfwd)];
1298 #endif
1299   };
1300
1301 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
1302    It uses one of these struct subtypes to get the type field.  */
1303
1304 union Lisp_Misc
1305   {
1306     struct Lisp_Free u_free;
1307     struct Lisp_Marker u_marker;
1308     struct Lisp_Intfwd u_intfwd;
1309     struct Lisp_Boolfwd u_boolfwd;
1310     struct Lisp_Objfwd u_objfwd;
1311     struct Lisp_Buffer_Objfwd u_buffer_objfwd;
1312     struct Lisp_Buffer_Local_Value u_buffer_local_value;
1313     struct Lisp_Overlay u_overlay;
1314     struct Lisp_Kboard_Objfwd u_kboard_objfwd;
1315     struct Lisp_Save_Value u_save_value;
1316   };
1317 \f
1318 /* Lisp floating point type */
1319 struct Lisp_Float
1320   {
1321     union
1322     {
1323 #ifdef HIDE_LISP_IMPLEMENTATION
1324       double data_;
1325 #else
1326       double data;
1327 #endif
1328       struct Lisp_Float *chain;
1329     } u;
1330   };
1331
1332 #ifdef HIDE_LISP_IMPLEMENTATION
1333 #define XFLOAT_DATA(f)  (XFLOAT (f)->u.data_)
1334 #else
1335 #define XFLOAT_DATA(f)  (XFLOAT (f)->u.data)
1336 #endif
1337
1338 /* A character, declared with the following typedef, is a member
1339    of some character set associated with the current buffer.  */
1340 #ifndef _UCHAR_T  /* Protect against something in ctab.h on AIX.  */
1341 #define _UCHAR_T
1342 typedef unsigned char UCHAR;
1343 #endif
1344
1345 /* Meanings of slots in a Lisp_Compiled:  */
1346
1347 #define COMPILED_ARGLIST 0
1348 #define COMPILED_BYTECODE 1
1349 #define COMPILED_CONSTANTS 2
1350 #define COMPILED_STACK_DEPTH 3
1351 #define COMPILED_DOC_STRING 4
1352 #define COMPILED_INTERACTIVE 5
1353
1354 /* Flag bits in a character.  These also get used in termhooks.h.
1355    Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
1356    (MUlti-Lingual Emacs) might need 22 bits for the character value
1357    itself, so we probably shouldn't use any bits lower than 0x0400000.  */
1358 #define CHAR_ALT   (0x0400000)
1359 #define CHAR_SUPER (0x0800000)
1360 #define CHAR_HYPER (0x1000000)
1361 #define CHAR_SHIFT (0x2000000)
1362 #define CHAR_CTL   (0x4000000)
1363 #define CHAR_META  (0x8000000)
1364
1365 #define CHAR_MODIFIER_MASK \
1366   (CHAR_ALT | CHAR_SUPER | CHAR_HYPER  | CHAR_SHIFT | CHAR_CTL | CHAR_META)
1367
1368
1369 /* Actually, the current Emacs uses 19 bits for the character value
1370    itself.  */
1371 #define CHARACTERBITS 19
1372
1373 /* The maximum byte size consumed by push_key_description.
1374    All callers should assure that at least this size of memory is
1375    allocated at the place pointed by the second argument.
1376
1377    Thers are 6 modifiers, each consumes 2 chars.
1378    The octal form of a character code consumes
1379    (1 + CHARACTERBITS / 3 + 1) chars (including backslash at the head).
1380    We need one more byte for string terminator `\0'.  */
1381 #define KEY_DESCRIPTION_SIZE ((2 * 6) + 1 + (CHARACTERBITS / 3) + 1 + 1)
1382
1383 #ifdef USE_X_TOOLKIT
1384 #ifdef NO_UNION_TYPE
1385 /* Use this for turning a (void *) into a Lisp_Object, as when the
1386    Lisp_Object is passed into a toolkit callback function.  */
1387 #define VOID_TO_LISP(larg,varg) \
1388   do { ((larg) = ((Lisp_Object) (varg))); } while (0)
1389 #define CVOID_TO_LISP VOID_TO_LISP
1390
1391 /* Use this for turning a Lisp_Object into a  (void *), as when the
1392    Lisp_Object is passed into a toolkit callback function.  */
1393 #define LISP_TO_VOID(larg) ((void *) (larg))
1394 #define LISP_TO_CVOID(varg) ((const void *) (larg))
1395
1396 #else /* not NO_UNION_TYPE */
1397 /* Use this for turning a (void *) into a Lisp_Object, as when the
1398   Lisp_Object is passed into a toolkit callback function.  */
1399 #define VOID_TO_LISP(larg,varg) \
1400   do { ((larg).v = (void *) (varg)); } while (0)
1401 #define CVOID_TO_LISP(larg,varg) \
1402   do { ((larg).cv = (const void *) (varg)); } while (0)
1403
1404 /* Use this for turning a Lisp_Object into a  (void *), as when the
1405    Lisp_Object is passed into a toolkit callback function.  */
1406 #define LISP_TO_VOID(larg) ((larg).v)
1407 #define LISP_TO_CVOID(larg) ((larg).cv)
1408 #endif /* not NO_UNION_TYPE */
1409 #endif /* USE_X_TOOLKIT */
1410
1411 \f
1412 /* The glyph datatype, used to represent characters on the display.  */
1413
1414 /* Glyph code to use as an index to the glyph table.  If it is out of
1415    range for the glyph table, or the corresonding element in the table
1416    is nil, the low 8 bits are the single byte character code, and the
1417    bits above are the numeric face ID.  If FID is the face ID of a
1418    glyph on a frame F, then F->display.x->faces[FID] contains the
1419    description of that face.  This is an int instead of a short, so we
1420    can support a good bunch of face ID's (2^(31 - 8)); given that we
1421    have no mechanism for tossing unused frame face ID's yet, we'll
1422    probably run out of 255 pretty quickly.
1423    This is always -1 for a multibyte character.  */
1424 #define GLYPH int
1425
1426 /* Mask bits for face.  */
1427 #define GLYPH_MASK_FACE    0x7FF80000
1428  /* Mask bits for character code.  */
1429 #define GLYPH_MASK_CHAR    0x0007FFFF /* The lowest 19 bits */
1430
1431 /* The FAST macros assume that we already know we're in an X window.  */
1432
1433 /* Set a character code and a face ID in a glyph G.  */
1434 #define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << CHARACTERBITS))
1435
1436 /* Return a glyph's character code.  */
1437 #define FAST_GLYPH_CHAR(glyph) ((glyph) & GLYPH_MASK_CHAR)
1438
1439 /* Return a glyph's face ID.  */
1440 #define FAST_GLYPH_FACE(glyph) (((glyph) & GLYPH_MASK_FACE) >> CHARACTERBITS)
1441
1442 /* Slower versions that test the frame type first.  */
1443 #define MAKE_GLYPH(f, char, face) (FAST_MAKE_GLYPH (char, face))
1444 #define GLYPH_CHAR(f, g) (FAST_GLYPH_CHAR (g))
1445 #define GLYPH_FACE(f, g) (FAST_GLYPH_FACE (g))
1446
1447 /* Return 1 iff GLYPH contains valid character code.  */
1448 #define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (FAST_GLYPH_CHAR (glyph), 1)
1449
1450 /* The ID of the mode line highlighting face.  */
1451 #define GLYPH_MODE_LINE_FACE 1
1452 \f
1453 /* Data type checking */
1454
1455 #define NILP(x)  EQ (x, Qnil)
1456 #define GC_NILP(x) GC_EQ (x, Qnil)
1457
1458 #define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
1459 #define GC_NUMBERP(x) (GC_INTEGERP (x) || GC_FLOATP (x))
1460 #define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
1461 #define GC_NATNUMP(x) (GC_INTEGERP (x) && XINT (x) >= 0)
1462
1463 #define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
1464 #define GC_INTEGERP(x) INTEGERP (x)
1465 #define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
1466 #define GC_SYMBOLP(x) (XGCTYPE ((x)) == Lisp_Symbol)
1467 #define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
1468 #define GC_MISCP(x) (XGCTYPE ((x)) == Lisp_Misc)
1469 #define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
1470 #define GC_VECTORLIKEP(x) (XGCTYPE ((x)) == Lisp_Vectorlike)
1471 #define STRINGP(x) (XTYPE ((x)) == Lisp_String)
1472 #define GC_STRINGP(x) (XGCTYPE ((x)) == Lisp_String)
1473 #define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
1474 #define GC_CONSP(x) (XGCTYPE ((x)) == Lisp_Cons)
1475
1476 #define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
1477 #define GC_FLOATP(x) (XGCTYPE ((x)) == Lisp_Float)
1478 #define VECTORP(x) (VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
1479 #define GC_VECTORP(x) (GC_VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
1480 #define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1481 #define GC_OVERLAYP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1482 #define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1483 #define GC_MARKERP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1484 #define INTFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
1485 #define GC_INTFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
1486 #define BOOLFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
1487 #define GC_BOOLFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
1488 #define OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
1489 #define GC_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
1490 #define BUFFER_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
1491 #define GC_BUFFER_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
1492 #define BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
1493 #define GC_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
1494 #define SOME_BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
1495 #define GC_SOME_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
1496 #define KBOARD_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
1497 #define GC_KBOARD_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
1498
1499
1500 /* True if object X is a pseudovector whose code is CODE.  */
1501 #define PSEUDOVECTORP(x, code)                                  \
1502   (VECTORLIKEP (x)                                              \
1503    && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code))))     \
1504        == (PSEUDOVECTOR_FLAG | (code))))
1505
1506 /* True if object X is a pseudovector whose code is CODE.
1507    This one works during GC.  */
1508 #define GC_PSEUDOVECTORP(x, code)                               \
1509   (GC_VECTORLIKEP (x)                                           \
1510    && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code))))     \
1511        == (PSEUDOVECTOR_FLAG | (code))))
1512
1513 /* Test for specific pseudovector types.  */
1514 #define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1515 #define GC_WINDOW_CONFIGURATIONP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1516 #define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
1517 #define GC_PROCESSP(x) GC_PSEUDOVECTORP (x, PVEC_PROCESS)
1518 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
1519 #define GC_WINDOWP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW)
1520 #define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
1521 #define GC_SUBRP(x) GC_PSEUDOVECTORP (x, PVEC_SUBR)
1522 #define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
1523 #define GC_COMPILEDP(x) GC_PSEUDOVECTORP (x, PVEC_COMPILED)
1524 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
1525 #define GC_BUFFERP(x) GC_PSEUDOVECTORP (x, PVEC_BUFFER)
1526 #define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1527 #define GC_CHAR_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1528 #define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
1529 #define GC_BOOL_VECTOR_P(x) GC_PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
1530 #define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
1531 #define GC_FRAMEP(x) GC_PSEUDOVECTORP (x, PVEC_FRAME)
1532
1533 #define SUB_CHAR_TABLE_P(x) (CHAR_TABLE_P (x) && NILP (XCHAR_TABLE (x)->top))
1534
1535 /* Test for image (image . spec)  */
1536 #define IMAGEP(x) (CONSP (x) && EQ (XCAR (x), Qimage))
1537
1538 /* Array types.  */
1539
1540 #define ARRAYP(x) \
1541   (VECTORP (x) || STRINGP (x) || CHAR_TABLE_P (x) || BOOL_VECTOR_P (x))
1542 \f
1543 #define GC_EQ(x, y) EQ (x, y)
1544
1545 #define CHECK_LIST(x) \
1546   CHECK_TYPE (CONSP (x) || NILP (x), Qlistp, x)
1547
1548 #define CHECK_LIST_CONS(x, y) \
1549   CHECK_TYPE (CONSP (x), Qlistp, y)
1550
1551 #define CHECK_LIST_END(x, y) \
1552   CHECK_TYPE (NILP (x), Qlistp, y)
1553
1554 #define CHECK_STRING(x) \
1555   CHECK_TYPE (STRINGP (x), Qstringp, x)
1556
1557 #define CHECK_STRING_CAR(x) \
1558   CHECK_TYPE (STRINGP (XCAR (x)), Qstringp, XCAR (x))
1559
1560 #define CHECK_CONS(x) \
1561   CHECK_TYPE (CONSP (x), Qconsp, x)
1562
1563 #define CHECK_SYMBOL(x) \
1564   CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
1565
1566 #define CHECK_CHAR_TABLE(x) \
1567   CHECK_TYPE (CHAR_TABLE_P (x), Qchar_table_p, x)
1568
1569 #define CHECK_VECTOR(x) \
1570   CHECK_TYPE (VECTORP (x), Qvectorp, x)
1571
1572 #define CHECK_VECTOR_OR_STRING(x) \
1573   CHECK_TYPE (VECTORP (x) || STRINGP (x), Qarrayp, x)
1574
1575 #define CHECK_ARRAY(x, Qxxxp)                                                   \
1576   CHECK_TYPE (ARRAYP (x), Qxxxp, x)
1577
1578 #define CHECK_VECTOR_OR_CHAR_TABLE(x) \
1579   CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x)
1580
1581 #define CHECK_BUFFER(x) \
1582   CHECK_TYPE (BUFFERP (x), Qbufferp, x)
1583
1584 #define CHECK_WINDOW(x) \
1585   CHECK_TYPE (WINDOWP (x), Qwindowp, x)
1586
1587 #define CHECK_WINDOW_CONFIGURATION(x) \
1588   CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x)
1589
1590 /* This macro rejects windows on the interior of the window tree as
1591    "dead", which is what we want; this is an argument-checking macro, and
1592    the user should never get access to interior windows.
1593
1594    A window of any sort, leaf or interior, is dead iff the buffer,
1595    vchild, and hchild members are all nil.  */
1596
1597 #define CHECK_LIVE_WINDOW(x) \
1598   CHECK_TYPE (WINDOWP (x) && !NILP (XWINDOW (x)->buffer), Qwindow_live_p, x)
1599
1600 #define CHECK_PROCESS(x) \
1601   CHECK_TYPE (PROCESSP (x), Qprocessp, x)
1602
1603 #define CHECK_SUBR(x) \
1604   CHECK_TYPE (SUBRP (x), Qsubrp, x)
1605
1606 #define CHECK_NUMBER(x) \
1607   CHECK_TYPE (INTEGERP (x), Qintegerp, x)
1608
1609 #define CHECK_NATNUM(x) \
1610   CHECK_TYPE (NATNUMP (x), Qwholenump, x)
1611
1612 #define CHECK_MARKER(x) \
1613   CHECK_TYPE (MARKERP (x), Qmarkerp, x)
1614
1615 #define CHECK_NUMBER_COERCE_MARKER(x) \
1616   do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
1617     else CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); } while (0)
1618
1619 #define XFLOATINT(n) extract_float((n))
1620
1621 #define CHECK_FLOAT(x)          \
1622   CHECK_TYPE (FLOATP (x), Qfloatp, x)
1623
1624 #define CHECK_NUMBER_OR_FLOAT(x)        \
1625   CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x)
1626
1627 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
1628   do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x));   \
1629     else CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x); } while (0)
1630
1631 #define CHECK_OVERLAY(x) \
1632   CHECK_TYPE (OVERLAYP (x), Qoverlayp, x)
1633
1634 /* Since we can't assign directly to the CAR or CDR fields of a cons
1635    cell, use these when checking that those fields contain numbers.  */
1636 #define CHECK_NUMBER_CAR(x) \
1637   do {                                  \
1638     Lisp_Object tmp = XCAR (x);         \
1639     CHECK_NUMBER (tmp);                 \
1640     XSETCAR ((x), tmp);                 \
1641   } while (0)
1642
1643 #define CHECK_NUMBER_CDR(x) \
1644   do {                                  \
1645     Lisp_Object tmp = XCDR (x);         \
1646     CHECK_NUMBER (tmp);                 \
1647     XSETCDR ((x), tmp);                 \
1648   } while (0)
1649
1650 /* Cast pointers to this type to compare them.  Some machines want int.  */
1651 #ifndef PNTR_COMPARISON_TYPE
1652 #define PNTR_COMPARISON_TYPE EMACS_UINT
1653 #endif
1654 \f
1655 /* Define a built-in function for calling from Lisp.
1656  `lname' should be the name to give the function in Lisp,
1657     as a null-terminated C string.
1658  `fnname' should be the name of the function in C.
1659     By convention, it starts with F.
1660  `sname' should be the name for the C constant structure
1661     that records information on this function for internal use.
1662     By convention, it should be the same as `fnname' but with S instead of F.
1663     It's too bad that C macros can't compute this from `fnname'.
1664  `minargs' should be a number, the minimum number of arguments allowed.
1665  `maxargs' should be a number, the maximum number of arguments allowed,
1666     or else MANY or UNEVALLED.
1667     MANY means pass a vector of evaluated arguments,
1668          in the form of an integer number-of-arguments
1669          followed by the address of a vector of Lisp_Objects
1670          which contains the argument values.
1671     UNEVALLED means pass the list of unevaluated arguments
1672  `prompt' says how to read arguments for an interactive call.
1673     See the doc string for `interactive'.
1674     A null string means call interactively with no arguments.
1675  `doc' is documentation for the user.  */
1676
1677 #if (!defined (__STDC__) && !defined (PROTOTYPES)) \
1678     || defined (USE_NONANSI_DEFUN)
1679
1680 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc)      \
1681   Lisp_Object fnname ();                                                \
1682   DECL_ALIGN (struct Lisp_Subr, sname) =                                \
1683     { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),     \
1684       fnname, minargs, maxargs, lname, prompt, 0};                      \
1685   Lisp_Object fnname
1686
1687 #else
1688
1689 /* This version of DEFUN declares a function prototype with the right
1690    arguments, so we can catch errors with maxargs at compile-time.  */
1691 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc)      \
1692   Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                           \
1693   DECL_ALIGN (struct Lisp_Subr, sname) =                                \
1694     { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),     \
1695       fnname, minargs, maxargs, lname, prompt, 0};                      \
1696   Lisp_Object fnname
1697
1698 /* Note that the weird token-substitution semantics of ANSI C makes
1699    this work for MANY and UNEVALLED.  */
1700 #define DEFUN_ARGS_MANY         (int, Lisp_Object *)
1701 #define DEFUN_ARGS_UNEVALLED    (Lisp_Object)
1702 #define DEFUN_ARGS_0    (void)
1703 #define DEFUN_ARGS_1    (Lisp_Object)
1704 #define DEFUN_ARGS_2    (Lisp_Object, Lisp_Object)
1705 #define DEFUN_ARGS_3    (Lisp_Object, Lisp_Object, Lisp_Object)
1706 #define DEFUN_ARGS_4    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1707 #define DEFUN_ARGS_5    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1708                          Lisp_Object)
1709 #define DEFUN_ARGS_6    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1710                          Lisp_Object, Lisp_Object)
1711 #define DEFUN_ARGS_7    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1712                          Lisp_Object, Lisp_Object, Lisp_Object)
1713 #define DEFUN_ARGS_8    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1714                          Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1715 #endif
1716
1717 /* Non-zero if OBJ is a Lisp function.  */
1718
1719 #define FUNCTIONP(OBJ)                                  \
1720      ((CONSP (OBJ) && EQ (XCAR (OBJ), Qlambda))         \
1721       || (SYMBOLP (OBJ) && !NILP (Ffboundp (OBJ)))      \
1722       || COMPILEDP (OBJ)                                \
1723       || SUBRP (OBJ))
1724
1725 /* defsubr (Sname);
1726    is how we define the symbol for function `name' at start-up time.  */
1727 extern void defsubr P_ ((struct Lisp_Subr *));
1728
1729 #define MANY -2
1730 #define UNEVALLED -1
1731
1732 extern void defvar_lisp P_ ((char *, Lisp_Object *));
1733 extern void defvar_lisp_nopro P_ ((char *, Lisp_Object *));
1734 extern void defvar_bool P_ ((char *, int *));
1735 extern void defvar_int P_ ((char *, EMACS_INT *));
1736 extern void defvar_per_buffer P_ ((char *, Lisp_Object *, Lisp_Object, char *));
1737 extern void defvar_kboard P_ ((char *, int));
1738
1739 /* Macros we use to define forwarded Lisp variables.
1740    These are used in the syms_of_FILENAME functions.  */
1741
1742 #define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
1743 #define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
1744 #define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
1745 #define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
1746
1747 /* TYPE is nil for a general Lisp variable.
1748    An integer specifies a type; then only LIsp values
1749    with that type code are allowed (except that nil is allowed too).
1750    LNAME is the LIsp-level variable name.
1751    VNAME is the name of the buffer slot.
1752    DOC is a dummy where you write the doc string as a comment.  */
1753 #define DEFVAR_PER_BUFFER(lname, vname, type, doc)  \
1754  defvar_per_buffer (lname, vname, type, 0)
1755
1756 #define DEFVAR_KBOARD(lname, vname, doc) \
1757  defvar_kboard (lname, \
1758                 (int)((char *)(&current_kboard->vname) \
1759                       - (char *)current_kboard))
1760
1761
1762 \f
1763 /* Structure for recording Lisp call stack for backtrace purposes.  */
1764
1765 /* The special binding stack holds the outer values of variables while
1766    they are bound by a function application or a let form, stores the
1767    code to be executed for Lisp unwind-protect forms, and stores the C
1768    functions to be called for record_unwind_protect.
1769
1770    If func is non-zero, undoing this binding applies func to old_value;
1771       This implements record_unwind_protect.
1772
1773    Otherwise, the element is a variable binding.
1774
1775    If the symbol field is a symbol, it is an ordinary variable binding.
1776
1777    Otherwise, it should be a structure (SYMBOL WHERE
1778    . CURRENT-BUFFER), which means having bound a local value while
1779    CURRENT-BUFFER was active.  If WHERE is nil this means we saw the
1780    default value when binding SYMBOL.  WHERE being a buffer or frame
1781    means we saw a buffer-local or frame-local value.  Other values of
1782    WHERE mean an internal error.  */
1783
1784 typedef Lisp_Object (*specbinding_func) P_ ((Lisp_Object));
1785
1786 struct specbinding
1787   {
1788     Lisp_Object symbol, old_value;
1789     specbinding_func func;
1790     Lisp_Object unused;         /* Dividing by 16 is faster than by 12 */
1791   };
1792
1793 extern struct specbinding *specpdl;
1794 extern struct specbinding *specpdl_ptr;
1795 extern int specpdl_size;
1796
1797 extern EMACS_INT max_specpdl_size;
1798
1799 #define SPECPDL_INDEX() (specpdl_ptr - specpdl)
1800
1801 /* Everything needed to describe an active condition case.  */
1802 struct handler
1803   {
1804     /* The handler clauses and variable from the condition-case form.  */
1805     /* For a handler set up in Lisp code, this is always a list.
1806        For an internal handler set up by internal_condition_case*,
1807        this can instead be the symbol t or `error'.
1808        t: handle all conditions.
1809        error: handle all conditions, and errors can run the debugger
1810               or display a backtrace.  */
1811     Lisp_Object handler;
1812     Lisp_Object var;
1813     /* Fsignal stores here the condition-case clause that applies,
1814        and Fcondition_case thus knows which clause to run.  */
1815     Lisp_Object chosen_clause;
1816
1817     /* Used to effect the longjump out to the handler.  */
1818     struct catchtag *tag;
1819
1820     /* The next enclosing handler.  */
1821     struct handler *next;
1822   };
1823
1824 extern struct handler *handlerlist;
1825
1826 extern struct catchtag *catchlist;
1827 extern struct backtrace *backtrace_list;
1828
1829 extern Lisp_Object memory_signal_data;
1830
1831 /* An address near the bottom of the stack.
1832    Tells GC how to save a copy of the stack.  */
1833 extern char *stack_bottom;
1834
1835 /* Check quit-flag and quit if it is non-nil.
1836    Typing C-g does not directly cause a quit; it only sets Vquit_flag.
1837    So the program needs to do QUIT at times when it is safe to quit.
1838    Every loop that might run for a long time or might not exit
1839    ought to do QUIT at least once, at a safe place.
1840    Unless that is impossible, of course.
1841    But it is very desirable to avoid creating loops where QUIT is impossible.
1842
1843    Exception: if you set immediate_quit to nonzero,
1844    then the handler that responds to the C-g does the quit itself.
1845    This is a good thing to do around a loop that has no side effects
1846    and (in particular) cannot call arbitrary Lisp code.  */
1847
1848 #ifdef SYNC_INPUT
1849 extern void handle_async_input P_ ((void));
1850 extern int interrupt_input_pending;
1851
1852 #define QUIT                                            \
1853   do {                                                  \
1854     if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))     \
1855       {                                                 \
1856         Lisp_Object flag = Vquit_flag;                  \
1857         Vquit_flag = Qnil;                              \
1858         if (EQ (Vthrow_on_input, flag))                 \
1859           Fthrow (Vthrow_on_input, Qt);                 \
1860         Fsignal (Qquit, Qnil);                          \
1861       }                                                 \
1862     else if (interrupt_input_pending)                   \
1863       handle_async_input ();                            \
1864   } while (0)
1865
1866 #else  /* not SYNC_INPUT */
1867
1868 #define QUIT                                            \
1869   do {                                                  \
1870     if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))     \
1871       {                                                 \
1872         Lisp_Object flag = Vquit_flag;                  \
1873         Vquit_flag = Qnil;                              \
1874         if (EQ (Vthrow_on_input, flag))                 \
1875           Fthrow (Vthrow_on_input, Qt);                 \
1876         Fsignal (Qquit, Qnil);                          \
1877       }                                                 \
1878   } while (0)
1879
1880 #endif  /* not SYNC_INPUT */
1881
1882
1883 /* Nonzero if ought to quit now.  */
1884
1885 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
1886 \f
1887 /* Variables used locally in the following case handling macros.  */
1888 extern int case_temp1;
1889 extern Lisp_Object case_temp2;
1890
1891 /* Current buffer's map from characters to lower-case characters.  */
1892
1893 #define DOWNCASE_TABLE current_buffer->downcase_table
1894
1895 /* Current buffer's map from characters to upper-case characters.  */
1896
1897 #define UPCASE_TABLE current_buffer->upcase_table
1898
1899 /* Downcase a character, or make no change if that cannot be done.  */
1900
1901 #define DOWNCASE(CH)                                            \
1902   ((case_temp1 = (CH),                                          \
1903     case_temp2 = CHAR_TABLE_REF (DOWNCASE_TABLE, case_temp1),   \
1904     NATNUMP (case_temp2))                                       \
1905    ? XFASTINT (case_temp2) : case_temp1)
1906
1907 /* 1 if CH is upper case.  */
1908
1909 #define UPPERCASEP(CH) (DOWNCASE (CH) != (CH))
1910
1911 /* 1 if CH is neither upper nor lower case.  */
1912
1913 #define NOCASEP(CH) (UPCASE1 (CH) == (CH))
1914
1915 /* 1 if CH is lower case.  */
1916
1917 #define LOWERCASEP(CH) (!UPPERCASEP (CH) && !NOCASEP(CH))
1918
1919 /* Upcase a character, or make no change if that cannot be done.  */
1920
1921 #define UPCASE(CH) (!UPPERCASEP (CH) ? UPCASE1 (CH) : (CH))
1922
1923 /* Upcase a character known to be not upper case.  */
1924
1925 #define UPCASE1(CH)                                             \
1926   ((case_temp1 = (CH),                                          \
1927     case_temp2 = CHAR_TABLE_REF (UPCASE_TABLE, case_temp1),     \
1928     NATNUMP (case_temp2))                                       \
1929    ? XFASTINT (case_temp2) : case_temp1)
1930
1931 extern Lisp_Object Vascii_downcase_table, Vascii_upcase_table;
1932 extern Lisp_Object Vascii_canon_table, Vascii_eqv_table;
1933 \f
1934 /* Number of bytes of structure consed since last GC.  */
1935
1936 extern int consing_since_gc;
1937
1938 /* Thresholds for doing another gc.  */
1939
1940 extern EMACS_INT gc_cons_threshold;
1941
1942 extern EMACS_INT gc_relative_threshold;
1943
1944 extern EMACS_INT memory_full_cons_threshold;
1945
1946 /* Structure for recording stack slots that need marking.  */
1947
1948 /* This is a chain of structures, each of which points at a Lisp_Object variable
1949  whose value should be marked in garbage collection.
1950  Normally every link of the chain is an automatic variable of a function,
1951  and its `val' points to some argument or local variable of the function.
1952  On exit to the function, the chain is set back to the value it had on entry.
1953  This way, no link remains in the chain when the stack frame containing the
1954  link disappears.
1955
1956  Every function that can call Feval must protect in this fashion all
1957  Lisp_Object variables whose contents will be used again.  */
1958
1959 extern struct gcpro *gcprolist;
1960
1961 struct gcpro
1962 {
1963   struct gcpro *next;
1964
1965   /* Address of first protected variable.  */
1966   volatile Lisp_Object *var;
1967
1968   /* Number of consecutive protected variables.  */
1969   int nvars;
1970
1971 #ifdef DEBUG_GCPRO
1972   int level;
1973 #endif
1974 };
1975
1976 /* Values of GC_MARK_STACK during compilation:
1977
1978    0    Use GCPRO as before
1979    1    Do the real thing, make GCPROs and UNGCPRO no-ops.
1980    2    Mark the stack, and check that everything GCPRO'd is
1981         marked.
1982    3    Mark using GCPRO's, mark stack last, and count how many
1983         dead objects are kept alive.  */
1984
1985
1986 #define GC_USE_GCPROS_AS_BEFORE         0
1987 #define GC_MAKE_GCPROS_NOOPS            1
1988 #define GC_MARK_STACK_CHECK_GCPROS      2
1989 #define GC_USE_GCPROS_CHECK_ZOMBIES     3
1990
1991 #ifndef GC_MARK_STACK
1992 #define GC_MARK_STACK GC_USE_GCPROS_AS_BEFORE
1993 #endif
1994
1995 #if GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS
1996
1997 /* Do something silly with gcproN vars just so gcc shuts up.  */
1998 /* You get warnings from MIPSPro...  */
1999
2000 #define GCPRO1(varname) ((void) gcpro1)
2001 #define GCPRO2(varname1, varname2)(((void) gcpro2, (void) gcpro1))
2002 #define GCPRO3(varname1, varname2, varname3) \
2003   (((void) gcpro3, (void) gcpro2, (void) gcpro1))
2004 #define GCPRO4(varname1, varname2, varname3, varname4) \
2005   (((void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
2006 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
2007   (((void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
2008 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
2009   (((void) gcpro6, (void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
2010 #define UNGCPRO ((void) 0)
2011
2012 #else /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
2013
2014 #ifndef DEBUG_GCPRO
2015
2016 #define GCPRO1(varname) \
2017  {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
2018   gcprolist = &gcpro1; }
2019
2020 #define GCPRO2(varname1, varname2) \
2021  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2022   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2023   gcprolist = &gcpro2; }
2024
2025 #define GCPRO3(varname1, varname2, varname3) \
2026  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2027   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2028   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2029   gcprolist = &gcpro3; }
2030
2031 #define GCPRO4(varname1, varname2, varname3, varname4) \
2032  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2033   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2034   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2035   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2036   gcprolist = &gcpro4; }
2037
2038 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
2039  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2040   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2041   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2042   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2043   gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
2044   gcprolist = &gcpro5; }
2045
2046 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
2047  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2048   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2049   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2050   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2051   gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
2052   gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
2053   gcprolist = &gcpro6; }
2054
2055 #define UNGCPRO (gcprolist = gcpro1.next)
2056
2057 #else
2058
2059 extern int gcpro_level;
2060
2061 #define GCPRO1(varname) \
2062  {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
2063   gcpro1.level = gcpro_level++; \
2064   gcprolist = &gcpro1; }
2065
2066 #define GCPRO2(varname1, varname2) \
2067  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2068   gcpro1.level = gcpro_level; \
2069   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2070   gcpro2.level = gcpro_level++; \
2071   gcprolist = &gcpro2; }
2072
2073 #define GCPRO3(varname1, varname2, varname3) \
2074  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2075   gcpro1.level = gcpro_level; \
2076   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2077   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2078   gcpro3.level = gcpro_level++; \
2079   gcprolist = &gcpro3; }
2080
2081 #define GCPRO4(varname1, varname2, varname3, varname4) \
2082  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2083   gcpro1.level = gcpro_level; \
2084   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2085   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2086   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2087   gcpro4.level = gcpro_level++; \
2088   gcprolist = &gcpro4; }
2089
2090 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
2091  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2092   gcpro1.level = gcpro_level; \
2093   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2094   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2095   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2096   gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
2097   gcpro5.level = gcpro_level++; \
2098   gcprolist = &gcpro5; }
2099
2100 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
2101  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2102   gcpro1.level = gcpro_level; \
2103   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2104   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2105   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2106   gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
2107   gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
2108   gcpro6.level = gcpro_level++; \
2109   gcprolist = &gcpro6; }
2110
2111 #define UNGCPRO                                 \
2112  ((--gcpro_level != gcpro1.level)               \
2113   ? (abort (), 0)                               \
2114   : ((gcprolist = gcpro1.next), 0))
2115
2116 #endif /* DEBUG_GCPRO */
2117 #endif /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
2118
2119
2120 /* Evaluate expr, UNGCPRO, and then return the value of expr.  */
2121 #define RETURN_UNGCPRO(expr)                    \
2122 do                                              \
2123     {                                           \
2124       Lisp_Object ret_ungc_val;                 \
2125       ret_ungc_val = (expr);                    \
2126       UNGCPRO;                                  \
2127       return ret_ungc_val;                      \
2128     }                                           \
2129 while (0)
2130
2131 /* Call staticpro (&var) to protect static variable `var'.  */
2132
2133 void staticpro P_ ((Lisp_Object *));
2134 \f
2135 /* Declare a Lisp-callable function.  The MAXARGS parameter has the same
2136    meaning as in the DEFUN macro, and is used to construct a prototype.  */
2137 #if (!defined (__STDC__) &&  !defined (PROTOTYPES)) \
2138     || defined (USE_NONANSI_DEFUN)
2139 #define EXFUN(fnname, maxargs) \
2140   extern Lisp_Object fnname ()
2141 #else
2142 /* We can use the same trick as in the DEFUN macro to generate the
2143    appropriate prototype.  */
2144 #define EXFUN(fnname, maxargs) \
2145   extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
2146 #endif
2147
2148 /* Forward declarations for prototypes.  */
2149 struct window;
2150 struct frame;
2151
2152 /* Defined in data.c */
2153 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
2154 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
2155 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
2156 extern Lisp_Object Qvoid_variable, Qvoid_function;
2157 extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
2158 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
2159 extern Lisp_Object Qend_of_file, Qarith_error, Qmark_inactive;
2160 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
2161 extern Lisp_Object Qtext_read_only;
2162
2163 extern Lisp_Object Qintegerp, Qnatnump, Qwholenump, Qsymbolp, Qlistp, Qconsp;
2164 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
2165 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qinteger_or_marker_p, Qvectorp;
2166 extern Lisp_Object Qbuffer_or_string_p;
2167 extern Lisp_Object Qboundp, Qfboundp;
2168 extern Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
2169
2170 extern Lisp_Object Qcdr;
2171
2172 extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
2173 extern Lisp_Object Qoverflow_error, Qunderflow_error;
2174
2175 extern Lisp_Object Qfloatp;
2176 extern Lisp_Object Qnumberp, Qnumber_or_marker_p;
2177
2178 extern Lisp_Object Qinteger;
2179
2180 extern void circular_list_error P_ ((Lisp_Object)) NO_RETURN;
2181 EXFUN (Finteractive_form, 1);
2182
2183 /* Defined in frame.c */
2184 extern Lisp_Object Qframep;
2185
2186 EXFUN (Feq, 2);
2187 EXFUN (Fnull, 1);
2188 EXFUN (Flistp, 1);
2189 EXFUN (Fconsp, 1);
2190 EXFUN (Fatom, 1);
2191 EXFUN (Fnlistp, 1);
2192 EXFUN (Fintegerp, 1);
2193 EXFUN (Fnatnump, 1);
2194 EXFUN (Fsymbolp, 1);
2195 EXFUN (Fvectorp, 1);
2196 EXFUN (Fstringp, 1);
2197 EXFUN (Fmultibyte_string_p, 1);
2198 EXFUN (Farrayp, 1);
2199 EXFUN (Fsequencep, 1);
2200 EXFUN (Fbufferp, 1);
2201 EXFUN (Fmarkerp, 1);
2202 EXFUN (Fsubrp, 1);
2203 EXFUN (Fchar_or_string_p, 1);
2204 EXFUN (Finteger_or_marker_p, 1);
2205 EXFUN (Ffloatp, 1);
2206 EXFUN (Finteger_or_floatp, 1);
2207 EXFUN (Finteger_or_float_or_marker_p, 1);
2208
2209 EXFUN (Fcar, 1);
2210 EXFUN (Fcar_safe, 1);
2211 EXFUN (Fcdr, 1);
2212 EXFUN (Fcdr_safe, 1);
2213 EXFUN (Fsetcar, 2);
2214 EXFUN (Fsetcdr, 2);
2215 EXFUN (Fboundp, 1);
2216 EXFUN (Ffboundp, 1);
2217 EXFUN (Fmakunbound, 1);
2218 EXFUN (Ffmakunbound, 1);
2219 EXFUN (Fsymbol_function, 1);
2220 EXFUN (Fsymbol_plist, 1);
2221 EXFUN (Fsymbol_name, 1);
2222 extern Lisp_Object indirect_function P_ ((Lisp_Object));
2223 EXFUN (Findirect_function, 2);
2224 EXFUN (Ffset, 2);
2225 EXFUN (Fsetplist, 2);
2226 EXFUN (Fsymbol_value, 1);
2227 extern Lisp_Object find_symbol_value P_ ((Lisp_Object));
2228 EXFUN (Fset, 2);
2229 EXFUN (Fdefault_value, 1);
2230 EXFUN (Fset_default, 2);
2231 EXFUN (Fdefault_boundp, 1);
2232 EXFUN (Fmake_local_variable, 1);
2233 EXFUN (Flocal_variable_p, 2);
2234 EXFUN (Flocal_variable_if_set_p, 2);
2235
2236 EXFUN (Faref, 2);
2237 EXFUN (Faset, 3);
2238
2239 EXFUN (Fstring_to_number, 2);
2240 EXFUN (Fnumber_to_string, 1);
2241 EXFUN (Feqlsign, 2);
2242 EXFUN (Fgtr, 2);
2243 EXFUN (Flss, 2);
2244 EXFUN (Fgeq, 2);
2245 EXFUN (Fleq, 2);
2246 EXFUN (Fneq, 2);
2247 EXFUN (Fzerop, 1);
2248 EXFUN (Fplus, MANY);
2249 EXFUN (Fminus, MANY);
2250 EXFUN (Ftimes, MANY);
2251 EXFUN (Fquo, MANY);
2252 EXFUN (Frem, 2);
2253 EXFUN (Fmax, MANY);
2254 EXFUN (Fmin, MANY);
2255 EXFUN (Flogand, MANY);
2256 EXFUN (Flogior, MANY);
2257 EXFUN (Flogxor, MANY);
2258 EXFUN (Flognot, 1);
2259 EXFUN (Flsh, 2);
2260 EXFUN (Fash, 2);
2261
2262 EXFUN (Fadd1, 1);
2263 EXFUN (Fsub1, 1);
2264 EXFUN (Fmake_variable_buffer_local, 1);
2265
2266 extern Lisp_Object indirect_variable P_ ((Lisp_Object));
2267 extern Lisp_Object long_to_cons P_ ((unsigned long));
2268 extern unsigned long cons_to_long P_ ((Lisp_Object));
2269 extern void args_out_of_range P_ ((Lisp_Object, Lisp_Object)) NO_RETURN;
2270 extern void args_out_of_range_3 P_ ((Lisp_Object, Lisp_Object,
2271                                      Lisp_Object)) NO_RETURN;
2272 extern Lisp_Object wrong_type_argument P_ ((Lisp_Object, Lisp_Object)) NO_RETURN;
2273 extern void store_symval_forwarding P_ ((Lisp_Object, Lisp_Object,
2274                                          Lisp_Object, struct buffer *));
2275 extern Lisp_Object do_symval_forwarding P_ ((Lisp_Object));
2276 extern Lisp_Object set_internal P_ ((Lisp_Object, Lisp_Object, struct buffer *, int));
2277 extern void syms_of_data P_ ((void));
2278 extern void init_data P_ ((void));
2279 extern void swap_in_global_binding P_ ((Lisp_Object));
2280
2281 /* Defined in cmds.c */
2282 EXFUN (Fend_of_line, 1);
2283 EXFUN (Fforward_char, 1);
2284 EXFUN (Fforward_line, 1);
2285 extern int internal_self_insert P_ ((int, int));
2286 extern void syms_of_cmds P_ ((void));
2287 extern void keys_of_cmds P_ ((void));
2288
2289 /* Defined in coding.c */
2290 EXFUN (Fcoding_system_p, 1);
2291 EXFUN (Fcheck_coding_system, 1);
2292 EXFUN (Fread_coding_system, 2);
2293 EXFUN (Fread_non_nil_coding_system, 1);
2294 EXFUN (Ffind_operation_coding_system, MANY);
2295 EXFUN (Fupdate_coding_systems_internal, 0);
2296 EXFUN (Fencode_coding_string, 3);
2297 EXFUN (Fdecode_coding_string, 3);
2298 extern Lisp_Object detect_coding_system P_ ((const unsigned char *, int, int,
2299                                              int));
2300 extern void init_coding P_ ((void));
2301 extern void init_coding_once P_ ((void));
2302 extern void syms_of_coding P_ ((void));
2303 extern Lisp_Object code_convert_string_norecord P_ ((Lisp_Object, Lisp_Object,
2304                                                      int));
2305
2306 /* Defined in charset.c */
2307 extern EMACS_INT nonascii_insert_offset;
2308 extern Lisp_Object Vnonascii_translation_table;
2309 EXFUN (Fchar_bytes, 1);
2310 EXFUN (Fchar_width, 1);
2311 EXFUN (Fstring, MANY);
2312 extern int chars_in_text P_ ((const unsigned char *, int));
2313 extern int multibyte_chars_in_text P_ ((const unsigned char *, int));
2314 extern int unibyte_char_to_multibyte P_ ((int));
2315 extern int multibyte_char_to_unibyte P_ ((int, Lisp_Object));
2316 extern Lisp_Object Qcharset;
2317 extern void init_charset_once P_ ((void));
2318 extern void syms_of_charset P_ ((void));
2319
2320 /* Defined in syntax.c */
2321 EXFUN (Fforward_word, 1);
2322 EXFUN (Fskip_chars_forward, 2);
2323 EXFUN (Fskip_chars_backward, 2);
2324 EXFUN (Fsyntax_table_p, 1);
2325 EXFUN (Fsyntax_table, 0);
2326 EXFUN (Fset_syntax_table, 1);
2327 extern void init_syntax_once P_ ((void));
2328 extern void syms_of_syntax P_ ((void));
2329
2330 /* Defined in fns.c */
2331 extern int use_dialog_box;
2332 extern int next_almost_prime P_ ((int));
2333 extern Lisp_Object larger_vector P_ ((Lisp_Object, int, Lisp_Object));
2334 extern void sweep_weak_hash_tables P_ ((void));
2335 extern Lisp_Object Qstring_lessp;
2336 EXFUN (Foptimize_char_table, 1);
2337 extern Lisp_Object Vfeatures;
2338 extern Lisp_Object QCtest, QCweakness, Qequal;
2339 unsigned sxhash P_ ((Lisp_Object, int));
2340 Lisp_Object make_hash_table P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
2341                                  Lisp_Object, Lisp_Object, Lisp_Object,
2342                                  Lisp_Object));
2343 Lisp_Object copy_hash_table P_ ((struct Lisp_Hash_Table *));
2344 int hash_lookup P_ ((struct Lisp_Hash_Table *, Lisp_Object, unsigned *));
2345 int hash_put P_ ((struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
2346                   unsigned));
2347 void hash_remove P_ ((struct Lisp_Hash_Table *, Lisp_Object));
2348 void hash_clear P_ ((struct Lisp_Hash_Table *));
2349 void remove_hash_entry P_ ((struct Lisp_Hash_Table *, int));
2350 extern void init_fns P_ ((void));
2351 EXFUN (Fsxhash, 1);
2352 EXFUN (Fmake_hash_table, MANY);
2353 EXFUN (Fcopy_hash_table, 1);
2354 EXFUN (Fhash_table_count, 1);
2355 EXFUN (Fhash_table_rehash_size, 1);
2356 EXFUN (Fhash_table_rehash_threshold, 1);
2357 EXFUN (Fhash_table_size, 1);
2358 EXFUN (Fhash_table_test, 1);
2359 EXFUN (Fhash_table_weak, 1);
2360 EXFUN (Fhash_table_p, 1);
2361 EXFUN (Fclrhash, 1);
2362 EXFUN (Fgethash, 3);
2363 EXFUN (Fputhash, 3);
2364 EXFUN (Fremhash, 2);
2365 EXFUN (Fmaphash, 2);
2366 EXFUN (Fdefine_hash_table_test, 3);
2367
2368 EXFUN (Fidentity, 1);
2369 EXFUN (Frandom, 1);
2370 EXFUN (Flength, 1);
2371 EXFUN (Fsafe_length, 1);
2372 EXFUN (Fappend, MANY);
2373 EXFUN (Fconcat, MANY);
2374 EXFUN (Fvconcat, MANY);
2375 EXFUN (Fcopy_sequence, 1);
2376 EXFUN (Fstring_make_multibyte, 1);
2377 EXFUN (Fstring_make_unibyte, 1);
2378 EXFUN (Fstring_as_multibyte, 1);
2379 EXFUN (Fstring_as_unibyte, 1);
2380 EXFUN (Fstring_to_multibyte, 1);
2381 EXFUN (Fsubstring, 3);
2382 extern Lisp_Object substring_both P_ ((Lisp_Object, int, int, int, int));
2383 EXFUN (Fnth, 2);
2384 EXFUN (Fnthcdr, 2);
2385 EXFUN (Fmemq, 2);
2386 EXFUN (Fassq, 2);
2387 EXFUN (Fassoc, 2);
2388 EXFUN (Felt, 2);
2389 EXFUN (Fmember, 2);
2390 EXFUN (Frassq, 2);
2391 EXFUN (Fdelq, 2);
2392 EXFUN (Fdelete, 2);
2393 EXFUN (Fsort, 2);
2394 EXFUN (Freverse, 1);
2395 EXFUN (Fnreverse, 1);
2396 EXFUN (Fget, 2);
2397 EXFUN (Fput, 3);
2398 EXFUN (Fequal, 2);
2399 EXFUN (Ffillarray, 2);
2400 EXFUN (Fnconc, MANY);
2401 EXFUN (Fmapcar, 2);
2402 EXFUN (Fmapconcat, 3);
2403 EXFUN (Fy_or_n_p, 1);
2404 extern Lisp_Object do_yes_or_no_p P_ ((Lisp_Object));
2405 EXFUN (Frequire, 3);
2406 EXFUN (Fprovide, 2);
2407 extern Lisp_Object concat2 P_ ((Lisp_Object, Lisp_Object));
2408 extern Lisp_Object concat3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2409 extern Lisp_Object nconc2 P_ ((Lisp_Object, Lisp_Object));
2410 extern Lisp_Object assq_no_quit P_ ((Lisp_Object, Lisp_Object));
2411 extern void clear_string_char_byte_cache P_ ((void));
2412 extern int string_char_to_byte P_ ((Lisp_Object, int));
2413 extern int string_byte_to_char P_ ((Lisp_Object, int));
2414 extern Lisp_Object string_make_multibyte P_ ((Lisp_Object));
2415 extern Lisp_Object string_to_multibyte P_ ((Lisp_Object));
2416 extern Lisp_Object string_make_unibyte P_ ((Lisp_Object));
2417 EXFUN (Fcopy_alist, 1);
2418 EXFUN (Fplist_get, 2);
2419 EXFUN (Fplist_put, 3);
2420 EXFUN (Fplist_member, 2);
2421 EXFUN (Fset_char_table_parent, 2);
2422 EXFUN (Fchar_table_extra_slot, 2);
2423 EXFUN (Fset_char_table_extra_slot, 3);
2424 EXFUN (Frassoc, 2);
2425 EXFUN (Fstring_equal, 2);
2426 EXFUN (Fcompare_strings, 7);
2427 EXFUN (Fstring_lessp, 2);
2428 extern int char_table_translate P_ ((Lisp_Object, int));
2429 extern void map_char_table P_ ((void (*) (Lisp_Object, Lisp_Object, Lisp_Object),
2430                                 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, int,
2431                                 Lisp_Object *));
2432 extern Lisp_Object char_table_ref_and_index P_ ((Lisp_Object, int, int *));
2433 extern void syms_of_fns P_ ((void));
2434
2435 /* Defined in floatfns.c */
2436 extern double extract_float P_ ((Lisp_Object));
2437 EXFUN (Ffloat, 1);
2438 EXFUN (Ftruncate, 2);
2439 extern void init_floatfns P_ ((void));
2440 extern void syms_of_floatfns P_ ((void));
2441
2442 /* Defined in fringe.c */
2443 extern void syms_of_fringe P_ ((void));
2444 extern void init_fringe P_ ((void));
2445 extern void init_fringe_once P_ ((void));
2446
2447 /* Defined in image.c */
2448 EXFUN (Finit_image_library, 2);
2449 extern void syms_of_image P_ ((void));
2450 extern void init_image P_ ((void));
2451
2452 /* Defined in insdel.c */
2453 extern Lisp_Object Qinhibit_modification_hooks;
2454 extern void move_gap P_ ((int));
2455 extern void move_gap_both P_ ((int, int));
2456 extern void make_gap P_ ((int));
2457 extern int copy_text P_ ((const unsigned char *, unsigned char *, int, int, int));
2458 extern int count_size_as_multibyte P_ ((const unsigned char *, int));
2459 extern int count_combining_before P_ ((const unsigned char *, int, int, int));
2460 extern int count_combining_after P_ ((const unsigned char *, int, int, int));
2461 extern void insert P_ ((const unsigned char *, int));
2462 extern void insert_and_inherit P_ ((const unsigned char *, int));
2463 extern void insert_1 P_ ((const unsigned char *, int, int, int, int));
2464 extern void insert_1_both P_ ((const unsigned char *, int, int, int, int, int));
2465 extern void insert_from_string P_ ((Lisp_Object, int, int, int, int, int));
2466 extern void insert_from_buffer P_ ((struct buffer *, int, int, int));
2467 extern void insert_char P_ ((int));
2468 extern void insert_string P_ ((const char *));
2469 extern void insert_before_markers P_ ((const unsigned char *, int));
2470 extern void insert_before_markers_and_inherit P_ ((const unsigned char *, int));
2471 extern void insert_from_string_before_markers P_ ((Lisp_Object, int, int, int, int, int));
2472 extern void del_range P_ ((int, int));
2473 extern Lisp_Object del_range_1 P_ ((int, int, int, int));
2474 extern void del_range_byte P_ ((int, int, int));
2475 extern void del_range_both P_ ((int, int, int, int, int));
2476 extern Lisp_Object del_range_2 P_ ((int, int, int, int, int));
2477 extern void modify_region P_ ((struct buffer *, int, int, int));
2478 extern void prepare_to_modify_buffer P_ ((int, int, int *));
2479 extern void signal_before_change P_ ((int, int, int *));
2480 extern void signal_after_change P_ ((int, int, int));
2481 extern void adjust_after_replace P_ ((int, int, Lisp_Object, int, int));
2482 extern void adjust_after_replace_noundo P_ ((int, int, int, int, int, int));
2483 extern void adjust_after_insert P_ ((int, int, int, int, int));
2484 extern void replace_range P_ ((int, int, Lisp_Object, int, int, int));
2485 extern void replace_range_2 P_ ((int, int, int, int, char *, int, int, int));
2486 extern void syms_of_insdel P_ ((void));
2487
2488 /* Defined in dispnew.c */
2489 extern Lisp_Object selected_frame;
2490 extern EMACS_INT baud_rate;
2491 EXFUN (Fding, 1);
2492 EXFUN (Fredraw_frame, 1);
2493 EXFUN (Fredraw_display, 0);
2494 EXFUN (Fsleep_for, 2);
2495 EXFUN (Fredisplay, 1);
2496 extern Lisp_Object sit_for P_ ((Lisp_Object, int, int));
2497 extern void init_display P_ ((void));
2498 extern void syms_of_display P_ ((void));
2499 extern void safe_bcopy P_ ((const char *, char *, int));
2500
2501 /* Defined in xdisp.c */
2502 extern Lisp_Object Qinhibit_point_motion_hooks;
2503 extern Lisp_Object Qinhibit_redisplay, Qdisplay;
2504 extern Lisp_Object Qinhibit_eval_during_redisplay;
2505 extern Lisp_Object Qmessage_truncate_lines;
2506 extern Lisp_Object Qimage;
2507 extern Lisp_Object Vmessage_log_max;
2508 extern int message_enable_multibyte;
2509 extern Lisp_Object echo_area_buffer[2];
2510 extern void check_message_stack P_ ((void));
2511 extern void setup_echo_area_for_printing P_ ((int));
2512 extern int push_message P_ ((void));
2513 extern Lisp_Object pop_message_unwind P_ ((Lisp_Object));
2514 extern Lisp_Object restore_message_unwind P_ ((Lisp_Object));
2515 extern void pop_message P_ ((void));
2516 extern void restore_message P_ ((void));
2517 extern Lisp_Object current_message P_ ((void));
2518 extern void set_message P_ ((const char *s, Lisp_Object, int, int));
2519 extern void clear_message P_ ((int, int));
2520 extern void message P_ ((/* char *, ... */));
2521 extern void message_nolog P_ ((/* char *, ... */));
2522 extern void message1 P_ ((char *));
2523 extern void message1_nolog P_ ((char *));
2524 extern void message2 P_ ((const char *, int, int));
2525 extern void message2_nolog P_ ((const char *, int, int));
2526 extern void message3 P_ ((Lisp_Object, int, int));
2527 extern void message3_nolog P_ ((Lisp_Object, int, int));
2528 extern void message_dolog P_ ((const char *, int, int, int));
2529 extern void message_with_string P_ ((char *, Lisp_Object, int));
2530 extern void message_log_maybe_newline P_ ((void));
2531 extern void update_echo_area P_ ((void));
2532 extern void truncate_echo_area P_ ((int));
2533 extern void redisplay P_ ((void));
2534 extern int check_point_in_composition
2535         P_ ((struct buffer *, int, struct buffer *, int));
2536 extern void redisplay_preserve_echo_area P_ ((int));
2537 extern void prepare_menu_bars P_ ((void));
2538
2539 void set_frame_cursor_types P_ ((struct frame *, Lisp_Object));
2540 extern void syms_of_xdisp P_ ((void));
2541 extern void init_xdisp P_ ((void));
2542 extern Lisp_Object safe_eval P_ ((Lisp_Object));
2543 extern int pos_visible_p P_ ((struct window *, int, int *,
2544                               int *, int *, int *, int *, int *));
2545
2546 /* Defined in vm-limit.c.  */
2547 extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
2548
2549 /* Defined in alloc.c */
2550 extern void check_pure_size P_ ((void));
2551 extern void allocate_string_data P_ ((struct Lisp_String *, int, int));
2552 extern void reset_malloc_hooks P_ ((void));
2553 extern void uninterrupt_malloc P_ ((void));
2554 extern void malloc_warning P_ ((char *));
2555 extern void memory_full P_ ((void)) NO_RETURN;
2556 extern void buffer_memory_full P_ ((void)) NO_RETURN;
2557 extern int survives_gc_p P_ ((Lisp_Object));
2558 extern void mark_object P_ ((Lisp_Object));
2559 extern Lisp_Object Vpurify_flag;
2560 extern Lisp_Object Vmemory_full;
2561 EXFUN (Fcons, 2);
2562 EXFUN (list1, 1);
2563 EXFUN (list2, 2);
2564 EXFUN (list3, 3);
2565 EXFUN (list4, 4);
2566 EXFUN (list5, 5);
2567 EXFUN (Flist, MANY);
2568 EXFUN (Fmake_list, 2);
2569 extern Lisp_Object allocate_misc P_ ((void));
2570 EXFUN (Fmake_vector, 2);
2571 EXFUN (Fvector, MANY);
2572 EXFUN (Fmake_symbol, 1);
2573 EXFUN (Fmake_marker, 0);
2574 EXFUN (Fmake_string, 2);
2575 extern Lisp_Object build_string P_ ((const char *));
2576 extern Lisp_Object make_string P_ ((const char *, int));
2577 extern Lisp_Object make_unibyte_string P_ ((const char *, int));
2578 extern Lisp_Object make_multibyte_string P_ ((const char *, int, int));
2579 extern Lisp_Object make_event_array P_ ((int, Lisp_Object *));
2580 extern Lisp_Object make_uninit_string P_ ((int));
2581 extern Lisp_Object make_uninit_multibyte_string P_ ((int, int));
2582 extern Lisp_Object make_string_from_bytes P_ ((const char *, int, int));
2583 extern Lisp_Object make_specified_string P_ ((const char *, int, int, int));
2584 EXFUN (Fpurecopy, 1);
2585 extern Lisp_Object make_pure_string P_ ((char *, int, int, int));
2586 extern Lisp_Object pure_cons P_ ((Lisp_Object, Lisp_Object));
2587 extern Lisp_Object make_pure_vector P_ ((EMACS_INT));
2588 EXFUN (Fgarbage_collect, 0);
2589 EXFUN (Fmake_byte_code, MANY);
2590 EXFUN (Fmake_bool_vector, 2);
2591 EXFUN (Fmake_char_table, 2);
2592 extern Lisp_Object make_sub_char_table P_ ((Lisp_Object));
2593 extern Lisp_Object Qchar_table_extra_slots;
2594 extern struct Lisp_Vector *allocate_vector P_ ((EMACS_INT));
2595 extern struct Lisp_Vector *allocate_other_vector P_ ((EMACS_INT));
2596 extern struct Lisp_Hash_Table *allocate_hash_table P_ ((void));
2597 extern struct window *allocate_window P_ ((void));
2598 extern struct frame *allocate_frame P_ ((void));
2599 extern struct Lisp_Process *allocate_process P_ ((void));
2600 extern int gc_in_progress;
2601 extern int abort_on_gc;
2602 extern Lisp_Object make_float P_ ((double));
2603 extern void display_malloc_warning P_ ((void));
2604 extern int inhibit_garbage_collection P_ ((void));
2605 extern Lisp_Object make_save_value P_ ((void *, int));
2606 extern void free_misc P_ ((Lisp_Object));
2607 extern void free_marker P_ ((Lisp_Object));
2608 extern void free_cons P_ ((struct Lisp_Cons *));
2609 extern void init_alloc_once P_ ((void));
2610 extern void init_alloc P_ ((void));
2611 extern void syms_of_alloc P_ ((void));
2612 extern struct buffer * allocate_buffer P_ ((void));
2613 extern int valid_lisp_object_p P_ ((Lisp_Object));
2614
2615 /* Defined in print.c */
2616 extern Lisp_Object Vprin1_to_string_buffer;
2617 extern void debug_print P_ ((Lisp_Object));
2618 EXFUN (Fprin1, 2);
2619 EXFUN (Fprin1_to_string, 2);
2620 EXFUN (Fprinc, 2);
2621 EXFUN (Fterpri, 1);
2622 EXFUN (Fprint, 2);
2623 EXFUN (Ferror_message_string, 1);
2624 extern Lisp_Object Vstandard_output, Qstandard_output;
2625 extern Lisp_Object Qexternal_debugging_output;
2626 extern void temp_output_buffer_setup P_ ((const char *));
2627 extern int print_level, print_escape_newlines;
2628 extern Lisp_Object Qprint_escape_newlines;
2629 extern void write_string P_ ((char *, int));
2630 extern void write_string_1 P_ ((char *, int, Lisp_Object));
2631 extern void print_error_message P_ ((Lisp_Object, Lisp_Object, char *, Lisp_Object));
2632 extern Lisp_Object internal_with_output_to_temp_buffer
2633         P_ ((const char *, Lisp_Object (*) (Lisp_Object), Lisp_Object));
2634 extern void float_to_string P_ ((unsigned char *, double));
2635 extern void syms_of_print P_ ((void));
2636
2637 /* Defined in doprnt.c */
2638 extern int doprnt P_ ((char *, int, char *, char *, int, char **));
2639 extern int doprnt_lisp P_ ((char *, int, char *, char *, int, char **));
2640
2641 /* Defined in lread.c */
2642 extern Lisp_Object Qvariable_documentation, Qstandard_input;
2643 extern Lisp_Object Vobarray, initial_obarray, Vstandard_input;
2644 EXFUN (Fread, 1);
2645 EXFUN (Fread_from_string, 3);
2646 EXFUN (Fintern, 2);
2647 EXFUN (Fintern_soft, 2);
2648 EXFUN (Fload, 5);
2649 EXFUN (Fget_load_suffixes, 0);
2650 EXFUN (Fget_file_char, 0);
2651 EXFUN (Fread_char, 3);
2652 EXFUN (Fread_event, 3);
2653 extern Lisp_Object read_filtered_event P_ ((int, int, int, int, Lisp_Object));
2654 EXFUN (Feval_region, 4);
2655 extern Lisp_Object check_obarray P_ ((Lisp_Object));
2656 extern Lisp_Object intern P_ ((const char *));
2657 extern Lisp_Object make_symbol P_ ((char *));
2658 extern Lisp_Object oblookup P_ ((Lisp_Object, const char *, int, int));
2659 #define LOADHIST_ATTACH(x) \
2660  if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
2661 extern Lisp_Object Vcurrent_load_list;
2662 extern Lisp_Object Vload_history, Vload_suffixes, Vload_file_rep_suffixes;
2663 extern int openp P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
2664                       Lisp_Object *, Lisp_Object));
2665 extern int isfloat_string P_ ((char *));
2666 extern void map_obarray P_ ((Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
2667                              Lisp_Object));
2668 extern void dir_warning P_ ((char *, Lisp_Object));
2669 extern void close_load_descs P_ ((void));
2670 extern void init_obarray P_ ((void));
2671 extern void init_lread P_ ((void));
2672 extern void syms_of_lread P_ ((void));
2673
2674 /* Defined in eval.c */
2675 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
2676 extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
2677 extern Lisp_Object Vautoload_queue;
2678 extern Lisp_Object Vdebug_on_error;
2679 extern Lisp_Object Vsignaling_function;
2680 extern int handling_signal;
2681 extern int interactive_p P_ ((int));
2682
2683 /* To run a normal hook, use the appropriate function from the list below.
2684    The calling convention:
2685
2686    if (!NILP (Vrun_hooks))
2687      call1 (Vrun_hooks, Qmy_funny_hook);
2688
2689    should no longer be used.  */
2690 extern Lisp_Object Vrun_hooks;
2691 EXFUN (Frun_hooks, MANY);
2692 EXFUN (Frun_hook_with_args, MANY);
2693 EXFUN (Frun_hook_with_args_until_success, MANY);
2694 EXFUN (Frun_hook_with_args_until_failure, MANY);
2695 extern Lisp_Object run_hook_list_with_args P_ ((Lisp_Object, int, Lisp_Object *));
2696 extern void run_hook_with_args_2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2697 EXFUN (Fand, UNEVALLED);
2698 EXFUN (For, UNEVALLED);
2699 EXFUN (Fif, UNEVALLED);
2700 EXFUN (Fprogn, UNEVALLED);
2701 EXFUN (Fprog1, UNEVALLED);
2702 EXFUN (Fprog2, UNEVALLED);
2703 EXFUN (Fsetq, UNEVALLED);
2704 EXFUN (Fquote, UNEVALLED);
2705 EXFUN (Fuser_variable_p, 1);
2706 EXFUN (Finteractive_p, 0);
2707 EXFUN (Fdefun, UNEVALLED);
2708 EXFUN (Flet, UNEVALLED);
2709 EXFUN (FletX, UNEVALLED);
2710 EXFUN (Fwhile, UNEVALLED);
2711 EXFUN (Fcatch, UNEVALLED);
2712 EXFUN (Fthrow, 2) NO_RETURN;
2713 EXFUN (Funwind_protect, UNEVALLED);
2714 EXFUN (Fcondition_case, UNEVALLED);
2715 EXFUN (Fsignal, 2);
2716 extern void xsignal P_ ((Lisp_Object, Lisp_Object)) NO_RETURN;
2717 extern void xsignal0 P_ ((Lisp_Object)) NO_RETURN;
2718 extern void xsignal1 P_ ((Lisp_Object, Lisp_Object)) NO_RETURN;
2719 extern void xsignal2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object)) NO_RETURN;
2720 extern void xsignal3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)) NO_RETURN;
2721 extern void signal_error P_ ((char *, Lisp_Object)) NO_RETURN;
2722 EXFUN (Fautoload, 5);
2723 EXFUN (Fcommandp, 2);
2724 EXFUN (Feval, 1);
2725 EXFUN (Fapply, MANY);
2726 EXFUN (Ffuncall, MANY);
2727 EXFUN (Fbacktrace, 0);
2728 extern Lisp_Object apply1 P_ ((Lisp_Object, Lisp_Object));
2729 extern Lisp_Object call0 P_ ((Lisp_Object));
2730 extern Lisp_Object call1 P_ ((Lisp_Object, Lisp_Object));
2731 extern Lisp_Object call2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2732 extern Lisp_Object call3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2733 extern Lisp_Object call4 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2734 extern Lisp_Object call5 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2735 extern Lisp_Object call6 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2736 EXFUN (Fdo_auto_save, 2);
2737 extern Lisp_Object apply_lambda P_ ((Lisp_Object, Lisp_Object, int));
2738 extern Lisp_Object internal_catch P_ ((Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object));
2739 extern Lisp_Object internal_lisp_condition_case P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2740 extern Lisp_Object internal_condition_case P_ ((Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2741 extern Lisp_Object internal_condition_case_1 P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2742 extern Lisp_Object internal_condition_case_2 P_ ((Lisp_Object (*) (int, Lisp_Object *), int, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2743 extern void specbind P_ ((Lisp_Object, Lisp_Object));
2744 extern void record_unwind_protect P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object));
2745 extern Lisp_Object unbind_to P_ ((int, Lisp_Object));
2746 extern void error P_ ((/* char *, ... */)) NO_RETURN;
2747 extern void do_autoload P_ ((Lisp_Object, Lisp_Object));
2748 extern Lisp_Object un_autoload P_ ((Lisp_Object));
2749 EXFUN (Ffetch_bytecode, 1);
2750 extern void init_eval_once P_ ((void));
2751 extern Lisp_Object safe_call P_ ((int, Lisp_Object *));
2752 extern Lisp_Object safe_call1 P_ ((Lisp_Object, Lisp_Object));
2753 extern void init_eval P_ ((void));
2754 extern void syms_of_eval P_ ((void));
2755
2756 /* Defined in editfns.c */
2757 EXFUN (Fpropertize, MANY);
2758 EXFUN (Fcurrent_message, 0);
2759 EXFUN (Fgoto_char, 1);
2760 EXFUN (Fpoint_min_marker, 0);
2761 EXFUN (Fpoint_max_marker, 0);
2762 EXFUN (Fpoint_min, 0);
2763 EXFUN (Fpoint_max, 0);
2764 EXFUN (Fpoint, 0);
2765 EXFUN (Fpoint_marker, 0);
2766 EXFUN (Fmark_marker, 0);
2767 EXFUN (Fline_beginning_position, 1);
2768 EXFUN (Fline_end_position, 1);
2769 EXFUN (Ffollowing_char, 0);
2770 EXFUN (Fprevious_char, 0);
2771 EXFUN (Fchar_after, 1);
2772 EXFUN (Finsert, MANY);
2773 EXFUN (Finsert_and_inherit, MANY);
2774 EXFUN (Finsert_before_markers, MANY);
2775 EXFUN (Finsert_buffer_substring, 3);
2776 EXFUN (Finsert_char, 3);
2777 extern void insert1 P_ ((Lisp_Object));
2778 EXFUN (Feolp, 0);
2779 EXFUN (Feobp, 0);
2780 EXFUN (Fbolp, 0);
2781 EXFUN (Fbobp, 0);
2782 EXFUN (Fformat, MANY);
2783 EXFUN (Fmessage, MANY);
2784 extern Lisp_Object format2 P_ ((char *, Lisp_Object, Lisp_Object));
2785 EXFUN (Fbuffer_substring, 2);
2786 EXFUN (Fbuffer_string, 0);
2787 extern Lisp_Object save_excursion_save P_ ((void));
2788 extern Lisp_Object save_restriction_save P_ ((void));
2789 extern Lisp_Object save_excursion_restore P_ ((Lisp_Object));
2790 extern Lisp_Object save_restriction_restore P_ ((Lisp_Object));
2791 EXFUN (Fchar_to_string, 1);
2792 EXFUN (Fdelete_region, 2);
2793 EXFUN (Fnarrow_to_region, 2);
2794 EXFUN (Fwiden, 0);
2795 EXFUN (Fuser_login_name, 1);
2796 EXFUN (Fsystem_name, 0);
2797 EXFUN (Fcurrent_time, 0);
2798 extern int clip_to_bounds P_ ((int, int, int));
2799 extern Lisp_Object make_buffer_string P_ ((int, int, int));
2800 extern Lisp_Object make_buffer_string_both P_ ((int, int, int, int, int));
2801 extern void init_editfns P_ ((void));
2802 extern void syms_of_editfns P_ ((void));
2803 extern Lisp_Object Vinhibit_field_text_motion;
2804 EXFUN (Fconstrain_to_field, 5);
2805 EXFUN (Ffield_string, 1);
2806 EXFUN (Fdelete_field, 1);
2807 EXFUN (Ffield_beginning, 3);
2808 EXFUN (Ffield_end, 3);
2809 EXFUN (Ffield_string_no_properties, 1);
2810 extern void set_time_zone_rule P_ ((char *));
2811
2812 /* defined in buffer.c */
2813 extern int mouse_face_overlay_overlaps P_ ((Lisp_Object));
2814 extern void nsberror P_ ((Lisp_Object)) NO_RETURN;
2815 extern char *no_switch_window P_ ((Lisp_Object window));
2816 EXFUN (Fset_buffer_multibyte, 1);
2817 EXFUN (Foverlay_start, 1);
2818 EXFUN (Foverlay_end, 1);
2819 extern void adjust_overlays_for_insert P_ ((EMACS_INT, EMACS_INT));
2820 extern void adjust_overlays_for_delete P_ ((EMACS_INT, EMACS_INT));
2821 extern void fix_start_end_in_overlays P_ ((int, int));
2822 extern void report_overlay_modification P_ ((Lisp_Object, Lisp_Object, int,
2823                                              Lisp_Object, Lisp_Object, Lisp_Object));
2824 extern int overlay_touches_p P_ ((int));
2825 extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
2826 EXFUN (Fget_buffer, 1);
2827 EXFUN (Fget_buffer_create, 1);
2828 EXFUN (Fset_buffer, 1);
2829 EXFUN (set_buffer_if_live, 1);
2830 EXFUN (Fbarf_if_buffer_read_only, 0);
2831 EXFUN (Fcurrent_buffer, 0);
2832 EXFUN (Fswitch_to_buffer, 2);
2833 EXFUN (Fpop_to_buffer, 3);
2834 EXFUN (Fother_buffer, 3);
2835 EXFUN (Foverlay_get, 2);
2836 EXFUN (Fbuffer_modified_p, 1);
2837 EXFUN (Fset_buffer_modified_p, 1);
2838 EXFUN (Fkill_buffer, 1);
2839 EXFUN (Fkill_all_local_variables, 0);
2840 EXFUN (Fbuffer_disable_undo, 1);
2841 EXFUN (Fbuffer_enable_undo, 1);
2842 EXFUN (Ferase_buffer, 0);
2843 extern Lisp_Object Qoverlayp;
2844 extern Lisp_Object Qevaporate;
2845 extern Lisp_Object get_truename_buffer P_ ((Lisp_Object));
2846 extern struct buffer *all_buffers;
2847 EXFUN (Fprevious_overlay_change, 1);
2848 EXFUN (Fbuffer_file_name, 1);
2849 extern void init_buffer_once P_ ((void));
2850 extern void init_buffer P_ ((void));
2851 extern void syms_of_buffer P_ ((void));
2852 extern void keys_of_buffer P_ ((void));
2853
2854 /* defined in marker.c */
2855
2856 EXFUN (Fmarker_position, 1);
2857 EXFUN (Fmarker_buffer, 1);
2858 EXFUN (Fcopy_marker, 2);
2859 EXFUN (Fset_marker, 3);
2860 extern int marker_position P_ ((Lisp_Object));
2861 extern int marker_byte_position P_ ((Lisp_Object));
2862 extern void clear_charpos_cache P_ ((struct buffer *));
2863 extern int charpos_to_bytepos P_ ((int));
2864 extern int buf_charpos_to_bytepos P_ ((struct buffer *, int));
2865 extern int buf_bytepos_to_charpos P_ ((struct buffer *, int));
2866 extern void unchain_marker P_ ((struct Lisp_Marker *marker));
2867 extern Lisp_Object set_marker_restricted P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2868 extern Lisp_Object set_marker_both P_ ((Lisp_Object, Lisp_Object, int, int));
2869 extern Lisp_Object set_marker_restricted_both P_ ((Lisp_Object, Lisp_Object,
2870                                                    int, int));
2871 extern void syms_of_marker P_ ((void));
2872
2873 /* Defined in fileio.c */
2874
2875 extern Lisp_Object Qfile_error;
2876 EXFUN (Ffind_file_name_handler, 2);
2877 EXFUN (Ffile_name_as_directory, 1);
2878 EXFUN (Fmake_temp_name, 1);
2879 EXFUN (Fexpand_file_name, 2);
2880 EXFUN (Ffile_name_nondirectory, 1);
2881 EXFUN (Fsubstitute_in_file_name, 1);
2882 EXFUN (Ffile_symlink_p, 1);
2883 EXFUN (Fverify_visited_file_modtime, 1);
2884 EXFUN (Ffile_exists_p, 1);
2885 EXFUN (Ffile_name_absolute_p, 1);
2886 EXFUN (Fdirectory_file_name, 1);
2887 EXFUN (Ffile_name_directory, 1);
2888 extern Lisp_Object expand_and_dir_to_file P_ ((Lisp_Object, Lisp_Object));
2889 EXFUN (Ffile_accessible_directory_p, 1);
2890 EXFUN (Funhandled_file_name_directory, 1);
2891 EXFUN (Ffile_directory_p, 1);
2892 EXFUN (Fwrite_region, 7);
2893 EXFUN (Ffile_readable_p, 1);
2894 EXFUN (Ffile_executable_p, 1);
2895 EXFUN (Fread_file_name, 6);
2896 extern Lisp_Object close_file_unwind P_ ((Lisp_Object));
2897 extern void report_file_error P_ ((const char *, Lisp_Object)) NO_RETURN;
2898 extern int internal_delete_file P_ ((Lisp_Object));
2899 extern void syms_of_fileio P_ ((void));
2900 extern void init_fileio_once P_ ((void));
2901 extern Lisp_Object make_temp_name P_ ((Lisp_Object, int));
2902 EXFUN (Fmake_symbolic_link, 3);
2903
2904 /* Defined in abbrev.c */
2905
2906 extern void syms_of_abbrev P_ ((void));
2907
2908 /* defined in search.c */
2909 extern void shrink_regexp_cache P_ ((void));
2910 EXFUN (Fstring_match, 3);
2911 extern void restore_search_regs P_ ((void));
2912 EXFUN (Fmatch_data, 3);
2913 EXFUN (Fset_match_data, 2);
2914 EXFUN (Fmatch_beginning, 1);
2915 EXFUN (Fmatch_end, 1);
2916 extern void record_unwind_save_match_data P_ ((void));
2917 EXFUN (Flooking_at, 1);
2918 extern int fast_string_match P_ ((Lisp_Object, Lisp_Object));
2919 extern int fast_c_string_match_ignore_case P_ ((Lisp_Object, const char *));
2920 extern int fast_string_match_ignore_case P_ ((Lisp_Object, Lisp_Object));
2921 extern int scan_buffer P_ ((int, int, int, int, int *, int));
2922 extern int scan_newline P_ ((int, int, int, int, int, int));
2923 extern int find_next_newline P_ ((int, int));
2924 extern int find_next_newline_no_quit P_ ((int, int));
2925 extern int find_before_next_newline P_ ((int, int, int));
2926 extern void syms_of_search P_ ((void));
2927 extern void clear_regexp_cache P_ ((void));
2928
2929 /* defined in minibuf.c */
2930
2931 extern Lisp_Object last_minibuf_string;
2932 extern void choose_minibuf_frame P_ ((void));
2933 EXFUN (Fcompleting_read, 8);
2934 EXFUN (Fread_from_minibuffer, 7);
2935 EXFUN (Fread_variable, 2);
2936 EXFUN (Fread_buffer, 3);
2937 EXFUN (Fread_minibuffer, 2);
2938 EXFUN (Feval_minibuffer, 2);
2939 EXFUN (Fread_string, 5);
2940 EXFUN (Fread_no_blanks_input, 3);
2941 extern Lisp_Object get_minibuffer P_ ((int));
2942 extern void temp_echo_area_glyphs P_ ((Lisp_Object));
2943 extern void init_minibuf_once P_ ((void));
2944 extern void syms_of_minibuf P_ ((void));
2945 extern void keys_of_minibuf P_ ((void));
2946
2947 /* Defined in callint.c */
2948
2949 extern Lisp_Object Qminus, Qplus, Vcurrent_prefix_arg;
2950 extern Lisp_Object Vcommand_history;
2951 extern Lisp_Object Qcall_interactively, Qmouse_leave_buffer_hook;
2952 EXFUN (Fcall_interactively, 3);
2953 EXFUN (Fprefix_numeric_value, 1);
2954 extern void syms_of_callint P_ ((void));
2955
2956 /* defined in casefiddle.c */
2957
2958 EXFUN (Fdowncase, 1);
2959 EXFUN (Fupcase, 1);
2960 EXFUN (Fcapitalize, 1);
2961 EXFUN (Fupcase_region, 2);
2962 EXFUN (Fupcase_initials, 1);
2963 EXFUN (Fupcase_initials_region, 2);
2964 extern void syms_of_casefiddle P_ ((void));
2965 extern void keys_of_casefiddle P_ ((void));
2966
2967 /* defined in casetab.c */
2968
2969 EXFUN (Fset_case_table, 1);
2970 EXFUN (Fset_standard_case_table, 1);
2971 extern void init_casetab_once P_ ((void));
2972 extern void syms_of_casetab P_ ((void));
2973
2974 /* defined in keyboard.c */
2975
2976 extern int echoing;
2977 extern Lisp_Object echo_message_buffer;
2978 extern struct kboard *echo_kboard;
2979 extern void cancel_echoing P_ ((void));
2980 extern Lisp_Object Qdisabled, QCfilter;
2981 extern Lisp_Object Vtty_erase_char, Vhelp_form, Vtop_level;
2982 extern Lisp_Object Vthrow_on_input;
2983 extern int input_pending;
2984 EXFUN (Fdiscard_input, 0);
2985 EXFUN (Frecursive_edit, 0);
2986 EXFUN (Ftop_level, 0);
2987 EXFUN (Fcommand_execute, 4);
2988 EXFUN (Finput_pending_p, 0);
2989 extern Lisp_Object menu_bar_items P_ ((Lisp_Object));
2990 extern Lisp_Object tool_bar_items P_ ((Lisp_Object, int *));
2991 extern Lisp_Object Qvertical_scroll_bar;
2992 extern void discard_mouse_events P_ ((void));
2993 EXFUN (Fevent_convert_list, 1);
2994 EXFUN (Fread_key_sequence, 5);
2995 EXFUN (Fset_input_mode, 4);
2996 extern int detect_input_pending P_ ((void));
2997 extern int detect_input_pending_ignore_squeezables P_ ((void));
2998 extern int detect_input_pending_run_timers P_ ((int));
2999 extern void safe_run_hooks P_ ((Lisp_Object));
3000 extern void cmd_error_internal P_ ((Lisp_Object, char *));
3001 extern Lisp_Object command_loop_1 P_ ((void));
3002 extern Lisp_Object recursive_edit_1 P_ ((void));
3003 extern void record_auto_save P_ ((void));
3004 extern void init_keyboard P_ ((void));
3005 extern void syms_of_keyboard P_ ((void));
3006 extern void keys_of_keyboard P_ ((void));
3007 extern char *push_key_description P_ ((unsigned int, char *, int));
3008
3009
3010 /* defined in indent.c */
3011 EXFUN (Fvertical_motion, 2);
3012 EXFUN (Findent_to, 2);
3013 EXFUN (Fcurrent_column, 0);
3014 EXFUN (Fmove_to_column, 2);
3015 extern double current_column P_ ((void));
3016 extern void invalidate_current_column P_ ((void));
3017 extern int indented_beyond_p P_ ((int, int, double));
3018 extern void syms_of_indent P_ ((void));
3019
3020 /* defined in frame.c */
3021 #ifdef HAVE_WINDOW_SYSTEM
3022 extern Lisp_Object Vx_resource_name;
3023 extern Lisp_Object Vx_resource_class;
3024 #endif /* HAVE_WINDOW_SYSTEM */
3025 extern Lisp_Object Qvisible;
3026 extern void store_frame_param P_ ((struct frame *, Lisp_Object, Lisp_Object));
3027 extern void store_in_alist P_ ((Lisp_Object *, Lisp_Object, Lisp_Object));
3028 extern Lisp_Object do_switch_frame P_ ((Lisp_Object, int, int));
3029 extern Lisp_Object get_frame_param P_ ((struct frame *, Lisp_Object));
3030 extern Lisp_Object frame_buffer_predicate P_ ((Lisp_Object));
3031 EXFUN (Fframep, 1);
3032 EXFUN (Fselect_frame, 1);
3033 EXFUN (Fselected_frame, 0);
3034 EXFUN (Fwindow_frame, 1);
3035 EXFUN (Fframe_root_window, 1);
3036 EXFUN (Fframe_first_window, 1);
3037 EXFUN (Fframe_selected_window, 1);
3038 EXFUN (Fframe_list, 0);
3039 EXFUN (Fnext_frame, 2);
3040 EXFUN (Fdelete_frame, 2);
3041 EXFUN (Fset_mouse_position, 3);
3042 EXFUN (Fmake_frame_visible, 1);
3043 EXFUN (Fmake_frame_invisible, 2);
3044 EXFUN (Ficonify_frame, 1);
3045 EXFUN (Fframe_visible_p, 1);
3046 EXFUN (Fvisible_frame_list, 0);
3047 EXFUN (Fframe_parameter, 2);
3048 EXFUN (Fframe_parameters, 1);
3049 EXFUN (Fmodify_frame_parameters, 2);
3050 EXFUN (Fset_frame_height, 3);
3051 EXFUN (Fset_frame_width, 3);
3052 EXFUN (Fset_frame_size, 3);
3053 EXFUN (Fset_frame_position, 3);
3054 EXFUN (Fraise_frame, 1);
3055 EXFUN (Fredirect_frame_focus, 2);
3056 EXFUN (Fset_frame_selected_window, 2);
3057 extern Lisp_Object frame_buffer_list P_ ((Lisp_Object));
3058 extern void frames_discard_buffer P_ ((Lisp_Object));
3059 extern void set_frame_buffer_list P_ ((Lisp_Object, Lisp_Object));
3060 extern void frames_bury_buffer P_ ((Lisp_Object));
3061 extern void syms_of_frame P_ ((void));
3062
3063 /* defined in emacs.c */
3064 extern Lisp_Object decode_env_path P_ ((char *, char *));
3065 extern Lisp_Object Vinvocation_name, Vinvocation_directory;
3066 extern Lisp_Object Vinstallation_directory;
3067 extern Lisp_Object empty_unibyte_string, empty_multibyte_string;
3068 EXFUN (Fkill_emacs, 1);
3069 #if HAVE_SETLOCALE
3070 void fixup_locale P_ ((void));
3071 void synchronize_system_messages_locale P_ ((void));
3072 void synchronize_system_time_locale P_ ((void));
3073 #else
3074 #define setlocale(category, locale)
3075 #define fixup_locale()
3076 #define synchronize_system_messages_locale()
3077 #define synchronize_system_time_locale()
3078 #endif
3079 void shut_down_emacs P_ ((int, int, Lisp_Object));
3080 /* Nonzero means don't do interactive redisplay and don't change tty modes */
3081 extern int noninteractive;
3082 /* Nonzero means don't do use window-system-specific display code */
3083 extern int inhibit_window_system;
3084 /* Nonzero means that a filter or a sentinel is running.  */
3085 extern int running_asynch_code;
3086
3087 /* defined in process.c */
3088 EXFUN (Fget_process, 1);
3089 EXFUN (Fget_buffer_process, 1);
3090 EXFUN (Fprocessp, 1);
3091 EXFUN (Fprocess_status, 1);
3092 EXFUN (Fkill_process, 2);
3093 EXFUN (Fprocess_send_eof, 1);
3094 EXFUN (Fwaiting_for_user_input_p, 0);
3095 extern Lisp_Object Qprocessp;
3096 extern void kill_buffer_processes P_ ((Lisp_Object));
3097 extern int wait_reading_process_output P_ ((int, int, int, int,
3098                                             Lisp_Object,
3099                                             struct Lisp_Process *,
3100                                             int));
3101 extern void add_keyboard_wait_descriptor P_ ((int));
3102 extern void delete_keyboard_wait_descriptor P_ ((int));
3103 extern void add_gpm_wait_descriptor P_ ((int));
3104 extern void delete_gpm_wait_descriptor P_ ((int));
3105 extern void close_process_descs P_ ((void));
3106 extern void init_process P_ ((void));
3107 extern void syms_of_process P_ ((void));
3108 extern void setup_process_coding_systems P_ ((Lisp_Object));
3109
3110 /* defined in callproc.c */
3111 extern Lisp_Object Vexec_path, Vexec_suffixes,
3112                    Vexec_directory, Vdata_directory;
3113 extern Lisp_Object Vdoc_directory;
3114 EXFUN (Fcall_process, MANY);
3115 extern int child_setup P_ ((int, int, int, char **, int, Lisp_Object));
3116 extern void init_callproc_1 P_ ((void));
3117 extern void init_callproc P_ ((void));
3118 extern void set_process_environment P_ ((void));
3119 extern void syms_of_callproc P_ ((void));
3120
3121 /* defined in doc.c */
3122 extern Lisp_Object Vdoc_file_name;
3123 EXFUN (Fsubstitute_command_keys, 1);
3124 EXFUN (Fdocumentation, 2);
3125 EXFUN (Fdocumentation_property, 3);
3126 extern Lisp_Object read_doc_string P_ ((Lisp_Object));
3127 extern Lisp_Object get_doc_string P_ ((Lisp_Object, int, int));
3128 extern void syms_of_doc P_ ((void));
3129 extern int read_bytecode_char P_ ((int));
3130
3131 /* defined in bytecode.c */
3132 extern Lisp_Object Qbytecode;
3133 EXFUN (Fbyte_code, 3);
3134 extern void syms_of_bytecode P_ ((void));
3135 extern struct byte_stack *byte_stack_list;
3136 extern void mark_byte_stack P_ ((void));
3137 extern void unmark_byte_stack P_ ((void));
3138
3139 /* defined in macros.c */
3140 extern Lisp_Object Qexecute_kbd_macro;
3141 EXFUN (Fexecute_kbd_macro, 3);
3142 EXFUN (Fcancel_kbd_macro_events, 0);
3143 extern void init_macros P_ ((void));
3144 extern void syms_of_macros P_ ((void));
3145
3146 /* defined in undo.c */
3147 extern Lisp_Object Qinhibit_read_only;
3148 EXFUN (Fundo_boundary, 0);
3149 extern void truncate_undo_list P_ ((struct buffer *));
3150 extern void record_marker_adjustment P_ ((Lisp_Object, int));
3151 extern void record_insert P_ ((int, int));
3152 extern void record_delete P_ ((int, Lisp_Object));
3153 extern void record_first_change P_ ((void));
3154 extern void record_change P_ ((int, int));
3155 extern void record_property_change P_ ((int, int, Lisp_Object, Lisp_Object,
3156                                         Lisp_Object));
3157 extern void syms_of_undo P_ ((void));
3158 extern Lisp_Object Vundo_outer_limit;
3159
3160 /* defined in textprop.c */
3161 extern Lisp_Object Qfont, Qmouse_face;
3162 extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
3163 EXFUN (Fnext_single_property_change, 4);
3164 EXFUN (Fnext_single_char_property_change, 4);
3165 EXFUN (Fprevious_single_property_change, 4);
3166 EXFUN (Fput_text_property, 5);
3167 EXFUN (Fprevious_char_property_change, 2);
3168 EXFUN (Fnext_char_property_change, 2);
3169 extern void report_interval_modification P_ ((Lisp_Object, Lisp_Object));
3170 extern Lisp_Object next_single_char_property_change P_ ((Lisp_Object,
3171                                                          Lisp_Object,
3172                                                          Lisp_Object,
3173                                                          Lisp_Object));
3174
3175 /* defined in xmenu.c */
3176 EXFUN (Fx_popup_menu, 2);
3177 EXFUN (Fx_popup_dialog, 3);
3178 extern void syms_of_xmenu P_ ((void));
3179
3180 /* defined in sysdep.c */
3181 #ifndef HAVE_GET_CURRENT_DIR_NAME
3182 extern char *get_current_dir_name P_ ((void));
3183 #endif
3184 extern void stuff_char P_ ((char c));
3185 extern void init_sigio P_ ((int));
3186 extern void request_sigio P_ ((void));
3187 extern void unrequest_sigio P_ ((void));
3188 extern void reset_sys_modes P_ ((void));
3189 extern void sys_subshell P_ ((void));
3190 extern void sys_suspend P_ ((void));
3191 extern void discard_tty_input P_ ((void));
3192 extern void init_sys_modes P_ ((void));
3193 extern void get_frame_size P_ ((int *, int *));
3194 extern void wait_for_termination P_ ((int));
3195 extern void flush_pending_output P_ ((int));
3196 extern void child_setup_tty P_ ((int));
3197 extern void setup_pty P_ ((int));
3198 extern int set_window_size P_ ((int, int, int));
3199 extern void create_process P_ ((Lisp_Object, char **, Lisp_Object));
3200 extern int tabs_safe_p P_ ((void));
3201 extern void init_baud_rate P_ ((void));
3202 extern int emacs_open P_ ((const char *, int, int));
3203 extern int emacs_close P_ ((int));
3204 extern int emacs_read P_ ((int, char *, unsigned int));
3205 extern int emacs_write P_ ((int, const char *, unsigned int));
3206
3207 /* defined in filelock.c */
3208 EXFUN (Funlock_buffer, 0);
3209 EXFUN (Ffile_locked_p, 1);
3210 extern void unlock_all_files P_ ((void));
3211 extern void lock_file P_ ((Lisp_Object));
3212 extern void unlock_file P_ ((Lisp_Object));
3213 extern void unlock_buffer P_ ((struct buffer *));
3214 extern void syms_of_filelock P_ ((void));
3215 extern void init_filelock P_ ((void));
3216
3217 /* Defined in sound.c */
3218 extern void syms_of_sound P_ ((void));
3219 extern void init_sound P_ ((void));
3220
3221 /* Defined in category.c */
3222 extern void init_category_once P_ ((void));
3223 extern void syms_of_category P_ ((void));
3224
3225 /* Defined in ccl.c */
3226 extern void syms_of_ccl P_ ((void));
3227
3228 /* Defined in dired.c */
3229 EXFUN (Ffile_attributes, 2);
3230 extern void syms_of_dired P_ ((void));
3231
3232 /* Defined in term.c */
3233 extern void syms_of_term P_ ((void));
3234 extern void fatal () NO_RETURN;
3235
3236 #ifdef HAVE_WINDOW_SYSTEM
3237 /* Defined in fontset.c */
3238 extern void syms_of_fontset P_ ((void));
3239 EXFUN (Fset_fontset_font, 4);
3240
3241 /* Defined in xfns.c, w32fns.c, or macfns.c */
3242 EXFUN (Fxw_display_color_p, 1);
3243 EXFUN (Fx_file_dialog, 5);
3244 #endif
3245
3246 /* Defined in xfaces.c */
3247 extern void syms_of_xfaces P_ ((void));
3248
3249 #ifndef HAVE_GETLOADAVG
3250 /* Defined in getloadavg.c */
3251 extern int getloadavg P_ ((double *, int));
3252 #endif
3253
3254 #ifdef HAVE_X_WINDOWS
3255 /* Defined in xfns.c */
3256 extern void syms_of_xfns P_ ((void));
3257
3258 /* Defined in xsmfns.c */
3259 extern void syms_of_xsmfns P_ ((void));
3260
3261 /* Defined in xselect.c */
3262 extern void syms_of_xselect P_ ((void));
3263
3264 /* Defined in xterm.c */
3265 extern void syms_of_xterm P_ ((void));
3266 #endif /* HAVE_X_WINDOWS */
3267
3268 #ifdef MSDOS
3269 /* Defined in msdos.c */
3270 EXFUN (Fmsdos_downcase_filename, 1);
3271 #endif
3272
3273 #ifdef MAC_OS
3274 /* Defined in macfns.c */
3275 extern void syms_of_macfns P_ ((void));
3276
3277 /* Defined in macselect.c */
3278 extern void syms_of_macselect P_ ((void));
3279
3280 /* Defined in macterm.c */
3281 extern void syms_of_macterm P_ ((void));
3282
3283 /* Defined in macmenu.c */
3284 extern void syms_of_macmenu P_ ((void));
3285
3286 /* Defined in mac.c */
3287 extern void syms_of_mac P_ ((void));
3288 #ifdef MAC_OSX
3289 extern void init_mac_osx_environment P_ ((void));
3290 #endif /* MAC_OSX */
3291 #endif /* MAC_OS */
3292 \f
3293 /* Nonzero means Emacs has already been initialized.
3294    Used during startup to detect startup of dumped Emacs.  */
3295 extern int initialized;
3296
3297 extern int immediate_quit;          /* Nonzero means ^G can quit instantly */
3298
3299 extern POINTER_TYPE *xmalloc P_ ((size_t));
3300 extern POINTER_TYPE *xrealloc P_ ((POINTER_TYPE *, size_t));
3301 extern void xfree P_ ((POINTER_TYPE *));
3302
3303 extern char *xstrdup P_ ((const char *));
3304
3305 extern char *egetenv P_ ((char *));
3306
3307 /* Set up the name of the machine we're running on.  */
3308 extern void init_system_name P_ ((void));
3309
3310 /* Some systems (e.g., NT) use a different path separator than Unix,
3311    in addition to a device separator.  Default the path separator
3312    to '/', and don't test for a device separator in IS_ANY_SEP.  */
3313
3314 #ifdef WINDOWSNT
3315 extern Lisp_Object Vdirectory_sep_char;
3316 #endif
3317
3318 #ifndef DIRECTORY_SEP
3319 #define DIRECTORY_SEP '/'
3320 #endif
3321 #ifndef IS_DIRECTORY_SEP
3322 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
3323 #endif
3324 #ifndef IS_DEVICE_SEP
3325 #ifndef DEVICE_SEP
3326 #define IS_DEVICE_SEP(_c_) 0
3327 #else
3328 #define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
3329 #endif
3330 #endif
3331 #ifndef IS_ANY_SEP
3332 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
3333 #endif
3334
3335 #ifdef SWITCH_ENUM_BUG
3336 #define SWITCH_ENUM_CAST(x) ((int)(x))
3337 #else
3338 #define SWITCH_ENUM_CAST(x) (x)
3339 #endif
3340
3341 /* Loop over Lisp list LIST.  Signal an error if LIST is not a proper
3342    list, or if it contains circles.
3343
3344    HARE and TORTOISE should be the names of Lisp_Object variables, and
3345    N should be the name of an EMACS_INT variable declared in the
3346    function where the macro is used.  Each nested loop should use
3347    its own variables.
3348
3349    In the loop body, HARE is set to each cons of LIST, and N is the
3350    length of the list processed so far.  */
3351
3352 #define LIST_END_P(list, obj)                           \
3353   (NILP (obj)                                           \
3354    ? 1                                                  \
3355    : (CONSP (obj)                                       \
3356       ? 0                                               \
3357       : (wrong_type_argument (Qlistp, (list))), 1))
3358
3359 #define FOREACH(hare, list, tortoise, n)                \
3360   for (tortoise = hare = (list), n = 0;                 \
3361        !LIST_END_P (list, hare);                        \
3362        (hare = XCDR (hare), ++n,                        \
3363         ((n & 1) != 0                                   \
3364          ? (tortoise = XCDR (tortoise),                 \
3365             (EQ (hare, tortoise)                        \
3366              && (circular_list_error ((list)), 1)))     \
3367          : 0)))
3368
3369 /* The ubiquitous min and max macros.  */
3370
3371 #ifdef max
3372 #undef max
3373 #undef min
3374 #endif
3375 #define min(a, b)       ((a) < (b) ? (a) : (b))
3376 #define max(a, b)       ((a) > (b) ? (a) : (b))
3377
3378 /* Return a fixnum or float, depending on whether VAL fits in a Lisp
3379    fixnum.  */
3380
3381 #define make_fixnum_or_float(val) \
3382    (FIXNUM_OVERFLOW_P (val) \
3383     ? make_float (val) \
3384     : make_number ((EMACS_INT)(val)))
3385
3386
3387 /* Checks the `cycle check' variable CHECK to see if it indicates that
3388    EL is part of a cycle; CHECK must be either Qnil or a value returned
3389    by an earlier use of CYCLE_CHECK.  SUSPICIOUS is the number of
3390    elements after which a cycle might be suspected; after that many
3391    elements, this macro begins consing in order to keep more precise
3392    track of elements.
3393
3394    Returns nil if a cycle was detected, otherwise a new value for CHECK
3395    that includes EL.
3396
3397    CHECK is evaluated multiple times, EL and SUSPICIOUS 0 or 1 times, so
3398    the caller should make sure that's ok.  */
3399
3400 #define CYCLE_CHECK(check, el, suspicious)      \
3401   (NILP (check)                                 \
3402    ? make_number (0)                            \
3403    : (INTEGERP (check)                          \
3404       ? (XFASTINT (check) < (suspicious)        \
3405          ? make_number (XFASTINT (check) + 1)   \
3406          : Fcons (el, Qnil))                    \
3407       : (!NILP (Fmemq ((el), (check)))          \
3408          ? Qnil                                 \
3409          : Fcons ((el), (check)))))
3410
3411
3412 /* SAFE_ALLOCA normally allocates memory on the stack, but if size is
3413    larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack.  */
3414
3415 #define MAX_ALLOCA 16*1024
3416
3417 extern Lisp_Object safe_alloca_unwind (Lisp_Object);
3418
3419 #define USE_SAFE_ALLOCA                 \
3420   int sa_count = SPECPDL_INDEX (), sa_must_free = 0
3421
3422 /* SAFE_ALLOCA allocates a simple buffer.  */
3423
3424 #define SAFE_ALLOCA(buf, type, size)                      \
3425   do {                                                    \
3426     if ((size) < MAX_ALLOCA)                              \
3427       buf = (type) alloca (size);                         \
3428     else                                                  \
3429       {                                                   \
3430         buf = (type) xmalloc (size);                      \
3431         sa_must_free++;                                   \
3432         record_unwind_protect (safe_alloca_unwind,        \
3433                                make_save_value (buf, 0)); \
3434       }                                                   \
3435   } while (0)
3436
3437 /* SAFE_FREE frees xmalloced memory and enables GC as needed.  */
3438
3439 #define SAFE_FREE()                     \
3440   do {                                  \
3441     if (sa_must_free) {                 \
3442       sa_must_free = 0;                 \
3443       unbind_to (sa_count, Qnil);       \
3444     }                                   \
3445   } while (0)
3446
3447
3448 /* SAFE_ALLOCA_LISP allocates an array of Lisp_Objects.  */
3449
3450 #define SAFE_ALLOCA_LISP(buf, nelt)                       \
3451   do {                                                    \
3452     int size_ = (nelt) * sizeof (Lisp_Object);            \
3453     if (size_ < MAX_ALLOCA)                               \
3454       buf = (Lisp_Object *) alloca (size_);               \
3455     else                                                  \
3456       {                                                   \
3457         Lisp_Object arg_;                                 \
3458         buf = (Lisp_Object *) xmalloc (size_);            \
3459         arg_ = make_save_value (buf, nelt);               \
3460         XSAVE_VALUE (arg_)->dogc = 1;                     \
3461         sa_must_free++;                                   \
3462         record_unwind_protect (safe_alloca_unwind, arg_); \
3463       }                                                   \
3464   } while (0)
3465
3466
3467 #endif /* EMACS_LISP_H */
3468
3469 /* arch-tag: 9b2ed020-70eb-47ac-94ee-e1c2a5107d5e
3470    (do not change this comment) */