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