src/lisp.h

   1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
   2    Copyright (C) 1985, 1986, 1987, 1993 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 /* Define the fundamental Lisp data structures */
  22
  23 /* This is the set of Lisp data types */
  24
  25 enum Lisp_Type
  26   {
  27     /* Integer.  XINT(obj) is the integer value. */
  28     Lisp_Int,
  29
  30     /* Symbol.  XSYMBOL (object) points to a struct Lisp_Symbol. */
  31     Lisp_Symbol,
  32
  33     /* Marker (buffer ptr).  XMARKER(object) points to a struct Lisp_Marker. */
  34     Lisp_Marker,
  35
  36     /* String.  XSTRING (object) points to a struct Lisp_String.
  37        The length of the string, and its contents, are stored therein. */
  38     Lisp_String,
  39
  40     /* Vector of Lisp objects.  XVECTOR(object) points to a struct Lisp_Vector.
  41        The length of the vector, and its contents, are stored therein. */
  42     Lisp_Vector,
  43
  44     /* Cons.  XCONS (object) points to a struct Lisp_Cons. */
  45     Lisp_Cons,
  46
  47     /* Byte-compiled function.  A vector of 4 to 6 elements which are the
  48        arglist, bytecode-string, constant vector, stack size,
  49        (optional) doc string, and (optional) interactive spec.  */
  50     Lisp_Compiled,
  51
  52     /* Editor buffer.  XBUFFER(obj) points to a struct buffer.  */
  53     Lisp_Buffer,
  54
  55     /* Built-in function.  XSUBR(obj) points to a struct Lisp_Subr
  56        which describes how to call the function, and its documentation,
  57        as well as pointing to the code. */
  58     Lisp_Subr,
  59
  60     /* Internal value return by subroutines of read.
  61        The user never sees this data type.
  62        Its value is just a number. */
  63     Lisp_Internal,
  64
  65     /* Forwarding pointer to an int variable.
  66        This is allowed only in the value cell of a symbol,
  67        and it means that the symbol's value really lives in the
  68        specified int variable.
  69        XINTPTR(obj) points to the int variable. */
  70     Lisp_Intfwd,
  71
  72     /* Boolean forwarding pointer to an int variable.
  73        This is like Lisp_Intfwd except that the ostensible
  74        "value" of the symbol is t if the int variable is nonzero,
  75        nil if it is zero.  XINTPTR(obj) points to the int variable. */
  76     Lisp_Boolfwd,
  77
  78     /* Object describing a connection to a subprocess.
  79        It points to storage of type  struct Lisp_Process  */
  80     Lisp_Process,
  81
  82     /* Forwarding pointer to a Lisp_Object variable.
  83        This is allowed only in the value cell of a symbol,
  84        and it means that the symbol's value really lives in the
  85        specified variable.
  86        XOBJFWD(obj) points to the Lisp_Object variable. */
  87     Lisp_Objfwd,
  88
  89 #ifdef MULTI_FRAME
  90     /* Pointer to a vector-like object describing a display frame
  91        on which Emacs can display a window hierarchy.  We don't define
  92        this unless MULTI_FRAME is defined; this helps the compiler catch
  93        code that won't work on a non-MULTI_FRAME configuration.  */
  94     Lisp_Frame,
  95 #endif
  96
  97     /* Used when a FILE * value needs to be passed
  98        in an argument of type Lisp_Object.
  99        You must do *(FILE **) XPNTR(obj) to get the value.
 100        The user will never see this data type. */
 101     Lisp_Internal_Stream,
 102
 103     /* Used in a symbol value cell when the symbol's value is per-buffer.
 104        The actual contents are a cons cell which starts a list like this:
 105        (REALVALUE BUFFER CURRENT-ALIST-ELEMENT . DEFAULT-VALUE).
 106
 107        BUFFER is the last buffer for which this symbol's value was
 108        made up to date.
 109
 110        CURRENT-ALIST-ELEMENT is a pointer to an element of BUFFER's
 111        local_var_alist, that being the element whose car is this
 112        variable.  Or it can be a pointer to the
 113        (CURRENT-ALIST-ELEMENT . DEFAULT-VALUE),
 114        if BUFFER does not have an element in its alist for this
 115        variable (that is, if BUFFER sees the default value of this
 116        variable).
 117
 118        If we want to examine or set the value and BUFFER is current,
 119        we just examine or set REALVALUE. If BUFFER is not current, we
 120        store the current REALVALUE value into CURRENT-ALIST-ELEMENT,
 121        then find the appropriate alist element for the buffer now
 122        current and set up CURRENT-ALIST-ELEMENT.  Then we set
 123        REALVALUE out of that element, and store into BUFFER.
 124
 125        If we are setting the variable and the current buffer does not
 126        have an alist entry for this variable, an alist entry is
 127        created.
 128
 129        Note that REALVALUE can be a forwarding pointer.  Each time it
 130        is examined or set, forwarding must be done.  Each time we
 131        switch buffers, buffer-local variables which forward into C
 132        variables are swapped immediately, so the C code can assume
 133        that they are always up to date.  */
 134     Lisp_Buffer_Local_Value,
 135
 136     /* Like Lisp_Buffer_Local_Value with one difference:
 137        merely setting the variable while some buffer is current
 138        does not cause that buffer to have its own local value of this variable.
 139        Only make-local-variable does that.  */
 140     Lisp_Some_Buffer_Local_Value,
 141
 142
 143     /* Like Lisp_Objfwd except that value lives in a slot
 144        in the current buffer.  Value is byte index of slot within buffer */
 145     Lisp_Buffer_Objfwd,
 146
 147     /* In symbol value cell, means var is unbound.
 148        In symbol function cell, means function name is undefined. */
 149     Lisp_Void,
 150
 151     /* Window used for Emacs display.
 152        Data inside looks like a Lisp_Vector.  */
 153     Lisp_Window,
 154
 155     /* Used by save,set,restore-window-configuration */
 156     Lisp_Window_Configuration,
 157
 158 #ifdef LISP_FLOAT_TYPE
 159     Lisp_Float,
 160 #endif /* LISP_FLOAT_TYPE */
 161
 162     /* The overlay type.
 163        An overlay values is actually a retagged cons, the first in a
 164        list of the form
 165            ((START . END) nil . PLIST)
 166        where START and END are markers in the overlay's buffer, and
 167        PLIST is the overlay's property list.  */
 168     Lisp_Overlay
 169   };
 170
 171 #ifndef NO_UNION_TYPE
 172
 173 #ifndef BIG_ENDIAN
 174
 175 /* Definition of Lisp_Object for little-endian machines.  */
 176
 177 typedef
 178 union Lisp_Object
 179   {
 180     /* Used for comparing two Lisp_Objects;
 181        also, positive integers can be accessed fast this way. */
 182     int i;
 183
 184     struct
 185       {
 186         int val: 24;
 187         char type;
 188       } s;
 189     struct
 190       {
 191         unsigned int val: 24;
 192         char type;
 193       } u;
 194     struct
 195       {
 196         unsigned int val: 24;
 197         enum Lisp_Type type: 7;
 198         /* The markbit is not really part of the value of a Lisp_Object,
 199            and is always zero except during garbage collection.  */
 200         unsigned int markbit: 1;
 201       } gu;
 202   }
 203 Lisp_Object;
 204
 205 #else /* If BIG_ENDIAN */
 206
 207 typedef
 208 union Lisp_Object
 209   {
 210     /* Used for comparing two Lisp_Objects;
 211        also, positive integers can be accessed fast this way. */
 212     int i;
 213
 214     struct
 215       {
 216         char type;
 217         int val: 24;
 218       } s;
 219     struct
 220       {
 221         char type;
 222         unsigned int val: 24;
 223       } u;
 224     struct
 225       {
 226         /* The markbit is not really part of the value of a Lisp_Object,
 227            and is always zero except during garbage collection.  */
 228         unsigned int markbit: 1;
 229         enum Lisp_Type type: 7;
 230         unsigned int val: 24;
 231       } gu;
 232   }
 233 Lisp_Object;
 234
 235 #endif /* BIG_ENDIAN */
 236
 237 #endif /* NO_UNION_TYPE */
 238
 239
 240 /* If union type is not wanted, define Lisp_Object as just a number
 241    and define the macros below to extract fields by shifting */
 242
 243 #ifdef NO_UNION_TYPE
 244
 245 #define Lisp_Object int
 246
 247 /* These values are overridden by the m- file on some machines.  */
 248 #ifndef VALBITS
 249 #define VALBITS 24
 250 #endif
 251
 252 #ifndef GCTYPEBITS
 253 #define GCTYPEBITS 7
 254 #endif
 255
 256 #ifndef VALMASK
 257 #define VALMASK ((1<<VALBITS) - 1)
 258 #endif
 259 #define GCTYPEMASK ((1<<GCTYPEBITS) - 1)
 260 #define MARKBIT (1 << (VALBITS + GCTYPEBITS))
 261
 262 #endif /* NO_UNION_TYPE */
 263 \f
 264 /* These macros extract various sorts of values from a Lisp_Object.
 265  For example, if tem is a Lisp_Object whose type is Lisp_Cons,
 266  XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */
 267
 268 #ifdef NO_UNION_TYPE
 269
 270 /* One need to override this if there must be high bits set in data space
 271    (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
 272     on all machines, but would penalise machines which don't need it)
 273  */
 274 #ifndef XTYPE
 275 #define XTYPE(a) ((enum Lisp_Type) ((a) >> VALBITS))
 276 #endif
 277
 278 #ifndef XSETTYPE
 279 #define XSETTYPE(a, b) ((a)  =  XUINT (a) | ((int)(b) << VALBITS))
 280 #endif
 281
 282 /* Use XFASTINT for fast retrieval and storage of integers known
 283   to be positive.  This takes advantage of the fact that Lisp_Int is 0.  */
 284 #define XFASTINT(a) (a)
 285
 286 /* Extract the value of a Lisp_Object as a signed integer.  */
 287
 288 #ifndef XINT   /* Some machines need to do this differently.  */
 289 #define XINT(a) (((a) << (INTBITS-VALBITS)) >> (INTBITS-VALBITS))
 290 #endif
 291
 292 /* Extract the value as an unsigned integer.  This is a basis
 293    for extracting it as a pointer to a structure in storage.  */
 294
 295 #ifndef XUINT
 296 #define XUINT(a) ((a) & VALMASK)
 297 #endif
 298
 299 #ifndef XPNTR
 300 #ifdef HAVE_SHM
 301 /* In this representation, data is found in two widely separated segments.  */
 302 extern int pure_size;
 303 #define XPNTR(a) \
 304   (XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
 305 #else /* not HAVE_SHM */
 306 #ifdef DATA_SEG_BITS
 307 /* This case is used for the rt-pc.
 308    In the diffs I was given, it checked for ptr = 0
 309    and did not adjust it in that case.
 310    But I don't think that zero should ever be found
 311    in a Lisp object whose data type says it points to something.  */
 312 #define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
 313 #else
 314 #define XPNTR(a) XUINT (a)
 315 #endif
 316 #endif /* not HAVE_SHM */
 317 #endif /* no XPNTR */
 318
 319 #ifndef XSETINT
 320 #define XSETINT(a, b)  ((a) = ((a) & ~VALMASK) |  ((b) & VALMASK))
 321 #endif
 322
 323 #ifndef XSETUINT
 324 #define XSETUINT(a, b) XSETINT (a, b)
 325 #endif
 326
 327 #ifndef XSETPNTR
 328 #define XSETPNTR(a, b) XSETINT (a, b)
 329 #endif
 330
 331 #ifndef XSET
 332 #define XSET(var, type, ptr) \
 333    ((var) = ((int)(type) << VALBITS) + ((int) (ptr) & VALMASK))
 334 #endif
 335
 336 /* During garbage collection, XGCTYPE must be used for extracting types
 337  so that the mark bit is ignored.  XMARKBIT accesses the markbit.
 338  Markbits are used only in particular slots of particular structure types.
 339  Other markbits are always zero.
 340  Outside of garbage collection, all mark bits are always zero.  */
 341
 342 #ifndef XGCTYPE
 343 #define XGCTYPE(a) ((enum Lisp_Type) (((a) >> VALBITS) & GCTYPEMASK))
 344 #endif
 345
 346 #if VALBITS + GCTYPEBITS == INTBITS - 1
 347 /* Make XMARKBIT faster if mark bit is sign bit.  */
 348 #ifndef XMARKBIT
 349 #define XMARKBIT(a) ((a) < 0)
 350 #endif
 351 #endif /* markbit is sign bit */
 352
 353 #ifndef XMARKBIT
 354 #define XMARKBIT(a) ((a) & MARKBIT)
 355 #endif
 356
 357 #ifndef XSETMARKBIT
 358 #define XSETMARKBIT(a,b) ((a) = ((a) & ~MARKBIT) | ((b) ? MARKBIT : 0))
 359 #endif
 360
 361 #ifndef XMARK
 362 #define XMARK(a) ((a) |= MARKBIT)
 363 #endif
 364
 365 #ifndef XUNMARK
 366 #define XUNMARK(a) ((a) &= ~MARKBIT)
 367 #endif
 368
 369 #endif /* NO_UNION_TYPE */
 370
 371 #ifndef NO_UNION_TYPE
 372
 373 #define XTYPE(a) ((enum Lisp_Type) (a).u.type)
 374 #define XSETTYPE(a, b) ((a).u.type = (char) (b))
 375
 376 /* Use XFASTINT for fast retrieval and storage of integers known
 377   to be positive.  This takes advantage of the fact that Lisp_Int is 0.  */
 378 #define XFASTINT(a) ((a).i)
 379
 380 #ifdef EXPLICIT_SIGN_EXTEND
 381 /* Make sure we sign-extend; compilers have been known to fail to do so.  */
 382 #define XINT(a) (((a).i << 8) >> 8)
 383 #else
 384 #define XINT(a) ((a).s.val)
 385 #endif /* EXPLICIT_SIGN_EXTEND */
 386
 387 #define XUINT(a) ((a).u.val)
 388 #define XPNTR(a) ((a).u.val)
 389 #define XSETINT(a, b) ((a).s.val = (int) (b))
 390 #define XSETUINT(a, b) ((a).s.val = (int) (b))
 391 #define XSETPNTR(a, b) ((a).s.val = (int) (b))
 392
 393 #define XSET(var, vartype, ptr) \
 394    (((var).s.type = ((char) (vartype))), ((var).s.val = ((int) (ptr))))
 395
 396 /* During garbage collection, XGCTYPE must be used for extracting types
 397  so that the mark bit is ignored.  XMARKBIT access the markbit.
 398  Markbits are used only in particular slots of particular structure types.
 399  Other markbits are always zero.
 400  Outside of garbage collection, all mark bits are always zero.  */
 401
 402 #define XGCTYPE(a) ((a).gu.type)
 403 #define XMARKBIT(a) ((a).gu.markbit)
 404 #define XSETMARKBIT(a,b) (XMARKBIT(a) = (b))
 405 #define XMARK(a) (XMARKBIT(a) = 1)
 406 #define XUNMARK(a) (XMARKBIT(a) = 0)
 407
 408 #endif /* NO_UNION_TYPE */
 409
 410
 411 #define XCONS(a) ((struct Lisp_Cons *) XPNTR(a))
 412 #define XBUFFER(a) ((struct buffer *) XPNTR(a))
 413 #define XVECTOR(a) ((struct Lisp_Vector *) XPNTR(a))
 414 #define XSUBR(a) ((struct Lisp_Subr *) XPNTR(a))
 415 #define XSTRING(a) ((struct Lisp_String *) XPNTR(a))
 416 #define XSYMBOL(a) ((struct Lisp_Symbol *) XPNTR(a))
 417 #define XFUNCTION(a) ((Lisp_Object (*)()) XPNTR(a))
 418 #define XMARKER(a) ((struct Lisp_Marker *) XPNTR(a))
 419 #define XOBJFWD(a) ((Lisp_Object *) XPNTR(a))
 420 #define XINTPTR(a) ((int *) XPNTR(a))
 421 #define XWINDOW(a) ((struct window *) XPNTR(a))
 422 #define XPROCESS(a) ((struct Lisp_Process *) XPNTR(a))
 423 #define XFLOAT(a) ((struct Lisp_Float *) XPNTR(a))
 424
 425 #define XSETCONS(a, b) XSETPNTR(a, (int) (b))
 426 #define XSETBUFFER(a, b) XSETPNTR(a, (int) (b))
 427 #define XSETVECTOR(a, b) XSETPNTR(a, (int) (b))
 428 #define XSETSUBR(a, b) XSETPNTR(a, (int) (b))
 429 #define XSETSTRING(a, b) XSETPNTR(a, (int) (b))
 430 #define XSETSYMBOL(a, b) XSETPNTR(a, (int) (b))
 431 #define XSETFUNCTION(a, b) XSETPNTR(a, (int) (b))
 432 #define XSETMARKER(a, b) XSETPNTR(a, (int) (b))
 433 #define XSETOBJFWD(a, b) XSETPNTR(a, (int) (b))
 434 #define XSETINTPTR(a, b) XSETPNTR(a, (int) (b))
 435 #define XSETWINDOW(a, b) XSETPNTR(a, (int) (b))
 436 #define XSETPROCESS(a, b) XSETPNTR(a, (int) (b))
 437 #define XSETFLOAT(a, b) XSETPNTR(a, (int) (b))
 438 \f
 439 #ifdef USE_TEXT_PROPERTIES
 440 /* Basic data type for use of intervals.  See the macros in intervals.h */
 441
 442 struct interval
 443 {
 444   /* The first group of entries deal with the tree structure. */
 445
 446   unsigned int total_length;    /* Length of myself and both children. */
 447   unsigned int position;        /* Cache of interval's character position  */
 448   struct interval *left;        /* Intervals which precede me. */
 449   struct interval *right;       /* Intervals which succeed me. */
 450
 451   /* Parent in the tree, or the Lisp_Object containing this interval tree.
 452
 453      The mark bit on the root interval of an interval tree says
 454      whether we have started (and possibly finished) marking the
 455      tree.  If GC comes across an interval tree whose root's parent
 456      field has its markbit set, it leaves the tree alone.
 457
 458      You'd think we could store this information in the parent object
 459      somewhere (after all, that should be visited once and then
 460      ignored too, right?), but strings are GC'd strangely.  */
 461   struct interval *parent;
 462
 463   /* The remaining components are `properties' of the interval.
 464      The first four are duplicates for things which can be on the list,
 465      for purposes of speed. */
 466
 467   unsigned char write_protect;      /* Non-zero means can't modify.  */
 468   unsigned char visible;            /* Zero means don't display. */
 469   unsigned char front_sticky;       /* Non-zero means text inserted just
 470                                        before this interval goes into it. */
 471   unsigned char rear_sticky;        /* Likewise for just after it. */
 472
 473   /* Properties of this interval.
 474      The mark bit on this field says whether this particular interval
 475      tree node has been visited.  Since intervals should never be
 476      shared, GC aborts if it seems to have visited an interval twice.  */
 477   Lisp_Object plist;
 478 };
 479
 480 typedef struct interval *INTERVAL;
 481
 482 /* Complain if object is not string or buffer type */
 483 #define CHECK_STRING_OR_BUFFER(x, i) \
 484   { if (XTYPE ((x)) != Lisp_String && XTYPE ((x)) != Lisp_Buffer) \
 485       x = wrong_type_argument (Qbuffer_or_string_p, (x)); }
 486
 487 /* Macro used to conditionally compile intervals into certain data
 488    structures.  See, e.g., struct Lisp_String below. */
 489 #define DECLARE_INTERVALS INTERVAL intervals;
 490
 491 /* Macro used to conditionally compile interval initialization into
 492    certain code.  See, e.g., alloc.c. */
 493 #define INITIALIZE_INTERVAL(ptr,val) ptr->intervals = val
 494
 495 #else  /* No text properties */
 496
 497 /* If no intervals are used, make the above definitions go away. */
 498
 499 #define CHECK_STRING_OR_BUFFER(x, i)
 500
 501 #define INTERVAL
 502 #define DECLARE_INTERVALS
 503 #define INITIALIZE_INTERVAL(ptr,val)
 504
 505 #endif /* USE_TEXT_PROPERTIES */
 506 \f
 507 /* In a cons, the markbit of the car is the gc mark bit */
 508
 509 struct Lisp_Cons
 510   {
 511     Lisp_Object car, cdr;
 512   };
 513
 514 /* Like a cons, but records info on where the text lives that it was read from */
 515 /* This is not really in use now */
 516
 517 struct Lisp_Buffer_Cons
 518   {
 519     Lisp_Object car, cdr;
 520     struct buffer *buffer;
 521     int bufpos;
 522   };
 523
 524 /* In a string or vector, the sign bit of the `size' is the gc mark bit */
 525
 526 struct Lisp_String
 527   {
 528     int size;
 529     DECLARE_INTERVALS           /* `data' field must be last. */
 530     unsigned char data[1];
 531   };
 532
 533 struct Lisp_Vector
 534   {
 535     int size;
 536     struct Lisp_Vector *next;
 537     Lisp_Object contents[1];
 538   };
 539
 540 /* In a symbol, the markbit of the plist is used as the gc mark bit */
 541
 542 struct Lisp_Symbol
 543   {
 544     struct Lisp_String *name;
 545     Lisp_Object value;
 546     Lisp_Object function;
 547     Lisp_Object plist;
 548     struct Lisp_Symbol *next;   /* -> next symbol in this obarray bucket */
 549   };
 550
 551 struct Lisp_Subr
 552   {
 553     Lisp_Object (*function) ();
 554     short min_args, max_args;
 555     char *symbol_name;
 556     char *prompt;
 557     char *doc;
 558   };
 559
 560 /* In a marker, the markbit of the chain field is used as the gc mark bit */
 561
 562 struct Lisp_Marker
 563   {
 564     struct buffer *buffer;
 565     Lisp_Object chain;
 566     int bufpos;
 567     int modified;
 568   };
 569
 570 #ifdef LISP_FLOAT_TYPE
 571 /* Optional Lisp floating point type */
 572 struct Lisp_Float
 573   {
 574     Lisp_Object type;           /* essentially used for mark-bit
 575                                    and chaining when on free-list */
 576     double data;
 577   };
 578 #endif /* LISP_FLOAT_TYPE */
 579
 580 /* A character, declared with the following typedef, is a member
 581    of some character set associated with the current buffer. */
 582 #ifndef _UCHAR_T  /* Protect against something in ctab.h on AIX.  */
 583 #define _UCHAR_T
 584 typedef unsigned char UCHAR;
 585 #endif
 586
 587 /* Meanings of slots in a Lisp_Compiled:  */
 588
 589 #define COMPILED_ARGLIST 0
 590 #define COMPILED_BYTECODE 1
 591 #define COMPILED_CONSTANTS 2
 592 #define COMPILED_STACK_DEPTH 3
 593 #define COMPILED_DOC_STRING 4
 594 #define COMPILED_INTERACTIVE 5
 595
 596 /* Flag bits in a character.  These also get used in termhooks.h.
 597    Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
 598    (MUlti-Lingual Emacs) might need 18 bits for the character value
 599    itself, so we probably shouldn't use any bits lower than 0x040000.  */
 600 #define CHAR_ALT   (0x040000)
 601 #define CHAR_SUPER (0x080000)
 602 #define CHAR_HYPER (0x100000)
 603 #define CHAR_SHIFT (0x200000)
 604 #define CHAR_CTL   (0x400000)
 605 #define CHAR_META  (0x800000)
 606
 607 \f
 608 /* The glyph datatype, used to represent characters on the display.  */
 609
 610 /* The low eight bits are the character code, and the bits above them
 611    are the numeric face ID.  If FID is the face ID of a glyph on a
 612    frame F, then F->display.x->faces[FID] contains the description of
 613    that face.  This is an int instead of a short, so we can support a
 614    good bunch of face ID's; given that we have no mechanism for
 615    tossing unused frame face ID's yet, we'll probably run out of 255
 616    pretty quickly.  */
 617 #define GLYPH unsigned int
 618
 619 /* Given a character code and a face ID, return the appropriate glyph.  */
 620 #define MAKE_GLYPH(char, face) ((char) | ((face) << 8))
 621
 622 /* Return a glyph's character code.  */
 623 #define GLYPH_CHAR(glyph) ((glyph) & 0xff)
 624
 625 /* Return a glyph's face ID.  */
 626 #define GLYPH_FACE(glyph) (((glyph) >> 8) & ((1 << 24) - 1))
 627
 628 \f
 629 /* Data type checking */
 630
 631 #define NILP(x)  (XFASTINT (x) == XFASTINT (Qnil))
 632 #define GC_NILP(x) GC_EQ (x, Qnil)
 633
 634 #ifdef LISP_FLOAT_TYPE
 635 #define NUMBERP(x) (XTYPE (x) == Lisp_Int || XTYPE (x) == Lisp_Float)
 636 #else
 637 #define NUMBERP(x) (XTYPE (x) == Lisp_Int)
 638 #endif
 639
 640 #define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
 641 #define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
 642 #define MARKERP(x) (XTYPE ((x)) == Lisp_Marker)
 643 #define STRINGP(x) (XTYPE ((x)) == Lisp_String)
 644 #define VECTORP(x) (XTYPE ((x)) == Lisp_Vector)
 645 #define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
 646 #define COMPILEDP(x) (XTYPE ((x)) == Lisp_Compiled)
 647 #define BUFFERP(x) (XTYPE ((x)) == Lisp_Buffer)
 648 #define SUBRP(x) (XTYPE ((x)) == Lisp_Subr)
 649 #define PROCESSP(x) (XTYPE ((x)) == Lisp_Process)
 650 #define FRAMEP(x) (XTYPE ((x)) == Lisp_Frame)
 651 #define WINDOWP(x) (XTYPE ((x)) == Lisp_Window)
 652 #define WINDOW_CONFIGURATIONP(x) (XTYPE ((x)) == Lisp_Window_Configuration)
 653 #ifdef LISP_FLOAT_TYPE
 654 #define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
 655 #else
 656 #define FLOATP(x) (0)
 657 #endif
 658 #define OVERLAYP(x) (XTYPE ((x)) == Lisp_Overlay)
 659
 660 #define EQ(x, y) (XFASTINT (x) == XFASTINT (y))
 661 #define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y))
 662
 663 #define CHECK_LIST(x, i) \
 664   do { if ((XTYPE ((x)) != Lisp_Cons) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); } while (0)
 665
 666 #define CHECK_STRING(x, i) \
 667   do { if (XTYPE ((x)) != Lisp_String) x = wrong_type_argument (Qstringp, (x)); } while (0)
 668
 669 #define CHECK_CONS(x, i) \
 670   do { if (XTYPE ((x)) != Lisp_Cons) x = wrong_type_argument (Qconsp, (x)); } while (0)
 671
 672 #define CHECK_SYMBOL(x, i) \
 673   do { if (XTYPE ((x)) != Lisp_Symbol) x = wrong_type_argument (Qsymbolp, (x)); } while (0)
 674
 675 #define CHECK_VECTOR(x, i) \
 676   do { if (XTYPE ((x)) != Lisp_Vector) x = wrong_type_argument (Qvectorp, (x)); } while (0)
 677
 678 #define CHECK_BUFFER(x, i) \
 679   do { if (XTYPE ((x)) != Lisp_Buffer) x = wrong_type_argument (Qbufferp, (x)); } while (0)
 680
 681 #define CHECK_WINDOW(x, i) \
 682   do { if (XTYPE ((x)) != Lisp_Window) x = wrong_type_argument (Qwindowp, (x)); } while (0)
 683
 684 /* This macro rejects windows on the interior of the window tree as
 685    "dead", which is what we want; this is an argument-checking macro, and
 686    the user should never get access to interior windows.
 687
 688    A window of any sort, leaf or interior, is dead iff the buffer,
 689    vchild, and hchild members are all nil.  */
 690
 691 #define CHECK_LIVE_WINDOW(x, i)                         \
 692   do {                                                  \
 693     if (XTYPE ((x)) != Lisp_Window                      \
 694         || NILP (XWINDOW ((x))->buffer))                \
 695       x = wrong_type_argument (Qwindow_live_p, (x));    \
 696   } while (0)
 697
 698 #define CHECK_PROCESS(x, i) \
 699   do { if (XTYPE ((x)) != Lisp_Process) x = wrong_type_argument (Qprocessp, (x)); } while (0)
 700
 701 #define CHECK_NUMBER(x, i) \
 702   do { if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qintegerp, (x)); } while (0)
 703
 704 #define CHECK_NATNUM(x, i) \
 705   do { if (XTYPE ((x)) != Lisp_Int || XINT ((x)) < 0)   \
 706       x = wrong_type_argument (Qnatnump, (x)); } while (0)
 707
 708 #define CHECK_MARKER(x, i) \
 709   do { if (XTYPE ((x)) != Lisp_Marker) x = wrong_type_argument (Qmarkerp, (x)); } while (0)
 710
 711 #define CHECK_NUMBER_COERCE_MARKER(x, i) \
 712   do { if (XTYPE ((x)) == Lisp_Marker) XFASTINT (x) = marker_position (x); \
 713     else if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } while (0)
 714
 715 #ifdef LISP_FLOAT_TYPE
 716
 717 #ifndef DBL_DIG
 718 #define DBL_DIG 20
 719 #endif
 720
 721 #define XFLOATINT(n) extract_float((n))
 722
 723 #define CHECK_FLOAT(x, i)               \
 724   do { if (XTYPE (x) != Lisp_Float)     \
 725     x = wrong_type_argument (Qfloatp, (x)); } while (0)
 726
 727 #define CHECK_NUMBER_OR_FLOAT(x, i)     \
 728   do { if (XTYPE (x) != Lisp_Float && XTYPE (x) != Lisp_Int)    \
 729     x = wrong_type_argument (Qnumberp, (x)); } while (0)
 730
 731 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x, i) \
 732   do { if (XTYPE (x) == Lisp_Marker) XFASTINT (x) = marker_position (x);        \
 733   else if (XTYPE (x) != Lisp_Int && XTYPE (x) != Lisp_Float)            \
 734     x = wrong_type_argument (Qnumber_or_marker_p, (x)); } while (0)
 735
 736 #else  /* Not LISP_FLOAT_TYPE */
 737
 738 #define CHECK_NUMBER_OR_FLOAT CHECK_NUMBER
 739
 740 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER CHECK_NUMBER_COERCE_MARKER
 741
 742 #define XFLOATINT(n) XINT((n))
 743 #endif /* LISP_FLOAT_TYPE */
 744
 745 #define CHECK_OVERLAY(x, i) \
 746   do { if (XTYPE ((x)) != Lisp_Overlay) x = wrong_type_argument (Qoverlayp, (x));} while (0)
 747
 748 /* Cast pointers to this type to compare them.  Some machines want int.  */
 749 #ifndef PNTR_COMPARISON_TYPE
 750 #define PNTR_COMPARISON_TYPE unsigned int
 751 #endif
 752 \f
 753 /* Define a built-in function for calling from Lisp.
 754  `lname' should be the name to give the function in Lisp,
 755     as a null-terminated C string.
 756  `fnname' should be the name of the function in C.
 757     By convention, it starts with F.
 758  `sname' should be the name for the C constant structure
 759     that records information on this function for internal use.
 760     By convention, it should be the same as `fnname' but with S instead of F.
 761     It's too bad that C macros can't compute this from `fnname'.
 762  `minargs' should be a number, the minimum number of arguments allowed.
 763  `maxargs' should be a number, the maximum number of arguments allowed,
 764     or else MANY or UNEVALLED.
 765     MANY means pass a vector of evaluated arguments,
 766          in the form of an integer number-of-arguments
 767          followed by the address of a vector of Lisp_Objects
 768          which contains the argument values.
 769     UNEVALLED means pass the list of unevaluated arguments
 770  `prompt' says how to read arguments for an interactive call.
 771     This can be zero or a C string.
 772     Zero means that interactive calls are not allowed.
 773     A string is interpreted in a hairy way:
 774      it should contain one line for each argument to be read, terminated by \n.
 775      The first character of the line controls the type of parsing:
 776        s  --  read a string.
 777        S  --  read a symbol.
 778        k  --  read a key sequence and return it as a string.
 779        a  --  read a function name (symbol) with completion.
 780        C  --  read a command name (symbol) with completion.
 781        v  --  read a variable name (symbol) with completion.
 782        b  --  read a buffer name (a string) with completion.
 783        B  --  buffer name, may be existing buffer or may not be.
 784        f  --  read a file name, file must exist.
 785        F  --  read a file name, file need not exist.
 786        n  --  read a number.
 787        c  --  read a character and return it as a number.
 788        p  --  use the numeric value of the prefix argument.
 789        P  --  use raw value of prefix - can be nil, -, (NUMBER) or NUMBER.
 790        x  --  read a Lisp object from the minibuffer.
 791        X  --  read a Lisp form from the minibuffer and use its value.
 792     A null string means call interactively with no arguments.
 793  `doc' is documentation for the user.
 794 */
 795
 796 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
 797   Lisp_Object fnname (); \
 798   struct Lisp_Subr sname = {fnname, minargs, maxargs, lname, prompt, 0}; \
 799   Lisp_Object fnname
 800
 801 /* defsubr (Sname);
 802  is how we define the symbol for function `name' at start-up time. */
 803 extern void defsubr ();
 804
 805 #define MANY -2
 806 #define UNEVALLED -1
 807
 808 extern void defvar_lisp ();
 809 extern void defvar_bool ();
 810 extern void defvar_int ();
 811
 812 /* Macros we use to define forwarded Lisp variables.
 813    These are used in the syms_of_FILENAME functions.  */
 814
 815 #define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
 816 #define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
 817 #define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
 818 #define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
 819 #define DEFVAR_PER_BUFFER(lname, vname, type, doc)  \
 820  defvar_per_buffer (lname, vname, type, 0)
 821 \f
 822 /* Structure for recording Lisp call stack for backtrace purposes.  */
 823
 824 /* The special binding stack holds the outer values of variables while
 825    they are bound by a function application or a let form, stores the
 826    code to be executed for Lisp unwind-protect forms, and stores the C
 827    functions to be called for record_unwind_protect.
 828
 829    If func is non-zero, undoing this binding applies func to old_value;
 830       This implements record_unwind_protect.
 831    If func is zero and symbol is nil, undoing this binding evaluates
 832       the list of forms in old_value; this implements Lisp's unwind-protect
 833       form.
 834    Otherwise, undoing this binding stores old_value as symbol's value; this
 835       undoes the bindings made by a let form or function call.  */
 836 struct specbinding
 837   {
 838     Lisp_Object symbol, old_value;
 839     Lisp_Object (*func) ();
 840     Lisp_Object unused;         /* Dividing by 16 is faster than by 12 */
 841   };
 842
 843 extern struct specbinding *specpdl;
 844 extern struct specbinding *specpdl_ptr;
 845 extern int specpdl_size;
 846
 847 /* Everything needed to describe an active condition case.  */
 848 struct handler
 849   {
 850     /* The handler clauses and variable from the condition-case form.  */
 851     Lisp_Object handler;
 852     Lisp_Object var;
 853
 854     /* Used to effect the longjump out to the handler.  */
 855     struct catchtag *tag;
 856
 857     /* The next enclosing handler.  */
 858     struct handler *next;
 859   };
 860
 861 extern struct handler *handlerlist;
 862
 863 extern struct catchtag *catchlist;
 864 extern struct backtrace *backtrace_list;
 865
 866 /* An address near the bottom of the stack.
 867    Tells GC how to save a copy of the stack.  */
 868 extern char *stack_bottom;
 869
 870 /* Check quit-flag and quit if it is non-nil. */
 871
 872 #define QUIT \
 873   if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
 874     { Vquit_flag = Qnil; Fsignal (Qquit, Qnil); }
 875
 876 /* Nonzero if ought to quit now.  */
 877
 878 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
 879 \f
 880 /* 1 if CH is upper case.  */
 881
 882 #define UPPERCASEP(CH) \
 883   (XSTRING (current_buffer->downcase_table)->data[CH] != (CH))
 884
 885 /* 1 if CH is lower case.  */
 886
 887 #define LOWERCASEP(CH) \
 888   (!UPPERCASEP (CH) \
 889    && XSTRING (current_buffer->upcase_table)->data[CH] != (CH))
 890
 891 /* 1 if CH is neither upper nor lower case.  */
 892
 893 #define NOCASEP(CH) (XSTRING (current_buffer->upcase_table)->data[CH] == (CH))
 894
 895 /* Upcase a character, or make no change if that cannot be done.  */
 896
 897 #define UPCASE(CH) \
 898   (XSTRING (current_buffer->downcase_table)->data[CH] == (CH) \
 899    ? UPCASE1 (CH) : (CH))
 900
 901 /* Upcase a character known to be not upper case.  */
 902
 903 #define UPCASE1(CH) (XSTRING (current_buffer->upcase_table)->data[CH])
 904
 905 /* Downcase a character, or make no change if that cannot be done. */
 906
 907 #define DOWNCASE(CH) (XSTRING (current_buffer->downcase_table)->data[CH])
 908
 909 /* Current buffer's map from characters to lower-case characters.  */
 910
 911 #define DOWNCASE_TABLE XSTRING (current_buffer->downcase_table)->data
 912
 913 /* Table mapping each char to the next char with the same lowercase version.
 914    This mapping is a no-op only for characters that don't have case.  */
 915 #define UPCASE_TABLE XSTRING (current_buffer->upcase_table)->data
 916
 917 extern Lisp_Object Vascii_downcase_table, Vascii_upcase_table;
 918 \f
 919 /* number of bytes of structure consed since last GC */
 920
 921 extern int consing_since_gc;
 922
 923 /* threshold for doing another gc */
 924
 925 extern int gc_cons_threshold;
 926
 927 /* Structure for recording stack slots that need marking */
 928
 929 /* This is a chain of structures, each of which points at a Lisp_Object variable
 930  whose value should be marked in garbage collection.
 931  Normally every link of the chain is an automatic variable of a function,
 932  and its `val' points to some argument or local variable of the function.
 933  On exit to the function, the chain is set back to the value it had on entry.
 934  This way, no link remains in the chain when the stack frame containing the link disappears.
 935
 936  Every function that can call Feval must protect in this fashion all
 937  Lisp_Object variables whose contents will be used again. */
 938
 939 extern struct gcpro *gcprolist;
 940
 941 struct gcpro
 942   {
 943     struct gcpro *next;
 944     Lisp_Object *var;           /* Address of first protected variable */
 945     int nvars;                  /* Number of consecutive protected variables */
 946   };
 947
 948 #define GCPRO1(varname) \
 949  {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
 950   gcprolist = &gcpro1; }
 951
 952 #define GCPRO2(varname1, varname2) \
 953  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
 954   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
 955   gcprolist = &gcpro2; }
 956
 957 #define GCPRO3(varname1, varname2, varname3) \
 958  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
 959   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
 960   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
 961   gcprolist = &gcpro3; }
 962
 963 #define GCPRO4(varname1, varname2, varname3, varname4) \
 964  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
 965   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
 966   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
 967   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
 968   gcprolist = &gcpro4; }
 969
 970 /* Call staticpro (&var) to protect static variable `var'. */
 971
 972 void staticpro();
 973
 974 #define UNGCPRO (gcprolist = gcpro1.next)
 975
 976 /* Evaluate expr, UNGCPRO, and then return the value of expr.  I used
 977    to have a `do ... while' clause around this to make it interact
 978    with semicolons correctly, but this makes some compilers complain
 979    that the while is never reached.  */
 980 #define RETURN_UNGCPRO(expr)            \
 981     {                                   \
 982       Lisp_Object ret_ungc_val;         \
 983       ret_ungc_val = (expr);            \
 984       UNGCPRO;                          \
 985       return ret_ungc_val;              \
 986     }                                   \
 987 \f
 988 /* Defined in data.c */
 989 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
 990 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
 991 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
 992 extern Lisp_Object Qvoid_variable, Qvoid_function;
 993 extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
 994 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
 995 extern Lisp_Object Qend_of_file, Qarith_error;
 996 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
 997 extern Lisp_Object Qmark_inactive;
 998
 999 extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
