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