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