src/lisp.h

   1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
   2    Copyright (C) 1985, 1986, 1987, 1992 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       ,
 160     Lisp_Float
 161 #endif /* LISP_FLOAT_TYPE */
 162   };
 163
 164 #ifndef NO_UNION_TYPE
 165
 166 #ifndef BIG_ENDIAN
 167
 168 /* Definition of Lisp_Object for little-endian machines.  */
 169
 170 typedef
 171 union Lisp_Object
 172   {
 173     /* Used for comparing two Lisp_Objects;
 174        also, positive integers can be accessed fast this way. */
 175     int i;
 176
 177     struct
 178       {
 179         int val: 24;
 180         char type;
 181       } s;
 182     struct
 183       {
 184         unsigned int val: 24;
 185         char type;
 186       } u;
 187     struct
 188       {
 189         unsigned int val: 24;
 190         enum Lisp_Type type: 7;
 191         /* The markbit is not really part of the value of a Lisp_Object,
 192            and is always zero except during garbage collection.  */
 193         unsigned int markbit: 1;
 194       } gu;
 195   }
 196 Lisp_Object;
 197
 198 #else /* If BIG_ENDIAN */
 199
 200 typedef
 201 union Lisp_Object
 202   {
 203     /* Used for comparing two Lisp_Objects;
 204        also, positive integers can be accessed fast this way. */
 205     int i;
 206
 207     struct
 208       {
 209         char type;
 210         int val: 24;
 211       } s;
 212     struct
 213       {
 214         char type;
 215         unsigned int val: 24;
 216       } u;
 217     struct
 218       {
 219         /* The markbit is not really part of the value of a Lisp_Object,
 220            and is always zero except during garbage collection.  */
 221         unsigned int markbit: 1;
 222         enum Lisp_Type type: 7;
 223         unsigned int val: 24;
 224       } gu;
 225   }
 226 Lisp_Object;
 227
 228 #endif /* BIG_ENDIAN */
 229
 230 #endif /* NO_UNION_TYPE */
 231
 232
 233 /* If union type is not wanted, define Lisp_Object as just a number
 234    and define the macros below to extract fields by shifting */
 235
 236 #ifdef NO_UNION_TYPE
 237
 238 #define Lisp_Object int
 239
 240 /* These values are overridden by the m- file on some machines.  */
 241 #ifndef VALBITS
 242 #define VALBITS 24
 243 #endif
 244
 245 #ifndef GCTYPEBITS
 246 #define GCTYPEBITS 7
 247 #endif
 248
 249 #ifndef VALMASK
 250 #define VALMASK ((1<<VALBITS) - 1)
 251 #endif
 252 #define GCTYPEMASK ((1<<GCTYPEBITS) - 1)
 253 #define MARKBIT (1 << (VALBITS + GCTYPEBITS))
 254
 255 #endif /* NO_UNION_TYPE */
 256 \f
 257 /* These macros extract various sorts of values from a Lisp_Object.
 258  For example, if tem is a Lisp_Object whose type is Lisp_Cons,
 259  XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */
 260
 261 #ifdef NO_UNION_TYPE
 262
 263 /* One need to override this if there must be high bits set in data space
 264    (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
 265     on all machines, but would penalise machines which don't need it)
 266  */
 267 #ifndef XTYPE
 268 #define XTYPE(a) ((enum Lisp_Type) ((a) >> VALBITS))
 269 #endif
 270
 271 #ifndef XSETTYPE
 272 #define XSETTYPE(a, b) ((a)  =  XUINT (a) | ((int)(b) << VALBITS))
 273 #endif
 274
 275 /* Use XFASTINT for fast retrieval and storage of integers known
 276   to be positive.  This takes advantage of the fact that Lisp_Int is 0.  */
 277 #define XFASTINT(a) (a)
 278
 279 /* Extract the value of a Lisp_Object as a signed integer.  */
 280
 281 #ifndef XINT   /* Some machines need to do this differently.  */
 282 #define XINT(a) (((a) << (INTBITS-VALBITS)) >> (INTBITS-VALBITS))
 283 #endif
 284
 285 /* Extract the value as an unsigned integer.  This is a basis
 286    for extracting it as a pointer to a structure in storage.  */
 287
 288 #ifndef XUINT
 289 #define XUINT(a) ((a) & VALMASK)
 290 #endif
 291
 292 #ifndef XPNTR
 293 #ifdef HAVE_SHM
 294 /* In this representation, data is found in two widely separated segments.  */
 295 extern int pure_size;
 296 #define XPNTR(a) \
 297   (XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
 298 #else /* not HAVE_SHM */
 299 #ifdef DATA_SEG_BITS
 300 /* This case is used for the rt-pc.
 301    In the diffs I was given, it checked for ptr = 0
 302    and did not adjust it in that case.
 303    But I don't think that zero should ever be found
 304    in a Lisp object whose data type says it points to something.  */
 305 #define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
 306 #else
 307 #define XPNTR(a) XUINT (a)
 308 #endif
 309 #endif /* not HAVE_SHM */
 310 #endif /* no XPNTR */
 311
 312 #ifndef XSETINT
 313 #define XSETINT(a, b)  ((a) = ((a) & ~VALMASK) |  ((b) & VALMASK))
 314 #endif
 315
 316 #ifndef XSETUINT
 317 #define XSETUINT(a, b) XSETINT (a, b)
 318 #endif
 319
 320 #ifndef XSETPNTR
 321 #define XSETPNTR(a, b) XSETINT (a, b)
 322 #endif
 323
 324 #ifndef XSET
 325 #define XSET(var, type, ptr) \
 326    ((var) = ((int)(type) << VALBITS) + ((int) (ptr) & VALMASK))
 327 #endif
 328
 329 /* During garbage collection, XGCTYPE must be used for extracting types
 330  so that the mark bit is ignored.  XMARKBIT accesses the markbit.
 331  Markbits are used only in particular slots of particular structure types.
 332  Other markbits are always zero.
 333  Outside of garbage collection, all mark bits are always zero.  */
 334
 335 #ifndef XGCTYPE
 336 #define XGCTYPE(a) ((enum Lisp_Type) (((a) >> VALBITS) & GCTYPEMASK))
 337 #endif
 338
 339 #if VALBITS + GCTYPEBITS == INTBITS - 1
 340 /* Make XMARKBIT faster if mark bit is sign bit.  */
 341 #ifndef XMARKBIT
 342 #define XMARKBIT(a) ((a) < 0)
 343 #endif
 344 #endif /* markbit is sign bit */
 345
 346 #ifndef XMARKBIT
 347 #define XMARKBIT(a) ((a) & MARKBIT)
 348 #endif
 349
 350 #ifndef XSETMARKBIT
 351 #define XSETMARKBIT(a,b) ((a) = ((a) & ~MARKBIT) | ((b) ? MARKBIT : 0))
 352 #endif
 353
 354 #ifndef XMARK
 355 #define XMARK(a) ((a) |= MARKBIT)
 356 #endif
 357
 358 #ifndef XUNMARK
 359 #define XUNMARK(a) ((a) &= ~MARKBIT)
 360 #endif
 361
 362 #endif /* NO_UNION_TYPE */
 363
 364 #ifndef NO_UNION_TYPE
 365
 366 #define XTYPE(a) ((enum Lisp_Type) (a).u.type)
 367 #define XSETTYPE(a, b) ((a).u.type = (char) (b))
 368
 369 /* Use XFASTINT for fast retrieval and storage of integers known
 370   to be positive.  This takes advantage of the fact that Lisp_Int is 0.  */
 371 #define XFASTINT(a) ((a).i)
 372
 373 #ifdef EXPLICIT_SIGN_EXTEND
 374 /* Make sure we sign-extend; compilers have been known to fail to do so.  */
 375 #define XINT(a) (((a).i << 8) >> 8)
 376 #else
 377 #define XINT(a) ((a).s.val)
 378 #endif /* EXPLICIT_SIGN_EXTEND */
 379
 380 #define XUINT(a) ((a).u.val)
 381 #define XPNTR(a) ((a).u.val)
 382 #define XSETINT(a, b) ((a).s.val = (int) (b))
 383 #define XSETUINT(a, b) ((a).s.val = (int) (b))
 384 #define XSETPNTR(a, b) ((a).s.val = (int) (b))
 385
 386 #define XSET(var, vartype, ptr) \
 387    (((var).s.type = ((char) (vartype))), ((var).s.val = ((int) (ptr))))
 388
 389 /* During garbage collection, XGCTYPE must be used for extracting types
 390  so that the mark bit is ignored.  XMARKBIT access the markbit.
 391  Markbits are used only in particular slots of particular structure types.
 392  Other markbits are always zero.
 393  Outside of garbage collection, all mark bits are always zero.  */
 394
 395 #define XGCTYPE(a) ((a).gu.type)
 396 #define XMARKBIT(a) ((a).gu.markbit)
 397 #define XSETMARKBIT(a,b) (XMARKBIT(a) = (b))
 398 #define XMARK(a) (XMARKBIT(a) = 1)
 399 #define XUNMARK(a) (XMARKBIT(a) = 0)
 400
 401 #endif /* NO_UNION_TYPE */
 402
 403
 404 #define XCONS(a) ((struct Lisp_Cons *) XPNTR(a))
 405 #define XBUFFER(a) ((struct buffer *) XPNTR(a))
 406 #define XVECTOR(a) ((struct Lisp_Vector *) XPNTR(a))
 407 #define XSUBR(a) ((struct Lisp_Subr *) XPNTR(a))
 408 #define XSTRING(a) ((struct Lisp_String *) XPNTR(a))
 409 #define XSYMBOL(a) ((struct Lisp_Symbol *) XPNTR(a))
 410 #define XFUNCTION(a) ((Lisp_Object (*)()) XPNTR(a))
 411 #define XMARKER(a) ((struct Lisp_Marker *) XPNTR(a))
 412 #define XOBJFWD(a) ((Lisp_Object *) XPNTR(a))
 413 #define XINTPTR(a) ((int *) XPNTR(a))
 414 #define XWINDOW(a) ((struct window *) XPNTR(a))
 415 #define XPROCESS(a) ((struct Lisp_Process *) XPNTR(a))
 416 #define XFLOAT(a) ((struct Lisp_Float *) XPNTR(a))
 417
 418 #define XSETCONS(a, b) XSETPNTR(a, (int) (b))
 419 #define XSETBUFFER(a, b) XSETPNTR(a, (int) (b))
 420 #define XSETVECTOR(a, b) XSETPNTR(a, (int) (b))
 421 #define XSETSUBR(a, b) XSETPNTR(a, (int) (b))
 422 #define XSETSTRING(a, b) XSETPNTR(a, (int) (b))
 423 #define XSETSYMBOL(a, b) XSETPNTR(a, (int) (b))
 424 #define XSETFUNCTION(a, b) XSETPNTR(a, (int) (b))
 425 #define XSETMARKER(a, b) XSETPNTR(a, (int) (b))
 426 #define XSETOBJFWD(a, b) XSETPNTR(a, (int) (b))
 427 #define XSETINTPTR(a, b) XSETPNTR(a, (int) (b))
 428 #define XSETWINDOW(a, b) XSETPNTR(a, (int) (b))
 429 #define XSETPROCESS(a, b) XSETPNTR(a, (int) (b))
 430 #define XSETFLOAT(a, b) XSETPNTR(a, (int) (b))
 431 \f
 432 #ifdef USE_TEXT_PROPERTIES
 433 /* Basic data type for use of intervals.  See the macros in intervals.h */
 434
 435 struct interval
 436 {
 437   /* The first group of entries deal with the tree structure. */
 438
 439   unsigned int total_length;    /* Length of myself and both children. */
 440   unsigned int position;        /* Cache of interval's character position  */
 441   struct interval *left;        /* Intervals which precede me. */
 442   struct interval *right;       /* Intervals which succeed me. */
 443   struct interval *parent;      /* Parent in the tree, or the Lisp_Object
 444                                    containing this interval tree. */
 445
 446   /* The remaining components are `properties' of the interval.
 447      The first four are duplicates for things which can be on the list,
 448      for purposes of speed. */
 449
 450   unsigned char write_protect;      /* Non-zero means can't modify.  */
 451   unsigned char visible;            /* Zero means don't display. */
 452   unsigned char front_sticky;       /* Non-zero means text inserted just
 453                                        before this interval goes into it. */
 454   unsigned char rear_sticky;        /* Likewise for just after it. */
 455
 456   Lisp_Object plist;                /* Properties of this interval. */
 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 (XTYPE ((x)) != Lisp_String && XTYPE ((x)) != Lisp_Buffer) \
 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 condionally 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     int size;
 508     DECLARE_INTERVALS           /* `data' field must be last. */
 509     unsigned char data[1];
 510   };
 511
 512 struct Lisp_Vector
 513   {
 514     int size;
 515     struct Lisp_Vector *next;
 516     Lisp_Object contents[1];
 517   };
 518
 519 /* In a symbol, the markbit of the plist is used as the gc mark bit */
 520
 521 struct Lisp_Symbol
 522   {
 523     struct Lisp_String *name;
 524     Lisp_Object value;
 525     Lisp_Object function;
 526     Lisp_Object plist;
 527     struct Lisp_Symbol *next;   /* -> next symbol in this obarray bucket */
 528   };
 529
 530 struct Lisp_Subr
 531   {
 532     Lisp_Object (*function) ();
 533     short min_args, max_args;
 534     char *symbol_name;
 535     char *prompt;
 536     char *doc;
 537   };
 538
 539 /* In a marker, the markbit of the chain field is used as the gc mark bit */
 540
 541 struct Lisp_Marker
 542   {
 543     struct buffer *buffer;
 544     Lisp_Object chain;
 545     int bufpos;
 546     int modified;
 547   };
 548
 549 #ifdef LISP_FLOAT_TYPE
 550 /* Optional Lisp floating point type */
 551 struct Lisp_Float
 552   {
 553     Lisp_Object type;           /* essentially used for mark-bit
 554                                    and chaining when on free-list */
 555     double data;
 556   };
 557 #endif /* LISP_FLOAT_TYPE */
 558
 559 /* A character, declared with the following typedef, is a member
 560    of some character set associated with the current buffer. */
 561 typedef unsigned char UCHAR;
 562
 563 /* Meanings of slots in a Lisp_Compiled:  */
 564
 565 #define COMPILED_ARGLIST 0
 566 #define COMPILED_BYTECODE 1
 567 #define COMPILED_CONSTANTS 2
 568 #define COMPILED_STACK_DEPTH 3
 569 #define COMPILED_DOC_STRING 4
 570 #define COMPILED_INTERACTIVE 5
 571
 572 /* Flag bits in a character.  */
 573
 574 #define CHAR_META 0x800000
 575 #define CHAR_CTL  0x400000
 576 #define CHAR_SHIFT 0x200000
 577 \f
 578 /* Data type checking */
 579
 580 #define NILP(x)  (XFASTINT (x) == XFASTINT (Qnil))
 581 #define GC_NILP(x) GC_EQ (x, Qnil)
 582
 583 #ifdef LISP_FLOAT_TYPE
 584 #define NUMBERP(x) (XTYPE (x) == Lisp_Int || XTYPE (x) == Lisp_Float)
 585 #else
 586 #define NUMBERP(x) (XTYPE (x) == Lisp_Int)
 587 #endif
 588
 589 #define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
 590 #define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
 591 #define MARKERP(x) (XTYPE ((x)) == Lisp_Marker)
 592 #define STRINGP(x) (XTYPE ((x)) == Lisp_String)
 593 #define VECTORP(x) (XTYPE ((x)) == Lisp_Vector)
 594 #define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
 595 #define COMPILEDP(x) (XTYPE ((x)) == Lisp_Compiled)
 596 #define BUFFERP(x) (XTYPE ((x)) == Lisp_Buffer)
 597 #define SUBRP(x) (XTYPE ((x)) == Lisp_Subr)
 598 #define PROCESSP(x) (XTYPE ((x)) == Lisp_Process)
 599 #define FRAMEP(x) (XTYPE ((x)) == Lisp_Frame)
 600 #define WINDOWP(x) (XTYPE ((x)) == Lisp_Window)
 601 #define WINDOW_CONFIGURATIONP(x) (XTYPE ((x)) == Lisp_Window_Configuration)
 602 #define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
 603
 604 #define EQ(x, y) (XFASTINT (x) == XFASTINT (y))
 605 #define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y))
 606
 607 #define CHECK_LIST(x, i) \
 608   { if ((XTYPE ((x)) != Lisp_Cons) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); }
 609
 610 #define CHECK_STRING(x, i) \
 611   { if (XTYPE ((x)) != Lisp_String) x = wrong_type_argument (Qstringp, (x)); }
 612
 613 #define CHECK_CONS(x, i) \
 614   { if (XTYPE ((x)) != Lisp_Cons) x = wrong_type_argument (Qconsp, (x)); }
 615
 616 #define CHECK_SYMBOL(x, i) \
 617   { if (XTYPE ((x)) != Lisp_Symbol) x = wrong_type_argument (Qsymbolp, (x)); }
 618
 619 #define CHECK_VECTOR(x, i) \
 620   { if (XTYPE ((x)) != Lisp_Vector) x = wrong_type_argument (Qvectorp, (x)); }
 621
 622 #define CHECK_BUFFER(x, i) \
 623   { if (XTYPE ((x)) != Lisp_Buffer) x = wrong_type_argument (Qbufferp, (x)); }
 624
 625 #define CHECK_WINDOW(x, i) \
 626   { if (XTYPE ((x)) != Lisp_Window) x = wrong_type_argument (Qwindowp, (x)); }
 627
 628 /* This macro rejects windows on the interior of the window tree as
 629    "dead", which is what we want; this is an argument-checking macro, and
 630    the user should never get access to interior windows.
 631
 632    A window of any sort, leaf or interior, is dead iff the buffer,
 633    vchild, and hchild members are all nil.  */
 634
 635 #define CHECK_LIVE_WINDOW(x, i)                         \
 636   {                                                     \
 637     if (XTYPE ((x)) != Lisp_Window                      \
 638         || NILP (XWINDOW ((x))->buffer))                \
 639       x = wrong_type_argument (Qwindow_live_p, (x));    \
 640   }
 641
 642 #define CHECK_PROCESS(x, i) \
 643   { if (XTYPE ((x)) != Lisp_Process) x = wrong_type_argument (Qprocessp, (x)); }
 644
 645 #define CHECK_NUMBER(x, i) \
 646   { if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qintegerp, (x)); }
 647
 648 #define CHECK_NATNUM(x, i) \
 649   { if (XTYPE ((x)) != Lisp_Int || XINT ((x)) < 0)      \
 650       x = wrong_type_argument (Qnatnump, (x)); }
 651
 652 #define CHECK_MARKER(x, i) \
 653   { if (XTYPE ((x)) != Lisp_Marker) x = wrong_type_argument (Qmarkerp, (x)); }
 654
 655 #define CHECK_NUMBER_COERCE_MARKER(x, i) \
 656   { if (XTYPE ((x)) == Lisp_Marker) XFASTINT (x) = marker_position (x); \
 657     else if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qinteger_or_marker_p, (x)); }
 658
 659 #ifdef LISP_FLOAT_TYPE
 660
 661 #ifndef DBL_DIG
 662 #define DBL_DIG 20
 663 #endif
 664
 665 #define XFLOATINT(n) extract_float((n))
 666
 667 #define CHECK_FLOAT(x, i)               \
 668 { if (XTYPE (x) != Lisp_Float)  \
 669     x = wrong_type_argument (Qfloatp, (x)); }
 670
 671 #define CHECK_NUMBER_OR_FLOAT(x, i)     \
 672 { if (XTYPE (x) != Lisp_Float && XTYPE (x) != Lisp_Int) \
 673     x = wrong_type_argument (Qnumberp, (x)); }
 674
 675 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x, i) \
 676 { if (XTYPE (x) == Lisp_Marker) XFASTINT (x) = marker_position (x);     \
 677   else if (XTYPE (x) != Lisp_Int && XTYPE (x) != Lisp_Float)            \
 678     x = wrong_type_argument (Qnumber_or_marker_p, (x)); }
 679
 680 #else  /* Not LISP_FLOAT_TYPE */
 681
 682 #define CHECK_NUMBER_OR_FLOAT CHECK_NUMBER
 683
 684 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER CHECK_NUMBER_COERCE_MARKER
 685
 686 #define XFLOATINT(n) XINT((n))
 687 #endif /* LISP_FLOAT_TYPE */
 688
 689 /* Cast pointers to this type to compare them.  Some machines want int.  */
 690 #ifndef PNTR_COMPARISON_TYPE
 691 #define PNTR_COMPARISON_TYPE unsigned int
 692 #endif
 693 \f
 694 /* Define a built-in function for calling from Lisp.
 695  `lname' should be the name to give the function in Lisp,
 696     as a null-terminated C string.
 697  `fnname' should be the name of the function in C.
 698     By convention, it starts with F.
 699  `sname' should be the name for the C constant structure
 700     that records information on this function for internal use.
 701     By convention, it should be the same as `fnname' but with S instead of F.
 702     It's too bad that C macros can't compute this from `fnname'.
 703  `minargs' should be a number, the minimum number of arguments allowed.
 704  `maxargs' should be a number, the maximum number of arguments allowed,
 705     or else MANY or UNEVALLED.
 706     MANY means pass a vector of evaluated arguments,
 707          in the form of an integer number-of-arguments
 708          followed by the address of a vector of Lisp_Objects
 709          which contains the argument values.
 710     UNEVALLED means pass the list of unevaluated arguments
 711  `prompt' says how to read arguments for an interactive call.
 712     This can be zero or a C string.
 713     Zero means that interactive calls are not allowed.
 714     A string is interpreted in a hairy way:
 715      it should contain one line for each argument to be read, terminated by \n.
 716      The first character of the line controls the type of parsing:
 717        s  --  read a string.
 718        S  --  read a symbol.
 719        k  --  read a key sequence and return it as a string.
 720        a  --  read a function name (symbol) with completion.
 721        C  --  read a command name (symbol) with completion.
 722        v  --  read a variable name (symbol) with completion.
 723        b  --  read a buffer name (a string) with completion.
 724        B  --  buffer name, may be existing buffer or may not be.
 725        f  --  read a file name, file must exist.
 726        F  --  read a file name, file need not exist.
 727        n  --  read a number.
 728        c  --  read a character and return it as a number.
 729        p  --  use the numeric value of the prefix argument.
 730        P  --  use raw value of prefix - can be nil, -, (NUMBER) or NUMBER.
 731        x  --  read a Lisp object from the minibuffer.
 732        X  --  read a Lisp form from the minibuffer and use its value.
 733     A null string means call interactively with no arguments.
 734  `doc' is documentation for the user.
 735 */
 736
 737 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
 738   Lisp_Object fnname (); \
 739   struct Lisp_Subr sname = {fnname, minargs, maxargs, lname, prompt, 0}; \
 740   Lisp_Object fnname
 741
 742 /* defsubr (Sname);
 743  is how we define the symbol for function `name' at start-up time. */
 744 extern void defsubr ();
 745
 746 #define MANY -2
 747 #define UNEVALLED -1
 748
 749 extern void defvar_lisp ();
 750 extern void defvar_bool ();
 751 extern void defvar_int ();
 752
 753 /* Macros we use to define forwarded Lisp variables.
 754    These are used in the syms_of_FILENAME functions.  */
 755
 756 #define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
 757 #define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
 758 #define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
 759 #define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
 760 #define DEFVAR_PER_BUFFER(lname, vname, type, doc)  \
 761  defvar_per_buffer (lname, vname, type, 0)
 762 \f
 763 /* Structure for recording Lisp call stack for backtrace purposes.  */
 764
 765 /* The special binding stack holds the outer values of variables while
 766    they are bound by a function application or a let form, stores the
 767    code to be executed for Lisp unwind-protect forms, and stores the C
 768    functions to be called for record_unwind_protect.
 769
 770    If func is non-zero, undoing this binding applies func to old_value;
 771       This implements record_unwind_protect.
 772    If func is zero and symbol is nil, undoing this binding evaluates
 773       the list of forms in old_value; this implements Lisp's unwind-protect
 774       form.
 775    Otherwise, undoing this binding stores old_value as symbol's value; this
 776       undoes the bindings made by a let form or function call.  */
 777 struct specbinding
 778   {
 779     Lisp_Object symbol, old_value;
 780     Lisp_Object (*func) ();
 781     Lisp_Object unused;         /* Dividing by 16 is faster than by 12 */
 782   };
 783
 784 extern struct specbinding *specpdl;
 785 extern struct specbinding *specpdl_ptr;
 786 extern int specpdl_size;
 787
 788 /* Everything needed to describe an active condition case.  */
 789 struct handler
 790   {
 791     /* The handler clauses and variable from the condition-case form.  */
 792     Lisp_Object handler;
 793     Lisp_Object var;
 794
 795     /* Used to effect the longjump out to the handler.  */
 796     struct catchtag *tag;
 797
 798     /* The next enclosing handler.  */
 799     struct handler *next;
 800   };
 801
 802 extern struct handler *handlerlist;
 803
 804 extern struct catchtag *catchlist;
 805 extern struct backtrace *backtrace_list;
 806
 807 /* An address near the bottom of the stack.
 808    Tells GC how to save a copy of the stack.  */
 809 extern char *stack_bottom;
 810
 811 /* Check quit-flag and quit if it is non-nil. */
 812
 813 #define QUIT \
 814   if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
 815     { Vquit_flag = Qnil; Fsignal (Qquit, Qnil); }
 816
 817 /* Nonzero if ought to quit now.  */
 818
 819 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
 820 \f
 821 /* 1 if CH is upper case.  */
 822
 823 #define UPPERCASEP(CH) \
 824   (XSTRING (current_buffer->downcase_table)->data[CH] != (CH))
 825
 826 /* 1 if CH is lower case.  */
 827
 828 #define LOWERCASEP(CH) \
 829   (!UPPERCASEP (CH) \
 830    && XSTRING (current_buffer->upcase_table)->data[CH] != (CH))
 831
 832 /* 1 if CH is neither upper nor lower case.  */
 833
 834 #define NOCASEP(CH) (XSTRING (current_buffer->upcase_table)->data[CH] == (CH))
 835
 836 /* Upcase a character, or make no change if that cannot be done.  */
 837
 838 #define UPCASE(CH) \
 839   (XSTRING (current_buffer->downcase_table)->data[CH] == (CH) \
 840    ? UPCASE1 (CH) : (CH))
 841
 842 /* Upcase a character known to be not upper case.  */
 843
 844 #define UPCASE1(CH) (XSTRING (current_buffer->upcase_table)->data[CH])
 845
 846 /* Downcase a character, or make no change if that cannot be done. */
 847
 848 #define DOWNCASE(CH) (XSTRING (current_buffer->downcase_table)->data[CH])
 849
 850 /* Current buffer's map from characters to lower-case characters.  */
 851
 852 #define DOWNCASE_TABLE XSTRING (current_buffer->downcase_table)->data
 853
 854 /* Table mapping each char to the next char with the same lowercase version.
 855    This mapping is a no-op only for characters that don't have case.  */
 856 #define UPCASE_TABLE XSTRING (current_buffer->upcase_table)->data
 857
 858 extern Lisp_Object Vascii_downcase_table, Vascii_upcase_table;
 859 \f
 860 /* number of bytes of structure consed since last GC */
 861
 862 extern int consing_since_gc;
 863
 864 /* threshold for doing another gc */
 865
 866 extern int gc_cons_threshold;
 867
 868 /* Structure for recording stack slots that need marking */
 869
 870 /* This is a chain of structures, each of which points at a Lisp_Object variable
 871  whose value should be marked in garbage collection.
 872  Normally every link of the chain is an automatic variable of a function,
 873  and its `val' points to some argument or local variable of the function.
 874  On exit to the function, the chain is set back to the value it had on entry.
 875  This way, no link remains in the chain when the stack frame containing the link disappears.
 876
 877  Every function that can call Feval must protect in this fashion all
 878  Lisp_Object variables whose contents will be used again. */
 879
 880 extern struct gcpro *gcprolist;
 881
 882 struct gcpro
 883   {
 884     struct gcpro *next;
 885     Lisp_Object *var;           /* Address of first protected variable */
 886     int nvars;                  /* Number of consecutive protected variables */
 887   };
 888
 889 #define GCPRO1(varname) \
 890  {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
 891   gcprolist = &gcpro1; }
 892
 893 #define GCPRO2(varname1, varname2) \
 894  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
 895   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
 896   gcprolist = &gcpro2; }
 897
 898 #define GCPRO3(varname1, varname2, varname3) \
 899  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
 900   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
 901   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
 902   gcprolist = &gcpro3; }
 903
 904 #define GCPRO4(varname1, varname2, varname3, varname4) \
 905  {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
 906   gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
 907   gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
 908   gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
 909   gcprolist = &gcpro4; }
 910
 911 /* Call staticpro (&var) to protect static variable `var'. */
 912
 913 void staticpro();
 914
 915 #define UNGCPRO (gcprolist = gcpro1.next)
 916
 917 /* Evaluate expr, UNGCPRO, and then return the value of expr.  I used
 918    to have a `do ... while' clause around this to make it interact
 919    with semicolons correctly, but this makes some compilers complain
 920    that the while is never reached.  */
 921 #define RETURN_UNGCPRO(expr)            \
 922     {                                   \
 923       Lisp_Object ret_ungc_val;         \
 924       ret_ungc_val = (expr);            \
 925       UNGCPRO;                          \
 926       return ret_ungc_val;              \
 927     }                                   \
 928 \f
 929 /* Defined in data.c */
 930 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
 931 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
 932 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
 933 extern Lisp_Object Qvoid_variable, Qvoid_function;
 934 extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
 935 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
 936 extern Lisp_Object Qend_of_file, Qarith_error;
 937 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
 938
 939 Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
 940 Lisp_Object Qoverflow_error, Qunderflow_error;
 941
 942 extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qsymbolp, Qlistp, Qconsp;
 943 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
 944 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp;
 945 extern Lisp_Object Qinteger_or_marker_p, Qnumber_or_marker_p;
 946 extern Lisp_Object Qboundp, Qfboundp;
 947 extern Lisp_Object Qbuffer_or_string_p;
 948 extern Lisp_Object Qcdr;
 949
 950 #ifdef LISP_FLOAT_TYPE
 951 extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
 952 #endif /* LISP_FLOAT_TYPE */
 953
 954 extern Lisp_Object Qframep;
 955
 956 extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp ();
 957 extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp ();
 958 extern Lisp_Object Fvectorp (), Fstringp (), Farrayp (), Fsequencep ();
 959 extern Lisp_Object Fbufferp (), Fmarkerp (), Fsubrp (), Fchar_or_string_p ();
 960 extern Lisp_Object Finteger_or_marker_p ();
 961 #ifdef LISP_FLOAT_TYPE
 962 extern Lisp_Object Ffloatp(), Finteger_or_floatp();
 963 extern Lisp_Object Finteger_or_float_or_marker_p(), Ftruncate();
 964 #endif /* LISP_FLOAT_TYPE */
 965
 966 extern Lisp_Object Fcar (), Fcar_safe(), Fcdr (), Fcdr_safe();
 967 extern Lisp_Object Fsetcar (), Fsetcdr ();
 968 extern Lisp_Object Fboundp (), Ffboundp (), Fmakunbound (), Ffmakunbound ();
 969 extern Lisp_Object Fsymbol_function (), Fsymbol_plist (), Fsymbol_name ();
 970 extern Lisp_Object indirect_function (), Findirect_function ();
 971 extern Lisp_Object Ffset (), Fsetplist ();
 972 extern Lisp_Object Fsymbol_value (), find_symbol_value (), Fset ();
 973 extern Lisp_Object Fdefault_value (), Fset_default (), Fdefault_boundp ();
 974
 975 extern Lisp_Object Faref (), Faset (), Farray_length ();
 976
 977 extern Lisp_Object Fstring_to_number (), Fnumber_to_string ();
 978 extern Lisp_Object Feqlsign (), Fgtr (), Flss (), Fgeq (), Fleq ();
 979 extern Lisp_Object Fneq (), Fzerop ();
 980 extern Lisp_Object Fplus (), Fminus (), Ftimes (), Fquo (), Frem ();
 981 extern Lisp_Object Fmax (), Fmin ();
 982 extern Lisp_Object Flogand (), Flogior (), Flogxor (), Flognot ();
 983 extern Lisp_Object Flsh (), Fash ();
 984
 985 extern Lisp_Object Fadd1 (), Fsub1 ();
 986
 987 extern Lisp_Object make_number ();
 988 extern Lisp_Object   long_to_cons ();
 989 extern unsigned long cons_to_long ();
 990 extern void args_out_of_range ();
 991 extern void args_out_of_range_3 ();
 992 extern Lisp_Object wrong_type_argument ();
 993 #ifdef LISP_FLOAT_TYPE
 994 extern Lisp_Object Ffloat_to_int(), Fint_to_float();
 995 extern double extract_float();
 996 extern Lisp_Object make_float ();
 997 extern Lisp_Object Ffloat ();
 998 #endif /* LISP_FLOAT_TYPE */
 999
