src/lisp.h

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