code.delx.au - gnu-emacs/blob - 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 /* During garbage collection, XGCTYPE must be used for extracting types
 376  so that the mark bit is ignored.  XMARKBIT access the markbit.
 377  Markbits are used only in particular slots of particular structure types.
 378  Other markbits are always zero.
 379  Outside of garbage collection, all mark bits are always zero.  */
 380
 381 #define XGCTYPE(a) ((a).gu.type)
 382 #define XMARKBIT(a) ((a).gu.markbit)
 383 #define XSETMARKBIT(a,b) (XMARKBIT(a) = (b))
 384 #define XMARK(a) (XMARKBIT(a) = 1)
 385 #define XUNMARK(a) (XMARKBIT(a) = 0)
 386
 387 #endif /* NO_UNION_TYPE */
 388
 389 /* Extract a value or address from a Lisp_Object.  */
 390
 391 #define XCONS(a) ((struct Lisp_Cons *) XPNTR(a))
 392 #define XVECTOR(a) ((struct Lisp_Vector *) XPNTR(a))
 393 #define XSTRING(a) ((struct Lisp_String *) XPNTR(a))
 394 #define XSYMBOL(a) ((struct Lisp_Symbol *) XPNTR(a))
 395 #define XFLOAT(a) ((struct Lisp_Float *) XPNTR(a))
 396
 397 /* Misc types.  */
 398 #define XMISC(a)   ((union Lisp_Misc *) XPNTR(a))
 399 #define XMISCTYPE(a)   (XMARKER (a)->type)
 400 #define XMARKER(a) (&(XMISC(a)->u_marker))
 401 #define XINTFWD(a) (&(XMISC(a)->u_intfwd))
 402 #define XBOOLFWD(a) (&(XMISC(a)->u_boolfwd))
 403 #define XOBJFWD(a) (&(XMISC(a)->u_objfwd))
 404 #define XBUFFER_OBJFWD(a) (&(XMISC(a)->u_buffer_objfwd))
 405 #define XBUFFER_LOCAL_VALUE(a) (&(XMISC(a)->u_buffer_local_value))
 406 #define XOVERLAY(a) (&(XMISC(a)->u_overlay))
 407 #define XKBOARD_OBJFWD(a) (&(XMISC(a)->u_kboard_objfwd))
 408
 409 /* Pseudovector types.  */
 410 #define XPROCESS(a) ((struct Lisp_Process *) XPNTR(a))
 411 #define XWINDOW(a) ((struct window *) XPNTR(a))
 412 #define XSUBR(a) ((struct Lisp_Subr *) XPNTR(a))
 413 #define XBUFFER(a) ((struct buffer *) XPNTR(a))
 414 #define XCHAR_TABLE(a) ((struct Lisp_Char_Table *) XPNTR(a))
 415 #define XBOOL_VECTOR(a) ((struct Lisp_Bool_Vector *) XPNTR(a))
 416
 417
 418 /* Construct a Lisp_Object from a value or address.  */
 419
 420 #define XSETINT(a, b) XSET (a, Lisp_Int, b)
 421 #define XSETCONS(a, b) XSET (a, Lisp_Cons, b)
 422 #define XSETVECTOR(a, b) XSET (a, Lisp_Vectorlike, b)
 423 #define XSETSTRING(a, b) XSET (a, Lisp_String, b)
 424 #define XSETSYMBOL(a, b) XSET (a, Lisp_Symbol, b)
 425 #define XSETFLOAT(a, b) XSET (a, Lisp_Float, b)
 426
 427 /* Misc types.  */
 428 #define XSETMISC(a, b) XSET (a, Lisp_Misc, b)
 429 #define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
 430
 431 /* Pseudovector types.  */
 432 #define XSETPSEUDOVECTOR(a, b, code) \
 433   (XSETVECTOR (a, b), XVECTOR (a)->size |= PSEUDOVECTOR_FLAG | (code))
 434 #define XSETWINDOW_CONFIGURATION(a, b) \
 435   (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
 436 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
 437 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
 438 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
 439 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
 440 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
 441 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
 442 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
 443 \f
 444 #ifdef USE_TEXT_PROPERTIES
 445 /* Basic data type for use of intervals.  See the macros in intervals.h.  */
 446
 447 struct interval
 448 {
 449   /* The first group of entries deal with the tree structure.  */
 450
 451   unsigned int total_length;    /* Length of myself and both children.  */
 452   unsigned int position;        /* Cache of interval's character position.  */
 453   struct interval *left;        /* Intervals which precede me.  */
 454   struct interval *right;       /* Intervals which succeed me.  */
 455
 456   /* Parent in the tree, or the Lisp_Object containing this interval tree.
 457
 458      The mark bit on the root interval of an interval tree says
 459      whether we have started (and possibly finished) marking the
 460      tree.  If GC comes across an interval tree whose root's parent
 461      field has its markbit set, it leaves the tree alone.
 462
 463      You'd think we could store this information in the parent object
 464      somewhere (after all, that should be visited once and then
 465      ignored too, right?), but strings are GC'd strangely.  */
 466   struct interval *parent;
 467
 468   /* The remaining components are `properties' of the interval.
 469      The first four are duplicates for things which can be on the list,
 470      for purposes of speed.  */
 471
 472   unsigned char write_protect;      /* Non-zero means can't modify.  */
 473   unsigned char visible;            /* Zero means don't display.  */
 474   unsigned char front_sticky;       /* Non-zero means text inserted just
 475                                        before this interval goes into it.  */
 476   unsigned char rear_sticky;        /* Likewise for just after it.  */
 477
 478   /* Properties of this interval.
 479      The mark bit on this field says whether this particular interval
 480      tree node has been visited.  Since intervals should never be
 481      shared, GC aborts if it seems to have visited an interval twice.  */
 482   Lisp_Object plist;
 483 };
 484
 485 typedef struct interval *INTERVAL;
 486
 487 /* Complain if object is not string or buffer type */
 488 #define CHECK_STRING_OR_BUFFER(x, i) \
 489   { if (!STRINGP ((x)) && !BUFFERP ((x))) \
 490       x = wrong_type_argument (Qbuffer_or_string_p, (x)); }
 491
 492 /* Macro used to conditionally compile intervals into certain data
 493    structures.  See, e.g., struct Lisp_String below.  */
 494 #define DECLARE_INTERVALS INTERVAL intervals;
 495
 496 /* Macro used to conditionally compile interval initialization into
 497    certain code.  See, e.g., alloc.c.  */
 498 #define INITIALIZE_INTERVAL(ptr,val) ptr->intervals = val
 499
 500 #else  /* No text properties */
 501
 502 /* If no intervals are used, make the above definitions go away.  */
 503
 504 #define CHECK_STRING_OR_BUFFER(x, i)
 505
 506 #define INTERVAL
 507 #define DECLARE_INTERVALS
 508 #define INITIALIZE_INTERVAL(ptr,val)
 509
 510 #endif /* USE_TEXT_PROPERTIES */
 511 \f
 512 /* In a cons, the markbit of the car is the gc mark bit */
 513
 514 struct Lisp_Cons
 515   {
 516     Lisp_Object car, cdr;
 517   };
 518
 519 /* Take the car or cdr of something known to be a cons cell.  */
 520 #define XCAR(c) (XCONS ((c))->car)
 521 #define XCDR(c) (XCONS ((c))->cdr)
 522
 523 /* Take the car or cdr of something whose type is not known.  */
 524 #define CAR(c)                                  \
 525  (CONSP ((c)) ? XCAR ((c))                      \
 526   : NILP ((c)) ? Qnil                           \
 527   : wrong_type_argument (Qlistp, (c)))
 528
 529 #define CDR(c)                                  \
 530  (CONSP ((c)) ? XCDR ((c))                      \
 531   : NILP ((c)) ? Qnil                           \
 532   : wrong_type_argument (Qlistp, (c)))
 533
 534 /* Like a cons, but records info on where the text lives that it was read from */
 535 /* This is not really in use now */
 536
 537 struct Lisp_Buffer_Cons
 538   {
 539     Lisp_Object car, cdr;
 540     struct buffer *buffer;
 541     int bufpos;
 542   };
 543
 544 /* In a string or vector, the sign bit of the `size' is the gc mark bit */
 545
 546 struct Lisp_String
 547   {
 548     EMACS_INT size;
 549     DECLARE_INTERVALS           /* `data' field must be last.  */
 550     unsigned char data[1];
 551   };
 552
 553 /* If a struct is made to look like a vector, this macro returns the length
 554    of the shortest vector that would hold that struct.  */
 555 #define VECSIZE(type) ((sizeof (type) - (sizeof (struct Lisp_Vector)  \
 556                                          - sizeof (Lisp_Object))      \
 557                         + sizeof(Lisp_Object) - 1) /* round up */     \
 558                        / sizeof (Lisp_Object))
 559
 560 struct Lisp_Vector
 561   {
 562     EMACS_INT size;
 563     struct Lisp_Vector *next;
 564     Lisp_Object contents[1];
 565   };
 566
 567 /* A char table is a kind of vectorlike, with contents are like a
 568    vector but with a few other slots.  For some purposes, it makes
 569    sense to handle a chartable with type struct Lisp_Vector.  An
 570    element of a char table can be any Lisp objects, but if it is a sub
 571    char-table, we treat it a table that contains information of a
 572    group of characters of the same charsets or a specific character of
 573    a charset.  A sub char-table has the same structure as a char table
 574    except for that the former omits several slots at the tail.  A sub
 575    char table appears only in an element of a char table, and there's
 576    no way to access it directly from Emacs Lisp program.  */
 577
 578 /* This is the number of slots that apply to characters or character
 579    sets.  The first 128 are for ASCII, the next 128 are for 8-bit
 580    European characters, and the last 128 are for multibyte characters.
 581    The first 256 are indexed by the code itself, but the last 128 are
 582    indexed by (charset-id + 128).  */
 583 #define CHAR_TABLE_ORDINARY_SLOTS 384
 584
 585 /* This is the number of slots that apply to characters of ASCII and
 586    8-bit Europeans only.  */
 587 #define CHAR_TABLE_SINGLE_BYTE_SLOTS 256
 588
 589 /* This is the number of slots that every char table must have.  This
 590    counts the ordinary slots and the top, defalt, parent, and purpose
 591    slots.  */
 592 #define CHAR_TABLE_STANDARD_SLOTS (CHAR_TABLE_ORDINARY_SLOTS + 4)
 593
 594 /* This is the number of slots that apply to position-code-1 and
 595    position-code-2 of a multibyte character at the 2nd and 3rd level
 596    sub char tables respectively.  */
 597 #define SUB_CHAR_TABLE_ORDINARY_SLOTS 128
 598
 599 /* This is the number of slots that every sub char table must have.
 600    This counts the ordinary slots and the top and defalt slot.  */
 601 #define SUB_CHAR_TABLE_STANDARD_SLOTS (SUB_CHAR_TABLE_ORDINARY_SLOTS + 2)
 602
 603 /* Return the number of "extra" slots in the char table CT.  */
 604
 605 #define CHAR_TABLE_EXTRA_SLOTS(CT)      \
 606   (((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
 607
 608 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
 609    and 8-bit Europeans characters.  Do not follow parent.  */
 610 #define CHAR_TABLE_REF(CT, IDX)                                         \
 611   (CHAR_TABLE_P (CT) && IDX >= 0 && IDX < CHAR_TABLE_SINGLE_BYTE_SLOTS  \
 612    ? (!NILP (XCHAR_TABLE (CT)->contents[IDX])                           \
 613       ? XCHAR_TABLE (CT)->contents[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.  */
 619 #define CHAR_TABLE_SET(CT, IDX, VAL)                                         \
 620   do {                                                                       \
 621     if (CHAR_TABLE_P (CT) && IDX >= 0 && IDX < CHAR_TABLE_SINGLE_BYTE_SLOTS) \
 622       XCHAR_TABLE (CT)->contents[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 /* 1 if CH is upper case.  */
1317
1318 #define UPPERCASEP(CH) \
1319   (XCHAR_TABLE (current_buffer->downcase_table)->contents[CH] != (CH))
1320
1321 /* 1 if CH is lower case.  */
1322
1323 #define LOWERCASEP(CH) (!UPPERCASEP (CH) && !NOCASEP(CH))
1324
1325 /* 1 if CH is neither upper nor lower case.  */
1326
1327 #define NOCASEP(CH) \
1328   (XCHAR_TABLE (current_buffer->upcase_table)->contents[CH] == (CH))
1329
1330 /* Upcase a character, or make no change if that cannot be done.  */
1331
1332 #define UPCASE(CH) (!UPPERCASEP (CH) ? UPCASE1 (CH) : (CH))
1333
1334 /* Upcase a character known to be not upper case.  */
1335
1336 #define UPCASE1(CH) (XCHAR_TABLE (current_buffer->upcase_table)->contents[CH])
1337
1338 /* Downcase a character, or make no change if that cannot be done.  */
1339
1340 #define DOWNCASE(CH) \
1341   (XCHAR_TABLE (current_buffer->downcase_table)->contents[CH])
1342
1343 /* Current buffer's map from characters to lower-case characters.  */
1344
1345 #define DOWNCASE_TABLE XCHAR_TABLE (current_buffer->downcase_table)->contents
1346
1347 extern Lisp_Object Vascii_downcase_table;
1348 \f
1349 /* Number of bytes of structure consed since last GC.  */
1350
1351 extern int consing_since_gc;
1352
1353 /* Threshold for doing another gc.  */
1354
1355 extern int gc_cons_threshold;
1356
1357 /* Structure for recording stack slots that need marking.  */
1358
1359 /* This is a chain of structures, each of which points at a Lisp_Object variable
1360  whose value should be marked in garbage collection.
1361  Normally every link of the chain is an automatic variable of a function,
1362  and its `val' points to some argument or local variable of the function.
1363  On exit to the function, the chain is set back to the value it had on entry.
1364  This way, no link remains in the chain when the stack frame containing the
1365  link disappears.
1366
1367  Every function that can call Feval must protect in this fashion all
1368  Lisp_Object variables whose contents will be used again.  */
1369
1370 extern struct gcpro *gcprolist;
1371
1372 struct gcpro
1373   {
1374     struct gcpro *next;
1375     Lisp_Object *var;           /* Address of first protected variable */
1376     int nvars;                  /* Number of consecutive protected variables */
1377   };
1378
1379 #define GCPRO1(varname) \
1380  {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
1381   gcprolist = &gcpro1; }
1382
1383 #define GCPRO2(varname1, varname2) \
1384  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1385   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1386   gcprolist = &gcpro2; }
1387
1388 #define GCPRO3(varname1, varname2, varname3) \
1389  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1390   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1391   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1392   gcprolist = &gcpro3; }
1393
1394 #define GCPRO4(varname1, varname2, varname3, varname4) \
1395  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1396   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1397   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1398   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1399   gcprolist = &gcpro4; }
1400
1401 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1402  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1403   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1404   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1405   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1406   gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1407   gcprolist = &gcpro5; }
1408
1409 /* Call staticpro (&var) to protect static variable `var'.  */
1410
1411 void staticpro();
1412
1413 #define UNGCPRO (gcprolist = gcpro1.next)
1414
1415 /* Evaluate expr, UNGCPRO, and then return the value of expr.  */
1416 #define RETURN_UNGCPRO(expr)                    \
1417 if (1)                                          \
1418     {                                           \
1419       Lisp_Object ret_ungc_val;                 \
1420       ret_ungc_val = (expr);                    \
1421       UNGCPRO;                                  \
1422       return ret_ungc_val;                      \
1423     }                                           \
1424 else
1425 \f
1426 /* Defined in data.c */
1427 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
1428 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
1429 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
1430 extern Lisp_Object Qvoid_variable, Qvoid_function;
1431 extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
1432 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
1433 extern Lisp_Object Qend_of_file, Qarith_error;
1434 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
1435 extern Lisp_Object Qmark_inactive;
1436
1437 extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
1438 extern Lisp_Object Qoverflow_error, Qunderflow_error;
1439
1440 extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qwholenump;
1441 extern Lisp_Object Qsymbolp, Qlistp, Qconsp;
1442 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
1443 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp;
1444 extern Lisp_Object Qinteger_or_marker_p, Qnumber_or_marker_p;
1445 extern Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
1446 extern Lisp_Object Qboundp, Qfboundp;
1447 extern Lisp_Object Qbuffer_or_string_p;
1448 extern Lisp_Object Qcdr;
1449
1450 #ifdef LISP_FLOAT_TYPE
1451 extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
1452 #endif /* LISP_FLOAT_TYPE */
1453
1454 extern Lisp_Object Qframep;
1455
1456 extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp ();
1457 extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp ();
1458 extern Lisp_Object Fvectorp (), Fstringp (), Farrayp (), Fsequencep ();
1459 extern Lisp_Object Fbufferp (), Fmarkerp (), Fsubrp (), Fchar_or_string_p ();
1460 extern Lisp_Object Finteger_or_marker_p ();
1461 #ifdef LISP_FLOAT_TYPE
1462 extern Lisp_Object Ffloatp(), Finteger_or_floatp();
1463 extern Lisp_Object Finteger_or_float_or_marker_p(), Ftruncate();
1464 #endif /* LISP_FLOAT_TYPE */
1465
1466 extern Lisp_Object Fcar (), Fcar_safe(), Fcdr (), Fcdr_safe();
1467 extern Lisp_Object Fsetcar (), Fsetcdr ();
1468 extern Lisp_Object Fboundp (), Ffboundp (), Fmakunbound (), Ffmakunbound ();
1469 extern Lisp_Object Fsymbol_function (), Fsymbol_plist (), Fsymbol_name ();
1470 extern Lisp_Object indirect_function (), Findirect_function ();
1471 extern Lisp_Object Ffset (), Fsetplist ();
1472 extern Lisp_Object Fsymbol_value (), find_symbol_value (), Fset ();
1473 extern Lisp_Object Fdefault_value (), Fset_default (), Fdefault_boundp ();
1474 extern Lisp_Object Fmake_local_variable ();
1475
1476 extern Lisp_Object Faref (), Faset ();
1477
1478 extern Lisp_Object Fstring_to_number (), Fnumber_to_string ();
1479 extern Lisp_Object Feqlsign (), Fgtr (), Flss (), Fgeq (), Fleq ();
1480 extern Lisp_Object Fneq (), Fzerop ();
1481 extern Lisp_Object Fplus (), Fminus (), Ftimes (), Fquo (), Frem ();
1482 extern Lisp_Object Fmax (), Fmin ();
1483 extern Lisp_Object Flogand (), Flogior (), Flogxor (), Flognot ();
1484 extern Lisp_Object Flsh (), Fash ();
1485
1486 extern Lisp_Object Fadd1 (), Fsub1 ();
1487
1488 extern Lisp_Object   long_to_cons ();
1489 extern unsigned long cons_to_long ();
1490 extern void args_out_of_range ();
1491 extern void args_out_of_range_3 ();
1492 extern Lisp_Object wrong_type_argument ();
1493 extern void store_symval_forwarding ();
1494 extern Lisp_Object do_symval_forwarding ();
1495 #ifdef LISP_FLOAT_TYPE
1496 extern Lisp_Object Ffloat_to_int(), Fint_to_float();
1497 extern double extract_float();
1498 extern Lisp_Object make_float ();
1499 extern Lisp_Object Ffloat ();
1500 #endif /* LISP_FLOAT_TYPE */
1501
1502 /* Defined in cmds.c */
1503 extern Lisp_Object Fend_of_line (), Fforward_char (), Fforward_line ();
1504
1505 /* Defined in coding.c */
1506 extern Lisp_Object Fcoding_system_p (), Fcheck_coding_system ();
1507 extern Lisp_Object Fread_coding_system (), Fread_non_nil_coding_system ();
1508
1509 /* Defined in syntax.c */
1510 extern Lisp_Object Fforward_word ();
1511
1512 /* Defined in fns.c */
1513 extern Lisp_Object Qstring_lessp;
1514 extern Lisp_Object Vfeatures;
1515 extern Lisp_Object Fidentity (), Frandom ();
1516 extern Lisp_Object Flength (), Fsafe_length ();
1517 extern Lisp_Object Fappend (), Fconcat (), Fvconcat (), Fcopy_sequence ();
1518 extern Lisp_Object Fsubstring ();
1519 extern Lisp_Object Fnth (), Fnthcdr (), Fmemq (), Fassq (), Fassoc ();
1520 extern Lisp_Object Felt (), Fmember (), Frassq (), Fdelq (), Fsort ();
1521 extern Lisp_Object Freverse (), Fnreverse (), Fget (), Fput (), Fequal ();
1522 extern Lisp_Object Ffillarray (), Fnconc (), Fmapcar (), Fmapconcat ();
1523 extern Lisp_Object Fy_or_n_p (), do_yes_or_no_p ();
1524 extern Lisp_Object Ffeaturep (), Frequire () , Fprovide ();
1525 extern Lisp_Object concat2 (), nconc2 ();
1526 extern Lisp_Object assq_no_quit ();
1527 extern Lisp_Object Fcopy_alist ();
1528 extern Lisp_Object Fplist_get ();
1529 extern Lisp_Object Fset_char_table_parent ();
1530
1531 /* Defined in insdel.c */
1532 extern void move_gap ();
1533 extern void make_gap ();
1534 extern void insert ();
1535 extern void insert_and_inherit ();
1536 extern void insert_1 ();
1537 extern void insert_from_string ();
1538 extern void insert_from_buffer ();
1539 extern void insert_char ();
1540 extern void insert_string ();
1541 extern void insert_before_markers ();
1542 extern void insert_before_markers_and_inherit ();
1543 extern void insert_from_string_before_markers ();
1544 extern void del_range ();
1545 extern void del_range_1 ();
1546 extern void modify_region ();
1547 extern void prepare_to_modify_buffer ();
1548 extern void signal_before_change ();
1549 extern void signal_after_change ();
1550
1551 /* Defined in dispnew.c */
1552 extern Lisp_Object Fding (), Fredraw_display ();
1553 extern Lisp_Object Fsleep_for ();
1554
1555 /* Defined in xdisp.c */
1556 extern Lisp_Object Vmessage_log_max;
1557 extern void message ();
1558 extern void message_nolog ();
1559 extern void message1 ();
1560 extern void message1_nolog ();
1561 extern void message2 ();
1562 extern void message2_nolog ();
1563 extern void message_dolog ();
1564 extern void message_log_maybe_newline ();
1565
1566 /* Defined in alloc.c */
1567 extern Lisp_Object Vpurify_flag;
1568 extern Lisp_Object Fcons (), Flist(), Fmake_list (), allocate_misc ();
1569 extern Lisp_Object Fmake_vector (), Fvector (), Fmake_symbol (), Fmake_marker ();
1570 extern Lisp_Object Fmake_string (), build_string (), make_string ();
1571 extern Lisp_Object make_event_array (), make_uninit_string ();
1572 extern Lisp_Object Fpurecopy (), make_pure_string ();
1573 extern Lisp_Object pure_cons (), make_pure_vector ();
1574 extern Lisp_Object Fgarbage_collect ();
1575 extern Lisp_Object Fmake_byte_code ();
1576 extern Lisp_Object Fmake_bool_vector (), Fmake_char_table ();
1577 extern Lisp_Object make_sub_char_table ();
1578 extern Lisp_Object Qchar_table_extra_slots;
1579 extern struct Lisp_Vector *allocate_vectorlike ();
1580 extern int gc_in_progress;
1581
1582 /* Defined in print.c */
1583 extern Lisp_Object Vprin1_to_string_buffer;
1584 extern Lisp_Object Fprin1 (), Fprin1_to_string (), Fprinc ();
1585 extern Lisp_Object Fterpri (), Fprint ();
1586 extern Lisp_Object Ferror_message_string ();
1587 extern Lisp_Object Vstandard_output, Qstandard_output;
1588 extern Lisp_Object Qexternal_debugging_output;
1589 extern void temp_output_buffer_setup (), temp_output_buffer_show ();
1590 extern int print_level, print_escape_newlines;
1591 extern Lisp_Object Qprint_escape_newlines;
1592
1593 /* Defined in lread.c */
1594 extern Lisp_Object Qvariable_documentation, Qstandard_input;
1595 extern Lisp_Object Vobarray, Vstandard_input;
1596 extern Lisp_Object Fread (), Fread_from_string ();
1597 extern Lisp_Object Fintern (), Fintern_soft (), Fload ();
1598 extern Lisp_Object Fget_file_char (), Fread_char ();
1599 extern Lisp_Object read_filtered_event ();
1600 extern Lisp_Object Feval_current_buffer (), Feval_region ();
1601 extern Lisp_Object intern (), make_symbol (), oblookup ();
1602 #define LOADHIST_ATTACH(x) \
1603  if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
1604 extern Lisp_Object Vcurrent_load_list;
1605 extern Lisp_Object Vload_history;
1606
1607 /* Defined in eval.c */
1608 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
1609 extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
1610 extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments;
1611 extern Lisp_Object Vautoload_queue;
1612 extern Lisp_Object Vdebug_on_error;
1613 /* To run a normal hook, use the appropriate function from the list below.
1614    The calling convention:
1615
1616    if (!NILP (Vrun_hooks))
1617      call1 (Vrun_hooks, Qmy_funny_hook);
1618
1619    should no longer be used.  */
1620 extern Lisp_Object Vrun_hooks;
1621 extern Lisp_Object Frun_hooks (), Frun_hook_with_args ();
1622 extern Lisp_Object Frun_hook_with_args_until_success ();
1623 extern Lisp_Object Frun_hook_with_args_until_failure ();
1624 extern Lisp_Object Fand (), For (), Fif (), Fprogn (), Fprog1 (), Fprog2 ();
1625 extern Lisp_Object Fsetq (), Fquote ();
1626 extern Lisp_Object Fuser_variable_p (), Finteractive_p ();
1627 extern Lisp_Object Fdefun (), Flet (), FletX (), Fwhile ();
1628 extern Lisp_Object Fcatch (), Fthrow (), Funwind_protect ();
1629 extern Lisp_Object Fcondition_case (), Fsignal ();
1630 extern Lisp_Object Ffunction_type (), Fautoload (), Fcommandp ();
1631 extern Lisp_Object Feval (), Fapply (), Ffuncall ();
1632 extern Lisp_Object Fglobal_set (), Fglobal_value (), Fbacktrace ();
1633 extern Lisp_Object apply1 (), call0 (), call1 (), call2 (), call3 ();
1634 extern Lisp_Object call4 (), call5 (), call6 ();
1635 extern Lisp_Object Fkill_emacs (), Fkey_binding (), Fsit_for ();
1636 extern Lisp_Object Fdo_auto_save (), Fset_marker ();
1637 extern Lisp_Object apply_lambda ();
1638 extern Lisp_Object internal_catch ();
1639 extern Lisp_Object internal_condition_case ();
1640 extern Lisp_Object internal_condition_case_1 ();
1641 extern Lisp_Object unbind_to ();
1642 extern void error ();
1643 extern Lisp_Object un_autoload ();
1644 extern Lisp_Object Ffetch_bytecode ();
1645
1646 /* Defined in editfns.c */
1647 extern Lisp_Object Fgoto_char ();
1648 extern Lisp_Object Fpoint_min_marker (), Fpoint_max_marker ();
1649 extern Lisp_Object Fpoint_min (), Fpoint_max ();
1650 extern Lisp_Object Fpoint (), Fpoint_marker (), Fmark_marker ();
1651 extern Lisp_Object Fline_beginning_position (), Fline_end_position ();
1652 extern Lisp_Object Ffollowing_char (), Fprevious_char (), Fchar_after ();
1653 extern Lisp_Object Finsert (), Finsert_and_inherit ();
1654 extern Lisp_Object Finsert_before_markers ();
1655 extern Lisp_Object Finsert_buffer_substring ();
1656 extern Lisp_Object Finsert_char ();
1657 extern Lisp_Object Feolp (), Feobp (), Fbolp (), Fbobp ();
1658 extern Lisp_Object Fformat (), format1 ();
1659 extern Lisp_Object make_buffer_string (), Fbuffer_substring ();
1660 extern Lisp_Object Fbuffer_string ();
1661 extern Lisp_Object Fstring_equal (), Fstring_lessp (), Fbuffer_substring_lessp ();
1662 extern Lisp_Object save_excursion_save (), save_restriction_save ();
1663 extern Lisp_Object save_excursion_restore (), save_restriction_restore ();
1664 extern Lisp_Object Fchar_to_string ();
1665 extern Lisp_Object Fdelete_region (), Fnarrow_to_region (), Fwiden ();
1666
1667 /* defined in buffer.c */
1668 extern Lisp_Object Foverlay_start (), Foverlay_end ();
1669 extern void adjust_overlays_for_insert ();
1670 extern void adjust_overlays_for_delete ();
1671 extern void fix_overlays_in_range ();
1672 extern int overlay_touches_p ();
1673 extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
1674 extern Lisp_Object Fget_buffer (), Fget_buffer_create (), Fset_buffer ();
1675 extern Lisp_Object Fbarf_if_buffer_read_only ();
1676 extern Lisp_Object Fcurrent_buffer (), Fswitch_to_buffer (), Fpop_to_buffer ();
1677 extern Lisp_Object Fother_buffer ();
1678 extern Lisp_Object Foverlay_get ();
1679 extern Lisp_Object Fbuffer_modified_p (), Fset_buffer_modified_p ();
1680 extern Lisp_Object Fkill_buffer (), Fkill_all_local_variables ();
1681 extern Lisp_Object Fbuffer_disable_undo (), Fbuffer_enable_undo ();
1682 extern Lisp_Object Ferase_buffer ();
1683 extern Lisp_Object Qoverlayp;
1684 extern struct buffer *all_buffers;
1685
1686 /* defined in marker.c */
1687
1688 extern Lisp_Object Fmarker_position (), Fmarker_buffer ();
1689 extern Lisp_Object Fcopy_marker ();
1690
1691 /* Defined in fileio.c */
1692
1693 extern Lisp_Object Qfile_error;
1694 extern Lisp_Object Ffind_file_name_handler ();
1695 extern Lisp_Object Ffile_name_as_directory ();
1696 extern Lisp_Object Fexpand_file_name (), Ffile_name_nondirectory ();
1697 extern Lisp_Object Fsubstitute_in_file_name ();
1698 extern Lisp_Object Ffile_symlink_p ();
1699 extern Lisp_Object Fverify_visited_file_modtime ();
1700 extern Lisp_Object Ffile_exists_p ();
1701 extern Lisp_Object Ffile_name_absolute_p ();
1702 extern Lisp_Object Fdirectory_file_name ();
1703 extern Lisp_Object Ffile_name_directory ();
1704 extern Lisp_Object expand_and_dir_to_file ();
1705 extern Lisp_Object Ffile_accessible_directory_p ();
1706 extern Lisp_Object Funhandled_file_name_directory ();
1707 extern Lisp_Object Ffile_directory_p ();
1708 extern Lisp_Object Fwrite_region ();
1709
1710 /* Defined in abbrev.c */
1711
1712 extern Lisp_Object Vfundamental_mode_abbrev_table;
1713
1714 /* defined in search.c */
1715 extern Lisp_Object Fstring_match ();
1716 extern Lisp_Object Fscan_buffer ();
1717 extern void restore_match_data ();
1718 extern Lisp_Object Fmatch_data (), Fstore_match_data ();
1719 extern Lisp_Object Fmatch_beginning (), Fmatch_end ();
1720 extern Lisp_Object Fskip_chars_forward (), Fskip_chars_backward ();
1721
1722 /* defined in minibuf.c */
1723
1724 extern Lisp_Object last_minibuf_string;
1725 extern Lisp_Object read_minibuf (), Fcompleting_read ();
1726 extern Lisp_Object Fread_from_minibuffer ();
1727 extern Lisp_Object Fread_variable (), Fread_buffer (), Fread_key_sequence ();
1728 extern Lisp_Object Fread_minibuffer (), Feval_minibuffer ();
1729 extern Lisp_Object Fread_string (), Fread_file_name ();
1730 extern Lisp_Object Fread_no_blanks_input ();
1731 extern Lisp_Object get_minibuffer ();
1732
1733 /* Defined in callint.c */
1734
1735 extern Lisp_Object Qminus, Qplus, Vcurrent_prefix_arg;
1736 extern Lisp_Object Vcommand_history;
1737 extern Lisp_Object Qcall_interactively, Qmouse_leave_buffer_hook;
1738 extern Lisp_Object Fcall_interactively ();
1739 extern Lisp_Object Fprefix_numeric_value ();
1740
1741 /* defined in casefiddle.c */
1742
1743 extern Lisp_Object Fdowncase (), Fupcase (), Fcapitalize ();
1744 extern Lisp_Object Fupcase_region ();
1745 extern Lisp_Object Fupcase_initials (), Fupcase_initials_region ();
1746
1747 /* defined in casetab.c */
1748
1749 extern Lisp_Object Fset_case_table ();
1750 extern Lisp_Object Fset_standard_case_table ();
1751
1752 /* defined in keyboard.c */
1753
1754 extern Lisp_Object Qdisabled;
1755 extern Lisp_Object Vhelp_form, Vtop_level;
1756 extern Lisp_Object Fdiscard_input (), Frecursive_edit ();
1757 extern Lisp_Object Fcommand_execute (), Finput_pending_p ();
1758 extern Lisp_Object menu_bar_items ();
1759 extern Lisp_Object Qvertical_scroll_bar;
1760 extern Lisp_Object Fevent_convert_list ();
1761 #ifdef MULTI_KBOARD
1762 extern void delete_kboard ();
1763 #endif
1764
1765 /* defined in keymap.c */
1766
1767 extern Lisp_Object Qkeymap, Qmenu_bar;
1768 extern Lisp_Object current_global_map;
1769 extern Lisp_Object Fdefine_key ();
1770 extern Lisp_Object Fkey_description (), Fsingle_key_description ();
1771 extern Lisp_Object Fwhere_is_internal ();
1772 extern Lisp_Object access_keymap (), store_in_keymap ();
1773 extern Lisp_Object get_keyelt (), get_keymap (), get_keymap_1 ();
1774 extern void describe_map_tree ();
1775
1776 /* defined in indent.c */
1777 extern Lisp_Object Fvertical_motion (), Findent_to (), Fcurrent_column ();
1778
1779 /* defined in window.c */
1780 extern Lisp_Object Qwindowp, Qwindow_live_p;
1781 extern Lisp_Object Fselected_window ();
1782 extern Lisp_Object Fget_buffer_window ();
1783 extern Lisp_Object Fsave_window_excursion ();
1784 extern Lisp_Object Fset_window_configuration (), Fcurrent_window_configuration ();
1785 extern Lisp_Object Fcoordinates_in_window_p ();
1786 extern Lisp_Object Fwindow_at ();
1787 extern Lisp_Object Fpos_visible_in_window_p ();
1788 extern int window_internal_height (), window_internal_width ();
1789 extern Lisp_Object Frecenter ();
1790 extern Lisp_Object Fscroll_other_window ();
1791 extern Lisp_Object Fset_window_start ();
1792
1793 /* defined in frame.c */
1794 extern Lisp_Object Qvisible;
1795 extern void store_frame_param (), store_in_alist ();
1796 extern Lisp_Object do_switch_frame ();
1797 extern Lisp_Object get_frame_param();
1798 extern Lisp_Object frame_buffer_predicate ();
1799 extern Lisp_Object Fframep ();
1800 extern Lisp_Object Fselect_frame ();
1801 extern Lisp_Object Fselected_frame ();
1802 extern Lisp_Object Fwindow_frame ();
1803 extern Lisp_Object Fframe_root_window ();
1804 extern Lisp_Object Fframe_first_window ();
1805 extern Lisp_Object Fframe_selected_window ();
1806 extern Lisp_Object Fframe_list ();
1807 extern Lisp_Object Fnext_frame ();
1808 extern Lisp_Object Fdelete_frame ();
1809 extern Lisp_Object Fread_mouse_position ();
1810 extern Lisp_Object Fset_mouse_position ();
1811 extern Lisp_Object Fmake_frame_visible ();
1812 extern Lisp_Object Fmake_frame_invisible ();
1813 extern Lisp_Object Ficonify_frame ();
1814 extern Lisp_Object Fdeiconify_frame ();
1815 extern Lisp_Object Fframe_visible_p ();
1816 extern Lisp_Object Fvisible_frame_list ();
1817 extern Lisp_Object Fframe_parameters ();
1818 extern Lisp_Object Fmodify_frame_parameters ();
1819 extern Lisp_Object Fframe_pixel_size ();
1820 extern Lisp_Object Fframe_height ();
1821 extern Lisp_Object Fframe_width ();
1822 extern Lisp_Object Fset_frame_height ();
1823 extern Lisp_Object Fset_frame_width ();
1824 extern Lisp_Object Fset_frame_size ();
1825 extern Lisp_Object Fset_frame_position ();
1826 extern Lisp_Object Fraise_frame ();
1827 extern Lisp_Object Fredirect_frame_focus ();
1828
1829 /* defined in emacs.c */
1830 extern Lisp_Object decode_env_path ();
1831 extern Lisp_Object Vinvocation_name, Vinvocation_directory;
1832 extern Lisp_Object Vinstallation_directory;
1833 void shut_down_emacs ( /* int signal, int no_x, Lisp_Object stuff */ );
1834 /* Nonzero means don't do interactive redisplay and don't change tty modes */
1835 extern int noninteractive;
1836 /* Nonzero means don't do use window-system-specific display code */
1837 extern int inhibit_window_system;
1838 /* Nonzero means that a filter or a sentinel is running.  */
1839 extern int running_asynch_code;
1840
1841 /* defined in process.c */
1842 extern Lisp_Object Fget_process (), Fget_buffer_process (), Fprocessp ();
1843 extern Lisp_Object Fprocess_status (), Fkill_process ();
1844 extern Lisp_Object Fprocess_send_eof ();
1845 extern Lisp_Object Fwaiting_for_user_input_p ();
1846 extern Lisp_Object Qprocessp;
1847
1848 /* defined in callproc.c */
1849 extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
1850 extern Lisp_Object Vdoc_directory;
1851
1852 /* defined in doc.c */
1853 extern Lisp_Object Vdoc_file_name;
1854 extern Lisp_Object Fsubstitute_command_keys ();
1855 extern Lisp_Object Fdocumentation (), Fdocumentation_property ();
1856 extern Lisp_Object read_doc_string ();
1857
1858 /* defined in bytecode.c */
1859 extern Lisp_Object Qbytecode;
1860 extern Lisp_Object Fbyte_code ();
1861
1862 /* defined in macros.c */
1863 extern Lisp_Object Qexecute_kbd_macro;
1864 extern Lisp_Object Fexecute_kbd_macro ();
1865
1866 /* defined in undo.c */
1867 extern Lisp_Object Qinhibit_read_only;
1868 extern Lisp_Object Fundo_boundary ();
1869 extern Lisp_Object truncate_undo_list ();
1870
1871 /* defined in textprop.c */
1872 extern Lisp_Object Qmodification_hooks;
1873 extern Lisp_Object Qrear_nonsticky, Qfont;
1874 extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
1875 extern Lisp_Object Fnext_property_change ();
1876 extern Lisp_Object Fnext_single_property_change ();
1877 extern Lisp_Object Fprevious_single_property_change ();
1878 extern Lisp_Object Fget_text_property (), Fput_text_property ();
1879 extern Lisp_Object Fset_text_properties ();
1880 extern Lisp_Object Ftext_property_not_all ();
1881
1882 /* defined in intervals.c */
1883 extern Lisp_Object get_local_map ();
1884
1885 /* defined in xmenu.c */
1886 extern Lisp_Object Fx_popup_menu (), Fx_popup_dialog ();
1887 \f
1888 /* Nonzero means Emacs has already been initialized.
1889    Used during startup to detect startup of dumped Emacs.  */
1890 extern int initialized;
1891
1892 extern int immediate_quit;          /* Nonzero means ^G can quit instantly */
1893
1894 extern void debugger ();
1895
1896 extern char *getenv (), *ctime (), *getwd ();
1897 extern long *xmalloc (), *xrealloc ();
1898 extern void xfree ();
1899
1900 extern char *egetenv ();
1901
1902 /* Set up the name of the machine we're running on.  */
1903 extern void init_system_name ();
1904
1905 /* Some systems (e.g., NT) use a different path separator than Unix,
1906    in addition to a device separator.  Default the path separator
1907    to '/', and don't test for a device separator in IS_ANY_SEP.  */
1908
1909 #ifdef WINDOWSNT
1910 extern Lisp_Object Vdirectory_sep_char;
1911 #endif
1912
1913 #ifndef DIRECTORY_SEP
1914 #define DIRECTORY_SEP '/'
1915 #endif
1916 #ifndef IS_DIRECTORY_SEP
1917 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
1918 #endif
1919 #ifndef IS_DEVICE_SEP
1920 #ifndef DEVICE_SEP
1921 #define IS_DEVICE_SEP(_c_) 0
1922 #else
1923 #define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
1924 #endif
1925 #endif
1926 #ifndef IS_ANY_SEP
1927 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
1928 #endif
1929
1930 #ifdef SWITCH_ENUM_BUG
1931 #define SWITCH_ENUM_CAST(x) ((int)(x))
1932 #else
1933 #define SWITCH_ENUM_CAST(x) (x)
1934 #endif