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