1000 /* Defined in fns.c */
1001 extern Lisp_Object Qstring_lessp;
1002 extern Lisp_Object Vfeatures;
1003 extern Lisp_Object Fidentity (), Frandom ();
1004 extern Lisp_Object Flength ();
1005 extern Lisp_Object Fappend (), Fconcat (), Fvconcat (), Fcopy_sequence ();
1006 extern Lisp_Object Fsubstring ();
1007 extern Lisp_Object Fnth (), Fnthcdr (), Fmemq (), Fassq (), Fassoc ();
1008 extern Lisp_Object Frassq (), Fdelq (), Fsort ();
1009 extern Lisp_Object Freverse (), Fnreverse (), Fget (), Fput (), Fequal ();
1010 extern Lisp_Object Ffillarray (), Fnconc (), Fmapcar (), Fmapconcat ();
1011 extern Lisp_Object Fy_or_n_p (), do_yes_or_no_p ();
1012 extern Lisp_Object Ffeaturep (), Frequire () , Fprovide ();
1013 extern Lisp_Object concat2 (), nconc2 ();
1014 extern Lisp_Object assq_no_quit ();
1015 extern Lisp_Object Fcopy_alist ();
1016
1017 /* Defined in alloc.c */
1018 extern Lisp_Object Vpurify_flag;
1019 extern Lisp_Object Fcons (), Flist(), Fmake_list ();
1020 extern Lisp_Object Fmake_vector (), Fvector (), Fmake_symbol (), Fmake_marker ();
1021 extern Lisp_Object Fmake_string (), build_string (), make_string ();
1022 extern Lisp_Object make_event_array (), make_uninit_string ();
1023 extern Lisp_Object Fpurecopy (), make_pure_string ();
1024 extern Lisp_Object pure_cons (), make_pure_vector ();
1025 extern Lisp_Object Fgarbage_collect ();
1026 extern Lisp_Object Fmake_byte_code ();
1027
1028 /* Defined in print.c */
1029 extern Lisp_Object Vprin1_to_string_buffer;
1030 extern Lisp_Object Fprin1 (), Fprin1_to_string (), Fprinc ();
1031 extern Lisp_Object Fterpri (), Fprint ();
1032 extern Lisp_Object Vstandard_output, Qstandard_output;
1033 extern Lisp_Object Qexternal_debugging_output;
1034 extern void temp_output_buffer_setup (), temp_output_buffer_show ();
1035 extern int print_level, print_escape_newlines;
1036 extern Lisp_Object Qprint_escape_newlines;
1037
1038 /* Defined in lread.c */
1039 extern Lisp_Object Qvariable_documentation, Qstandard_input;
1040 extern Lisp_Object Vobarray, Vstandard_input;
1041 extern Lisp_Object Fread (), Fread_from_string ();
1042 extern Lisp_Object Fintern (), Fintern_soft (), Fload ();
1043 extern Lisp_Object Fget_file_char (), Fread_char ();
1044 extern Lisp_Object Feval_current_buffer (), Feval_region ();
1045 extern Lisp_Object intern (), oblookup ();
1046
1047 /* Defined in eval.c */
1048 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
1049 extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
1050 extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments;
1051 extern Lisp_Object Vautoload_queue;
1052 extern Lisp_Object Vrun_hooks;
1053 extern Lisp_Object Fand (), For (), Fif (), Fprogn (), Fprog1 (), Fprog2 ();
1054 extern Lisp_Object Fsetq (), Fquote ();
1055 extern Lisp_Object Fuser_variable_p (), Finteractive_p ();
1056 extern Lisp_Object Fdefun (), Flet (), FletX (), Fwhile ();
1057 extern Lisp_Object Fcatch (), Fthrow (), Funwind_protect ();
1058 extern Lisp_Object Fcondition_case (), Fsignal ();
1059 extern Lisp_Object Ffunction_type (), Fautoload (), Fcommandp ();
1060 extern Lisp_Object Feval (), Fapply (), Ffuncall ();
1061 extern Lisp_Object Fglobal_set (), Fglobal_value (), Fbacktrace ();
1062 extern Lisp_Object apply1 (), call0 (), call1 (), call2 (), call3 ();
1063 extern Lisp_Object apply_lambda ();
1064 extern Lisp_Object internal_catch ();
1065 extern Lisp_Object internal_condition_case ();
1066 extern Lisp_Object unbind_to ();
1067 extern void error ();
1068 extern Lisp_Object un_autoload ();
1069
1070 /* Defined in editfns.c */
1071 extern Lisp_Object Vprefix_arg, Qminus, Vcurrent_prefix_arg;
1072 extern Lisp_Object Fgoto_char ();
1073 extern Lisp_Object Fpoint_min_marker (), Fpoint_max_marker ();
1074 extern Lisp_Object Fpoint_min (), Fpoint_max ();
1075 extern Lisp_Object Fpoint (), Fpoint_marker (), Fmark_marker ();
1076 extern Lisp_Object Ffollowing_char (), Fprevious_char (), Fchar_after ();
1077 extern Lisp_Object Finsert ();
1078 extern Lisp_Object Feolp (), Feobp (), Fbolp (), Fbobp ();
1079 extern Lisp_Object Fformat (), format1 ();
1080 extern Lisp_Object make_buffer_string (), Fbuffer_substring ();
1081 extern Lisp_Object Fbuffer_string ();
1082 extern Lisp_Object Fstring_equal (), Fstring_lessp (), Fbuffer_substring_lessp ();
1083 extern Lisp_Object save_excursion_save (), save_restriction_save ();
1084 extern Lisp_Object save_excursion_restore (), save_restriction_restore ();
1085 extern Lisp_Object Fchar_to_string ();
1086
1087 /* defined in buffer.c */
1088 extern Lisp_Object Vbuffer_alist;
1089 extern Lisp_Object Fget_buffer (), Fget_buffer_create (), Fset_buffer ();
1090 extern Lisp_Object Fbarf_if_buffer_read_only ();
1091 extern Lisp_Object Fcurrent_buffer (), Fswitch_to_buffer (), Fpop_to_buffer ();
1092 extern Lisp_Object Fother_buffer ();
1093 extern struct buffer *all_buffers;
1094
1095 /* defined in marker.c */
1096
1097 extern Lisp_Object Fmarker_position (), Fmarker_buffer ();
1098 extern Lisp_Object Fcopy_marker ();
1099
1100 /* Defined in fileio.c */
1101
1102 extern Lisp_Object Qfile_error;
1103 extern Lisp_Object Ffind_file_name_handler ();
1104 extern Lisp_Object Ffile_name_as_directory ();
1105 extern Lisp_Object Fexpand_file_name (), Ffile_name_nondirectory ();
1106 extern Lisp_Object Fsubstitute_in_file_name ();
1107 extern Lisp_Object Ffile_symlink_p ();
1108 extern Lisp_Object Fverify_visited_file_modtime ();
1109 extern Lisp_Object Ffile_exists_p ();
1110 extern Lisp_Object Fdirectory_file_name ();
1111 extern Lisp_Object Ffile_name_directory ();
1112 extern Lisp_Object expand_and_dir_to_file ();
1113 extern Lisp_Object Ffile_accessible_directory_p ();
1114
1115 /* Defined in abbrev.c */
1116
1117 extern Lisp_Object Vfundamental_mode_abbrev_table;
1118
1119 /* defined in search.c */
1120 extern Lisp_Object Fstring_match ();
1121 extern Lisp_Object Fscan_buffer ();
1122
1123 /* defined in minibuf.c */
1124
1125 extern Lisp_Object last_minibuf_string;
1126 extern Lisp_Object read_minibuf (), Fcompleting_read ();
1127 extern Lisp_Object Fread_from_minibuffer ();
1128 extern Lisp_Object Fread_variable (), Fread_buffer (), Fread_key_sequence ();
1129 extern Lisp_Object Fread_minibuffer (), Feval_minibuffer ();
1130 extern Lisp_Object Fread_string (), Fread_file_name ();
1131 extern Lisp_Object Fread_no_blanks_input ();
1132
1133 /* Defined in callint.c */
1134
1135 extern Lisp_Object Vcommand_history;
1136 extern Lisp_Object Qcall_interactively;
1137 extern Lisp_Object Fcall_interactively ();
1138 extern Lisp_Object Fprefix_numeric_value ();
1139
1140 /* defined in casefiddle.c */
1141
1142 extern Lisp_Object Fdowncase (), Fupcase (), Fcapitalize ();
1143
1144 /* defined in keyboard.c */
1145
1146 extern Lisp_Object Qdisabled;
1147 extern Lisp_Object Vhelp_form, Vtop_level;
1148 extern Lisp_Object Fdiscard_input (), Frecursive_edit ();
1149 extern Lisp_Object Fcommand_execute (), Finput_pending_p ();
1150 extern Lisp_Object Qvertical_scroll_bar;
1151
1152 /* defined in keymap.c */
1153
1154 extern Lisp_Object Qkeymap;
1155 extern Lisp_Object current_global_map;
1156 extern Lisp_Object Fkey_description (), Fsingle_key_description ();
1157 extern Lisp_Object Fwhere_is_internal ();
1158 extern Lisp_Object access_keymap (), store_in_keymap ();
1159 extern Lisp_Object get_keyelt (), get_keymap();
1160
1161 /* defined in indent.c */
1162 extern Lisp_Object Fvertical_motion (), Findent_to (), Fcurrent_column ();
1163
1164 /* defined in window.c */
1165 extern Lisp_Object Qwindowp, Qwindow_live_p;
1166 extern Lisp_Object Fget_buffer_window ();
1167 extern Lisp_Object Fsave_window_excursion ();
1168 extern Lisp_Object Fset_window_configuration (), Fcurrent_window_configuration ();
1169 extern Lisp_Object Fcoordinates_in_window_p ();
1170 extern Lisp_Object Fwindow_at ();
1171 extern int window_internal_height (), window_internal_width ();
1172
1173 /* defined in frame.c */
1174 extern Lisp_Object Fframep ();
1175 extern Lisp_Object Fselect_frame ();
1176 extern Lisp_Object Ffocus_frame ();
1177 extern Lisp_Object Funfocus_frame ();
1178 extern Lisp_Object Fselected_frame ();
1179 extern Lisp_Object Fwindow_frame ();
1180 extern Lisp_Object Fframe_root_window ();
1181 extern Lisp_Object Fframe_selected_window ();
1182 extern Lisp_Object Fframe_list ();
1183 extern Lisp_Object Fnext_frame ();
1184 extern Lisp_Object Fdelete_frame ();
1185 extern Lisp_Object Fread_mouse_position ();
1186 extern Lisp_Object Fset_mouse_position ();
1187 extern Lisp_Object Fmake_frame_visible ();
1188 extern Lisp_Object Fmake_frame_invisible ();
1189 extern Lisp_Object Ficonify_frame ();
1190 extern Lisp_Object Fdeiconify_frame ();
1191 extern Lisp_Object Fframe_visible_p ();
1192 extern Lisp_Object Fvisible_frame_list ();
1193 extern Lisp_Object Fframe_parameters ();
1194 extern Lisp_Object Fmodify_frame_parameters ();
1195 extern Lisp_Object Fframe_pixel_size ();
1196 extern Lisp_Object Fframe_height ();
1197 extern Lisp_Object Fframe_width ();
1198 extern Lisp_Object Fset_frame_height ();
1199 extern Lisp_Object Fset_frame_width ();
1200 extern Lisp_Object Fset_frame_size ();
1201 extern Lisp_Object Fset_frame_position ();
1202 #ifndef HAVE_X11
1203 extern Lisp_Object Frubber_band_rectangle ();
1204 #endif  /* HAVE_X11 */
1205
1206 /* defined in emacs.c */
1207 extern Lisp_Object decode_env_path ();
1208 extern Lisp_Object Vinvocation_name;
1209 void shut_down_emacs ( /* int signal */ );
1210 /* Nonzero means don't do interactive redisplay and don't change tty modes */
1211 extern int noninteractive;
1212 /* Nonzero means don't do use window-system-specific display code */
1213 extern int inhibit_window_system;
1214
1215 /* defined in process.c */
1216 extern Lisp_Object Fget_process (), Fget_buffer_process (), Fprocessp ();
1217 extern Lisp_Object Fprocess_status (), Fkill_process ();
1218
1219 /* defined in callproc.c */
1220 extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
1221
1222 /* defined in doc.c */
1223 extern Lisp_Object Vdoc_file_name;
1224 extern Lisp_Object Fsubstitute_command_keys ();
1225 extern Lisp_Object Fdocumentation (), Fdocumentation_property ();
1226
1227 /* defined in bytecode.c */
1228 extern Lisp_Object Qbytecode;
1229 extern Lisp_Object Fbyte_code ();
1230
1231 /* defined in macros.c */
1232 extern Lisp_Object Qexecute_kbd_macro;
1233 extern Lisp_Object Fexecute_kbd_macro ();
1234
1235 /* defined in undo.c */
1236 extern Lisp_Object Fundo_boundary ();
1237 extern Lisp_Object truncate_undo_list ();
1238
1239 /* Nonzero means Emacs has already been initialized.
1240    Used during startup to detect startup of dumped Emacs.  */
1241 extern int initialized;
1242
1243 extern int immediate_quit;          /* Nonzero means ^G can quit instantly */
1244
1245 extern void debugger ();
1246
1247 extern char *malloc (), *realloc (), *getenv (), *ctime (), *getwd ();
1248 extern long *xmalloc (), *xrealloc ();
1249 extern void xfree ();
1250
1251 extern char *egetenv ();