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     Lisp_Object this_command_keys;
 497     Lisp_Object internal_last_event_frame;
 498
 499     /* Vector to GCPRO the frames and windows mentioned in kbd_buffer.
 500
 501        The interrupt-level event handlers will never enqueue an event on a
 502        frame which is not in Vframe_list, and once an event is dequeued,
 503        internal_last_event_frame or the event itself points to the frame.
 504        So that's all fine.
 505
 506        But while the event is sitting in the queue, it's completely
 507        unprotected.  Suppose the user types one command which will run for
 508        a while and then delete a frame, and then types another event at
 509        the frame that will be deleted, before the command gets around to
 510        it.  Suppose there are no references to this frame elsewhere in
 511        Emacs, and a GC occurs before the second event is dequeued.  Now we
 512        have an event referring to a freed frame, which will crash Emacs
 513        when it is dequeued.
 514
 515        Similar things happen when an event on a scroll bar is enqueued; the
 516        window may be deleted while the event is in the queue.
 517
 518        So, we use this vector to protect the frame_or_window field in the
 519        event queue.  That way, they'll be dequeued as dead frames or
 520        windows, but still valid lisp objects.
 521
 522        If perd->kbd_buffer[i].kind != no_event, then
 523          (XVECTOR (perd->kbd_buffer_frame_or_window)->contents[i]
 524           == perd->kbd_buffer[i].frame_or_window.  */
 525     Lisp_Object kbd_buffer_frame_or_window;
 526
 527     /* Circular buffer for pre-read keyboard input.  */
 528     struct input_event *kbd_buffer;
 529
 530     /* Pointer to next available character in kbd_buffer.
 531        If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
 532        This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the the
 533        next available char is in kbd_buffer[0].  */
 534     struct input_event *kbd_fetch_ptr;
 535
 536     /* Pointer to next place to store character in kbd_buffer.  This
 537        may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
 538        character should go in kbd_buffer[0].  */
 539     volatile struct input_event *kbd_store_ptr;
 540
 541     /* The above pair of variables forms a "queue empty" flag.  When we
 542        enqueue a non-hook event, we increment kbd_store_ptr.  When we
 543        dequeue a non-hook event, we increment kbd_fetch_ptr.  We say that
 544        there is input available iff the two counters are not equal.
 545
 546        Why not just have a flag set and cleared by the enqueuing and
 547        dequeuing functions?  Such a flag could be screwed up by interrupts
 548        at inopportune times.  */
 549
 550     int this_command_key_count;
 551
 552     /* Nonzero means echo each character as typed.  */
 553     int immediate_echo;
 554
 555     /* If we have echoed a prompt string specified by the user,
 556        this is its length.  Otherwise this is -1.  */
 557     int echo_after_prompt;
 558
 559     /* Where to append more text to echobuf if we want to.  */
 560     char *echoptr;
 561
 562     /* The text we're echoing in the modeline - partial key sequences,
 563        usually.  '\0'-terminated.  This really shouldn't have a fixed size.  */
 564     char echobuf[ECHOBUFSIZE];
 565   };
 566
 567 #ifdef MULTI_PERDISPLAY
 568 /* The perdisplay object associated with a particular frame.  */
 569 extern PERDISPLAY *get_perdisplay ();
 570
 571 /* The perdisplay object associated with the currently executing command.  */
 572 extern PERDISPLAY *current_perdisplay;
 573
 574 /* A list of all perdisplay objects, linked through next_perdisplay.  */
 575 extern PERDISPLAY *all_perdisplays;
 576 #else
 577 extern PERDISPLAY the_only_perdisplay;
 578 #define get_perdisplay(f) (&the_only_perdisplay)
 579 #define current_perdisplay (&the_only_perdisplay)
 580 #define all_perdisplays (&the_only_perdisplay)
 581 #endif
 582 \f
 583 /* In a cons, the markbit of the car is the gc mark bit */
 584
 585 struct Lisp_Cons
 586   {
 587     Lisp_Object car, cdr;
 588   };
 589
 590 /* Like a cons, but records info on where the text lives that it was read from */
 591 /* This is not really in use now */
 592
 593 struct Lisp_Buffer_Cons
 594   {
 595     Lisp_Object car, cdr;
 596     struct buffer *buffer;
 597     int bufpos;
 598   };
 599
 600 /* In a string or vector, the sign bit of the `size' is the gc mark bit */
 601
 602 struct Lisp_String
 603   {
 604     EMACS_INT size;
 605     DECLARE_INTERVALS           /* `data' field must be last.  */
 606     unsigned char data[1];
 607   };
 608
 609 /* If a struct is made to look like a vector, this macro returns the length
 610    of that vector.  */
 611 #define VECSIZE(type) ((sizeof (type) - (sizeof (struct Lisp_Vector)    \
 612                                          - sizeof (Lisp_Object)))       \
 613                        / sizeof (Lisp_Object))
 614
 615 struct Lisp_Vector
 616   {
 617     EMACS_INT size;
 618     struct Lisp_Vector *next;
 619     Lisp_Object contents[1];
 620   };
 621
 622 /* In a symbol, the markbit of the plist is used as the gc mark bit */
 623
 624 struct Lisp_Symbol
 625   {
 626     struct Lisp_String *name;
 627     Lisp_Object value;
 628     Lisp_Object function;
 629     Lisp_Object plist;
 630     struct Lisp_Symbol *next;   /* -> next symbol in this obarray bucket */
 631   };
 632
 633 /* This structure describes a built-in function.
 634    It is generated by the DEFUN macro only.
 635    defsubr makes it into a Lisp object.
 636
 637    This type is treated in most respects as a pseudovector,
 638    but since we never dynamically allocate or free them,
 639    we don't need a next-vector field.  */
 640
 641 struct Lisp_Subr
 642   {
 643     EMACS_INT size;
 644     Lisp_Object (*function) ();
 645     short min_args, max_args;
 646     char *symbol_name;
 647     char *prompt;
 648     char *doc;
 649   };
 650 \f
 651 /* These structures are used for various misc types.  */
 652
 653 /* A miscellaneous object, when it's on the free list.  */
 654 struct Lisp_Free
 655   {
 656     int type : 16;      /* = Lisp_Misc_Free */
 657     int spacer : 16;
 658     union Lisp_Misc *chain;
 659   };
 660
 661 /* In a marker, the markbit of the chain field is used as the gc mark bit */
 662 struct Lisp_Marker
 663   {
 664     int type : 16;      /* = Lisp_Misc_Marker */
 665     int spacer : 15;
 666     /* 1 means normal insertion at the marker's position
 667        leaves the marker after the inserted text.  */
 668     int insertion_type : 1;
 669     struct buffer *buffer;
 670     Lisp_Object chain;
 671     int bufpos;
 672   };
 673
 674 /* Forwarding pointer to an int variable.
 675    This is allowed only in the value cell of a symbol,
 676    and it means that the symbol's value really lives in the
 677    specified int variable.  */
 678 struct Lisp_Intfwd
 679   {
 680     int type : 16;      /* = Lisp_Misc_Intfwd */
 681     int spacer : 16;
 682     int *intvar;
 683   };
 684
 685 /* Boolean forwarding pointer to an int variable.
 686    This is like Lisp_Intfwd except that the ostensible
 687    "value" of the symbol is t if the int variable is nonzero,
 688    nil if it is zero.  */
 689 struct Lisp_Boolfwd
 690   {
 691     int type : 16;      /* = Lisp_Misc_Boolfwd */
 692     int spacer : 16;
 693     int *boolvar;
 694   };
 695
 696 /* Forwarding pointer to a Lisp_Object variable.
 697    This is allowed only in the value cell of a symbol,
 698    and it means that the symbol's value really lives in the
 699    specified variable.  */
 700 struct Lisp_Objfwd
 701   {
 702     int type : 16;      /* = Lisp_Misc_Objfwd */
 703     int spacer : 16;
 704     Lisp_Object *objvar;
 705   };
 706
 707 /* Like Lisp_Objfwd except that value lives in a slot in the
 708    current buffer.  Value is byte index of slot within buffer.  */
 709 struct Lisp_Buffer_Objfwd
 710   {
 711     int type : 16;      /* = Lisp_Misc_Buffer_Objfwd */
 712     int spacer : 16;
 713     int offset;
 714   };
 715
 716 /* Used in a symbol value cell when the symbol's value is per-buffer.
 717    The actual contents resemble a cons cell which starts a list like this:
 718    (REALVALUE BUFFER CURRENT-ALIST-ELEMENT . DEFAULT-VALUE).
 719
 720    The cons-like structure is for historical reasons; it might be better
 721    to just put these elements into the struct, now.
 722
 723    BUFFER is the last buffer for which this symbol's value was
 724    made up to date.
 725
 726    CURRENT-ALIST-ELEMENT is a pointer to an element of BUFFER's
 727    local_var_alist, that being the element whose car is this
 728    variable.  Or it can be a pointer to the
 729    (CURRENT-ALIST-ELEMENT . DEFAULT-VALUE),
 730    if BUFFER does not have an element in its alist for this
 731    variable (that is, if BUFFER sees the default value of this
 732    variable).
 733
 734    If we want to examine or set the value and BUFFER is current,
 735    we just examine or set REALVALUE.  If BUFFER is not current, we
 736    store the current REALVALUE value into CURRENT-ALIST-ELEMENT,
 737    then find the appropriate alist element for the buffer now
 738    current and set up CURRENT-ALIST-ELEMENT.  Then we set
 739    REALVALUE out of that element, and store into BUFFER.
 740
 741    If we are setting the variable and the current buffer does not
 742    have an alist entry for this variable, an alist entry is
 743    created.
 744
 745    Note that REALVALUE can be a forwarding pointer.  Each time it
 746    is examined or set, forwarding must be done.  Each time we
 747    switch buffers, buffer-local variables which forward into C
 748    variables are swapped immediately, so the C code can assume
 749    that they are always up to date.
 750
 751    Lisp_Misc_Buffer_Local_Value and Lisp_Misc_Some_Buffer_Local_Value
 752    use the same substructure.  The difference is that with the latter,
 753    merely setting the variable while some buffer is current
 754    does not cause that buffer to have its own local value of this variable.
 755    Only make-local-variable does that.  */
 756 struct Lisp_Buffer_Local_Value
 757   {
 758     int type : 16; /* = Lisp_Misc_Buffer_Local_Value
 759                                       or Lisp_Misc_Some_Buffer_Local_Value */
 760     int spacer : 16;
 761     Lisp_Object car, cdr;
 762   };
 763
 764 /* In an overlay object, the mark bit of the plist is used as the GC mark.
 765    START and END are markers in the overlay's buffer, and
 766    PLIST is the overlay's property list.  */
 767 struct Lisp_Overlay
 768   {
 769     int type : 16;      /* = Lisp_Misc_Overlay */
 770     int spacer : 16;
 771     Lisp_Object start, end, plist;
 772   };
 773
 774 /* Like Lisp_Objfwd except that value lives in a slot in the
 775    current perdisplay.  */
 776 struct Lisp_Display_Objfwd
 777   {
 778     int type : 16;      /* = Lisp_Misc_Display_Objfwd */
 779     int spacer : 16;
 780     int offset;
 781   };
 782
 783
 784 union Lisp_Misc
 785   {
 786     int type : 16;
 787     struct Lisp_Free u_free;
 788     struct Lisp_Marker u_marker;
 789     struct Lisp_Intfwd u_intfwd;
 790     struct Lisp_Boolfwd u_boolfwd;
 791     struct Lisp_Objfwd u_objfwd;
 792     struct Lisp_Buffer_Objfwd u_buffer_objfwd;
 793     struct Lisp_Buffer_Local_Value u_buffer_local_value;
 794     struct Lisp_Overlay u_overlay;
 795     struct Lisp_Display_Objfwd u_display_objfwd;
 796   };
 797 \f
 798 #ifdef LISP_FLOAT_TYPE
 799 /* Optional Lisp floating point type */
 800 struct Lisp_Float
 801   {
 802     Lisp_Object type;           /* essentially used for mark-bit
 803                                    and chaining when on free-list */
 804     double data;
 805   };
 806 #endif /* LISP_FLOAT_TYPE */
 807
 808 /* A character, declared with the following typedef, is a member
 809    of some character set associated with the current buffer.  */
 810 #ifndef _UCHAR_T  /* Protect against something in ctab.h on AIX.  */
 811 #define _UCHAR_T
 812 typedef unsigned char UCHAR;
 813 #endif
 814
 815 /* Meanings of slots in a Lisp_Compiled:  */
 816
 817 #define COMPILED_ARGLIST 0
 818 #define COMPILED_BYTECODE 1
 819 #define COMPILED_CONSTANTS 2
 820 #define COMPILED_STACK_DEPTH 3
 821 #define COMPILED_DOC_STRING 4
 822 #define COMPILED_INTERACTIVE 5
 823
 824 /* Flag bits in a character.  These also get used in termhooks.h.
 825    Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
 826    (MUlti-Lingual Emacs) might need 22 bits for the character value
 827    itself, so we probably shouldn't use any bits lower than 0x0400000.  */
 828 #define CHAR_ALT   (0x0400000)
 829 #define CHAR_SUPER (0x0800000)
 830 #define CHAR_HYPER (0x1000000)
 831 #define CHAR_SHIFT (0x2000000)
 832 #define CHAR_CTL   (0x4000000)
 833 #define CHAR_META  (0x8000000)
 834
 835 #ifdef USE_X_TOOLKIT
 836 #ifdef NO_UNION_TYPE
 837 /* Use this for turning a (void *) into a Lisp_Object, as when the
 838    Lisp_Object is passed into a toolkit callback function.  */
 839 #define VOID_TO_LISP(larg,varg) \
 840   do { ((larg) = ((Lisp_Object) (varg))); } while (0)
 841 #define CVOID_TO_LISP VOID_TO_LISP
 842
 843 /* Use this for turning a Lisp_Object into a  (void *), as when the
 844    Lisp_Object is passed into a toolkit callback function.  */
 845 #define LISP_TO_VOID(larg) ((void *) (larg))
 846 #define LISP_TO_CVOID(varg) ((const void *) (larg))
 847
 848 #else /* not NO_UNION_TYPE */
 849 /* Use this for turning a (void *) into a Lisp_Object, as when the
 850   Lisp_Object is passed into a toolkit callback function.  */
 851 #define VOID_TO_LISP(larg,varg) \
 852   do { ((larg).v = (void *) (varg)); } while (0)
 853 #define CVOID_TO_LISP(larg,varg) \
 854   do { ((larg).cv = (const void *) (varg)); } while (0)
 855
 856 /* Use this for turning a Lisp_Object into a  (void *), as when the
 857    Lisp_Object is passed into a toolkit callback function.  */
 858 #define LISP_TO_VOID(larg) ((larg).v)
 859 #define LISP_TO_CVOID(larg) ((larg).cv)
 860 #endif /* not NO_UNION_TYPE */
 861 #endif /* USE_X_TOOLKIT */
 862
 863 \f
 864 /* The glyph datatype, used to represent characters on the display.  */
 865
 866 /* The low eight bits are the character code, and the bits above them
 867    are the numeric face ID.  If FID is the face ID of a glyph on a
 868    frame F, then F->display.x->faces[FID] contains the description of
 869    that face.  This is an int instead of a short, so we can support a
 870    good bunch of face ID's; given that we have no mechanism for
 871    tossing unused frame face ID's yet, we'll probably run out of 255
 872    pretty quickly.  */
 873 #define GLYPH unsigned int
 874
 875 #ifdef HAVE_FACES
 876 /* The FAST macros assume that we already know we're in an X window.  */
 877
 878 /* Given a character code and a face ID, return the appropriate glyph.  */
 879 #define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << 8))
 880
 881 /* Return a glyph's character code.  */
 882 #define FAST_GLYPH_CHAR(glyph) ((glyph) & 0xff)
 883
 884 /* Return a glyph's face ID.  */
 885 #define FAST_GLYPH_FACE(glyph) (((glyph) >> 8) & ((1 << 24) - 1))
 886
 887 /* Slower versions that test the frame type first.  */
 888 #define MAKE_GLYPH(f, char, face) (FRAME_TERMCAP_P (f) ? (char) \
 889                                    : FAST_MAKE_GLYPH (char, face))
 890 #define GLYPH_CHAR(f, g) (FRAME_TERMCAP_P (f) ? (g) : FAST_GLYPH_CHAR (g))
 891 #define GLYPH_FACE(f, g) (FRAME_TERMCAP_P (f) ? (0) : FAST_GLYPH_FACE (g))
 892 #else /* not HAVE_FACES */
 893 #define MAKE_GLYPH(f, char, face) (char)
 894 #define GLYPH_CHAR(f, g) (g)
 895 #define GLYPH_FACE(f, g) (g)
 896 #endif /* not HAVE_FACES */
 897
 898 /* The ID of the mode line highlighting face.  */
 899 #define GLYPH_MODE_LINE_FACE 1
 900 \f
 901 /* Data type checking */
 902
 903 #define NILP(x)  (XFASTINT (x) == XFASTINT (Qnil))
 904 #define GC_NILP(x) GC_EQ (x, Qnil)
 905
 906 #ifdef LISP_FLOAT_TYPE
 907 #define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
 908 #define GC_NUMBERP(x) (GC_INTEGERP (x) || GC_FLOATP (x))
 909 #else
 910 #define NUMBERP(x) (INTEGERP (x))
 911 #define GC_NUMBERP(x) (GC_INTEGERP (x))
 912 #endif
 913 #define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
 914 #define GC_NATNUMP(x) (GC_INTEGERP (x) && XINT (x) >= 0)
 915
 916 #define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
 917 #define GC_INTEGERP(x) (XGCTYPE ((x)) == Lisp_Int)
 918 #define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
 919 #define GC_SYMBOLP(x) (XGCTYPE ((x)) == Lisp_Symbol)
 920 #define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
 921 #define GC_MISCP(x) (XGCTYPE ((x)) == Lisp_Misc)
 922 #define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
 923 #define GC_VECTORLIKEP(x) (XGCTYPE ((x)) == Lisp_Vectorlike)
 924 #define STRINGP(x) (XTYPE ((x)) == Lisp_String)
 925 #define GC_STRINGP(x) (XGCTYPE ((x)) == Lisp_String)
 926 #define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
 927 #define GC_CONSP(x) (XGCTYPE ((x)) == Lisp_Cons)
 928
 929 #ifdef LISP_FLOAT_TYPE
 930 #define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
 931 #define GC_FLOATP(x) (XGCTYPE ((x)) == Lisp_Float)
 932 #else
 933 #define FLOATP(x) (0)
 934 #define GC_FLOATP(x) (0)
 935 #endif
 936 #define VECTORP(x) (VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
 937 #define GC_VECTORP(x) (GC_VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
 938 #define OVERLAYP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Overlay)
 939 #define GC_OVERLAYP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Overlay)
 940 #define MARKERP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Marker)
 941 #define GC_MARKERP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Marker)
 942 #define INTFWDP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Intfwd)
 943 #define GC_INTFWDP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Intfwd)
 944 #define BOOLFWDP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Boolfwd)
 945 #define GC_BOOLFWDP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Boolfwd)
 946 #define OBJFWDP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Objfwd)
 947 #define GC_OBJFWDP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Objfwd)
 948 #define BUFFER_OBJFWDP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Buffer_Objfwd)
 949 #define GC_BUFFER_OBJFWDP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Buffer_Objfwd)
 950 #define BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Buffer_Local_Value)
 951 #define GC_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Buffer_Local_Value)
 952 #define SOME_BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Some_Buffer_Local_Value)
 953 #define GC_SOME_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Some_Buffer_Local_Value)
 954 #define DISPLAY_OBJFWDP(x) (MISCP (x) && XMISC (x)->type == Lisp_Misc_Display_Objfwd)
 955 #define GC_DISPLAY_OBJFWDP(x) (GC_MISCP (x) && XMISC (x)->type == Lisp_Misc_Display_Objfwd)
 956
 957
 958 /* True if object X is a pseudovector whose code is CODE.  */
 959 #define PSEUDOVECTORP(x, code)                                  \
 960   (VECTORLIKEP (x)                                              \
 961    && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code))))     \
 962        == (PSEUDOVECTOR_FLAG | (code))))
 963
 964 /* True if object X is a pseudovector whose code is CODE.
 965    This one works during GC.  */
 966 #define GC_PSEUDOVECTORP(x, code)                               \
 967   (GC_VECTORLIKEP (x)                                           \
 968    && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code))))     \
 969        == (PSEUDOVECTOR_FLAG | (code))))
 970
 971 /* Test for specific pseudovector types.  */
 972 #define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
 973 #define GC_WINDOW_CONFIGURATIONP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
 974 #define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
 975 #define GC_PROCESSP(x) GC_PSEUDOVECTORP (x, PVEC_PROCESS)
 976 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
 977 #define GC_WINDOWP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW)
 978 #define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
 979 #define GC_SUBRP(x) GC_PSEUDOVECTORP (x, PVEC_SUBR)
 980 #define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
 981 #define GC_COMPILEDP(x) GC_PSEUDOVECTORP (x, PVEC_COMPILED)
 982 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
 983 #define GC_BUFFERP(x) GC_PSEUDOVECTORP (x, PVEC_BUFFER)
 984
 985 #ifdef MULTI_FRAME
 986 #define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
 987 #define GC_FRAMEP(x) GC_PSEUDOVECTORP (x, PVEC_FRAME)
 988 #else
 989 #ifdef HAVE_MOUSE
 990 /* We could use this in the !HAVE_MOUSE case also, but we prefer a compile-time
 991    error message in case FRAMEP is used.  */
 992 #define FRAMEP(x) (EQ (x, Fselected_frame ()))
 993 #define GC_FRAMEP(x) (GC_EQ (x, Fselected_frame ()))
 994 #endif
 995 #endif
 996
 997 \f
 998 #define EQ(x, y) (XFASTINT (x) == XFASTINT (y))
 999 #define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y))
