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