src/lisp.h

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