1000
1001 #define CHECK_LIST(x, i) \
1002   do { if (!CONSP ((x)) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); } while (0)
1003
1004 #define CHECK_STRING(x, i) \
1005   do { if (!STRINGP ((x))) x = wrong_type_argument (Qstringp, (x)); } while (0)
1006
1007 #define CHECK_CONS(x, i) \
1008   do { if (!CONSP ((x))) x = wrong_type_argument (Qconsp, (x)); } while (0)
1009
1010 #define CHECK_SYMBOL(x, i) \
1011   do { if (!SYMBOLP ((x))) x = wrong_type_argument (Qsymbolp, (x)); } while (0)
1012
1013 #define CHECK_VECTOR(x, i) \
1014   do { if (!VECTORP ((x))) x = wrong_type_argument (Qvectorp, (x)); } while (0)
1015
1016 #define CHECK_BUFFER(x, i) \
1017   do { if (!BUFFERP ((x))) x = wrong_type_argument (Qbufferp, (x)); } while (0)
1018
1019 #define CHECK_WINDOW(x, i) \
1020   do { if (!WINDOWP ((x))) x = wrong_type_argument (Qwindowp, (x)); } while (0)
1021
1022 /* This macro rejects windows on the interior of the window tree as
1023    "dead", which is what we want; this is an argument-checking macro, and
1024    the user should never get access to interior windows.
1025
1026    A window of any sort, leaf or interior, is dead iff the buffer,
1027    vchild, and hchild members are all nil.  */
1028
1029 #define CHECK_LIVE_WINDOW(x, i)                         \
1030   do {                                                  \
1031     if (!WINDOWP ((x))                                  \
1032         || NILP (XWINDOW ((x))->buffer))                \
1033       x = wrong_type_argument (Qwindow_live_p, (x));    \
1034   } while (0)
1035
1036 #define CHECK_PROCESS(x, i) \
1037   do { if (!PROCESSP ((x))) x = wrong_type_argument (Qprocessp, (x)); } while (0)
1038
1039 #define CHECK_NUMBER(x, i) \
1040   do { if (!INTEGERP ((x))) x = wrong_type_argument (Qintegerp, (x)); } while (0)
1041
1042 #define CHECK_NATNUM(x, i) \
1043   do { if (!NATNUMP (x)) x = wrong_type_argument (Qwholenump, (x)); } while (0)
1044
1045 #define CHECK_MARKER(x, i) \
1046   do { if (!MARKERP ((x))) x = wrong_type_argument (Qmarkerp, (x)); } while (0)
1047
1048 #define CHECK_NUMBER_COERCE_MARKER(x, i) \
1049   do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
1050     else if (!INTEGERP ((x))) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } while (0)
1051
1052 #ifdef LISP_FLOAT_TYPE
1053
1054 #ifndef DBL_DIG
1055 #define DBL_DIG 20
1056 #endif
1057
1058 #define XFLOATINT(n) extract_float((n))
1059
1060 #define CHECK_FLOAT(x, i)               \
1061   do { if (!FLOATP (x))                 \
1062     x = wrong_type_argument (Qfloatp, (x)); } while (0)
1063
1064 #define CHECK_NUMBER_OR_FLOAT(x, i)     \
1065   do { if (!FLOATP (x) && !INTEGERP (x))        \
1066     x = wrong_type_argument (Qnumberp, (x)); } while (0)
1067
1068 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x, i) \
1069   do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x));   \
1070   else if (!INTEGERP (x) && !FLOATP (x))                \
1071     x = wrong_type_argument (Qnumber_or_marker_p, (x)); } while (0)
1072
1073 #else  /* Not LISP_FLOAT_TYPE */
1074
1075 #define CHECK_NUMBER_OR_FLOAT CHECK_NUMBER
1076
1077 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER CHECK_NUMBER_COERCE_MARKER
1078
1079 #define XFLOATINT(n) XINT((n))
1080 #endif /* LISP_FLOAT_TYPE */
1081
1082 #define CHECK_OVERLAY(x, i) \
1083   do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
1084
1085 /* Cast pointers to this type to compare them.  Some machines want int.  */
1086 #ifndef PNTR_COMPARISON_TYPE
1087 #define PNTR_COMPARISON_TYPE unsigned int
1088 #endif
1089 \f
1090 /* Define a built-in function for calling from Lisp.
1091  `lname' should be the name to give the function in Lisp,
1092     as a null-terminated C string.
1093  `fnname' should be the name of the function in C.
1094     By convention, it starts with F.
1095  `sname' should be the name for the C constant structure
1096     that records information on this function for internal use.
1097     By convention, it should be the same as `fnname' but with S instead of F.
1098     It's too bad that C macros can't compute this from `fnname'.
1099  `minargs' should be a number, the minimum number of arguments allowed.
1100  `maxargs' should be a number, the maximum number of arguments allowed,
1101     or else MANY or UNEVALLED.
1102     MANY means pass a vector of evaluated arguments,
1103          in the form of an integer number-of-arguments
1104          followed by the address of a vector of Lisp_Objects
1105          which contains the argument values.
1106     UNEVALLED means pass the list of unevaluated arguments
1107  `prompt' says how to read arguments for an interactive call.
1108     See the doc string for `interactive'.
1109     A null string means call interactively with no arguments.
1110  `doc' is documentation for the user.  */
1111
1112 #if !defined (__STDC__) || defined (USE_NONANSI_DEFUN)
1113 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc)      \
1114   Lisp_Object fnname ();                                                \
1115   struct Lisp_Subr sname =                                              \
1116     { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),     \
1117       fnname, minargs, maxargs, lname, prompt, 0};                      \
1118   Lisp_Object fnname
1119
1120 #else
1121
1122 /* This version of DEFUN declares a function prototype with the right
1123    arguments, so we can catch errors with maxargs at compile-time.  */
1124 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc)      \
1125   Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                           \
1126   struct Lisp_Subr sname =                                              \
1127     { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),     \
1128       fnname, minargs, maxargs, lname, prompt, 0};                      \
1129   Lisp_Object fnname
1130
1131 /* Note that the weird token-substitution semantics of ANSI C makes
1132    this work for MANY and UNEVALLED.  */
1133 #define DEFUN_ARGS_MANY         (int, Lisp_Object *)
1134 #define DEFUN_ARGS_UNEVALLED    (Lisp_Object)
1135 #define DEFUN_ARGS_0    (void)
1136 #define DEFUN_ARGS_1    (Lisp_Object)
1137 #define DEFUN_ARGS_2    (Lisp_Object, Lisp_Object)
1138 #define DEFUN_ARGS_3    (Lisp_Object, Lisp_Object, Lisp_Object)
1139 #define DEFUN_ARGS_4    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1140 #define DEFUN_ARGS_5    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1141                          Lisp_Object)
1142 #define DEFUN_ARGS_6    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1143                          Lisp_Object, Lisp_Object)
1144 #define DEFUN_ARGS_7    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1145                          Lisp_Object, Lisp_Object, Lisp_Object)
1146 #endif
1147
1148 /* defsubr (Sname);
1149  is how we define the symbol for function `name' at start-up time.  */
1150 extern void defsubr ();
1151
1152 #define MANY -2
1153 #define UNEVALLED -1
1154
1155 extern void defvar_lisp ();
1156 extern void defvar_bool ();
1157 extern void defvar_int ();
1158 extern void defvar_display ();
1159
1160 /* Macros we use to define forwarded Lisp variables.
1161    These are used in the syms_of_FILENAME functions.  */
1162
1163 #define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
1164 #define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
1165 #define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
1166 #define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
1167 #define DEFVAR_PER_BUFFER(lname, vname, type, doc)  \
1168  defvar_per_buffer (lname, vname, type, 0)
1169 #define DEFVAR_DISPLAY(lname, vname, doc) \
1170  defvar_display (lname, \
1171                  (int)((char *)(&current_perdisplay->vname) \
1172                        - (char *)current_perdisplay))
1173 \f
1174 /* Structure for recording Lisp call stack for backtrace purposes.  */
1175
1176 /* The special binding stack holds the outer values of variables while
1177    they are bound by a function application or a let form, stores the
1178    code to be executed for Lisp unwind-protect forms, and stores the C
1179    functions to be called for record_unwind_protect.
1180
1181    If func is non-zero, undoing this binding applies func to old_value;
1182       This implements record_unwind_protect.
1183    If func is zero and symbol is nil, undoing this binding evaluates
1184       the list of forms in old_value; this implements Lisp's unwind-protect
1185       form.
1186    Otherwise, undoing this binding stores old_value as symbol's value; this
1187       undoes the bindings made by a let form or function call.  */
1188 struct specbinding
1189   {
1190     Lisp_Object symbol, old_value;
1191     Lisp_Object (*func) ();
1192     Lisp_Object unused;         /* Dividing by 16 is faster than by 12 */
1193   };
1194
1195 extern struct specbinding *specpdl;
1196 extern struct specbinding *specpdl_ptr;
1197 extern int specpdl_size;
1198
1199 /* Everything needed to describe an active condition case.  */
1200 struct handler
1201   {
1202     /* The handler clauses and variable from the condition-case form.  */
1203     Lisp_Object handler;
1204     Lisp_Object var;
1205     /* Fsignal stores here the condition-case clause that applies,
1206        and Fcondition_case thus knows which clause to run.  */
1207     Lisp_Object chosen_clause;
1208
1209     /* Used to effect the longjump out to the handler.  */
1210     struct catchtag *tag;
1211
1212     /* The next enclosing handler.  */
1213     struct handler *next;
1214   };
1215
1216 extern struct handler *handlerlist;
1217
1218 extern struct catchtag *catchlist;
1219 extern struct backtrace *backtrace_list;
1220
1221 extern Lisp_Object memory_signal_data;
1222
1223 /* An address near the bottom of the stack.
1224    Tells GC how to save a copy of the stack.  */
1225 extern char *stack_bottom;
1226
1227 /* Check quit-flag and quit if it is non-nil.  */
1228
1229 #define QUIT \
1230   if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
1231     { Vquit_flag = Qnil; Fsignal (Qquit, Qnil); }
1232
1233 /* Nonzero if ought to quit now.  */
1234
1235 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
1236 \f
1237 /* 1 if CH is upper case.  */
1238
1239 #define UPPERCASEP(CH) \
1240   (XSTRING (current_buffer->downcase_table)->data[CH] != (CH))
1241
1242 /* 1 if CH is lower case.  */
1243
1244 #define LOWERCASEP(CH) \
1245   (!UPPERCASEP (CH) \
1246    && XSTRING (current_buffer->upcase_table)->data[CH] != (CH))
1247
1248 /* 1 if CH is neither upper nor lower case.  */
1249
1250 #define NOCASEP(CH) (XSTRING (current_buffer->upcase_table)->data[CH] == (CH))
1251
1252 /* Upcase a character, or make no change if that cannot be done.  */
1253
1254 #define UPCASE(CH) \
1255   (XSTRING (current_buffer->downcase_table)->data[CH] == (CH) \
1256    ? UPCASE1 (CH) : (CH))
1257
1258 /* Upcase a character known to be not upper case.  */
1259
1260 #define UPCASE1(CH) (XSTRING (current_buffer->upcase_table)->data[CH])
1261
1262 /* Downcase a character, or make no change if that cannot be done.  */
1263
1264 #define DOWNCASE(CH) (XSTRING (current_buffer->downcase_table)->data[CH])
1265
1266 /* Current buffer's map from characters to lower-case characters.  */
1267
1268 #define DOWNCASE_TABLE XSTRING (current_buffer->downcase_table)->data
1269
1270 /* Table mapping each char to the next char with the same lowercase version.
1271    This mapping is a no-op only for characters that don't have case.  */
1272 #define UPCASE_TABLE XSTRING (current_buffer->upcase_table)->data
1273
1274 extern Lisp_Object Vascii_downcase_table, Vascii_upcase_table;
1275 extern Lisp_Object Vascii_canon_table, Vascii_eqv_table;
1276 \f
1277 /* Number of bytes of structure consed since last GC.  */
1278
1279 extern int consing_since_gc;
1280
1281 /* Threshold for doing another gc.  */
1282
1283 extern int gc_cons_threshold;
1284
1285 /* Structure for recording stack slots that need marking.  */
1286
1287 /* This is a chain of structures, each of which points at a Lisp_Object variable
1288  whose value should be marked in garbage collection.
1289  Normally every link of the chain is an automatic variable of a function,
1290  and its `val' points to some argument or local variable of the function.
1291  On exit to the function, the chain is set back to the value it had on entry.
1292  This way, no link remains in the chain when the stack frame containing the
1293  link disappears.
1294
1295  Every function that can call Feval must protect in this fashion all
1296  Lisp_Object variables whose contents will be used again.  */
1297
1298 extern struct gcpro *gcprolist;
1299
1300 struct gcpro
1301   {
1302     struct gcpro *next;
1303     Lisp_Object *var;           /* Address of first protected variable */
1304     int nvars;                  /* Number of consecutive protected variables */
1305   };
1306
1307 #define GCPRO1(varname) \
1308  {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
1309   gcprolist = &gcpro1; }
1310
1311 #define GCPRO2(varname1, varname2) \
1312  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1313   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1314   gcprolist = &gcpro2; }
1315
1316 #define GCPRO3(varname1, varname2, varname3) \
1317  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1318   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1319   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1320   gcprolist = &gcpro3; }
1321
1322 #define GCPRO4(varname1, varname2, varname3, varname4) \
1323  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1324   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1325   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1326   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1327   gcprolist = &gcpro4; }
1328
1329 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1330  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1331   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1332   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1333   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1334   gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1335   gcprolist = &gcpro5; }
1336
1337 /* Call staticpro (&var) to protect static variable `var'.  */
1338
1339 void staticpro();
1340
1341 #define UNGCPRO (gcprolist = gcpro1.next)
1342
1343 /* Evaluate expr, UNGCPRO, and then return the value of expr.  */
1344 #define RETURN_UNGCPRO(expr)                    \
1345 if (1)                                          \
1346     {                                           \
1347       Lisp_Object ret_ungc_val;                 \
1348       ret_ungc_val = (expr);                    \
1349       UNGCPRO;                                  \
1350       return ret_ungc_val;                      \
1351     }                                           \
1352 else
1353 \f
1354 /* Defined in data.c */
1355 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
1356 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
1357 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
1358 extern Lisp_Object Qvoid_variable, Qvoid_function;
1359 extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
1360 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
1361 extern Lisp_Object Qend_of_file, Qarith_error;
1362 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
1363 extern Lisp_Object Qmark_inactive;
1364
1365 extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
1366 extern Lisp_Object Qoverflow_error, Qunderflow_error;
1367
1368 extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qwholenump;
1369 extern Lisp_Object Qsymbolp, Qlistp, Qconsp;
1370 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
1371 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp;
1372 extern Lisp_Object Qinteger_or_marker_p, Qnumber_or_marker_p;
1373 extern Lisp_Object Qboundp, Qfboundp;
1374 extern Lisp_Object Qbuffer_or_string_p;
1375 extern Lisp_Object Qcdr;
1376
1377 #ifdef LISP_FLOAT_TYPE
1378 extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
1379 #endif /* LISP_FLOAT_TYPE */
1380
1381 extern Lisp_Object Qframep;
1382
1383 extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp ();
1384 extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp ();
1385 extern Lisp_Object Fvectorp (), Fstringp (), Farrayp (), Fsequencep ();
1386 extern Lisp_Object Fbufferp (), Fmarkerp (), Fsubrp (), Fchar_or_string_p ();
1387 extern Lisp_Object Finteger_or_marker_p ();
1388 #ifdef LISP_FLOAT_TYPE
1389 extern Lisp_Object Ffloatp(), Finteger_or_floatp();
1390 extern Lisp_Object Finteger_or_float_or_marker_p(), Ftruncate();
1391 #endif /* LISP_FLOAT_TYPE */
1392
1393 extern Lisp_Object Fcar (), Fcar_safe(), Fcdr (), Fcdr_safe();
1394 extern Lisp_Object Fsetcar (), Fsetcdr ();
1395 extern Lisp_Object Fboundp (), Ffboundp (), Fmakunbound (), Ffmakunbound ();
1396 extern Lisp_Object Fsymbol_function (), Fsymbol_plist (), Fsymbol_name ();
1397 extern Lisp_Object indirect_function (), Findirect_function ();
1398 extern Lisp_Object Ffset (), Fsetplist ();
1399 extern Lisp_Object Fsymbol_value (), find_symbol_value (), Fset ();
1400 extern Lisp_Object Fdefault_value (), Fset_default (), Fdefault_boundp ();
1401
1402 extern Lisp_Object Faref (), Faset ();
1403
1404 extern Lisp_Object Fstring_to_number (), Fnumber_to_string ();
1405 extern Lisp_Object Feqlsign (), Fgtr (), Flss (), Fgeq (), Fleq ();
1406 extern Lisp_Object Fneq (), Fzerop ();
1407 extern Lisp_Object Fplus (), Fminus (), Ftimes (), Fquo (), Frem ();
1408 extern Lisp_Object Fmax (), Fmin ();
1409 extern Lisp_Object Flogand (), Flogior (), Flogxor (), Flognot ();
1410 extern Lisp_Object Flsh (), Fash ();
1411
1412 extern Lisp_Object Fadd1 (), Fsub1 ();
1413
1414 extern Lisp_Object make_number ();
1415 extern Lisp_Object   long_to_cons ();
1416 extern unsigned long cons_to_long ();
1417 extern void args_out_of_range ();
1418 extern void args_out_of_range_3 ();
1419 extern Lisp_Object wrong_type_argument ();
1420 extern void store_symval_forwarding ();
1421 #ifdef LISP_FLOAT_TYPE
1422 extern Lisp_Object Ffloat_to_int(), Fint_to_float();
1423 extern double extract_float();
1424 extern Lisp_Object make_float ();
1425 extern Lisp_Object Ffloat ();
1426 #endif /* LISP_FLOAT_TYPE */
1427
1428 /* Defined in fns.c */
1429 extern Lisp_Object Qstring_lessp;
1430 extern Lisp_Object Vfeatures;
1431 extern Lisp_Object Fidentity (), Frandom ();
1432 extern Lisp_Object Flength ();
1433 extern Lisp_Object Fappend (), Fconcat (), Fvconcat (), Fcopy_sequence ();
1434 extern Lisp_Object Fsubstring ();
1435 extern Lisp_Object Fnth (), Fnthcdr (), Fmemq (), Fassq (), Fassoc ();
1436 extern Lisp_Object Fmember (), Frassq (), Fdelq (), Fsort ();
1437 extern Lisp_Object Freverse (), Fnreverse (), Fget (), Fput (), Fequal ();
1438 extern Lisp_Object Ffillarray (), Fnconc (), Fmapcar (), Fmapconcat ();
1439 extern Lisp_Object Fy_or_n_p (), do_yes_or_no_p ();
1440 extern Lisp_Object Ffeaturep (), Frequire () , Fprovide ();
1441 extern Lisp_Object concat2 (), nconc2 ();
1442 extern Lisp_Object assq_no_quit ();
1443 extern Lisp_Object Fcopy_alist ();
1444
1445 /* Defined in insdel.c */
1446 extern void move_gap ();
1447 extern void make_gap ();
1448 extern void insert ();
1449 extern void insert_and_inherit ();
1450 extern void insert_1 ();
1451 extern void insert_from_string ();
1452 extern void insert_from_buffer ();
1453 extern void insert_char ();
1454 extern void insert_string ();
1455 extern void insert_before_markers ();
1456 extern void insert_before_markers_and_inherit ();
1457 extern void insert_from_string_before_markers ();
1458 extern void del_range ();
1459 extern void del_range_1 ();
1460 extern void modify_region ();
1461 extern void prepare_to_modify_buffer ();
1462 extern void signal_before_change ();
1463 extern void signal_after_change ();
1464
1465 /* Defined in xdisp.c */
1466 extern void message ();
1467 extern void message1 ();
1468 extern void message1_nolog ();
1469 extern void message2 ();
1470 extern void message2_nolog ();
1471 extern void message_dolog ();
1472 extern void message_log_maybe_newline ();
1473
1474 /* Defined in alloc.c */
1475 extern Lisp_Object Vpurify_flag;
1476 extern Lisp_Object Fcons (), Flist(), Fmake_list (), allocate_misc ();
1477 extern Lisp_Object Fmake_vector (), Fvector (), Fmake_symbol (), Fmake_marker ();
1478 extern Lisp_Object Fmake_string (), build_string (), make_string ();
1479 extern Lisp_Object make_event_array (), make_uninit_string ();
1480 extern Lisp_Object Fpurecopy (), make_pure_string ();
1481 extern Lisp_Object pure_cons (), make_pure_vector ();
1482 extern Lisp_Object Fgarbage_collect ();
1483 extern Lisp_Object Fmake_byte_code ();
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, do
1518    if (!NILP (Vrun_hooks))
1519      call1 (Vrun_hooks, Qmy_funny_hook);  */
1520 extern Lisp_Object Vrun_hooks;
1521 extern Lisp_Object Fand (), For (), Fif (), Fprogn (), Fprog1 (), Fprog2 ();
1522 extern Lisp_Object Fsetq (), Fquote ();
1523 extern Lisp_Object Fuser_variable_p (), Finteractive_p ();
1524 extern Lisp_Object Fdefun (), Flet (), FletX (), Fwhile ();
1525 extern Lisp_Object Fcatch (), Fthrow (), Funwind_protect ();
1526 extern Lisp_Object Fcondition_case (), Fsignal ();
1527 extern Lisp_Object Ffunction_type (), Fautoload (), Fcommandp ();
1528 extern Lisp_Object Feval (), Fapply (), Ffuncall ();
1529 extern Lisp_Object Fglobal_set (), Fglobal_value (), Fbacktrace ();
1530 extern Lisp_Object apply1 (), call0 (), call1 (), call2 (), call3 ();
1531 extern Lisp_Object call4 (), call5 (), call6 ();
1532 extern Lisp_Object Fkill_emacs (), Fkey_binding (), Fsit_for ();
1533 extern Lisp_Object Fdo_auto_save (), Fset_marker ();
1534 extern Lisp_Object apply_lambda ();
1535 extern Lisp_Object internal_catch ();
1536 extern Lisp_Object internal_condition_case ();
1537 extern Lisp_Object internal_condition_case_1 ();
1538 extern Lisp_Object unbind_to ();
1539 extern void error ();
1540 extern Lisp_Object un_autoload ();
1541
1542 /* Defined in editfns.c */
1543 extern Lisp_Object Fgoto_char ();
1544 extern Lisp_Object Fpoint_min_marker (), Fpoint_max_marker ();
1545 extern Lisp_Object Fpoint_min (), Fpoint_max ();
1546 extern Lisp_Object Fpoint (), Fpoint_marker (), Fmark_marker ();
1547 extern Lisp_Object Ffollowing_char (), Fprevious_char (), Fchar_after ();
1548 extern Lisp_Object Finsert ();
1549 extern Lisp_Object Feolp (), Feobp (), Fbolp (), Fbobp ();
1550 extern Lisp_Object Fformat (), format1 ();
1551 extern Lisp_Object make_buffer_string (), Fbuffer_substring ();
1552 extern Lisp_Object Fbuffer_string ();
1553 extern Lisp_Object Fstring_equal (), Fstring_lessp (), Fbuffer_substring_lessp ();
1554 extern Lisp_Object save_excursion_save (), save_restriction_save ();
1555 extern Lisp_Object save_excursion_restore (), save_restriction_restore ();
1556 extern Lisp_Object Fchar_to_string ();
1557
1558 /* defined in buffer.c */
1559 extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
1560 extern Lisp_Object Fget_buffer (), Fget_buffer_create (), Fset_buffer ();
1561 extern Lisp_Object Fbarf_if_buffer_read_only ();
1562 extern Lisp_Object Fcurrent_buffer (), Fswitch_to_buffer (), Fpop_to_buffer ();
1563 extern Lisp_Object Fother_buffer ();
1564 extern Lisp_Object Foverlay_get ();
1565 extern Lisp_Object Qoverlayp;
1566 extern struct buffer *all_buffers;
1567
1568 /* defined in marker.c */
1569
1570 extern Lisp_Object Fmarker_position (), Fmarker_buffer ();
1571 extern Lisp_Object Fcopy_marker ();
1572
1573 /* Defined in fileio.c */
1574
1575 extern Lisp_Object Qfile_error;
1576 extern Lisp_Object Ffind_file_name_handler ();
1577 extern Lisp_Object Ffile_name_as_directory ();
1578 extern Lisp_Object Fexpand_file_name (), Ffile_name_nondirectory ();
1579 extern Lisp_Object Fsubstitute_in_file_name ();
1580 extern Lisp_Object Ffile_symlink_p ();
1581 extern Lisp_Object Fverify_visited_file_modtime ();
1582 extern Lisp_Object Ffile_exists_p ();
1583 extern Lisp_Object Fdirectory_file_name ();
1584 extern Lisp_Object Ffile_name_directory ();
1585 extern Lisp_Object expand_and_dir_to_file ();
1586 extern Lisp_Object Ffile_accessible_directory_p ();
1587 extern Lisp_Object Funhandled_file_name_directory ();
1588
1589 /* Defined in abbrev.c */
1590
1591 extern Lisp_Object Vfundamental_mode_abbrev_table;
1592
1593 /* defined in search.c */
1594 extern Lisp_Object Fstring_match ();
1595 extern Lisp_Object Fscan_buffer ();
1596 extern void restore_match_data ();
1597
1598 /* defined in minibuf.c */
1599
1600 extern Lisp_Object last_minibuf_string;
1601 extern Lisp_Object read_minibuf (), Fcompleting_read ();
1602 extern Lisp_Object Fread_from_minibuffer ();
1603 extern Lisp_Object Fread_variable (), Fread_buffer (), Fread_key_sequence ();
1604 extern Lisp_Object Fread_minibuffer (), Feval_minibuffer ();
1605 extern Lisp_Object Fread_string (), Fread_file_name ();
1606 extern Lisp_Object Fread_no_blanks_input ();
1607
1608 /* Defined in callint.c */
1609
1610 extern Lisp_Object Qminus, Qplus;
1611 extern Lisp_Object Vcommand_history;
1612 extern Lisp_Object Qcall_interactively;
1613 extern Lisp_Object Fcall_interactively ();
1614 extern Lisp_Object Fprefix_numeric_value ();
1615
1616 /* defined in casefiddle.c */
1617
1618 extern Lisp_Object Fdowncase (), Fupcase (), Fcapitalize ();
1619
1620 /* defined in keyboard.c */
1621
1622 extern Lisp_Object Qdisabled;
1623 extern Lisp_Object Vhelp_form, Vtop_level;
1624 extern Lisp_Object Fdiscard_input (), Frecursive_edit ();
1625 extern Lisp_Object Fcommand_execute (), Finput_pending_p ();
1626 extern Lisp_Object Qvertical_scroll_bar;
1627
1628 /* defined in keymap.c */
1629
1630 extern Lisp_Object Qkeymap, Qmenu_bar;
1631 extern Lisp_Object current_global_map;
1632 extern Lisp_Object Fkey_description (), Fsingle_key_description ();
1633 extern Lisp_Object Fwhere_is_internal ();
1634 extern Lisp_Object access_keymap (), store_in_keymap ();
1635 extern Lisp_Object get_keyelt (), get_keymap();
1636
1637 /* defined in indent.c */
1638 extern Lisp_Object Fvertical_motion (), Findent_to (), Fcurrent_column ();
1639
1640 /* defined in window.c */
1641 extern Lisp_Object Qwindowp, Qwindow_live_p;
1642 extern Lisp_Object Fget_buffer_window ();
1643 extern Lisp_Object Fsave_window_excursion ();
1644 extern Lisp_Object Fset_window_configuration (), Fcurrent_window_configuration ();
1645 extern Lisp_Object Fcoordinates_in_window_p ();
1646 extern Lisp_Object Fwindow_at ();
1647 extern int window_internal_height (), window_internal_width ();
1648
1649 /* defined in frame.c */
1650 extern Lisp_Object Qvisible;
1651 extern Lisp_Object Fframep ();
1652 extern Lisp_Object Fselect_frame ();
1653 extern Lisp_Object Ffocus_frame ();
1654 extern Lisp_Object Funfocus_frame ();
1655 extern Lisp_Object Fselected_frame ();
1656 extern Lisp_Object Fwindow_frame ();
1657 extern Lisp_Object Fframe_root_window ();
1658 extern Lisp_Object Fframe_selected_window ();
1659 extern Lisp_Object Fframe_list ();
1660 extern Lisp_Object Fnext_frame ();
1661 extern Lisp_Object Fdelete_frame ();
1662 extern Lisp_Object Fread_mouse_position ();
1663 extern Lisp_Object Fset_mouse_position ();
1664 extern Lisp_Object Fmake_frame_visible ();
1665 extern Lisp_Object Fmake_frame_invisible ();
1666 extern Lisp_Object Ficonify_frame ();
1667 extern Lisp_Object Fdeiconify_frame ();
1668 extern Lisp_Object Fframe_visible_p ();
1669 extern Lisp_Object Fvisible_frame_list ();
1670 extern Lisp_Object Fframe_parameters ();
1671 extern Lisp_Object Fmodify_frame_parameters ();
1672 extern Lisp_Object Fframe_pixel_size ();
1673 extern Lisp_Object Fframe_height ();
1674 extern Lisp_Object Fframe_width ();
1675 extern Lisp_Object Fset_frame_height ();
1676 extern Lisp_Object Fset_frame_width ();
1677 extern Lisp_Object Fset_frame_size ();
1678 extern Lisp_Object Fset_frame_position ();
1679 #ifndef HAVE_X11
1680 extern Lisp_Object Frubber_band_rectangle ();
1681 #endif  /* HAVE_X11 */
1682
1683 /* defined in emacs.c */
1684 extern Lisp_Object decode_env_path ();
1685 extern Lisp_Object Vinvocation_name, Vinvocation_directory;
1686 extern Lisp_Object Vinstallation_directory;
1687 void shut_down_emacs ( /* int signal, int no_x, Lisp_Object stuff */ );
1688 /* Nonzero means don't do interactive redisplay and don't change tty modes */
1689 extern int noninteractive;
1690 /* Nonzero means don't do use window-system-specific display code */
1691 extern int inhibit_window_system;
1692 /* Nonzero means that a filter or a sentinel is running.  */
1693 extern int running_asynch_code;
1694
1695 /* defined in process.c */
1696 extern Lisp_Object Fget_process (), Fget_buffer_process (), Fprocessp ();
1697 extern Lisp_Object Fprocess_status (), Fkill_process ();
1698 extern Lisp_Object Fprocess_send_eof ();
1699
1700 /* defined in callproc.c */
1701 extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
1702 extern Lisp_Object Vdoc_directory;
1703
1704 /* defined in doc.c */
1705 extern Lisp_Object Vdoc_file_name;
1706 extern Lisp_Object Fsubstitute_command_keys ();
1707 extern Lisp_Object Fdocumentation (), Fdocumentation_property ();
1708
1709 /* defined in bytecode.c */
1710 extern Lisp_Object Qbytecode;
1711 extern Lisp_Object Fbyte_code ();
1712
1713 /* defined in macros.c */
1714 extern Lisp_Object Qexecute_kbd_macro;
1715 extern Lisp_Object Fexecute_kbd_macro ();
1716
1717 /* defined in undo.c */
1718 extern Lisp_Object Fundo_boundary ();
1719 extern Lisp_Object truncate_undo_list ();
1720
1721 /* defined in textprop.c */
1722 extern Lisp_Object Qmodification_hooks;
1723 extern Lisp_Object Qrear_nonsticky;
1724 extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
1725 extern Lisp_Object Fnext_property_change ();
1726 extern Lisp_Object Fnext_single_property_change ();
1727
1728 /* Nonzero means Emacs has already been initialized.
1729    Used during startup to detect startup of dumped Emacs.  */
1730 extern int initialized;
1731
1732 extern int immediate_quit;          /* Nonzero means ^G can quit instantly */
1733
1734 extern void debugger ();
1735
1736 extern char *getenv (), *ctime (), *getwd ();
1737 extern long *xmalloc (), *xrealloc ();
1738 extern void xfree ();
1739
1740 extern char *egetenv ();
1741
1742 /* Set up the name of the machine we're running on.  */
1743 extern void init_system_name ();
1744
1745 /* Some systems (e.g., NT) use a different path separator than Unix,
1746    in addition to a device separator.  Default the path separator
1747    to '/', and don't test for a device separator in IS_ANY_SEP.  */
1748
1749 #ifndef DIRECTORY_SEP
1750 #define DIRECTORY_SEP '/'
1751 #endif
1752 #ifndef IS_DIRECTORY_SEP
1753 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
1754 #endif
1755 #ifndef IS_DEVICE_SEP
1756 #ifndef DEVICE_SEP
1757 #define IS_DEVICE_SEP(_c_) 0
1758 #else
1759 #define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
1760 #endif
1761 #endif
1762 #ifndef IS_ANY_SEP
1763 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
1764 #endif
1765
1766 #ifdef SWITCH_ENUM_BUG
1767 #define SWITCH_ENUM_CAST(x) ((int)(x))
1768 #else
1769 #define SWITCH_ENUM_CAST(x) (x)
1770 #endif