src/lisp.h

   1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
   2    Copyright (C) 1985,86,87,93,94,95 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 /* These are default choices for the types to use.  */
  23 #ifndef EMACS_INT
  24 #define EMACS_INT int
  25 #endif
  26 #ifndef EMACS_UINT
  27 #define EMACS_UINT unsigned int
  28 #endif
  29
  30 /* Define the fundamental Lisp data structures.  */
  31
  32 /* This is the set of Lisp data types.  */
  33
  34 enum Lisp_Type
  35   {
  36     /* Integer.  XINT (obj) is the integer value.  */
  37     Lisp_Int,
  38
  39     /* Symbol.  XSYMBOL (object) points to a struct Lisp_Symbol.  */
  40     Lisp_Symbol,
  41
  42     /* Miscellaneous.  XMISC (object) points to a union Lisp_Misc,
  43        whose first member indicates the subtype.  */
  44     Lisp_Misc,
  45
  46     /* String.  XSTRING (object) points to a struct Lisp_String.
  47        The length of the string, and its contents, are stored therein.  */
  48     Lisp_String,
  49
  50     /* Vector of Lisp objects, or something resembling it.
  51        XVECTOR (object) points to a struct Lisp_Vector, which contains
  52        the size and contents.  The size field also contains the type
  53        information, if it's not a real vector object.  */
  54     Lisp_Vectorlike,
  55
  56     /* Cons.  XCONS (object) points to a struct Lisp_Cons.  */
  57     Lisp_Cons,
  58
  59 #ifdef LISP_FLOAT_TYPE
  60     Lisp_Float,
  61 #endif /* LISP_FLOAT_TYPE */
  62
  63     /* This is not a type code.  It is for range checking.  */
  64     Lisp_Type_Limit
  65   };
  66
  67 /* This is the set of datatypes that share a common structure.
  68    The first member of the structure is a type code from this set.
  69    The enum values are arbitrary, but we'll use large numbers to make it
  70    more likely that we'll spot the error if a random word in memory is
  71    mistakenly interpreted as a Lisp_Misc.  */
  72 enum Lisp_Misc_Type
  73   {
  74     Lisp_Misc_Free = 0x5eab,
  75     Lisp_Misc_Marker,
  76     Lisp_Misc_Intfwd,
  77     Lisp_Misc_Boolfwd,
  78     Lisp_Misc_Objfwd,
  79     Lisp_Misc_Buffer_Objfwd,
  80     Lisp_Misc_Buffer_Local_Value,
  81     Lisp_Misc_Some_Buffer_Local_Value,
  82     Lisp_Misc_Overlay,
  83     Lisp_Misc_Kboard_Objfwd,
  84     /* Currently floats are not a misc type,
  85        but let's define this in case we want to change that.  */
  86     Lisp_Misc_Float,
  87     /* This is not a type code.  It is for range checking.  */
  88     Lisp_Misc_Limit
  89   };
  90
  91 /* These values are overridden by the m- file on some machines.  */
  92 #ifndef VALBITS
  93 #define VALBITS 28
  94 #endif
  95
  96 #ifndef GCTYPEBITS
  97 #define GCTYPEBITS 3
  98 #endif
  99
 100 /* Make these values available in GDB, which sees enums but not macros.  */
 101
 102 enum gdb_lisp_params
 103 {
 104   gdb_valbits = VALBITS,
 105   gdb_gctypebits = GCTYPEBITS,
 106   gdb_emacs_intbits = sizeof (EMACS_INT) * BITS_PER_CHAR,
 107 #ifdef DATA_SEG_BITS
 108   gdb_data_seg_bits = DATA_SEG_BITS
 109 #else
 110   gdb_data_seg_bits = 0
 111 #endif
 112 };
 113
 114 #ifndef NO_UNION_TYPE
 115
 116 #ifndef WORDS_BIG_ENDIAN
 117
 118 /* Definition of Lisp_Object for little-endian machines.  */
 119
 120 typedef
 121 union Lisp_Object
 122   {
 123     /* Used for comparing two Lisp_Objects;
 124        also, positive integers can be accessed fast this way.  */
 125     int i;
 126
 127     struct
 128       {
 129         int val: VALBITS;
 130         int type: GCTYPEBITS+1;
 131       } s;
 132     struct
 133       {
 134         unsigned int val: VALBITS;
 135         int type: GCTYPEBITS+1;
 136       } u;
 137     struct
 138       {
 139         unsigned int val: VALBITS;
 140         enum Lisp_Type type: GCTYPEBITS;
 141         /* The markbit is not really part of the value of a Lisp_Object,
 142            and is always zero except during garbage collection.  */
 143         unsigned int markbit: 1;
 144       } gu;
 145   }
 146 Lisp_Object;
 147
 148 #else /* If WORDS_BIG_ENDIAN */
 149
 150 typedef
 151 union Lisp_Object
 152   {
 153     /* Used for comparing two Lisp_Objects;
 154        also, positive integers can be accessed fast this way.  */
 155     int i;
 156
 157     struct
 158       {
 159         int type: GCTYPEBITS+1;
 160         int val: VALBITS;
 161       } s;
 162     struct
 163       {
 164         int type: GCTYPEBITS+1;
 165         unsigned int val: VALBITS;
 166       } u;
 167     struct
 168       {
 169         /* The markbit is not really part of the value of a Lisp_Object,
 170            and is always zero except during garbage collection.  */
 171         unsigned int markbit: 1;
 172         enum Lisp_Type type: GCTYPEBITS;
 173         unsigned int val: VALBITS;
 174       } gu;
 175   }
 176 Lisp_Object;
 177
 178 #endif /* WORDS_BIG_ENDIAN */
 179
 180 #endif /* NO_UNION_TYPE */
 181
 182
 183 /* If union type is not wanted, define Lisp_Object as just a number
 184    and define the macros below to extract fields by shifting */
 185
 186 #ifdef NO_UNION_TYPE
 187
 188 #define Lisp_Object EMACS_INT
 189
 190 #ifndef VALMASK
 191 #define VALMASK ((((EMACS_INT) 1)<<VALBITS) - 1)
 192 #endif
 193 #define GCTYPEMASK ((((EMACS_INT) 1)<<GCTYPEBITS) - 1)
 194
 195 /* Two flags that are set during GC.  On some machines, these flags
 196    are defined differently by the m- file.  */
 197
 198 /* This is set in the car of a cons and in the plist slot of a symbol
 199    to indicate it is marked.  Likewise in the plist slot of an interval,
 200    the chain slot of a marker, the type slot of a float, and the name
 201    slot of a buffer.
 202
 203    In strings, this bit in the size field indicates that the string
 204    is a "large" one, one which was separately malloc'd
 205    rather than being part of a string block.  */
 206
 207 #ifndef MARKBIT
 208 #define MARKBIT ((int) ((unsigned int) 1 << (VALBITS + GCTYPEBITS)))
 209 #endif /*MARKBIT */
 210
 211 /* In the size word of a vector, this bit means the vector has been marked.
 212    In the size word of a large string, likewise.  */
 213
 214 #ifndef ARRAY_MARK_FLAG
 215 #define ARRAY_MARK_FLAG ((MARKBIT >> 1) & ~MARKBIT)
 216 #endif /* no ARRAY_MARK_FLAG */
 217
 218 /* In the size word of a struct Lisp_Vector, this bit means it's really
 219    some other vector-like object.  */
 220 #ifndef PSEUDOVECTOR_FLAG
 221 #define PSEUDOVECTOR_FLAG ((ARRAY_MARK_FLAG >> 1) & ~ARRAY_MARK_FLAG)
 222 #endif
 223
 224 /* In a pseudovector, the size field actually contains a word with one
 225    PSEUDOVECTOR_FLAG bit set, and exactly one of the following bits to
 226    indicate the actual type.  */
 227 enum pvec_type
 228 {
 229   PVEC_NORMAL_VECTOR = 0,
 230   PVEC_PROCESS = 0x200,
 231   PVEC_FRAME = 0x400,
 232   PVEC_COMPILED = 0x800,
 233   PVEC_WINDOW = 0x1000,
 234   PVEC_WINDOW_CONFIGURATION = 0x2000,
 235   PVEC_SUBR = 0x4000,
 236   PVEC_CHAR_TABLE = 0x8000,
 237   PVEC_BOOL_VECTOR = 0x10000,
 238   PVEC_BUFFER = 0x20000,
 239   PVEC_TYPE_MASK = 0x3fe00,
 240   PVEC_FLAG = PSEUDOVECTOR_FLAG
 241 };
 242
 243 /* For convenience, we also store the number of elements in these bits.  */
 244 #define PSEUDOVECTOR_SIZE_MASK 0x1ff
 245
 246 #endif /* NO_UNION_TYPE */
 247 \f
 248 /* These macros extract various sorts of values from a Lisp_Object.
 249  For example, if tem is a Lisp_Object whose type is Lisp_Cons,
 250  XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons.  */
 251
 252 #ifdef NO_UNION_TYPE
 253
 254 /* One need to override this if there must be high bits set in data space
 255    (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
 256     on all machines, but would penalise machines which don't need it)
 257  */
 258 #ifndef XTYPE
 259 #define XTYPE(a) ((enum Lisp_Type) ((a) >> VALBITS))
 260 #endif
 261
 262 #ifndef XSETTYPE
 263 #define XSETTYPE(a, b) ((a)  =  XUINT (a) | ((EMACS_INT)(b) << VALBITS))
 264 #endif
 265
 266 /* For integers known to be positive, XFASTINT provides fast retrieval
 267    and XSETFASTINT provides fast storage.  This takes advantage of the
 268    fact that Lisp_Int is 0.  */
 269 #define XFASTINT(a) ((a) + 0)
 270 #define XSETFASTINT(a, b) ((a) = (b))
 271
 272 /* Extract the value of a Lisp_Object as a signed integer.  */
 273
 274 #ifndef XINT   /* Some machines need to do this differently.  */
 275 #define XINT(a) (((a) << (BITS_PER_INT-VALBITS)) >> (BITS_PER_INT-VALBITS))
 276 #endif
 277
 278 /* Extract the value as an unsigned integer.  This is a basis
 279    for extracting it as a pointer to a structure in storage.  */
 280
 281 #ifndef XUINT
 282 #define XUINT(a) ((a) & VALMASK)
 283 #endif
 284
 285 #ifndef XPNTR
 286 #ifdef HAVE_SHM
 287 /* In this representation, data is found in two widely separated segments.  */
 288 extern int pure_size;
 289 #define XPNTR(a) \
 290   (XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
 291 #else /* not HAVE_SHM */
 292 #ifdef DATA_SEG_BITS
 293 /* This case is used for the rt-pc.
 294    In the diffs I was given, it checked for ptr = 0
 295    and did not adjust it in that case.
 296    But I don't think that zero should ever be found
 297    in a Lisp object whose data type says it points to something.  */
 298 #define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
 299 #else
 300 #define XPNTR(a) XUINT (a)
 301 #endif
 302 #endif /* not HAVE_SHM */
 303 #endif /* no XPNTR */
 304
 305 #ifndef XSET
 306 #define XSET(var, type, ptr) \
 307    ((var) = ((EMACS_INT)(type) << VALBITS) + ((EMACS_INT) (ptr) & VALMASK))
 308 #endif
 309
 310 /* During garbage collection, XGCTYPE must be used for extracting types
 311  so that the mark bit is ignored.  XMARKBIT accesses the markbit.
 312  Markbits are used only in particular slots of particular structure types.
 313  Other markbits are always zero.
 314  Outside of garbage collection, all mark bits are always zero.  */
 315
 316 #ifndef XGCTYPE
 317 #define XGCTYPE(a) ((enum Lisp_Type) (((a) >> VALBITS) & GCTYPEMASK))
 318 #endif
 319
 320 #if VALBITS + GCTYPEBITS == BITS_PER_INT - 1
 321 /* Make XMARKBIT faster if mark bit is sign bit.  */
 322 #ifndef XMARKBIT
 323 #define XMARKBIT(a) ((a) < 0)
 324 #endif
 325 #endif /* markbit is sign bit */
 326
 327 #ifndef XMARKBIT
 328 #define XMARKBIT(a) ((a) & MARKBIT)
 329 #endif
 330
 331 #ifndef XSETMARKBIT
 332 #define XSETMARKBIT(a,b) ((a) = ((a) & ~MARKBIT) | ((b) ? MARKBIT : 0))
 333 #endif
 334
 335 #ifndef XMARK
 336 #define XMARK(a) ((a) |= MARKBIT)
 337 #endif
 338
 339 #ifndef XUNMARK
 340 #define XUNMARK(a) ((a) &= ~MARKBIT)
 341 #endif
 342
 343 #endif /* NO_UNION_TYPE */
 344
 345 #ifndef NO_UNION_TYPE
 346
 347 #define XTYPE(a) ((enum Lisp_Type) (a).u.type)
 348 #define XSETTYPE(a, b) ((a).u.type = (char) (b))
 349
 350 /* For integers known to be positive, XFASTINT provides fast retrieval
 351    and XSETFASTINT provides fast storage.  This takes advantage of the
 352    fact that Lisp_Int is 0.  */
 353 #define XFASTINT(a) ((a).i + 0)
 354 #define XSETFASTINT(a, b) ((a).i = (b))
 355
 356 #ifdef EXPLICIT_SIGN_EXTEND
 357 /* Make sure we sign-extend; compilers have been known to fail to do so.  */
 358 #define XINT(a) (((a).i << (BITS_PER_INT-VALBITS)) >> (BITS_PER_INT-VALBITS))
 359 #else
 360 #define XINT(a) ((a).s.val)
 361 #endif /* EXPLICIT_SIGN_EXTEND */
 362
 363 #define XUINT(a) ((a).u.val)
 364 #define XPNTR(a) ((a).u.val)
 365
 366 #define XSET(var, vartype, ptr) \
 367    (((var).s.type = ((char) (vartype))), ((var).s.val = ((int) (ptr))))
 368
 369 /* During garbage collection, XGCTYPE must be used for extracting types
 370  so that the mark bit is ignored.  XMARKBIT access the markbit.
 371  Markbits are used only in particular slots of particular structure types.
 372  Other markbits are always zero.
 373  Outside of garbage collection, all mark bits are always zero.  */
 374
 375 #define XGCTYPE(a) ((a).gu.type)
 376 #define XMARKBIT(a) ((a).gu.markbit)
 377 #define XSETMARKBIT(a,b) (XMARKBIT(a) = (b))
 378 #define XMARK(a) (XMARKBIT(a) = 1)
 379 #define XUNMARK(a) (XMARKBIT(a) = 0)
 380
 381 #endif /* NO_UNION_TYPE */
 382
 383 /* Extract a value or address from a Lisp_Object.  */
 384
 385 #define XCONS(a) ((struct Lisp_Cons *) XPNTR(a))
 386 #define XVECTOR(a) ((struct Lisp_Vector *) XPNTR(a))
 387 #define XSTRING(a) ((struct Lisp_String *) XPNTR(a))
 388 #define XSYMBOL(a) ((struct Lisp_Symbol *) XPNTR(a))
 389 #define XFLOAT(a) ((struct Lisp_Float *) XPNTR(a))
 390
 391 /* Misc types.  */
 392 #define XMISC(a)   ((union Lisp_Misc *) XPNTR(a))
 393 #define XMISCTYPE(a)   (XMARKER (a)->type)
 394 #define XMARKER(a) (&(XMISC(a)->u_marker))
 395 #define XINTFWD(a) (&(XMISC(a)->u_intfwd))
 396 #define XBOOLFWD(a) (&(XMISC(a)->u_boolfwd))
 397 #define XOBJFWD(a) (&(XMISC(a)->u_objfwd))
 398 #define XBUFFER_OBJFWD(a) (&(XMISC(a)->u_buffer_objfwd))
 399 #define XBUFFER_LOCAL_VALUE(a) (&(XMISC(a)->u_buffer_local_value))
 400 #define XOVERLAY(a) (&(XMISC(a)->u_overlay))
 401 #define XKBOARD_OBJFWD(a) (&(XMISC(a)->u_kboard_objfwd))
 402
 403 /* Pseudovector types.  */
 404 #define XPROCESS(a) ((struct Lisp_Process *) XPNTR(a))
 405 #define XWINDOW(a) ((struct window *) XPNTR(a))
 406 #define XSUBR(a) ((struct Lisp_Subr *) XPNTR(a))
 407 #define XBUFFER(a) ((struct buffer *) XPNTR(a))
 408 #define XCHAR_TABLE(a) ((struct Lisp_Char_Table *) XPNTR(a))
 409 #define XBOOL_VECTOR(a) ((struct Lisp_Bool_Vector *) XPNTR(a))
 410
 411
 412 /* Construct a Lisp_Object from a value or address.  */
 413
 414 #define XSETINT(a, b) XSET (a, Lisp_Int, b)
 415 #define XSETCONS(a, b) XSET (a, Lisp_Cons, b)
 416 #define XSETVECTOR(a, b) XSET (a, Lisp_Vectorlike, b)
 417 #define XSETSTRING(a, b) XSET (a, Lisp_String, b)
 418 #define XSETSYMBOL(a, b) XSET (a, Lisp_Symbol, b)
 419 #define XSETFLOAT(a, b) XSET (a, Lisp_Float, b)
 420
 421 /* Misc types.  */
 422 #define XSETMISC(a, b) XSET (a, Lisp_Misc, b)
 423 #define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
 424
 425 /* Pseudovector types.  */
 426 #define XSETPSEUDOVECTOR(a, b, code) \
 427   (XSETVECTOR (a, b), XVECTOR (a)->size |= PSEUDOVECTOR_FLAG | (code))
 428 #define XSETWINDOW_CONFIGURATION(a, b) \
 429   (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
 430 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
 431 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
 432 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
 433 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
 434 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
 435 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
 436 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
 437 \f
 438 #ifdef USE_TEXT_PROPERTIES
 439 /* Basic data type for use of intervals.  See the macros in intervals.h.  */
 440
 441 struct interval
 442 {
 443   /* The first group of entries deal with the tree structure.  */
 444
 445   unsigned int total_length;    /* Length of myself and both children.  */
 446   unsigned int position;        /* Cache of interval's character position.  */
 447   struct interval *left;        /* Intervals which precede me.  */
 448   struct interval *right;       /* Intervals which succeed me.  */
 449
 450   /* Parent in the tree, or the Lisp_Object containing this interval tree.
 451
 452      The mark bit on the root interval of an interval tree says
 453      whether we have started (and possibly finished) marking the
 454      tree.  If GC comes across an interval tree whose root's parent
 455      field has its markbit set, it leaves the tree alone.
 456
 457      You'd think we could store this information in the parent object
 458      somewhere (after all, that should be visited once and then
 459      ignored too, right?), but strings are GC'd strangely.  */
 460   struct interval *parent;
 461
 462   /* The remaining components are `properties' of the interval.
 463      The first four are duplicates for things which can be on the list,
 464      for purposes of speed.  */
 465
 466   unsigned char write_protect;      /* Non-zero means can't modify.  */
 467   unsigned char visible;            /* Zero means don't display.  */
 468   unsigned char front_sticky;       /* Non-zero means text inserted just
 469                                        before this interval goes into it.  */
 470   unsigned char rear_sticky;        /* Likewise for just after it.  */
 471
 472   /* Properties of this interval.
 473      The mark bit on this field says whether this particular interval
 474      tree node has been visited.  Since intervals should never be
 475      shared, GC aborts if it seems to have visited an interval twice.  */
 476   Lisp_Object plist;
 477 };
 478
 479 typedef struct interval *INTERVAL;
 480
 481 /* Complain if object is not string or buffer type */
 482 #define CHECK_STRING_OR_BUFFER(x, i) \
 483   { if (!STRINGP ((x)) && !BUFFERP ((x))) \
 484       x = wrong_type_argument (Qbuffer_or_string_p, (x)); }
 485
 486 /* Macro used to conditionally compile intervals into certain data
 487    structures.  See, e.g., struct Lisp_String below.  */
 488 #define DECLARE_INTERVALS INTERVAL intervals;
 489
 490 /* Macro used to conditionally compile interval initialization into
 491    certain code.  See, e.g., alloc.c.  */
 492 #define INITIALIZE_INTERVAL(ptr,val) ptr->intervals = val
 493
 494 #else  /* No text properties */
 495
 496 /* If no intervals are used, make the above definitions go away.  */
 497
 498 #define CHECK_STRING_OR_BUFFER(x, i)
 499
 500 #define INTERVAL
 501 #define DECLARE_INTERVALS
 502 #define INITIALIZE_INTERVAL(ptr,val)
 503
 504 #endif /* USE_TEXT_PROPERTIES */
 505 \f
 506 /* In a cons, the markbit of the car is the gc mark bit */
 507
 508 struct Lisp_Cons
 509   {
 510     Lisp_Object car, cdr;
 511   };
 512
 513 /* Like a cons, but records info on where the text lives that it was read from */
 514 /* This is not really in use now */
 515
 516 struct Lisp_Buffer_Cons
 517   {
 518     Lisp_Object car, cdr;
 519     struct buffer *buffer;
 520     int bufpos;
 521   };
 522
 523 /* In a string or vector, the sign bit of the `size' is the gc mark bit */
 524
 525 struct Lisp_String
 526   {
 527     EMACS_INT size;
 528     DECLARE_INTERVALS           /* `data' field must be last.  */
 529     unsigned char data[1];
 530   };
 531
 532 /* If a struct is made to look like a vector, this macro returns the length
 533    of that vector.  */
 534 #define VECSIZE(type) ((sizeof (type) - (sizeof (struct Lisp_Vector)    \
 535                                          - sizeof (Lisp_Object)))       \
 536                        / sizeof (Lisp_Object))
 537
 538 struct Lisp_Vector
 539   {
 540     EMACS_INT size;
 541     struct Lisp_Vector *next;
 542     Lisp_Object contents[1];
 543   };
 544
 545 /* A char table is a kind of vectorlike, with contents are like a vector
 546    but with a few other slots.  For some purposes, it makes sense
 547    to handle a chartable with type struct Lisp_Vector.  */
 548
 549 /* This is the number of slots that apply to characters
 550    or character sets.  */
 551 #define CHAR_TABLE_ORDINARY_SLOTS 256
 552
 553 /* This is the number of slots that every char table must have.
 554    This counts the ordinary slots and the parent and defalt slots.  */
 555 #define CHAR_TABLE_STANDARD_SLOTS (256+3)
 556
 557 /* Return the number of "extra" slots in the char table CT.  */
 558
 559 #define CHAR_TABLE_EXTRA_SLOTS(CT)      \
 560   (((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
 561
 562 struct Lisp_Char_Table
 563   {
 564     /* This is the vector's size field, which also holds the
 565        pseudovector type information.  It holds the size, too.
 566        The size counts the defalt and parent slots.  */
 567     EMACS_INT size;
 568     struct Lisp_Vector *next;
 569     Lisp_Object contents[CHAR_TABLE_ORDINARY_SLOTS];
 570     /* This holds a default value,
 571        which is used whenever the value for a specific character is nil.  */
 572     Lisp_Object defalt;
 573     /* This points to another char table, which we inherit from
 574        when the value for a specific character is nil.
 575        The `defalt' slot takes precedence over this.  */
 576     Lisp_Object parent;
 577     /* This should be a symbol which says what kind of use
 578        this char-table is meant for.
 579        Typically now the values can be `syntax-table' and `display-table'.  */
 580     Lisp_Object purpose;
 581     /* These hold additional data.  */
 582     Lisp_Object extras[1];
 583   };
 584
 585 /* A boolvector is a kind of vectorlike, with contents are like a string.  */
 586 struct Lisp_Bool_Vector
 587   {
 588     /* This is the vector's size field.  It doesn't have the real size,
 589        just the subtype information.  */
 590     EMACS_INT vector_size;
 591     struct Lisp_Vector *next;
 592     /* This is the size in bits.  */
 593     EMACS_INT size;
 594     /* This contains the actual bits, packed into bytes.  */
 595     unsigned char data[1];
 596   };
 597
 598 /* In a symbol, the markbit of the plist is used as the gc mark bit */
 599
 600 struct Lisp_Symbol
 601   {
 602     struct Lisp_String *name;
 603     Lisp_Object value;
 604     Lisp_Object function;
 605     Lisp_Object plist;
 606     struct Lisp_Symbol *next;   /* -> next symbol in this obarray bucket */
 607   };
 608
 609 /* This structure describes a built-in function.
 610    It is generated by the DEFUN macro only.
 611    defsubr makes it into a Lisp object.
 612
 613    This type is treated in most respects as a pseudovector,
 614    but since we never dynamically allocate or free them,
 615    we don't need a next-vector field.  */
 616
 617 struct Lisp_Subr
 618   {
 619     EMACS_INT size;
 620     Lisp_Object (*function) ();
 621     short min_args, max_args;
 622     char *symbol_name;
 623     char *prompt;
 624     char *doc;
 625   };
 626 \f
 627 /* These structures are used for various misc types.  */
 628
 629 /* A miscellaneous object, when it's on the free list.  */
 630 struct Lisp_Free
 631   {
 632     int type : 16;      /* = Lisp_Misc_Free */
 633     int spacer : 16;
 634     union Lisp_Misc *chain;
 635   };
 636
 637 /* In a marker, the markbit of the chain field is used as the gc mark bit */
 638 struct Lisp_Marker
 639 {
 640   int type : 16;                /* = Lisp_Misc_Marker */
 641   int spacer : 15;
 642   /* 1 means normal insertion at the marker's position
 643      leaves the marker after the inserted text.  */
 644   unsigned int insertion_type : 1;
 645   struct buffer *buffer;
 646   Lisp_Object chain;
 647   int bufpos;
 648 };
 649
 650 /* Forwarding pointer to an int variable.
 651    This is allowed only in the value cell of a symbol,
 652    and it means that the symbol's value really lives in the
 653    specified int variable.  */
 654 struct Lisp_Intfwd
 655   {
 656     int type : 16;      /* = Lisp_Misc_Intfwd */
 657     int spacer : 16;
 658     int *intvar;
 659   };
 660
 661 /* Boolean forwarding pointer to an int variable.
 662    This is like Lisp_Intfwd except that the ostensible
 663    "value" of the symbol is t if the int variable is nonzero,
 664    nil if it is zero.  */
 665 struct Lisp_Boolfwd
 666   {
 667     int type : 16;      /* = Lisp_Misc_Boolfwd */
 668     int spacer : 16;
 669     int *boolvar;
 670   };
 671
 672 /* Forwarding pointer to a Lisp_Object variable.
 673    This is allowed only in the value cell of a symbol,
 674    and it means that the symbol's value really lives in the
 675    specified variable.  */
 676 struct Lisp_Objfwd
 677   {
 678     int type : 16;      /* = Lisp_Misc_Objfwd */
 679     int spacer : 16;
 680     Lisp_Object *objvar;
 681   };
 682
 683 /* Like Lisp_Objfwd except that value lives in a slot in the
 684    current buffer.  Value is byte index of slot within buffer.  */
 685 struct Lisp_Buffer_Objfwd
 686   {
 687     int type : 16;      /* = Lisp_Misc_Buffer_Objfwd */
 688     int spacer : 16;
 689     int offset;
 690   };
 691
 692 /* Used in a symbol value cell when the symbol's value is per-buffer.
 693    The actual contents resemble a cons cell which starts a list like this:
 694    (REALVALUE BUFFER CURRENT-ALIST-ELEMENT . DEFAULT-VALUE).
 695
 696    The cons-like structure is for historical reasons; it might be better
 697    to just put these elements into the struct, now.
 698
 699    BUFFER is the last buffer for which this symbol's value was
 700    made up to date.
 701
 702    CURRENT-ALIST-ELEMENT is a pointer to an element of BUFFER's
 703    local_var_alist, that being the element whose car is this
 704    variable.  Or it can be a pointer to the
 705    (CURRENT-ALIST-ELEMENT . DEFAULT-VALUE),
 706    if BUFFER does not have an element in its alist for this
 707    variable (that is, if BUFFER sees the default value of this
 708    variable).
 709
 710    If we want to examine or set the value and BUFFER is current,
 711    we just examine or set REALVALUE.  If BUFFER is not current, we
 712    store the current REALVALUE value into CURRENT-ALIST-ELEMENT,
 713    then find the appropriate alist element for the buffer now
 714    current and set up CURRENT-ALIST-ELEMENT.  Then we set
 715    REALVALUE out of that element, and store into BUFFER.
 716
 717    If we are setting the variable and the current buffer does not
 718    have an alist entry for this variable, an alist entry is
 719    created.
 720
 721    Note that REALVALUE can be a forwarding pointer.  Each time it
 722    is examined or set, forwarding must be done.  Each time we
 723    switch buffers, buffer-local variables which forward into C
 724    variables are swapped immediately, so the C code can assume
 725    that they are always up to date.
 726
 727    Lisp_Misc_Buffer_Local_Value and Lisp_Misc_Some_Buffer_Local_Value
 728    use the same substructure.  The difference is that with the latter,
 729    merely setting the variable while some buffer is current
 730    does not cause that buffer to have its own local value of this variable.
 731    Only make-local-variable does that.  */
 732 struct Lisp_Buffer_Local_Value
 733   {
 734     int type : 16; /* = Lisp_Misc_Buffer_Local_Value
 735                                       or Lisp_Misc_Some_Buffer_Local_Value */
 736     int spacer : 16;
 737     Lisp_Object car, cdr;
 738   };
 739
 740 /* In an overlay object, the mark bit of the plist is used as the GC mark.
 741    START and END are markers in the overlay's buffer, and
 742    PLIST is the overlay's property list.  */
 743 struct Lisp_Overlay
 744   {
 745     int type : 16;      /* = Lisp_Misc_Overlay */
 746     int spacer : 16;
 747     Lisp_Object start, end, plist;
 748   };
 749
 750 /* Like Lisp_Objfwd except that value lives in a slot in the
 751    current kboard.  */
 752 struct Lisp_Kboard_Objfwd
 753   {
 754     int type : 16;      /* = Lisp_Misc_Kboard_Objfwd */
 755     int spacer : 16;
 756     int offset;
 757   };
 758
 759
 760 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
 761    It uses one of these struct subtypes to get the type field.  */
 762
 763 union Lisp_Misc
 764   {
 765     struct Lisp_Free u_free;
 766     struct Lisp_Marker u_marker;
 767     struct Lisp_Intfwd u_intfwd;
 768     struct Lisp_Boolfwd u_boolfwd;
 769     struct Lisp_Objfwd u_objfwd;
 770     struct Lisp_Buffer_Objfwd u_buffer_objfwd;
 771     struct Lisp_Buffer_Local_Value u_buffer_local_value;
 772     struct Lisp_Overlay u_overlay;
 773     struct Lisp_Kboard_Objfwd u_kboard_objfwd;
 774   };
 775 \f
 776 #ifdef LISP_FLOAT_TYPE
 777 /* Optional Lisp floating point type */
 778 struct Lisp_Float
 779   {
 780     Lisp_Object type;           /* essentially used for mark-bit
 781                                    and chaining when on free-list */
 782     double data;
 783   };
 784 #endif /* LISP_FLOAT_TYPE */
 785
 786 /* A character, declared with the following typedef, is a member
 787    of some character set associated with the current buffer.  */
 788 #ifndef _UCHAR_T  /* Protect against something in ctab.h on AIX.  */
 789 #define _UCHAR_T
 790 typedef unsigned char UCHAR;
 791 #endif
 792
 793 /* Meanings of slots in a Lisp_Compiled:  */
 794
 795 #define COMPILED_ARGLIST 0
 796 #define COMPILED_BYTECODE 1
 797 #define COMPILED_CONSTANTS 2
 798 #define COMPILED_STACK_DEPTH 3
 799 #define COMPILED_DOC_STRING 4
 800 #define COMPILED_INTERACTIVE 5
 801
 802 /* Flag bits in a character.  These also get used in termhooks.h.
 803    Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
 804    (MUlti-Lingual Emacs) might need 22 bits for the character value
 805    itself, so we probably shouldn't use any bits lower than 0x0400000.  */
 806 #define CHAR_ALT   (0x0400000)
 807 #define CHAR_SUPER (0x0800000)
 808 #define CHAR_HYPER (0x1000000)
 809 #define CHAR_SHIFT (0x2000000)
 810 #define CHAR_CTL   (0x4000000)
 811 #define CHAR_META  (0x8000000)
 812
 813 #ifdef USE_X_TOOLKIT
 814 #ifdef NO_UNION_TYPE
 815 /* Use this for turning a (void *) into a Lisp_Object, as when the
 816    Lisp_Object is passed into a toolkit callback function.  */
 817 #define VOID_TO_LISP(larg,varg) \
 818   do { ((larg) = ((Lisp_Object) (varg))); } while (0)
 819 #define CVOID_TO_LISP VOID_TO_LISP
 820
 821 /* Use this for turning a Lisp_Object into a  (void *), as when the
 822    Lisp_Object is passed into a toolkit callback function.  */
 823 #define LISP_TO_VOID(larg) ((void *) (larg))
 824 #define LISP_TO_CVOID(varg) ((const void *) (larg))
 825
 826 #else /* not NO_UNION_TYPE */
 827 /* Use this for turning a (void *) into a Lisp_Object, as when the
 828   Lisp_Object is passed into a toolkit callback function.  */
 829 #define VOID_TO_LISP(larg,varg) \
 830   do { ((larg).v = (void *) (varg)); } while (0)
 831 #define CVOID_TO_LISP(larg,varg) \
 832   do { ((larg).cv = (const void *) (varg)); } while (0)
 833
 834 /* Use this for turning a Lisp_Object into a  (void *), as when the
 835    Lisp_Object is passed into a toolkit callback function.  */
 836 #define LISP_TO_VOID(larg) ((larg).v)
 837 #define LISP_TO_CVOID(larg) ((larg).cv)
 838 #endif /* not NO_UNION_TYPE */
 839 #endif /* USE_X_TOOLKIT */
 840
 841 \f
 842 /* The glyph datatype, used to represent characters on the display.  */
 843
 844 /* The low eight bits are the character code, and the bits above them
 845    are the numeric face ID.  If FID is the face ID of a glyph on a
 846    frame F, then F->display.x->faces[FID] contains the description of
 847    that face.  This is an int instead of a short, so we can support a
 848    good bunch of face ID's; given that we have no mechanism for
 849    tossing unused frame face ID's yet, we'll probably run out of 255
 850    pretty quickly.  */
 851 #define GLYPH unsigned int
 852
 853 #ifdef HAVE_FACES
 854 /* The FAST macros assume that we already know we're in an X window.  */
 855
 856 /* Given a character code and a face ID, return the appropriate glyph.  */
 857 #define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << 8))
 858
 859 /* Return a glyph's character code.  */
 860 #define FAST_GLYPH_CHAR(glyph) ((glyph) & 0xff)
 861
 862 /* Return a glyph's face ID.  */
 863 #define FAST_GLYPH_FACE(glyph) (((glyph) >> 8) & ((1 << 24) - 1))
 864
 865 /* Slower versions that test the frame type first.  */
 866 #define MAKE_GLYPH(f, char, face) (FRAME_TERMCAP_P (f) ? (char) \
 867                                    : FAST_MAKE_GLYPH (char, face))
 868 #define GLYPH_CHAR(f, g) (FRAME_TERMCAP_P (f) ? (g) : FAST_GLYPH_CHAR (g))
 869 #define GLYPH_FACE(f, g) (FRAME_TERMCAP_P (f) ? (0) : FAST_GLYPH_FACE (g))
 870 #else /* not HAVE_FACES */
 871 #define MAKE_GLYPH(f, char, face) (char)
 872 #define GLYPH_CHAR(f, g) (g)
 873 #define GLYPH_FACE(f, g) (g)
 874 #endif /* not HAVE_FACES */
 875
 876 /* The ID of the mode line highlighting face.  */
 877 #define GLYPH_MODE_LINE_FACE 1
 878 \f
 879 /* Data type checking */
 880
 881 #define NILP(x)  (XFASTINT (x) == XFASTINT (Qnil))
 882 #define GC_NILP(x) GC_EQ (x, Qnil)
 883
 884 #ifdef LISP_FLOAT_TYPE
 885 #define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
 886 #define GC_NUMBERP(x) (GC_INTEGERP (x) || GC_FLOATP (x))
 887 #else
 888 #define NUMBERP(x) (INTEGERP (x))
 889 #define GC_NUMBERP(x) (GC_INTEGERP (x))
 890 #endif
 891 #define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
 892 #define GC_NATNUMP(x) (GC_INTEGERP (x) && XINT (x) >= 0)
 893
 894 #define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
 895 #define GC_INTEGERP(x) (XGCTYPE ((x)) == Lisp_Int)
 896 #define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
 897 #define GC_SYMBOLP(x) (XGCTYPE ((x)) == Lisp_Symbol)
 898 #define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
 899 #define GC_MISCP(x) (XGCTYPE ((x)) == Lisp_Misc)
 900 #define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
 901 #define GC_VECTORLIKEP(x) (XGCTYPE ((x)) == Lisp_Vectorlike)
 902 #define STRINGP(x) (XTYPE ((x)) == Lisp_String)
 903 #define GC_STRINGP(x) (XGCTYPE ((x)) == Lisp_String)
 904 #define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
 905 #define GC_CONSP(x) (XGCTYPE ((x)) == Lisp_Cons)
 906
 907 #ifdef LISP_FLOAT_TYPE
 908 #define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
 909 #define GC_FLOATP(x) (XGCTYPE ((x)) == Lisp_Float)
 910 #else
 911 #define FLOATP(x) (0)
 912 #define GC_FLOATP(x) (0)
 913 #endif
 914 #define VECTORP(x) (VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
 915 #define GC_VECTORP(x) (GC_VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
 916 #define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
 917 #define GC_OVERLAYP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
 918 #define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
 919 #define GC_MARKERP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
 920 #define INTFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
 921 #define GC_INTFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
 922 #define BOOLFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
 923 #define GC_BOOLFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
 924 #define OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
 925 #define GC_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
 926 #define BUFFER_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
 927 #define GC_BUFFER_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
 928 #define BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
 929 #define GC_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
 930 #define SOME_BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
 931 #define GC_SOME_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
 932 #define KBOARD_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
 933 #define GC_KBOARD_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
 934
 935
 936 /* True if object X is a pseudovector whose code is CODE.  */
 937 #define PSEUDOVECTORP(x, code)                                  \
 938   (VECTORLIKEP (x)                                              \
 939    && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code))))     \
 940        == (PSEUDOVECTOR_FLAG | (code))))
 941
 942 /* True if object X is a pseudovector whose code is CODE.
 943    This one works during GC.  */
 944 #define GC_PSEUDOVECTORP(x, code)                               \
 945   (GC_VECTORLIKEP (x)                                           \
 946    && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code))))     \
 947        == (PSEUDOVECTOR_FLAG | (code))))
 948
 949 /* Test for specific pseudovector types.  */
 950 #define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
 951 #define GC_WINDOW_CONFIGURATIONP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
 952 #define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
 953 #define GC_PROCESSP(x) GC_PSEUDOVECTORP (x, PVEC_PROCESS)
 954 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
 955 #define GC_WINDOWP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW)
 956 #define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
 957 #define GC_SUBRP(x) GC_PSEUDOVECTORP (x, PVEC_SUBR)
 958 #define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
 959 #define GC_COMPILEDP(x) GC_PSEUDOVECTORP (x, PVEC_COMPILED)
 960 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
 961 #define GC_BUFFERP(x) GC_PSEUDOVECTORP (x, PVEC_BUFFER)
 962 #define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
 963 #define GC_CHAR_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
 964 #define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
 965 #define GC_BOOL_VECTOR_P(x) GC_PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
 966
 967 #ifdef MULTI_FRAME
 968 #define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
 969 #define GC_FRAMEP(x) GC_PSEUDOVECTORP (x, PVEC_FRAME)
 970 #else
 971 #ifdef HAVE_MOUSE
 972 /* We could use this in the !HAVE_MOUSE case also, but we prefer a compile-time
 973    error message in case FRAMEP is used.  */
 974 #define FRAMEP(x) (EQ (x, Fselected_frame ()))
 975 #define GC_FRAMEP(x) (GC_EQ (x, Fselected_frame ()))
 976 #endif
 977 #endif
 978
 979 \f
 980 #define EQ(x, y) (XFASTINT (x) == XFASTINT (y))
 981 #define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y))
 982
 983 #define CHECK_LIST(x, i) \
 984   do { if (!CONSP ((x)) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); } while (0)
 985
 986 #define CHECK_STRING(x, i) \
 987   do { if (!STRINGP ((x))) x = wrong_type_argument (Qstringp, (x)); } while (0)
 988
 989 #define CHECK_CONS(x, i) \
 990   do { if (!CONSP ((x))) x = wrong_type_argument (Qconsp, (x)); } while (0)
 991
 992 #define CHECK_SYMBOL(x, i) \
 993   do { if (!SYMBOLP ((x))) x = wrong_type_argument (Qsymbolp, (x)); } while (0)
 994
 995 #define CHECK_CHAR_TABLE(x, i) \
 996   do { if (!CHAR_TABLE_P ((x))) \
 997          x = wrong_type_argument (Qchar_table_p, (x)); } while (0)
 998
 999 #define CHECK_VECTOR(x, i) \
