src/lisp.h

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