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