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