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