1000 extern Lisp_Object Qoverflow_error, Qunderflow_error;
1001
1002 extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qsymbolp, Qlistp, Qconsp;
1003 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
1004 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp;
1005 extern Lisp_Object Qinteger_or_marker_p, Qnumber_or_marker_p;
1006 extern Lisp_Object Qboundp, Qfboundp;
1007 extern Lisp_Object Qbuffer_or_string_p;
1008 extern Lisp_Object Qcdr;
1009
1010 #ifdef LISP_FLOAT_TYPE
1011 extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
1012 #endif /* LISP_FLOAT_TYPE */
1013
1014 extern Lisp_Object Qframep;
1015
1016 extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp ();
1017 extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp ();
1018 extern Lisp_Object Fvectorp (), Fstringp (), Farrayp (), Fsequencep ();
1019 extern Lisp_Object Fbufferp (), Fmarkerp (), Fsubrp (), Fchar_or_string_p ();
1020 extern Lisp_Object Finteger_or_marker_p ();
1021 #ifdef LISP_FLOAT_TYPE
1022 extern Lisp_Object Ffloatp(), Finteger_or_floatp();
1023 extern Lisp_Object Finteger_or_float_or_marker_p(), Ftruncate();
1024 #endif /* LISP_FLOAT_TYPE */
1025
1026 extern Lisp_Object Fcar (), Fcar_safe(), Fcdr (), Fcdr_safe();
1027 extern Lisp_Object Fsetcar (), Fsetcdr ();
1028 extern Lisp_Object Fboundp (), Ffboundp (), Fmakunbound (), Ffmakunbound ();
1029 extern Lisp_Object Fsymbol_function (), Fsymbol_plist (), Fsymbol_name ();
1030 extern Lisp_Object indirect_function (), Findirect_function ();
1031 extern Lisp_Object Ffset (), Fsetplist ();
1032 extern Lisp_Object Fsymbol_value (), find_symbol_value (), Fset ();
1033 extern Lisp_Object Fdefault_value (), Fset_default (), Fdefault_boundp ();
1034
1035 extern Lisp_Object Faref (), Faset (), Farray_length ();
1036
1037 extern Lisp_Object Fstring_to_number (), Fnumber_to_string ();
1038 extern Lisp_Object Feqlsign (), Fgtr (), Flss (), Fgeq (), Fleq ();
1039 extern Lisp_Object Fneq (), Fzerop ();
1040 extern Lisp_Object Fplus (), Fminus (), Ftimes (), Fquo (), Frem ();
1041 extern Lisp_Object Fmax (), Fmin ();
1042 extern Lisp_Object Flogand (), Flogior (), Flogxor (), Flognot ();
1043 extern Lisp_Object Flsh (), Fash ();
1044
1045 extern Lisp_Object Fadd1 (), Fsub1 ();
1046
1047 extern Lisp_Object make_number ();
1048 extern Lisp_Object   long_to_cons ();
1049 extern unsigned long cons_to_long ();
1050 extern void args_out_of_range ();
1051 extern void args_out_of_range_3 ();
1052 extern Lisp_Object wrong_type_argument ();
1053 #ifdef LISP_FLOAT_TYPE
1054 extern Lisp_Object Ffloat_to_int(), Fint_to_float();
1055 extern double extract_float();
1056 extern Lisp_Object make_float ();
1057 extern Lisp_Object Ffloat ();
1058 #endif /* LISP_FLOAT_TYPE */
1059
1060 /* Defined in fns.c */
1061 extern Lisp_Object Qstring_lessp;
1062 extern Lisp_Object Vfeatures;
1063 extern Lisp_Object Fidentity (), Frandom ();
1064 extern Lisp_Object Flength ();
1065 extern Lisp_Object Fappend (), Fconcat (), Fvconcat (), Fcopy_sequence ();
1066 extern Lisp_Object Fsubstring ();
1067 extern Lisp_Object Fnth (), Fnthcdr (), Fmemq (), Fassq (), Fassoc ();
1068 extern Lisp_Object Frassq (), Fdelq (), Fsort ();
1069 extern Lisp_Object Freverse (), Fnreverse (), Fget (), Fput (), Fequal ();
1070 extern Lisp_Object Ffillarray (), Fnconc (), Fmapcar (), Fmapconcat ();
1071 extern Lisp_Object Fy_or_n_p (), do_yes_or_no_p ();
1072 extern Lisp_Object Ffeaturep (), Frequire () , Fprovide ();
1073 extern Lisp_Object concat2 (), nconc2 ();
1074 extern Lisp_Object assq_no_quit ();
1075 extern Lisp_Object Fcopy_alist ();
1076
1077 /* Defined in alloc.c */
1078 extern Lisp_Object Vpurify_flag;
1079 extern Lisp_Object Fcons (), Flist(), Fmake_list ();
1080 extern Lisp_Object Fmake_vector (), Fvector (), Fmake_symbol (), Fmake_marker ();
1081 extern Lisp_Object Fmake_string (), build_string (), make_string ();
1082 extern Lisp_Object make_event_array (), make_uninit_string ();
1083 extern Lisp_Object Fpurecopy (), make_pure_string ();
1084 extern Lisp_Object pure_cons (), make_pure_vector ();
1085 extern Lisp_Object Fgarbage_collect ();
1086 extern Lisp_Object Fmake_byte_code ();
1087
1088 /* Defined in print.c */
1089 extern Lisp_Object Vprin1_to_string_buffer;
1090 extern Lisp_Object Fprin1 (), Fprin1_to_string (), Fprinc ();
1091 extern Lisp_Object Fterpri (), Fprint ();
1092 extern Lisp_Object Vstandard_output, Qstandard_output;
1093 extern Lisp_Object Qexternal_debugging_output;
1094 extern void temp_output_buffer_setup (), temp_output_buffer_show ();
1095 extern int print_level, print_escape_newlines;
1096 extern Lisp_Object Qprint_escape_newlines;
1097
1098 /* Defined in lread.c */
1099 extern Lisp_Object Qvariable_documentation, Qstandard_input;
1100 extern Lisp_Object Vobarray, Vstandard_input;
1101 extern Lisp_Object Fread (), Fread_from_string ();
1102 extern Lisp_Object Fintern (), Fintern_soft (), Fload ();
1103 extern Lisp_Object Fget_file_char (), Fread_char ();
1104 extern Lisp_Object read_filtered_event ();
1105 extern Lisp_Object Feval_current_buffer (), Feval_region ();
1106 extern Lisp_Object intern (), oblookup ();
1107 #define LOADHIST_ATTACH(x) \
1108  if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
1109 extern Lisp_Object Vcurrent_load_list;
1110 extern Lisp_Object Vload_history;
1111
1112 /* Defined in eval.c */
1113 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
1114 extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
1115 extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments;
1116 extern Lisp_Object Vautoload_queue;
1117 extern Lisp_Object Vrun_hooks;
1118 extern Lisp_Object Fand (), For (), Fif (), Fprogn (), Fprog1 (), Fprog2 ();
1119 extern Lisp_Object Fsetq (), Fquote ();
1120 extern Lisp_Object Fuser_variable_p (), Finteractive_p ();
1121 extern Lisp_Object Fdefun (), Flet (), FletX (), Fwhile ();
1122 extern Lisp_Object Fcatch (), Fthrow (), Funwind_protect ();
1123 extern Lisp_Object Fcondition_case (), Fsignal ();
1124 extern Lisp_Object Ffunction_type (), Fautoload (), Fcommandp ();
1125 extern Lisp_Object Feval (), Fapply (), Ffuncall ();
1126 extern Lisp_Object Fglobal_set (), Fglobal_value (), Fbacktrace ();
1127 extern Lisp_Object apply1 (), call0 (), call1 (), call2 (), call3 ();
1128 extern Lisp_Object apply_lambda ();
1129 extern Lisp_Object internal_catch ();
1130 extern Lisp_Object internal_condition_case ();
1131 extern Lisp_Object unbind_to ();
1132 extern void error ();
1133 extern Lisp_Object un_autoload ();
1134
1135 /* Defined in editfns.c */
1136 extern Lisp_Object Vprefix_arg, Qminus, Vcurrent_prefix_arg;
1137 extern Lisp_Object Fgoto_char ();
1138 extern Lisp_Object Fpoint_min_marker (), Fpoint_max_marker ();
1139 extern Lisp_Object Fpoint_min (), Fpoint_max ();
1140 extern Lisp_Object Fpoint (), Fpoint_marker (), Fmark_marker ();
1141 extern Lisp_Object Ffollowing_char (), Fprevious_char (), Fchar_after ();
1142 extern Lisp_Object Finsert ();
1143 extern Lisp_Object Feolp (), Feobp (), Fbolp (), Fbobp ();
1144 extern Lisp_Object Fformat (), format1 ();
1145 extern Lisp_Object make_buffer_string (), Fbuffer_substring ();
1146 extern Lisp_Object Fbuffer_string ();
1147 extern Lisp_Object Fstring_equal (), Fstring_lessp (), Fbuffer_substring_lessp ();
1148 extern Lisp_Object save_excursion_save (), save_restriction_save ();
1149 extern Lisp_Object save_excursion_restore (), save_restriction_restore ();
1150 extern Lisp_Object Fchar_to_string ();
1151
1152 /* defined in buffer.c */
1153 extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
1154 extern Lisp_Object Fget_buffer (), Fget_buffer_create (), Fset_buffer ();
1155 extern Lisp_Object Fbarf_if_buffer_read_only ();
1156 extern Lisp_Object Fcurrent_buffer (), Fswitch_to_buffer (), Fpop_to_buffer ();
1157 extern Lisp_Object Fother_buffer ();
1158 extern Lisp_Object Qoverlayp;
1159 extern struct buffer *all_buffers;
1160
1161 /* defined in marker.c */
1162
1163 extern Lisp_Object Fmarker_position (), Fmarker_buffer ();
1164 extern Lisp_Object Fcopy_marker ();
1165
1166 /* Defined in fileio.c */
1167
1168 extern Lisp_Object Qfile_error;
1169 extern Lisp_Object Ffind_file_name_handler ();
1170 extern Lisp_Object Ffile_name_as_directory ();
1171 extern Lisp_Object Fexpand_file_name (), Ffile_name_nondirectory ();
1172 extern Lisp_Object Fsubstitute_in_file_name ();
1173 extern Lisp_Object Ffile_symlink_p ();
1174 extern Lisp_Object Fverify_visited_file_modtime ();
1175 extern Lisp_Object Ffile_exists_p ();
1176 extern Lisp_Object Fdirectory_file_name ();
1177 extern Lisp_Object Ffile_name_directory ();
1178 extern Lisp_Object expand_and_dir_to_file ();
1179 extern Lisp_Object Ffile_accessible_directory_p ();
1180
1181 /* Defined in abbrev.c */
1182
1183 extern Lisp_Object Vfundamental_mode_abbrev_table;
1184
1185 /* defined in search.c */
1186 extern Lisp_Object Fstring_match ();
1187 extern Lisp_Object Fscan_buffer ();
1188
1189 /* defined in minibuf.c */
1190
1191 extern Lisp_Object last_minibuf_string;
1192 extern Lisp_Object read_minibuf (), Fcompleting_read ();
1193 extern Lisp_Object Fread_from_minibuffer ();
1194 extern Lisp_Object Fread_variable (), Fread_buffer (), Fread_key_sequence ();
1195 extern Lisp_Object Fread_minibuffer (), Feval_minibuffer ();
1196 extern Lisp_Object Fread_string (), Fread_file_name ();
1197 extern Lisp_Object Fread_no_blanks_input ();
1198
1199 /* Defined in callint.c */
1200
1201 extern Lisp_Object Vcommand_history;
1202 extern Lisp_Object Qcall_interactively;
1203 extern Lisp_Object Fcall_interactively ();
1204 extern Lisp_Object Fprefix_numeric_value ();
1205
1206 /* defined in casefiddle.c */
1207
1208 extern Lisp_Object Fdowncase (), Fupcase (), Fcapitalize ();
1209
1210 /* defined in keyboard.c */
1211
1212 extern Lisp_Object Qdisabled;
1213 extern Lisp_Object Vhelp_form, Vtop_level;
1214 extern Lisp_Object Fdiscard_input (), Frecursive_edit ();
1215 extern Lisp_Object Fcommand_execute (), Finput_pending_p ();
1216 extern Lisp_Object Qvertical_scroll_bar;
1217
1218 /* defined in keymap.c */
1219
1220 extern Lisp_Object Qkeymap;
1221 extern Lisp_Object current_global_map;
1222 extern Lisp_Object Fkey_description (), Fsingle_key_description ();
1223 extern Lisp_Object Fwhere_is_internal ();
1224 extern Lisp_Object access_keymap (), store_in_keymap ();
1225 extern Lisp_Object get_keyelt (), get_keymap();
1226
1227 /* defined in indent.c */
1228 extern Lisp_Object Fvertical_motion (), Findent_to (), Fcurrent_column ();
1229
1230 /* defined in window.c */
1231 extern Lisp_Object Qwindowp, Qwindow_live_p;
1232 extern Lisp_Object Fget_buffer_window ();
1233 extern Lisp_Object Fsave_window_excursion ();
1234 extern Lisp_Object Fset_window_configuration (), Fcurrent_window_configuration ();
1235 extern Lisp_Object Fcoordinates_in_window_p ();
1236 extern Lisp_Object Fwindow_at ();
1237 extern int window_internal_height (), window_internal_width ();
1238
1239 /* defined in frame.c */
1240 extern Lisp_Object Fframep ();
1241 extern Lisp_Object Fselect_frame ();
1242 extern Lisp_Object Ffocus_frame ();
1243 extern Lisp_Object Funfocus_frame ();
1244 extern Lisp_Object Fselected_frame ();
1245 extern Lisp_Object Fwindow_frame ();
1246 extern Lisp_Object Fframe_root_window ();
1247 extern Lisp_Object Fframe_selected_window ();
1248 extern Lisp_Object Fframe_list ();
1249 extern Lisp_Object Fnext_frame ();
1250 extern Lisp_Object Fdelete_frame ();
1251 extern Lisp_Object Fread_mouse_position ();
1252 extern Lisp_Object Fset_mouse_position ();
1253 extern Lisp_Object Fmake_frame_visible ();
1254 extern Lisp_Object Fmake_frame_invisible ();
1255 extern Lisp_Object Ficonify_frame ();
1256 extern Lisp_Object Fdeiconify_frame ();
1257 extern Lisp_Object Fframe_visible_p ();
1258 extern Lisp_Object Fvisible_frame_list ();
1259 extern Lisp_Object Fframe_parameters ();
1260 extern Lisp_Object Fmodify_frame_parameters ();
1261 extern Lisp_Object Fframe_pixel_size ();
1262 extern Lisp_Object Fframe_height ();
1263 extern Lisp_Object Fframe_width ();
1264 extern Lisp_Object Fset_frame_height ();
1265 extern Lisp_Object Fset_frame_width ();
1266 extern Lisp_Object Fset_frame_size ();
1267 extern Lisp_Object Fset_frame_position ();
1268 #ifndef HAVE_X11
1269 extern Lisp_Object Frubber_band_rectangle ();
1270 #endif  /* HAVE_X11 */
1271
1272 /* defined in emacs.c */
1273 extern Lisp_Object decode_env_path ();
1274 extern Lisp_Object Vinvocation_name;
1275 void shut_down_emacs ( /* int signal, int no_x, Lisp_Object stuff */ );
1276 /* Nonzero means don't do interactive redisplay and don't change tty modes */
1277 extern int noninteractive;
1278 /* Nonzero means don't do use window-system-specific display code */
1279 extern int inhibit_window_system;
1280
1281 /* defined in process.c */
1282 extern Lisp_Object Fget_process (), Fget_buffer_process (), Fprocessp ();
1283 extern Lisp_Object Fprocess_status (), Fkill_process ();
1284
1285 /* defined in callproc.c */
1286 extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
1287
1288 /* defined in doc.c */
1289 extern Lisp_Object Vdoc_file_name;
1290 extern Lisp_Object Fsubstitute_command_keys ();
1291 extern Lisp_Object Fdocumentation (), Fdocumentation_property ();
1292
1293 /* defined in bytecode.c */
1294 extern Lisp_Object Qbytecode;
1295 extern Lisp_Object Fbyte_code ();
1296
1297 /* defined in macros.c */
1298 extern Lisp_Object Qexecute_kbd_macro;
1299 extern Lisp_Object Fexecute_kbd_macro ();
1300
1301 /* defined in undo.c */
1302 extern Lisp_Object Fundo_boundary ();
1303 extern Lisp_Object truncate_undo_list ();
1304
1305 /* defined in textprop.c */
1306 extern Lisp_Object Qmodification_hooks;
1307 extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
1308
1309 /* Nonzero means Emacs has already been initialized.
1310    Used during startup to detect startup of dumped Emacs.  */
1311 extern int initialized;
1312
1313 extern int immediate_quit;          /* Nonzero means ^G can quit instantly */
1314
1315 extern void debugger ();
1316
1317 extern char *getenv (), *ctime (), *getwd ();
1318 extern long *xmalloc (), *xrealloc ();
1319 extern void xfree ();
1320
1321 extern char *egetenv ();
1322