src/lisp.h

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