![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lisp.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src|
Return to lisp.h CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src |
1.1 ! root 1: /* Fundamental definitions for GNU Emacs Lisp interpreter. ! 2: Copyright (C) 1985 Richard M. Stallman. ! 3: ! 4: This file is part of GNU Emacs. ! 5: ! 6: GNU Emacs is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU Emacs General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU Emacs, but only under the conditions described in the ! 15: GNU Emacs General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU Emacs so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: /* Define the fundamental Lisp data structures */ ! 23: ! 24: /* This is the set of Lisp data types */ ! 25: ! 26: enum Lisp_Type ! 27: { ! 28: /* Integer. object.v.integer is the integer value. */ ! 29: Lisp_Int, ! 30: ! 31: /* Symbol. object.v.symbol points to a struct Lisp_Symbol. */ ! 32: Lisp_Symbol, ! 33: ! 34: /* Marker (editor pointer). object.v.marker points to a struct Lisp_Marker. */ ! 35: Lisp_Marker, ! 36: ! 37: /* String. object.v.string points to a struct Lisp_String. ! 38: The length of the string, and its contents, are stored therein. */ ! 39: Lisp_String, ! 40: ! 41: /* Vector of Lisp objects. object.v.vector points to a struct Lisp_Vector. ! 42: The length of the vector, and its contents, are stored therein. */ ! 43: Lisp_Vector, ! 44: ! 45: /* Cons. object.v.cons points to a struct Lisp_Cons. */ ! 46: Lisp_Cons, ! 47: ! 48: /* Treated like vector in GC, except do not set its mark bit. ! 49: Used for internal data blocks that will be explicitly freed ! 50: but which, while active, are reached by GC mark exactly once ! 51: and should be marked through like a vector. */ ! 52: Lisp_Temp_Vector, ! 53: ! 54: /* Editor buffer. obj.v.buffer points to a struct buffer. ! 55: No buffer is ever truly freed; they can be "killed", but this ! 56: just marks them as dead. */ ! 57: Lisp_Buffer, ! 58: ! 59: /* Built-in function. obj.v.subr points to a struct Lisp_Subr ! 60: which describes how to call the function, and its documentation, ! 61: as well as pointing to the code. */ ! 62: Lisp_Subr, ! 63: ! 64: /* Internal value return by subroutines of read. ! 65: The user never sees this data type. ! 66: Its value is just a number. */ ! 67: Lisp_Internal, ! 68: ! 69: /* Forwarding pointer to an int variable. ! 70: This is allowed only in the value cell of a symbol, ! 71: and it means that the symbol's value really lives in the ! 72: specified int variable. ! 73: obj.v.intptr points to the int variable. */ ! 74: Lisp_Intfwd, ! 75: ! 76: /* Boolean forwarding pointer to an int variable. ! 77: This is like Lisp_Intfwd except that the ostensible "value" of the symbol ! 78: is t if the int variable is nonzero, nil if it is zero. ! 79: obj.v.intptr points to the int variable. */ ! 80: Lisp_Boolfwd, ! 81: ! 82: /* Object describing a connection to a subprocess. ! 83: It points to storage of type struct Lisp_Process */ ! 84: Lisp_Process, ! 85: ! 86: /* Forwarding pointer to a Lisp_Object variable. ! 87: This is allowed only in the value cell of a symbol, ! 88: and it means that the symbol's value really lives in the ! 89: specified variable. ! 90: obj.v.objfwd points to the Lisp_Object variable. */ ! 91: Lisp_Objfwd, ! 92: ! 93: /* Used when the core address of a function needs to be passed ! 94: in an argument of type Lisp_Object. ! 95: obj.v.function is the pointer-to-function. ! 96: The user will never see this data type. */ ! 97: Lisp_Internal_Function, ! 98: ! 99: /* Used when a FILE * value needs to be passed ! 100: in an argument of type Lisp_Object. ! 101: You must do (FILE *) obj.v.integer to get the value. ! 102: The user will never see this data type. */ ! 103: Lisp_Internal_Stream, ! 104: ! 105: /* Used in a symbol value cell when the symbol's value is per-buffer. ! 106: The actual contents are a cons cell which starts a list like this: ! 107: (REALVALUE BUFFER CURRENT-ALIST-ELEMENT . DEFAULT-VALUE)). ! 108: ! 109: BUFFER is the last buffer for which this symbol's value was ! 110: made up to date. ! 111: ! 112: CURRENT-ALIST-ELEMENT is a pointer to an element of BUFFER's ! 113: b_local_var_alist, that being the element whose car is this variable. ! 114: Or it can be a pointer to the (CURRENT-ALIST-ELEMENT . DEFAULT-VALUE), if BUFFER ! 115: does not have an element in its alist for this variable ! 116: (that is, if BUFFER sees the default value of this variable). ! 117: ! 118: If we want to examine or set the value and BUFFER is current, ! 119: we just examine or set REALVALUE. ! 120: If BUFFER is not current, we store the current REALVALUE value into ! 121: CURRENT-ALIST-ELEMENT, then find the appropriate alist element for ! 122: the buffer now current and set up CURRENT-ALIST-ELEMENT. ! 123: Then we set REALVALUE out of that element, and store into BUFFER. ! 124: ! 125: If we are setting the variable and the current buffer does not have ! 126: an alist entry for this variable, an alist entry is created. ! 127: ! 128: Note that REALVALUE can be a forwarding pointer. ! 129: Each time it is examined or set, forwarding must be done. */ ! 130: Lisp_Buffer_Local_Value, ! 131: ! 132: /* Like Lisp_Buffer_Local_Value with one difference: ! 133: merely setting the variable while some buffer is current ! 134: does not cause that buffer to have its own local value of this variable. ! 135: Only make-local-variable does that. */ ! 136: Lisp_Some_Buffer_Local_Value, ! 137: ! 138: ! 139: /* Like Lisp_Objfwd except that value lives in a slot ! 140: in the current buffer. Value is byte index of slot within buffer */ ! 141: Lisp_Buffer_Objfwd, ! 142: ! 143: /* In symbol value cell, means var is unbound. ! 144: In symbol function cell, means function name is undefined. */ ! 145: Lisp_Void, ! 146: ! 147: /* Window used for Emacs display. ! 148: Data inside looks like a Lisp_Vector. */ ! 149: Lisp_Window ! 150: }; ! 151: ! 152: #ifndef NO_UNION_TYPE ! 153: ! 154: #ifndef BIG_ENDIAN ! 155: ! 156: /* Definition of Lisp_Object for little-endian machines. */ ! 157: ! 158: typedef ! 159: union Lisp_Object ! 160: { ! 161: /* Used for comparing two Lisp_Objects; ! 162: also, positive integers can be accessed fast this way. */ ! 163: int i; ! 164: ! 165: struct ! 166: { ! 167: int val: 24; ! 168: char type; ! 169: } s; ! 170: struct ! 171: { ! 172: unsigned int val: 24; ! 173: char type; ! 174: } u; ! 175: struct ! 176: { ! 177: unsigned int val: 24; ! 178: enum Lisp_Type type: 7; ! 179: /* The markbit is not really part of the value of a Lisp_Object, ! 180: and is always zero except during garbage collection. */ ! 181: unsigned int markbit: 1; ! 182: } gu; ! 183: } ! 184: Lisp_Object; ! 185: ! 186: #else /* If BIG_ENDIAN */ ! 187: ! 188: typedef ! 189: union Lisp_Object ! 190: { ! 191: /* Used for comparing two Lisp_Objects; ! 192: also, positive integers can be accessed fast this way. */ ! 193: int i; ! 194: ! 195: struct ! 196: { ! 197: char type; ! 198: int val: 24; ! 199: } s; ! 200: struct ! 201: { ! 202: char type; ! 203: unsigned int val: 24; ! 204: } u; ! 205: struct ! 206: { ! 207: /* The markbit is not really part of the value of a Lisp_Object, ! 208: and is always zero except during garbage collection. */ ! 209: unsigned int markbit: 1; ! 210: enum Lisp_Type type: 7; ! 211: unsigned int val: 24; ! 212: } gu; ! 213: } ! 214: Lisp_Object; ! 215: ! 216: #endif BIG_ENDIAN ! 217: ! 218: #endif NO_UNION_TYPE ! 219: ! 220: ! 221: /* If union type is not wanted, define Lisp_Object as just a number ! 222: and define the macros below to extract fields by shifting */ ! 223: ! 224: #ifdef NO_UNION_TYPE ! 225: ! 226: #define Lisp_Object int ! 227: ! 228: /* These values are overridden by the m- file on some machines. */ ! 229: #ifndef VALBITS ! 230: #define VALBITS 24 ! 231: #endif ! 232: ! 233: #ifndef GCTYPEBITS ! 234: #define GCTYPEBITS 7 ! 235: #endif ! 236: ! 237: #define VALMASK ((1<<VALBITS) - 1) ! 238: #define GCTYPEMASK ((1<<GCTYPEBITS) - 1) ! 239: #define MARKBIT (1 << (VALBITS + GCTYPEBITS)) ! 240: ! 241: #endif NO_UNION_TYPE ! 242: ! 243: /* These macros extract various sorts of values from a Lisp_Object. ! 244: For example, if tem is a Lisp_Object whose type is Lisp_Cons, ! 245: XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */ ! 246: ! 247: #ifdef NO_UNION_TYPE ! 248: ! 249: #define XTYPE(a) ((enum Lisp_Type) ((a) >> VALBITS)) ! 250: #define XSETTYPE(a, b) ((a) = ((a) & VALMASK) + ((int)(b) << VALBITS)) ! 251: ! 252: /* Use XFASTINT for fast retrieval and storage of integers known ! 253: to be positive. This takes advantage of the fact that Lisp_Int is 0. */ ! 254: #define XFASTINT(a) (a) ! 255: ! 256: #define XINT(a) (((a) << INTBITS-VALBITS) >> INTBITS-VALBITS) ! 257: #define XUINT(a) ((a) & VALMASK) ! 258: ! 259: #define XSETINT(a, b) ((a) = ((a) & ~VALMASK) + ((b) & VALMASK)) ! 260: #define XSETUINT(a, b) ((a) = ((a) & ~VALMASK) + ((b) & VALMASK)) ! 261: ! 262: #define XSET(var, type, ptr) \ ! 263: ((var) = ((int)(type) << VALBITS) + ((int) (ptr) & VALMASK)) ! 264: ! 265: /* During garbage collection, XGCTYPE must be used for extracting types ! 266: so that the mark bit is ignored. XMARKBIT access the markbit. ! 267: Markbits are used only in particular slots of particular structure types. ! 268: Other markbits are always zero. ! 269: Outside of garbage collection, all mark bits are always zero. */ ! 270: ! 271: #define XGCTYPE(a) ((enum Lisp_Type) (((a) >> VALBITS) & GCTYPEMASK)) ! 272: #define XMARKBIT(a) ((a) & MARKBIT) ! 273: #define XSETMARKBIT(a,b) ((a) = ((a) & ~MARKBIT) + (b)) ! 274: #define XMARK(a) ((a) |= MARKBIT) ! 275: #define XUNMARK(a) ((a) &= ~MARKBIT) ! 276: ! 277: #endif ! 278: ! 279: #ifndef NO_UNION_TYPE ! 280: ! 281: #define XTYPE(a) ((enum Lisp_Type) (a).u.type) ! 282: #define XSETTYPE(a, b) ((a).u.type = (char) (b)) ! 283: ! 284: /* Use XFASTINT for fast retrieval and storage of integers known ! 285: to be positive. This takes advantage of the fact that Lisp_Int is 0. */ ! 286: #define XFASTINT(a) ((a).i) ! 287: ! 288: #ifdef EXPLICIT_SIGN_EXTEND ! 289: /* Make sure we sign-extend; compilers have been known to fail to do so. */ ! 290: #define XINT(a) (((a).i << 8) >> 8) ! 291: #else ! 292: #define XINT(a) ((a).s.val) ! 293: #endif ! 294: ! 295: #define XUINT(a) ((a).u.val) ! 296: #define XSETINT(a, b) ((a).s.val = (int) (b)) ! 297: #define XSETUINT(a, b) ((a).s.val = (int) (b)) ! 298: ! 299: #define XSET(var, vartype, ptr) \ ! 300: (((var).s.type = ((char) (vartype))), ((var).s.val = ((int) (ptr)))) ! 301: ! 302: /* During garbage collection, XGCTYPE must be used for extracting types ! 303: so that the mark bit is ignored. XMARKBIT access the markbit. ! 304: Markbits are used only in particular slots of particular structure types. ! 305: Other markbits are always zero. ! 306: Outside of garbage collection, all mark bits are always zero. */ ! 307: ! 308: #define XGCTYPE(a) ((a).gu.type) ! 309: #define XMARKBIT(a) ((a).gu.markbit) ! 310: #define XSETMARKBIT(a,b) (XMARKBIT(a) = (b)) ! 311: #define XMARK(a) (XMARKBIT(a) = 1) ! 312: #define XUNMARK(a) (XMARKBIT(a) = 0) ! 313: ! 314: #endif NO_UNION_TYPE ! 315: ! 316: ! 317: #define XCONS(a) ((struct Lisp_Cons *) XUINT(a)) ! 318: #define XBUFFER(a) ((struct buffer *) XUINT(a)) ! 319: #define XVECTOR(a) ((struct Lisp_Vector *) XUINT(a)) ! 320: #define XSUBR(a) ((struct Lisp_Subr *) XUINT(a)) ! 321: #define XSTRING(a) ((struct Lisp_String *) XUINT(a)) ! 322: #define XSYMBOL(a) ((struct Lisp_Symbol *) XUINT(a)) ! 323: #define XFUNCTION(a) ((Lisp_Object (*)()) XUINT(a)) ! 324: #define XMARKER(a) ((struct Lisp_Marker *) XUINT(a)) ! 325: #define XOBJFWD(a) ((Lisp_Object *) XUINT(a)) ! 326: #define XINTPTR(a) ((int *) XUINT(a)) ! 327: #define XWINDOW(a) ((struct window *) XUINT(a)) ! 328: #define XPROCESS(a) ((struct Lisp_Process *) XUINT(a)) ! 329: ! 330: #define XSETCONS(a, b) XSETUINT(a, (int) (b)) ! 331: #define XSETBUFFER(a, b) XSETUINT(a, (int) (b)) ! 332: #define XSETVECTOR(a, b) XSETUINT(a, (int) (b)) ! 333: #define XSETSUBR(a, b) XSETUINT(a, (int) (b)) ! 334: #define XSETSTRING(a, b) XSETUINT(a, (int) (b)) ! 335: #define XSETSYMBOL(a, b) XSETUINT(a, (int) (b)) ! 336: #define XSETFUNCTION(a, b) XSETUINT(a, (int) (b)) ! 337: #define XSETMARKER(a, b) XSETUINT(a, (int) (b)) ! 338: #define XSETOBJFWD(a, b) XSETUINT(a, (int) (b)) ! 339: #define XSETINTPTR(a, b) XSETUINT(a, (int) (b)) ! 340: #define XSETWINDOW(a, b) XSETUINT(a, (int) (b)) ! 341: #define XSETPROCESS(a, b) XSETUINT(a, (int) (b)) ! 342: ! 343: /* In a cons, the markbit of the car is the gc mark bit */ ! 344: ! 345: struct Lisp_Cons ! 346: { ! 347: Lisp_Object car, cdr; ! 348: }; ! 349: ! 350: /* Like a cons, but records info on where the text lives that it was read from */ ! 351: /* This is not really in use now */ ! 352: ! 353: struct Lisp_Buffer_Cons ! 354: { ! 355: Lisp_Object car, cdr; ! 356: struct buffer *buffer; ! 357: int bufpos; ! 358: }; ! 359: ! 360: /* In a string or vector, the sign bit of the `size' is the gc mark bit */ ! 361: ! 362: struct Lisp_String ! 363: { ! 364: int size; ! 365: unsigned char data[1]; ! 366: }; ! 367: ! 368: struct Lisp_Vector ! 369: { ! 370: int size; ! 371: struct Lisp_Vector *next; ! 372: Lisp_Object contents[1]; ! 373: }; ! 374: ! 375: /* In a symbol, the markbit of the plist is used as the gc mark bit */ ! 376: ! 377: struct Lisp_Symbol ! 378: { ! 379: struct Lisp_String *name; ! 380: Lisp_Object value; ! 381: Lisp_Object function; ! 382: Lisp_Object plist; ! 383: struct Lisp_Symbol *next; /* -> next symbol in this obarray bucket */ ! 384: }; ! 385: ! 386: struct Lisp_Subr ! 387: { ! 388: Lisp_Object (*function) (); ! 389: short min_args, max_args; ! 390: char *symbol_name; ! 391: char *prompt; ! 392: char *doc; ! 393: }; ! 394: ! 395: /* In a marker, the markbit of the chain field is used as the gc mark bit */ ! 396: ! 397: struct Lisp_Marker ! 398: { ! 399: struct buffer *buffer; ! 400: Lisp_Object chain; ! 401: int bufpos; ! 402: int modified; ! 403: }; ! 404: ! 405: /* Data type checking */ ! 406: ! 407: #define NULL(x) (XFASTINT (x) == XFASTINT (Qnil)) ! 408: #define LISTP(x) (XTYPE ((x)) == Lisp_Cons) ! 409: #define EQ(x, y) (XFASTINT (x) == XFASTINT (y)) ! 410: ! 411: #define CHECK_STRING(x, i) \ ! 412: { if (XTYPE ((x)) != Lisp_String) x = wrong_type_argument (Qstringp, (x)); } ! 413: ! 414: #define CHECK_SYMBOL(x, i) \ ! 415: { if (XTYPE ((x)) != Lisp_Symbol) x = wrong_type_argument (Qsymbolp, (x)); } ! 416: ! 417: #define CHECK_VECTOR(x, i) \ ! 418: { if (XTYPE ((x)) != Lisp_Vector) x = wrong_type_argument (Qvectorp, (x)); } ! 419: ! 420: #define CHECK_BUFFER(x, i) \ ! 421: { if (XTYPE ((x)) != Lisp_Buffer) x = wrong_type_argument (Qbufferp, (x)); } ! 422: ! 423: #define CHECK_WINDOW(x, i) \ ! 424: { if (XTYPE ((x)) != Lisp_Window) x = wrong_type_argument (Qwindowp, (x)); } ! 425: ! 426: #define CHECK_PROCESS(x, i) \ ! 427: { if (XTYPE ((x)) != Lisp_Process) x = wrong_type_argument (Qprocessp, (x)); } ! 428: ! 429: #define CHECK_NUMBER(x, i) \ ! 430: { if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qintegerp, (x)); } ! 431: ! 432: #define CHECK_MARKER(x, i) \ ! 433: { if (XTYPE ((x)) != Lisp_Marker) x = wrong_type_argument (Qmarkerp, (x)); } ! 434: ! 435: #define CHECK_NUMBER_COERCE_MARKER(x, i) \ ! 436: { if (XTYPE ((x)) == Lisp_Marker) XFASTINT (x) = marker_position (x); \ ! 437: else if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } ! 438: ! 439: #ifdef VIRT_ADDR_VARIES ! 440: /* For machines like APOLLO where text and data can go anywhere ! 441: in virtual memory. */ ! 442: #define CHECK_IMPURE(obj) \ ! 443: { extern int pure[]; \ ! 444: if (XUINT (obj) < (int) ((char *) pure + PURESIZE) \ ! 445: && XUINT (obj) >= (int) pure) \ ! 446: pure_write_error (); } ! 447: ! 448: #else /* not VIRT_ADDR_VARIES */ ! 449: ! 450: #define CHECK_IMPURE(obj) \ ! 451: { extern int my_edata; \ ! 452: if (XUINT (obj) < (unsigned int) &my_edata) \ ! 453: pure_write_error (); } ! 454: #endif /* not VIRT_ADDR_VARIES */ ! 455: ! 456: /* Define a built-in function for calling from Lisp. ! 457: `lname' should be the name to give the function in Lisp, ! 458: as a null-terminated C string. ! 459: `fnname' should be the name of the function in C. ! 460: By convention, it starts with F. ! 461: `sname' should be the name for the C constant structure ! 462: that records information on this function for internal use. ! 463: By convention, it should be the same as `fnname' but with S instead of F. ! 464: It's too bad that C macros can't compute this from `fnname'. ! 465: `minargs' should be a number, the minimum number of arguments allowed. ! 466: `maxargs' should be a number, the maximum number of arguments allowed, ! 467: or else MANY or UNEVALLED. ! 468: MANY means pass a vector of evaluated arguments, ! 469: in the form of an integer number-of-arguments ! 470: followed by the address of a vector of Lisp_Objects ! 471: which contains the argument values. ! 472: UNEVALLED means pass the list of unevaluated arguments ! 473: `prompt' says how to read arguments for an interactive call. ! 474: This can be zero or a C string. ! 475: Zero means that interactive calls are not allowed. ! 476: A string is interpreted in a hairy way: ! 477: it should contain one line for each argument to be read, terminated by \n. ! 478: The first character of the line controls the type of parsing: ! 479: s -- read a string. ! 480: S -- read a symbol. ! 481: k -- read a key sequence and return it as a string. ! 482: a -- read a function name (symbol) with completion. ! 483: C -- read a command name (symbol) with completion. ! 484: v -- read a variable name (symbol) with completion. ! 485: b -- read a buffer name (a string) with completion. ! 486: B -- buffer name, may be existing buffer or may not be. ! 487: f -- read a file name, file must exist. ! 488: F -- read a file name, file need not exist. ! 489: n -- read a number. ! 490: c -- read a character and return it as a number. ! 491: p -- use the numeric value of the prefix argument. ! 492: P -- use raw value of prefix - can be nil, -, (NUMBER) or NUMBER. ! 493: x -- read a Lisp object from the minibuffer. ! 494: X -- read a Lisp form from the minibuffer and use its value. ! 495: A null string means call interactively with no arguments. ! 496: `doc' is documentation for the user. ! 497: */ ! 498: ! 499: #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \ ! 500: Lisp_Object fnname (); \ ! 501: struct Lisp_Subr sname = {fnname, minargs, maxargs, lname, prompt, 0}; \ ! 502: Lisp_Object fnname ! 503: ! 504: /* defsubr (Sname); ! 505: is how we define the symbol for function `name' at start-up time. */ ! 506: extern void defsubr (); ! 507: ! 508: #define MANY -2 ! 509: #define UNEVALLED -1 ! 510: ! 511: #define DEFSIMPLE(lname, fnname, sname, doc, valtype, setcomp, exp) \ ! 512: DEFUN (lname, fnname, sname, 0, 0, 0, 0) () \ ! 513: { \ ! 514: Lisp_Object val; \ ! 515: XSET (val, valtype, exp); \ ! 516: return val; } ! 517: ! 518: #define DEFPRED(lname, fnname, sname, doc, boolexp) \ ! 519: DEFUN (lname, fnname, sname, 0, 0, 0, 0) () \ ! 520: { if (boolexp) return Qt; return Qnil; } ! 521: ! 522: /* Structure for recording Lisp call stack for backtrace purposes */ ! 523: ! 524: struct specbinding ! 525: { ! 526: Lisp_Object symbol, old_value; ! 527: }; ! 528: ! 529: extern struct specbinding *specpdl; ! 530: extern struct specbinding *specpdl_ptr; ! 531: extern int specpdl_size; ! 532: ! 533: struct handler ! 534: { ! 535: Lisp_Object handler; ! 536: Lisp_Object var; ! 537: struct catchtag *tag; ! 538: struct handler *next; ! 539: }; ! 540: ! 541: extern struct handler *handlerlist; ! 542: ! 543: /* Check quit-flag and quit if it is non-nil. */ ! 544: ! 545: #define QUIT \ ! 546: if (!NULL (Vquit_flag) && NULL (Vinhibit_quit)) \ ! 547: { Vquit_flag = Qnil; Fsignal (Qquit, Qnil); } ! 548: ! 549: /* number of bytes of structure consed since last GC */ ! 550: ! 551: extern int consing_since_gc; ! 552: ! 553: /* threshold for doing another gc */ ! 554: ! 555: extern int gc_cons_threshold; ! 556: ! 557: /* Structure for recording stack slots that need marking */ ! 558: ! 559: /* This is a chain of structures, each of which points at a Lisp_Object variable ! 560: whose value should be marked in garbage collection. ! 561: Normally every link of the chain is an automatic variable of a function, ! 562: and its `val' points to some argument or local variable of the function. ! 563: On exit to the function, the chain is set back to the value it had on entry. ! 564: This way, no link remains in the chain when the stack frame containing the link disappears. ! 565: ! 566: Every function that can call Feval must protect in this fashion all ! 567: Lisp_Object variables whose contents will be used again. */ ! 568: ! 569: extern struct gcpro *gcprolist; ! 570: ! 571: struct gcpro ! 572: { ! 573: struct gcpro *next; ! 574: Lisp_Object *var; /* Address of first protected variable */ ! 575: int nvars; /* Number of consecutive protected variables */ ! 576: }; ! 577: ! 578: #define GCPRO1(varname) \ ! 579: {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \ ! 580: gcprolist = &gcpro1; } ! 581: ! 582: #define GCPRO2(varname1, varname2) \ ! 583: {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \ ! 584: gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \ ! 585: gcprolist = &gcpro2; } ! 586: ! 587: #define GCPRO3(varname1, varname2, varname3) \ ! 588: {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \ ! 589: gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \ ! 590: gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \ ! 591: gcprolist = &gcpro3; } ! 592: ! 593: #define GCPRO4(varname1, varname2, varname3, varname4) \ ! 594: {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \ ! 595: gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \ ! 596: gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \ ! 597: gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \ ! 598: gcprolist = &gcpro4; } ! 599: ! 600: /* Call staticpro (&var) to protect static variable `var'. */ ! 601: ! 602: void staticpro(); ! 603: ! 604: #define UNGCPRO (gcprolist = gcpro1.next) ! 605: ! 606: /* Defined in data.c */ ! 607: extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound; ! 608: extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level; ! 609: extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range; ! 610: extern Lisp_Object Qvoid_variable, Qvoid_function; ! 611: extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax; ! 612: extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch; ! 613: extern Lisp_Object Qend_of_file, Qarith_error; ! 614: extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only; ! 615: ! 616: extern Lisp_Object Qintegerp, Qnatnump, Qsymbolp, Qlistp, Qconsp; ! 617: extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp; ! 618: extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp; ! 619: extern Lisp_Object Qinteger_or_marker_p, Qboundp, Qfboundp; ! 620: extern Lisp_Object Qcdr; ! 621: ! 622: extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp (); ! 623: extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp (); ! 624: extern Lisp_Object Fvectorp (), Fstringp (), Farrayp (), Fsequencep (); ! 625: extern Lisp_Object Fbufferp (), Fmarkerp (), Fsubrp (), Fchar_or_string_p (); ! 626: extern Lisp_Object Finteger_or_marker_p (); ! 627: ! 628: extern Lisp_Object Fcar (), Fcar_safe(), Fcdr (), Fcdr_safe(); ! 629: extern Lisp_Object Fsetcar (), Fsetcdr (); ! 630: extern Lisp_Object Fboundp (), Ffboundp (), Fmakunbound (), Ffmakunbound (); ! 631: extern Lisp_Object Fsymbol_function (), Fsymbol_plist (), Fsymbol_name (); ! 632: extern Lisp_Object Ffset (), Fsetplist (); ! 633: extern Lisp_Object Fsymbol_value (), Fset (); ! 634: extern Lisp_Object Fdefault_value (), Fset_default (); ! 635: ! 636: extern Lisp_Object Faref (), Faset (), Farray_length (); ! 637: ! 638: extern Lisp_Object Fstring_to_int (), Fint_to_string (); ! 639: extern Lisp_Object Feqlsign (), Fgtr (), Flss (), Fgeq (), Fleq (), Fneq (), Fzerop (); ! 640: extern Lisp_Object Fplus (), Fminus (), Ftimes (), Fquo (), Frem (), Fmax (), Fmin (); ! 641: extern Lisp_Object Flogand (), Flogior (), Flogxor (), Flognot (), Flsh (), Fash (); ! 642: extern Lisp_Object Fadd1 (), Fsub1 (); ! 643: ! 644: extern Lisp_Object make_number (); ! 645: extern Lisp_Object wrong_type_argument (); ! 646: ! 647: /* Defined in fns.c */ ! 648: extern Lisp_Object Qstring_lessp; ! 649: extern Lisp_Object Vfeatures; ! 650: extern Lisp_Object Fidentity (), Frandom (); ! 651: extern Lisp_Object Flength (), Fstring_equal (), Fstring_lessp (); ! 652: extern Lisp_Object Fappend (), Fconcat (), Fvconcat (), Fcopy_sequence (), Fsubstring (); ! 653: extern Lisp_Object Fnth (), Fnthcdr (), Fmemq (), Fassq (), Fassoc (); ! 654: extern Lisp_Object Frassq (), Fdelq (), Fsort (); ! 655: extern Lisp_Object Freverse (), Fnreverse (), Fget (), Fput (), Fequal (); ! 656: extern Lisp_Object Ffillarray (), Fnconc (), Fmapcar (), Fmapconcat (); ! 657: extern Lisp_Object Fy_or_n_p (), Fyes_or_no_p (); ! 658: extern Lisp_Object Ffeaturep (), Frequire () , Fprovide (); ! 659: extern Lisp_Object concat2 (), nconc2 (); ! 660: ! 661: /* Defined in alloc.c */ ! 662: extern Lisp_Object Vpurify_flag; ! 663: extern Lisp_Object Fcons (), Flist(), Fmake_list (); ! 664: extern Lisp_Object Fmake_vector (), Fvector (), Fmake_symbol (), Fmake_marker (); ! 665: extern Lisp_Object Fmake_string (), build_string (), make_string(); ! 666: extern Lisp_Object Fpurecopy (), make_pure_string (); ! 667: extern Lisp_Object pure_cons (), make_pure_vector (); ! 668: extern Lisp_Object Fgarbage_collect (); ! 669: ! 670: /* Defined in print.c */ ! 671: extern Lisp_Object Vprin1_to_string_buffer; ! 672: extern Lisp_Object Fprin1 (), Fprin1_to_string (), Fprinc (); ! 673: extern Lisp_Object Fterpri (), Fprint (); ! 674: extern Lisp_Object Vstandard_output, Qstandard_output; ! 675: extern temp_output_buffer_setup (), temp_output_buffer_show (); ! 676: ! 677: /* Defined in read.c */ ! 678: extern Lisp_Object Qvariable_documentation; ! 679: extern Lisp_Object Vobarray, Vstandard_input; ! 680: extern Lisp_Object Fread (), Fread_from_string (); ! 681: extern Lisp_Object Fintern (), Fintern_soft (), Fload (); ! 682: extern Lisp_Object Fget_file_char (), Fread_char (); ! 683: extern Lisp_Object Feval_current_buffer (), Feval_region (); ! 684: extern Lisp_Object intern (), oblookup (); ! 685: ! 686: /* Defined in eval.c */ ! 687: extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro; ! 688: extern Lisp_Object Vinhibit_quit, Vquit_flag; ! 689: extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments; ! 690: extern Lisp_Object Vautoload_queue; ! 691: extern Lisp_Object Fand (), For (), Fif (), Fprogn (), Fprog1 (), Fprog2 (); ! 692: extern Lisp_Object Fsetq (), Fquote (); ! 693: extern Lisp_Object Fuser_variable_p (); ! 694: extern Lisp_Object Fdefun (), Flet (), FletX (), Fwhile (); ! 695: extern Lisp_Object Fcatch (), Fthrow (), Funwind_protect (); ! 696: extern Lisp_Object Fcondition_case (), Fsignal (); ! 697: extern Lisp_Object Ffunction_type (), Fautoload (), Fdocumentation (), Fcommandp (); ! 698: extern Lisp_Object Feval (), Fapply (), Ffuncall (); ! 699: extern Lisp_Object Fglobal_set (), Fglobal_value (), Fbacktrace (); ! 700: extern Lisp_Object call1 (), call2 (), call3 (); ! 701: extern Lisp_Object apply_lambda (); ! 702: extern Lisp_Object internal_catch (); ! 703: extern Lisp_Object internal_condition_case (); ! 704: extern void unbind_to (); ! 705: extern void error (); ! 706: ! 707: /* Defined in editfns.c */ ! 708: extern Lisp_Object Vprefix_arg, Qminus, Vcurrent_prefix_arg; ! 709: extern Lisp_Object Finteractive_p (), Fgoto_char (); ! 710: extern Lisp_Object Fpoint_min_marker (), Fpoint_max_marker (); ! 711: extern Lisp_Object Fpoint_min (), Fpoint_max (); ! 712: extern Lisp_Object Fpoint (), Fmark (), Fpoint_marker (), Fmark_marker (); ! 713: extern Lisp_Object Ffollchar (), Fprevchar (), Fchar_after (), Finsert (); ! 714: extern Lisp_Object Feolp (), Feobp (), Fbolp (), Fbobp (), Fset_mark (); ! 715: extern Lisp_Object Fformat (), format1 (); ! 716: extern Lisp_Object Fgetenv (); ! 717: extern Lisp_Object Fbuffer_substring (), Fbuffer_string (); ! 718: extern Lisp_Object save_excursion_save (), save_restriction_save (); ! 719: extern Lisp_Object save_excursion_restore (), save_restriction_restore (); ! 720: extern Lisp_Object Fchar_to_string (); ! 721: ! 722: /* defined in buffer.c */ ! 723: extern Lisp_Object Vbuffer_alist; ! 724: extern Lisp_Object Fget_buffer (), Fget_buffer_create (), Fset_buffer (); ! 725: extern Lisp_Object Fbarf_if_buffer_read_only (); ! 726: extern Lisp_Object Fcurrent_buffer (), Fswitch_to_buffer (), Fpop_to_buffer (); ! 727: extern Lisp_Object Fother_buffer (); ! 728: extern struct buffer *all_buffers; ! 729: ! 730: /* defined in marker.c */ ! 731: ! 732: extern Lisp_Object Fmarker_position (), Fmarker_buffer (); ! 733: extern Lisp_Object Fcopy_marker (); ! 734: ! 735: /* Defined in fileio.c */ ! 736: ! 737: extern Lisp_Object Qfile_error; ! 738: extern Lisp_Object Fexpand_file_name (), Ffile_name_nondirectory (); ! 739: extern Lisp_Object Fsubstitute_in_file_name (); ! 740: extern Lisp_Object Ffile_symlink_p (); ! 741: ! 742: /* Defined in abbrev.c */ ! 743: ! 744: extern Lisp_Object Vfundamental_mode_abbrev_table; ! 745: ! 746: /* defined in search.c */ ! 747: ! 748: extern Lisp_Object Fstring_match (); ! 749: extern Lisp_Object Fscan_buffer (); ! 750: ! 751: /* defined in minibuf.c */ ! 752: ! 753: extern Lisp_Object last_minibuf_string; ! 754: extern Lisp_Object read_minibuf_string (), Fcompleting_read (); ! 755: extern Lisp_Object Fread_from_minibuffer (); ! 756: extern Lisp_Object Fread_variable (); ! 757: extern Lisp_Object Fread_minibuffer (), Feval_minibuffer (); ! 758: extern Lisp_Object Fread_string (), Fread_file_name (); ! 759: extern Lisp_Object Fread_no_blanks_input (); ! 760: ! 761: /* Defined in callint.c */ ! 762: ! 763: extern Lisp_Object Vcommand_history; ! 764: extern Lisp_Object Qcall_interactively; ! 765: extern Lisp_Object Fcall_interactively (); ! 766: extern Lisp_Object Fprefix_numeric_value (); ! 767: ! 768: /* defined in casefiddle.c */ ! 769: ! 770: extern Lisp_Object Fdowncase (), Fupcase (), Fcapitalize (); ! 771: ! 772: /* defined in keyboard.c */ ! 773: ! 774: extern Lisp_Object Vhelp_form, Vtop_level; ! 775: extern Lisp_Object Fdiscard_input (), Frecursive_edit (); ! 776: extern Lisp_Object Fcommand_execute (), Finput_pending_p (); ! 777: ! 778: /* defined in keymap.c */ ! 779: ! 780: extern Lisp_Object Qkeymap; ! 781: extern Lisp_Object Fkey_description (), Fsingle_key_description (); ! 782: extern Lisp_Object Fwhere_is_internal (); ! 783: extern Lisp_Object access_keymap (), store_in_keymap (); ! 784: extern Lisp_Object get_keyelt (), get_keymap(); ! 785: ! 786: /* defined in indent.c */ ! 787: extern Lisp_Object Fvertical_motion (), Findent_to (), Fcurrent_column (); ! 788: ! 789: /* defined in window.c */ ! 790: extern Lisp_Object Qwindowp; ! 791: extern Lisp_Object Fget_buffer_window (); ! 792: extern Lisp_Object Fsave_window_excursion (); ! 793: extern Lisp_Object save_window_save (); ! 794: extern Lisp_Object save_window_restore (); ! 795: ! 796: /* defined in emacs.c */ ! 797: extern Lisp_Object decode_env_path (); ! 798: /* Nonzero means don't do interactive redisplay and don't change tty modes */ ! 799: extern int noninteractive; ! 800: ! 801: /* defined in process.c */ ! 802: extern Lisp_Object Fget_process (), Fget_buffer_process (), Fprocessp (); ! 803: extern Lisp_Object Fprocess_status (), Fkill_process (); ! 804: ! 805: /* defined in callproc.c */ ! 806: extern Lisp_Object Vexec_path, Vexec_directory; ! 807: ! 808: /* defined in doc.c */ ! 809: extern Lisp_Object Vdoc_file_name; ! 810: extern Lisp_Object Fsubstitute_command_keys (); ! 811: ! 812: /* defined in bytecode.c */ ! 813: extern Lisp_Object Qbytecode; ! 814: ! 815: /* defined in macros.c */ ! 816: extern Lisp_Object Fexecute_kbd_macro (); ! 817: ! 818: extern void debugger (); ! 819: ! 820: extern char *malloc (), *realloc (), *getenv (), *ctime (), *getwd (); ! 821: extern long *xmalloc (), *xrealloc ();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.