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