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