1000   do { if (!VECTORP ((x))) x = wrong_type_argument (Qvectorp, (x)); } while (0)
1001
1002 #define CHECK_VECTOR_OR_CHAR_TABLE(x, i)                                \
1003   do { if (!VECTORP ((x)) && !CHAR_TABLE_P ((x)))                       \
1004          x = wrong_type_argument (Qvector_or_char_table_p, (x));        \
1005      } while (0)
1006
1007 #define CHECK_BUFFER(x, i) \
1008   do { if (!BUFFERP ((x))) x = wrong_type_argument (Qbufferp, (x)); } while (0)
1009
1010 #define CHECK_WINDOW(x, i) \
1011   do { if (!WINDOWP ((x))) x = wrong_type_argument (Qwindowp, (x)); } while (0)
1012
1013 /* This macro rejects windows on the interior of the window tree as
1014    "dead", which is what we want; this is an argument-checking macro, and
1015    the user should never get access to interior windows.
1016
1017    A window of any sort, leaf or interior, is dead iff the buffer,
1018    vchild, and hchild members are all nil.  */
1019
1020 #define CHECK_LIVE_WINDOW(x, i)                         \
1021   do {                                                  \
1022     if (!WINDOWP ((x))                                  \
1023         || NILP (XWINDOW ((x))->buffer))                \
1024       x = wrong_type_argument (Qwindow_live_p, (x));    \
1025   } while (0)
1026
1027 #define CHECK_PROCESS(x, i) \
1028   do { if (!PROCESSP ((x))) x = wrong_type_argument (Qprocessp, (x)); } while (0)
1029
1030 #define CHECK_NUMBER(x, i) \
1031   do { if (!INTEGERP ((x))) x = wrong_type_argument (Qintegerp, (x)); } while (0)
1032
1033 #define CHECK_NATNUM(x, i) \
1034   do { if (!NATNUMP (x)) x = wrong_type_argument (Qwholenump, (x)); } while (0)
1035
1036 #define CHECK_MARKER(x, i) \
1037   do { if (!MARKERP ((x))) x = wrong_type_argument (Qmarkerp, (x)); } while (0)
1038
1039 #define CHECK_NUMBER_COERCE_MARKER(x, i) \
1040   do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
1041     else if (!INTEGERP ((x))) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } while (0)
1042
1043 #ifdef LISP_FLOAT_TYPE
1044
1045 #ifndef DBL_DIG
1046 #define DBL_DIG 20
1047 #endif
1048
1049 #define XFLOATINT(n) extract_float((n))
1050
1051 #define CHECK_FLOAT(x, i)               \
1052   do { if (!FLOATP (x))                 \
1053     x = wrong_type_argument (Qfloatp, (x)); } while (0)
1054
1055 #define CHECK_NUMBER_OR_FLOAT(x, i)     \
1056   do { if (!FLOATP (x) && !INTEGERP (x))        \
1057     x = wrong_type_argument (Qnumberp, (x)); } while (0)
1058
1059 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x, i) \
1060   do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x));   \
1061   else if (!INTEGERP (x) && !FLOATP (x))                \
1062     x = wrong_type_argument (Qnumber_or_marker_p, (x)); } while (0)
1063
1064 #else  /* Not LISP_FLOAT_TYPE */
1065
1066 #define CHECK_NUMBER_OR_FLOAT CHECK_NUMBER
1067
1068 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER CHECK_NUMBER_COERCE_MARKER
1069
1070 #define XFLOATINT(n) XINT((n))
1071 #endif /* LISP_FLOAT_TYPE */
1072
1073 #define CHECK_OVERLAY(x, i) \
1074   do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
1075
1076 /* Cast pointers to this type to compare them.  Some machines want int.  */
1077 #ifndef PNTR_COMPARISON_TYPE
1078 #define PNTR_COMPARISON_TYPE unsigned int
1079 #endif
1080 \f
1081 /* Define a built-in function for calling from Lisp.
1082  `lname' should be the name to give the function in Lisp,
1083     as a null-terminated C string.
1084  `fnname' should be the name of the function in C.
1085     By convention, it starts with F.
1086  `sname' should be the name for the C constant structure
1087     that records information on this function for internal use.
1088     By convention, it should be the same as `fnname' but with S instead of F.
1089     It's too bad that C macros can't compute this from `fnname'.
1090  `minargs' should be a number, the minimum number of arguments allowed.
1091  `maxargs' should be a number, the maximum number of arguments allowed,
1092     or else MANY or UNEVALLED.
1093     MANY means pass a vector of evaluated arguments,
1094          in the form of an integer number-of-arguments
1095          followed by the address of a vector of Lisp_Objects
1096          which contains the argument values.
1097     UNEVALLED means pass the list of unevaluated arguments
1098  `prompt' says how to read arguments for an interactive call.
1099     See the doc string for `interactive'.
1100     A null string means call interactively with no arguments.
1101  `doc' is documentation for the user.  */
1102
1103 #if !defined (__STDC__) || defined (USE_NONANSI_DEFUN)
1104 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc)      \
1105   Lisp_Object fnname ();                                                \
1106   struct Lisp_Subr sname =                                              \
1107     { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),     \
1108       fnname, minargs, maxargs, lname, prompt, 0};                      \
1109   Lisp_Object fnname
1110
1111 #else
1112
1113 /* This version of DEFUN declares a function prototype with the right
1114    arguments, so we can catch errors with maxargs at compile-time.  */
1115 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc)      \
1116   Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                           \
1117   struct Lisp_Subr sname =                                              \
1118     { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),     \
1119       fnname, minargs, maxargs, lname, prompt, 0};                      \
1120   Lisp_Object fnname
1121
1122 /* Note that the weird token-substitution semantics of ANSI C makes
1123    this work for MANY and UNEVALLED.  */
1124 #define DEFUN_ARGS_MANY         (int, Lisp_Object *)
1125 #define DEFUN_ARGS_UNEVALLED    (Lisp_Object)
1126 #define DEFUN_ARGS_0    (void)
1127 #define DEFUN_ARGS_1    (Lisp_Object)
1128 #define DEFUN_ARGS_2    (Lisp_Object, Lisp_Object)
1129 #define DEFUN_ARGS_3    (Lisp_Object, Lisp_Object, Lisp_Object)
1130 #define DEFUN_ARGS_4    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1131 #define DEFUN_ARGS_5    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1132                          Lisp_Object)
1133 #define DEFUN_ARGS_6    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1134                          Lisp_Object, Lisp_Object)
1135 #define DEFUN_ARGS_7    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1136                          Lisp_Object, Lisp_Object, Lisp_Object)
1137 #endif
1138
1139 /* defsubr (Sname);
1140  is how we define the symbol for function `name' at start-up time.  */
1141 extern void defsubr ();
1142
1143 #define MANY -2
1144 #define UNEVALLED -1
1145
1146 extern void defvar_lisp ();
1147 extern void defvar_bool ();
1148 extern void defvar_int ();
1149 extern void defvar_kboard ();
1150
1151 /* Macros we use to define forwarded Lisp variables.
1152    These are used in the syms_of_FILENAME functions.  */
1153
1154 #define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
1155 #define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
1156 #define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
1157 #define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
1158 #define DEFVAR_PER_BUFFER(lname, vname, type, doc)  \
1159  defvar_per_buffer (lname, vname, type, 0)
1160 #define DEFVAR_KBOARD(lname, vname, doc) \
1161  defvar_kboard (lname, \
1162                 (int)((char *)(&current_kboard->vname) \
1163                       - (char *)current_kboard))
1164 \f
1165 /* Structure for recording Lisp call stack for backtrace purposes.  */
1166
1167 /* The special binding stack holds the outer values of variables while
1168    they are bound by a function application or a let form, stores the
1169    code to be executed for Lisp unwind-protect forms, and stores the C
1170    functions to be called for record_unwind_protect.
1171
1172    If func is non-zero, undoing this binding applies func to old_value;
1173       This implements record_unwind_protect.
1174    If func is zero and symbol is nil, undoing this binding evaluates
1175       the list of forms in old_value; this implements Lisp's unwind-protect
1176       form.
1177    Otherwise, undoing this binding stores old_value as symbol's value; this
1178       undoes the bindings made by a let form or function call.  */
1179 struct specbinding
1180   {
1181     Lisp_Object symbol, old_value;
1182     Lisp_Object (*func) ();
1183     Lisp_Object unused;         /* Dividing by 16 is faster than by 12 */
1184   };
1185
1186 extern struct specbinding *specpdl;
1187 extern struct specbinding *specpdl_ptr;
1188 extern int specpdl_size;
1189
1190 /* Everything needed to describe an active condition case.  */
1191 struct handler
1192   {
1193     /* The handler clauses and variable from the condition-case form.  */
1194     Lisp_Object handler;
1195     Lisp_Object var;
1196     /* Fsignal stores here the condition-case clause that applies,
1197        and Fcondition_case thus knows which clause to run.  */
1198     Lisp_Object chosen_clause;
1199
1200     /* Used to effect the longjump out to the handler.  */
1201     struct catchtag *tag;
1202
1203     /* The next enclosing handler.  */
1204     struct handler *next;
1205   };
1206
1207 extern struct handler *handlerlist;
1208
1209 extern struct catchtag *catchlist;
1210 extern struct backtrace *backtrace_list;
1211
1212 extern Lisp_Object memory_signal_data;
1213
1214 /* An address near the bottom of the stack.
1215    Tells GC how to save a copy of the stack.  */
1216 extern char *stack_bottom;
1217
1218 /* Check quit-flag and quit if it is non-nil.  */
1219
1220 #define QUIT \
1221   if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
1222     { Vquit_flag = Qnil; Fsignal (Qquit, Qnil); }
1223
1224 /* Nonzero if ought to quit now.  */
1225
1226 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
1227 \f
1228 /* 1 if CH is upper case.  */
1229
1230 #define UPPERCASEP(CH) \
1231   (XCHAR_TABLE (current_buffer->downcase_table)->contents[CH] != (CH))
1232
1233 /* 1 if CH is lower case.  */
1234
1235 #define LOWERCASEP(CH) \
1236   (!UPPERCASEP (CH) \
1237    && XCHAR_TABLE (current_buffer->upcase_table)->contents[CH] != (CH))
1238
1239 /* 1 if CH is neither upper nor lower case.  */
1240
1241 #define NOCASEP(CH) \
1242   (XCHAR_TABLE (current_buffer->upcase_table)->contents[CH] == (CH))
1243
1244 /* Upcase a character, or make no change if that cannot be done.  */
1245
1246 #define UPCASE(CH) \
1247   (XCHAR_TABLE (current_buffer->downcase_table)->contents[CH] == (CH) \
1248    ? UPCASE1 (CH) : (CH))
1249
1250 /* Upcase a character known to be not upper case.  */
1251
1252 #define UPCASE1(CH) (XCHAR_TABLE (current_buffer->upcase_table)->contents[CH])
1253
1254 /* Downcase a character, or make no change if that cannot be done.  */
1255
1256 #define DOWNCASE(CH) \
1257   (XCHAR_TABLE (current_buffer->downcase_table)->contents[CH])
1258
1259 /* Current buffer's map from characters to lower-case characters.  */
1260
1261 #define DOWNCASE_TABLE XCHAR_TABLE (current_buffer->downcase_table)->contents
1262
1263 extern Lisp_Object Vascii_downcase_table;
1264 \f
1265 /* Number of bytes of structure consed since last GC.  */
1266
1267 extern int consing_since_gc;
1268
1269 /* Threshold for doing another gc.  */
1270
1271 extern int gc_cons_threshold;
1272
1273 /* Structure for recording stack slots that need marking.  */
1274
1275 /* This is a chain of structures, each of which points at a Lisp_Object variable
1276  whose value should be marked in garbage collection.
1277  Normally every link of the chain is an automatic variable of a function,
1278  and its `val' points to some argument or local variable of the function.
1279  On exit to the function, the chain is set back to the value it had on entry.
1280  This way, no link remains in the chain when the stack frame containing the
1281  link disappears.
1282
1283  Every function that can call Feval must protect in this fashion all
1284  Lisp_Object variables whose contents will be used again.  */
1285
1286 extern struct gcpro *gcprolist;
1287
1288 struct gcpro
1289   {
1290     struct gcpro *next;
1291     Lisp_Object *var;           /* Address of first protected variable */
1292     int nvars;                  /* Number of consecutive protected variables */
1293   };
1294
1295 #define GCPRO1(varname) \
1296  {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
1297   gcprolist = &gcpro1; }
1298
1299 #define GCPRO2(varname1, varname2) \
1300  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1301   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1302   gcprolist = &gcpro2; }
1303
1304 #define GCPRO3(varname1, varname2, varname3) \
1305  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1306   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1307   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1308   gcprolist = &gcpro3; }
1309
1310 #define GCPRO4(varname1, varname2, varname3, varname4) \
1311  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1312   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1313   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1314   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1315   gcprolist = &gcpro4; }
1316
1317 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1318  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1319   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1320   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1321   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1322   gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1323   gcprolist = &gcpro5; }
1324
1325 /* Call staticpro (&var) to protect static variable `var'.  */
1326
1327 void staticpro();
1328
1329 #define UNGCPRO (gcprolist = gcpro1.next)
1330
1331 /* Evaluate expr, UNGCPRO, and then return the value of expr.  */
1332 #define RETURN_UNGCPRO(expr)                    \
1333 if (1)                                          \
1334     {                                           \
1335       Lisp_Object ret_ungc_val;                 \
1336       ret_ungc_val = (expr);                    \
1337       UNGCPRO;                                  \
1338       return ret_ungc_val;                      \
1339     }                                           \
1340 else
1341 \f
1342 /* Defined in data.c */
1343 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
1344 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
1345 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
1346 extern Lisp_Object Qvoid_variable, Qvoid_function;
1347 extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
1348 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
1349 extern Lisp_Object Qend_of_file, Qarith_error;
1350 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
1351 extern Lisp_Object Qmark_inactive;
1352
1353 extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
1354 extern Lisp_Object Qoverflow_error, Qunderflow_error;
1355
1356 extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qwholenump;
1357 extern Lisp_Object Qsymbolp, Qlistp, Qconsp;
1358 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
1359 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp;
1360 extern Lisp_Object Qinteger_or_marker_p, Qnumber_or_marker_p;
1361 extern Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
1362 extern Lisp_Object Qboundp, Qfboundp;
1363 extern Lisp_Object Qbuffer_or_string_p;
1364 extern Lisp_Object Qcdr;
1365
1366 #ifdef LISP_FLOAT_TYPE
1367 extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
1368 #endif /* LISP_FLOAT_TYPE */
1369
1370 extern Lisp_Object Qframep;
1371
1372 extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp ();
1373 extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp ();
1374 extern Lisp_Object Fvectorp (), Fstringp (), Farrayp (), Fsequencep ();
1375 extern Lisp_Object Fbufferp (), Fmarkerp (), Fsubrp (), Fchar_or_string_p ();
1376 extern Lisp_Object Finteger_or_marker_p ();
1377 #ifdef LISP_FLOAT_TYPE
1378 extern Lisp_Object Ffloatp(), Finteger_or_floatp();
1379 extern Lisp_Object Finteger_or_float_or_marker_p(), Ftruncate();
1380 #endif /* LISP_FLOAT_TYPE */
1381
1382 extern Lisp_Object Fcar (), Fcar_safe(), Fcdr (), Fcdr_safe();
1383 extern Lisp_Object Fsetcar (), Fsetcdr ();
1384 extern Lisp_Object Fboundp (), Ffboundp (), Fmakunbound (), Ffmakunbound ();
1385 extern Lisp_Object Fsymbol_function (), Fsymbol_plist (), Fsymbol_name ();
1386 extern Lisp_Object indirect_function (), Findirect_function ();
1387 extern Lisp_Object Ffset (), Fsetplist ();
1388 extern Lisp_Object Fsymbol_value (), find_symbol_value (), Fset ();
1389 extern Lisp_Object Fdefault_value (), Fset_default (), Fdefault_boundp ();
1390
1391 extern Lisp_Object Faref (), Faset ();
1392
1393 extern Lisp_Object Fstring_to_number (), Fnumber_to_string ();
1394 extern Lisp_Object Feqlsign (), Fgtr (), Flss (), Fgeq (), Fleq ();
1395 extern Lisp_Object Fneq (), Fzerop ();
1396 extern Lisp_Object Fplus (), Fminus (), Ftimes (), Fquo (), Frem ();
1397 extern Lisp_Object Fmax (), Fmin ();
1398 extern Lisp_Object Flogand (), Flogior (), Flogxor (), Flognot ();
1399 extern Lisp_Object Flsh (), Fash ();
1400
1401 extern Lisp_Object Fadd1 (), Fsub1 ();
1402
1403 extern Lisp_Object make_number ();
1404 extern Lisp_Object   long_to_cons ();
1405 extern unsigned long cons_to_long ();
1406 extern void args_out_of_range ();
1407 extern void args_out_of_range_3 ();
1408 extern Lisp_Object wrong_type_argument ();
1409 extern void store_symval_forwarding ();
1410 extern Lisp_Object do_symval_forwarding ();
1411 #ifdef LISP_FLOAT_TYPE
1412 extern Lisp_Object Ffloat_to_int(), Fint_to_float();
1413 extern double extract_float();
1414 extern Lisp_Object make_float ();
1415 extern Lisp_Object Ffloat ();
1416 #endif /* LISP_FLOAT_TYPE */
1417
1418 /* Defined in cmds.c */
1419 extern Lisp_Object Fend_of_line (), Fforward_char (), Fforward_line ();
1420
1421 /* Defined in syntax.c */
1422 extern Lisp_Object Fforward_word ();
1423
1424 /* Defined in fns.c */
1425 extern Lisp_Object Qstring_lessp;
1426 extern Lisp_Object Vfeatures;
1427 extern Lisp_Object Fidentity (), Frandom ();
1428 extern Lisp_Object Flength (), Fsafe_length ();
1429 extern Lisp_Object Fappend (), Fconcat (), Fvconcat (), Fcopy_sequence ();
1430 extern Lisp_Object Fsubstring ();
1431 extern Lisp_Object Fnth (), Fnthcdr (), Fmemq (), Fassq (), Fassoc ();
1432 extern Lisp_Object Felt (), Fmember (), Frassq (), Fdelq (), Fsort ();
1433 extern Lisp_Object Freverse (), Fnreverse (), Fget (), Fput (), Fequal ();
1434 extern Lisp_Object Ffillarray (), Fnconc (), Fmapcar (), Fmapconcat ();
1435 extern Lisp_Object Fy_or_n_p (), do_yes_or_no_p ();
1436 extern Lisp_Object Ffeaturep (), Frequire () , Fprovide ();
1437 extern Lisp_Object concat2 (), nconc2 ();
1438 extern Lisp_Object assq_no_quit ();
1439 extern Lisp_Object Fcopy_alist ();
1440 extern Lisp_Object Fplist_get ();
1441
1442 /* Defined in insdel.c */
1443 extern void move_gap ();
1444 extern void make_gap ();
1445 extern void insert ();
1446 extern void insert_and_inherit ();
1447 extern void insert_1 ();
1448 extern void insert_from_string ();
1449 extern void insert_from_buffer ();
1450 extern void insert_char ();
1451 extern void insert_string ();
1452 extern void insert_before_markers ();
1453 extern void insert_before_markers_and_inherit ();
1454 extern void insert_from_string_before_markers ();
1455 extern void del_range ();
1456 extern void del_range_1 ();
1457 extern void modify_region ();
1458 extern void prepare_to_modify_buffer ();
1459 extern void signal_before_change ();
1460 extern void signal_after_change ();
1461
1462 /* Defined in xdisp.c */
1463 extern Lisp_Object Vmessage_log_max;
1464 extern void message ();
1465 extern void message_nolog ();
1466 extern void message1 ();
1467 extern void message1_nolog ();
1468 extern void message2 ();
1469 extern void message2_nolog ();
1470 extern void message_dolog ();
1471 extern void message_log_maybe_newline ();
1472
1473 /* Defined in alloc.c */
1474 extern Lisp_Object Vpurify_flag;
1475 extern Lisp_Object Fcons (), Flist(), Fmake_list (), allocate_misc ();
1476 extern Lisp_Object Fmake_vector (), Fvector (), Fmake_symbol (), Fmake_marker ();
1477 extern Lisp_Object Fmake_string (), build_string (), make_string ();
1478 extern Lisp_Object make_event_array (), make_uninit_string ();
1479 extern Lisp_Object Fpurecopy (), make_pure_string ();
1480 extern Lisp_Object pure_cons (), make_pure_vector ();
1481 extern Lisp_Object Fgarbage_collect ();
1482 extern Lisp_Object Fmake_byte_code ();
1483 extern Lisp_Object Qchar_table_extra_slots;
1484 extern struct Lisp_Vector *allocate_vectorlike ();
1485 extern int gc_in_progress;
1486
1487 /* Defined in print.c */
1488 extern Lisp_Object Vprin1_to_string_buffer;
1489 extern Lisp_Object Fprin1 (), Fprin1_to_string (), Fprinc ();
1490 extern Lisp_Object Fterpri (), Fprint ();
1491 extern Lisp_Object Vstandard_output, Qstandard_output;
1492 extern Lisp_Object Qexternal_debugging_output;
1493 extern void temp_output_buffer_setup (), temp_output_buffer_show ();
1494 extern int print_level, print_escape_newlines;
1495 extern Lisp_Object Qprint_escape_newlines;
1496
1497 /* Defined in lread.c */
1498 extern Lisp_Object Qvariable_documentation, Qstandard_input;
1499 extern Lisp_Object Vobarray, Vstandard_input;
1500 extern Lisp_Object Fread (), Fread_from_string ();
1501 extern Lisp_Object Fintern (), Fintern_soft (), Fload ();
1502 extern Lisp_Object Fget_file_char (), Fread_char ();
1503 extern Lisp_Object read_filtered_event ();
1504 extern Lisp_Object Feval_current_buffer (), Feval_region ();
1505 extern Lisp_Object intern (), oblookup ();
1506 #define LOADHIST_ATTACH(x) \
1507  if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
1508 extern Lisp_Object Vcurrent_load_list;
1509 extern Lisp_Object Vload_history;
1510
1511 /* Defined in eval.c */
1512 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
1513 extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
1514 extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments;
1515 extern Lisp_Object Vautoload_queue;
1516 extern Lisp_Object Vdebug_on_error;
1517 /* To run a normal hook, use the appropriate function from the list below.
1518    The calling convention:
1519
1520    if (!NILP (Vrun_hooks))
1521      call1 (Vrun_hooks, Qmy_funny_hook);
1522
1523    should no longer be used.  */
1524 extern Lisp_Object Vrun_hooks;
1525 extern Lisp_Object Frun_hooks (), Frun_hook_with_args ();
1526 extern Lisp_Object Frun_hook_with_args_until_success ();
1527 extern Lisp_Object Frun_hook_with_args_until_failure ();
1528 extern Lisp_Object Fand (), For (), Fif (), Fprogn (), Fprog1 (), Fprog2 ();
1529 extern Lisp_Object Fsetq (), Fquote ();
1530 extern Lisp_Object Fuser_variable_p (), Finteractive_p ();
1531 extern Lisp_Object Fdefun (), Flet (), FletX (), Fwhile ();
1532 extern Lisp_Object Fcatch (), Fthrow (), Funwind_protect ();
1533 extern Lisp_Object Fcondition_case (), Fsignal ();
1534 extern Lisp_Object Ffunction_type (), Fautoload (), Fcommandp ();
1535 extern Lisp_Object Feval (), Fapply (), Ffuncall ();
1536 extern Lisp_Object Fglobal_set (), Fglobal_value (), Fbacktrace ();
1537 extern Lisp_Object apply1 (), call0 (), call1 (), call2 (), call3 ();
1538 extern Lisp_Object call4 (), call5 (), call6 ();
1539 extern Lisp_Object Fkill_emacs (), Fkey_binding (), Fsit_for ();
1540 extern Lisp_Object Fdo_auto_save (), Fset_marker ();
1541 extern Lisp_Object apply_lambda ();
1542 extern Lisp_Object internal_catch ();
1543 extern Lisp_Object internal_condition_case ();
1544 extern Lisp_Object internal_condition_case_1 ();
1545 extern Lisp_Object unbind_to ();
1546 extern void error ();
1547 extern Lisp_Object un_autoload ();
1548 extern Lisp_Object Ffetch_bytecode ();
1549
1550 /* Defined in editfns.c */
1551 extern Lisp_Object Fgoto_char ();
1552 extern Lisp_Object Fpoint_min_marker (), Fpoint_max_marker ();
1553 extern Lisp_Object Fpoint_min (), Fpoint_max ();
1554 extern Lisp_Object Fpoint (), Fpoint_marker (), Fmark_marker ();
1555 extern Lisp_Object Ffollowing_char (), Fprevious_char (), Fchar_after ();
1556 extern Lisp_Object Finsert ();
1557 extern Lisp_Object Feolp (), Feobp (), Fbolp (), Fbobp ();
1558 extern Lisp_Object Fformat (), format1 ();
1559 extern Lisp_Object make_buffer_string (), Fbuffer_substring ();
1560 extern Lisp_Object Fbuffer_string ();
1561 extern Lisp_Object Fstring_equal (), Fstring_lessp (), Fbuffer_substring_lessp ();
1562 extern Lisp_Object save_excursion_save (), save_restriction_save ();
1563 extern Lisp_Object save_excursion_restore (), save_restriction_restore ();
1564 extern Lisp_Object Fchar_to_string ();
1565 extern Lisp_Object Fdelete_region (), Fnarrow_to_region (), Fwiden ();
1566
1567 /* defined in buffer.c */
1568 extern Lisp_Object Foverlay_start (), Foverlay_end ();
1569 extern void adjust_overlays_for_insert ();
1570 extern void adjust_overlays_for_delete ();
1571 extern void fix_overlays_in_range ();
1572 extern int overlay_touches_p ();
1573 extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
1574 extern Lisp_Object Fget_buffer (), Fget_buffer_create (), Fset_buffer ();
1575 extern Lisp_Object Fbarf_if_buffer_read_only ();
1576 extern Lisp_Object Fcurrent_buffer (), Fswitch_to_buffer (), Fpop_to_buffer ();
1577 extern Lisp_Object Fother_buffer ();
1578 extern Lisp_Object Foverlay_get ();
1579 extern Lisp_Object Qoverlayp;
1580 extern struct buffer *all_buffers;
1581
1582 /* defined in marker.c */
1583
1584 extern Lisp_Object Fmarker_position (), Fmarker_buffer ();
1585 extern Lisp_Object Fcopy_marker ();
1586
1587 /* Defined in fileio.c */
1588
1589 extern Lisp_Object Qfile_error;
1590 extern Lisp_Object Ffind_file_name_handler ();
1591 extern Lisp_Object Ffile_name_as_directory ();
1592 extern Lisp_Object Fexpand_file_name (), Ffile_name_nondirectory ();
1593 extern Lisp_Object Fsubstitute_in_file_name ();
1594 extern Lisp_Object Ffile_symlink_p ();
1595 extern Lisp_Object Fverify_visited_file_modtime ();
1596 extern Lisp_Object Ffile_exists_p ();
1597 extern Lisp_Object Ffile_name_absolute_p ();
1598 extern Lisp_Object Fdirectory_file_name ();
1599 extern Lisp_Object Ffile_name_directory ();
1600 extern Lisp_Object expand_and_dir_to_file ();
1601 extern Lisp_Object Ffile_accessible_directory_p ();
1602 extern Lisp_Object Funhandled_file_name_directory ();
1603
1604 /* Defined in abbrev.c */
1605
1606 extern Lisp_Object Vfundamental_mode_abbrev_table;
1607
1608 /* defined in search.c */
1609 extern Lisp_Object Fstring_match ();
1610 extern Lisp_Object Fscan_buffer ();
1611 extern void restore_match_data ();
1612 extern Lisp_Object Fmatch_data (), Fstore_match_data ();
1613 extern Lisp_Object Fmatch_beginning (), Fmatch_end ();
1614 extern Lisp_Object Fskip_chars_forward (), Fskip_chars_backward ();
1615
1616 /* defined in minibuf.c */
1617
1618 extern Lisp_Object last_minibuf_string;
1619 extern Lisp_Object read_minibuf (), Fcompleting_read ();
1620 extern Lisp_Object Fread_from_minibuffer ();
1621 extern Lisp_Object Fread_variable (), Fread_buffer (), Fread_key_sequence ();
1622 extern Lisp_Object Fread_minibuffer (), Feval_minibuffer ();
1623 extern Lisp_Object Fread_string (), Fread_file_name ();
1624 extern Lisp_Object Fread_no_blanks_input ();
1625
1626 /* Defined in callint.c */
1627
1628 extern Lisp_Object Qminus, Qplus, Vcurrent_prefix_arg;
1629 extern Lisp_Object Vcommand_history;
1630 extern Lisp_Object Qcall_interactively;
1631 extern Lisp_Object Fcall_interactively ();
1632 extern Lisp_Object Fprefix_numeric_value ();
1633
1634 /* defined in casefiddle.c */
1635
1636 extern Lisp_Object Fdowncase (), Fupcase (), Fcapitalize ();
1637 extern Lisp_Object Fupcase_initials (), Fupcase_initials_region ();
1638
1639 /* defined in keyboard.c */
1640
1641 extern Lisp_Object Qdisabled;
1642 extern Lisp_Object Vhelp_form, Vtop_level;
1643 extern Lisp_Object Fdiscard_input (), Frecursive_edit ();
1644 extern Lisp_Object Fcommand_execute (), Finput_pending_p ();
1645 extern Lisp_Object menu_bar_items ();
1646 extern Lisp_Object Qvertical_scroll_bar;
1647 #ifdef MULTI_KBOARD
1648 extern void delete_kboard ();
1649 #endif
1650
1651 /* defined in keymap.c */
1652
1653 extern Lisp_Object Qkeymap, Qmenu_bar;
1654 extern Lisp_Object current_global_map;
1655 extern Lisp_Object Fkey_description (), Fsingle_key_description ();
1656 extern Lisp_Object Fwhere_is_internal ();
1657 extern Lisp_Object access_keymap (), store_in_keymap ();
1658 extern Lisp_Object get_keyelt (), get_keymap (), get_keymap_1 ();
1659 extern void describe_map_tree ();
1660
1661 /* defined in indent.c */
1662 extern Lisp_Object Fvertical_motion (), Findent_to (), Fcurrent_column ();
1663
1664 /* defined in window.c */
1665 extern Lisp_Object Qwindowp, Qwindow_live_p;
1666 extern Lisp_Object Fget_buffer_window ();
1667 extern Lisp_Object Fsave_window_excursion ();
1668 extern Lisp_Object Fset_window_configuration (), Fcurrent_window_configuration ();
1669 extern Lisp_Object Fcoordinates_in_window_p ();
1670 extern Lisp_Object Fwindow_at ();
1671 extern int window_internal_height (), window_internal_width ();
1672
1673 /* defined in frame.c */
1674 extern Lisp_Object Qvisible;
1675 extern void store_frame_param (), store_in_alist ();
1676 extern Lisp_Object do_switch_frame ();
1677 extern Lisp_Object get_frame_param();
1678 extern Lisp_Object frame_buffer_predicate ();
1679 extern Lisp_Object Fframep ();
1680 extern Lisp_Object Fselect_frame ();
1681 extern Lisp_Object Ffocus_frame ();
1682 extern Lisp_Object Funfocus_frame ();
1683 extern Lisp_Object Fselected_frame ();
1684 extern Lisp_Object Fwindow_frame ();
1685 extern Lisp_Object Fframe_root_window ();
1686 extern Lisp_Object Fframe_first_window ();
1687 extern Lisp_Object Fframe_selected_window ();
1688 extern Lisp_Object Fframe_list ();
1689 extern Lisp_Object Fnext_frame ();
1690 extern Lisp_Object Fdelete_frame ();
1691 extern Lisp_Object Fread_mouse_position ();
1692 extern Lisp_Object Fset_mouse_position ();
1693 extern Lisp_Object Fmake_frame_visible ();
1694 extern Lisp_Object Fmake_frame_invisible ();
1695 extern Lisp_Object Ficonify_frame ();
1696 extern Lisp_Object Fdeiconify_frame ();
1697 extern Lisp_Object Fframe_visible_p ();
1698 extern Lisp_Object Fvisible_frame_list ();
1699 extern Lisp_Object Fframe_parameters ();
1700 extern Lisp_Object Fmodify_frame_parameters ();
1701 extern Lisp_Object Fframe_pixel_size ();
1702 extern Lisp_Object Fframe_height ();
1703 extern Lisp_Object Fframe_width ();
1704 extern Lisp_Object Fset_frame_height ();
1705 extern Lisp_Object Fset_frame_width ();
1706 extern Lisp_Object Fset_frame_size ();
1707 extern Lisp_Object Fset_frame_position ();
1708
1709 /* defined in emacs.c */
1710 extern Lisp_Object decode_env_path ();
1711 extern Lisp_Object Vinvocation_name, Vinvocation_directory;
1712 extern Lisp_Object Vinstallation_directory;
1713 void shut_down_emacs ( /* int signal, int no_x, Lisp_Object stuff */ );
1714 /* Nonzero means don't do interactive redisplay and don't change tty modes */
1715 extern int noninteractive;
1716 /* Nonzero means don't do use window-system-specific display code */
1717 extern int inhibit_window_system;
1718 /* Nonzero means that a filter or a sentinel is running.  */
1719 extern int running_asynch_code;
1720
1721 /* defined in process.c */
1722 extern Lisp_Object Fget_process (), Fget_buffer_process (), Fprocessp ();
1723 extern Lisp_Object Fprocess_status (), Fkill_process ();
1724 extern Lisp_Object Fprocess_send_eof ();
1725 extern Lisp_Object Fwaiting_for_user_input_p ();
1726 extern Lisp_Object Qprocessp;
1727
1728 /* defined in callproc.c */
1729 extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
1730 extern Lisp_Object Vdoc_directory;
1731
1732 /* defined in doc.c */
1733 extern Lisp_Object Vdoc_file_name;
1734 extern Lisp_Object Fsubstitute_command_keys ();
1735 extern Lisp_Object Fdocumentation (), Fdocumentation_property ();
1736 extern Lisp_Object read_doc_string ();
1737
1738 /* defined in bytecode.c */
1739 extern Lisp_Object Qbytecode;
1740 extern Lisp_Object Fbyte_code ();
1741
1742 /* defined in macros.c */
1743 extern Lisp_Object Qexecute_kbd_macro;
1744 extern Lisp_Object Fexecute_kbd_macro ();
1745
1746 /* defined in undo.c */
1747 extern Lisp_Object Fundo_boundary ();
1748 extern Lisp_Object truncate_undo_list ();
1749
1750 /* defined in textprop.c */
1751 extern Lisp_Object Qmodification_hooks;
1752 extern Lisp_Object Qrear_nonsticky;
1753 extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
1754 extern Lisp_Object Fnext_property_change ();
1755 extern Lisp_Object Fnext_single_property_change ();
1756 extern Lisp_Object Fprevious_single_property_change ();
1757
1758 /* defined in intervals.c */
1759 extern Lisp_Object get_local_map ();
1760
1761 /* defined in xmenu.c */
1762 extern Lisp_Object Fx_popup_menu (), Fx_popup_dialog ();
1763 \f
1764 /* Nonzero means Emacs has already been initialized.
1765    Used during startup to detect startup of dumped Emacs.  */
1766 extern int initialized;
1767
1768 extern int immediate_quit;          /* Nonzero means ^G can quit instantly */
1769
1770 extern void debugger ();
1771
1772 extern char *getenv (), *ctime (), *getwd ();
1773 extern long *xmalloc (), *xrealloc ();
1774 extern void xfree ();
1775
1776 extern char *egetenv ();
1777
1778 /* Set up the name of the machine we're running on.  */
1779 extern void init_system_name ();
1780
1781 /* Some systems (e.g., NT) use a different path separator than Unix,
1782    in addition to a device separator.  Default the path separator
1783    to '/', and don't test for a device separator in IS_ANY_SEP.  */
1784
1785 #ifndef DIRECTORY_SEP
1786 #define DIRECTORY_SEP '/'
1787 #endif
1788 #ifndef IS_DIRECTORY_SEP
1789 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
1790 #endif
1791 #ifndef IS_DEVICE_SEP
1792 #ifndef DEVICE_SEP
1793 #define IS_DEVICE_SEP(_c_) 0
1794 #else
1795 #define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
1796 #endif
1797 #endif
1798 #ifndef IS_ANY_SEP
1799 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
1800 #endif
1801
1802 #ifdef SWITCH_ENUM_BUG
1803 #define SWITCH_ENUM_CAST(x) ((int)(x))
1804 #else
1805 #define SWITCH_ENUM_CAST(x) (x)
1806 #endif