Rebuild.
[emacs.git] / src / lisp.h
blob94de2c2960fdbeb3e32510927e1127b6a7a6817e
1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
2 Copyright (C) 1985,86,87,93,94,95,97,98,1999,2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 #ifndef EMACS_LISP_H
23 #define EMACS_LISP_H
25 /* Declare the prototype for a general external function. */
26 #if defined (PROTOTYPES) || defined (WINDOWSNT)
27 #define P_(proto) proto
28 #else
29 #define P_(proto) ()
30 #endif
32 #if 0
33 /* Define this temporarily to hunt a bug. If defined, the size of
34 strings is redundantly recorded in sdata structures so that it can
35 be compared to the sizes recorded in Lisp strings. */
37 #define GC_CHECK_STRING_BYTES 1
38 #endif /* 0 */
41 /* These are default choices for the types to use. */
42 #ifdef _LP64
43 #ifndef EMACS_INT
44 #define EMACS_INT long
45 #define BITS_PER_EMACS_INT BITS_PER_LONG
46 #endif
47 #ifndef EMACS_UINT
48 #define EMACS_UINT unsigned long
49 #endif
50 #else /* not _LP64 */
51 #ifndef EMACS_INT
52 #define EMACS_INT int
53 #define BITS_PER_EMACS_INT BITS_PER_INT
54 #endif
55 #ifndef EMACS_UINT
56 #define EMACS_UINT unsigned int
57 #endif
58 #endif
60 /* Extra internal type checking? */
61 extern int suppress_checking;
62 extern void die P_((const char *, const char *, int));
64 #ifdef ENABLE_CHECKING
66 #define CHECK(check,msg) (((check) || suppress_checking \
67 ? (void) 0 \
68 : die ((msg), __FILE__, __LINE__)), \
71 /* Let's get some compile-time checking too. */
72 #undef NO_UNION_TYPE
74 #else
76 /* Produce same side effects and result, but don't complain. */
77 #define CHECK(check,msg) ((check),0)
79 #endif
81 /* Used for making sure that Emacs is compilable in all
82 configurations. */
84 #ifdef USE_LISP_UNION_TYPE
85 #undef NO_UNION_TYPE
86 #endif
88 /* Define an Emacs version of "assert", since some system ones are
89 flaky. */
90 #ifndef ENABLE_CHECKING
91 #define eassert(X) (void) 0
92 #else /* ENABLE_CHECKING */
93 #if defined (__GNUC__) && __GNUC__ >= 2 && defined (__STDC__)
94 #define eassert(cond) CHECK(cond,"assertion failed: " #cond)
95 #else
96 #define eassert(cond) CHECK(cond,"assertion failed")
97 #endif
98 #endif /* ENABLE_CHECKING */
100 /* Define the fundamental Lisp data structures. */
102 /* This is the set of Lisp data types. */
104 enum Lisp_Type
106 /* Integer. XINT (obj) is the integer value. */
107 Lisp_Int,
109 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
110 Lisp_Symbol,
112 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
113 whose first member indicates the subtype. */
114 Lisp_Misc,
116 /* String. XSTRING (object) points to a struct Lisp_String.
117 The length of the string, and its contents, are stored therein. */
118 Lisp_String,
120 /* Vector of Lisp objects, or something resembling it.
121 XVECTOR (object) points to a struct Lisp_Vector, which contains
122 the size and contents. The size field also contains the type
123 information, if it's not a real vector object. */
124 Lisp_Vectorlike,
126 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
127 Lisp_Cons,
129 Lisp_Float,
131 /* This is not a type code. It is for range checking. */
132 Lisp_Type_Limit
135 /* This is the set of data types that share a common structure.
136 The first member of the structure is a type code from this set.
137 The enum values are arbitrary, but we'll use large numbers to make it
138 more likely that we'll spot the error if a random word in memory is
139 mistakenly interpreted as a Lisp_Misc. */
140 enum Lisp_Misc_Type
142 Lisp_Misc_Free = 0x5eab,
143 Lisp_Misc_Marker,
144 Lisp_Misc_Intfwd,
145 Lisp_Misc_Boolfwd,
146 Lisp_Misc_Objfwd,
147 Lisp_Misc_Buffer_Objfwd,
148 Lisp_Misc_Buffer_Local_Value,
149 Lisp_Misc_Some_Buffer_Local_Value,
150 Lisp_Misc_Overlay,
151 Lisp_Misc_Kboard_Objfwd,
152 Lisp_Misc_Save_Value,
153 /* Currently floats are not a misc type,
154 but let's define this in case we want to change that. */
155 Lisp_Misc_Float,
156 /* This is not a type code. It is for range checking. */
157 Lisp_Misc_Limit
160 #ifndef GCTYPEBITS
161 #define GCTYPEBITS 3
162 #endif
164 /* These values are overridden by the m- file on some machines. */
165 #ifndef VALBITS
166 #define VALBITS (BITS_PER_EMACS_INT - GCTYPEBITS)
167 #endif
169 #ifndef NO_UNION_TYPE
171 #ifndef WORDS_BIG_ENDIAN
173 /* Definition of Lisp_Object for little-endian machines. */
175 typedef
176 union Lisp_Object
178 /* Used for comparing two Lisp_Objects;
179 also, positive integers can be accessed fast this way. */
180 EMACS_INT i;
182 struct
184 EMACS_INT val : VALBITS;
185 EMACS_UINT type : GCTYPEBITS;
186 } s;
187 struct
189 EMACS_UINT val : VALBITS;
190 EMACS_UINT type : GCTYPEBITS;
191 } u;
192 struct
194 EMACS_UINT val : VALBITS;
195 enum Lisp_Type type : GCTYPEBITS;
196 } gu;
198 Lisp_Object;
200 #else /* If WORDS_BIG_ENDIAN */
202 typedef
203 union Lisp_Object
205 /* Used for comparing two Lisp_Objects;
206 also, positive integers can be accessed fast this way. */
207 EMACS_INT i;
209 struct
211 EMACS_UINT type : GCTYPEBITS;
212 EMACS_INT val : VALBITS;
213 } s;
214 struct
216 EMACS_UINT type : GCTYPEBITS;
217 EMACS_UINT val : VALBITS;
218 } u;
219 struct
221 enum Lisp_Type type : GCTYPEBITS;
222 EMACS_UINT val : VALBITS;
223 } gu;
225 Lisp_Object;
227 #endif /* WORDS_BIG_ENDIAN */
229 #ifdef __GNUC__
230 static __inline__ Lisp_Object
231 LISP_MAKE_RVALUE (Lisp_Object o)
233 return o;
235 #else
236 /* This isn't quite right - it keeps the argument as an lvalue.
237 Making it const via casting would help avoid code actually
238 modifying the location in question, but the casting could cover
239 other type-related bugs. */
240 #define LISP_MAKE_RVALUE(o) (o)
241 #endif
243 #endif /* NO_UNION_TYPE */
246 /* If union type is not wanted, define Lisp_Object as just a number. */
248 #ifdef NO_UNION_TYPE
249 #define Lisp_Object EMACS_INT
250 #define LISP_MAKE_RVALUE(o) (0+(o))
251 #endif /* NO_UNION_TYPE */
253 /* Two flags that are set during GC. On some machines, these flags
254 are defined differently by the m- file. */
256 /* In the size word of a vector, this bit means the vector has been marked. */
258 #ifndef ARRAY_MARK_FLAG
259 #define ARRAY_MARK_FLAG ((EMACS_INT) ((EMACS_UINT) 1 << (VALBITS + GCTYPEBITS - 1)))
260 #endif /* no ARRAY_MARK_FLAG */
262 /* In the size word of a struct Lisp_Vector, this bit means it's really
263 some other vector-like object. */
264 #ifndef PSEUDOVECTOR_FLAG
265 #define PSEUDOVECTOR_FLAG ((ARRAY_MARK_FLAG >> 1) & ~ARRAY_MARK_FLAG)
266 #endif
268 /* In a pseudovector, the size field actually contains a word with one
269 PSEUDOVECTOR_FLAG bit set, and exactly one of the following bits to
270 indicate the actual type. */
271 enum pvec_type
273 PVEC_NORMAL_VECTOR = 0,
274 PVEC_PROCESS = 0x200,
275 PVEC_FRAME = 0x400,
276 PVEC_COMPILED = 0x800,
277 PVEC_WINDOW = 0x1000,
278 PVEC_WINDOW_CONFIGURATION = 0x2000,
279 PVEC_SUBR = 0x4000,
280 PVEC_CHAR_TABLE = 0x8000,
281 PVEC_BOOL_VECTOR = 0x10000,
282 PVEC_BUFFER = 0x20000,
283 PVEC_HASH_TABLE = 0x40000,
284 PVEC_TYPE_MASK = 0x7fe00
286 #if 0 /* This is used to make the value of PSEUDOVECTOR_FLAG available to
287 GDB. It doesn't work on OS Alpha. Moved to a variable in
288 emacs.c. */
289 PVEC_FLAG = PSEUDOVECTOR_FLAG
290 #endif
293 /* For convenience, we also store the number of elements in these bits. */
294 #define PSEUDOVECTOR_SIZE_MASK 0x1ff
296 /* These macros extract various sorts of values from a Lisp_Object.
297 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
298 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */
300 #ifdef NO_UNION_TYPE
302 #define VALMASK ((((EMACS_INT) 1) << VALBITS) - 1)
304 /* One need to override this if there must be high bits set in data space
305 (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
306 on all machines, but would penalize machines which don't need it)
308 #define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) >> VALBITS))
310 /* For integers known to be positive, XFASTINT provides fast retrieval
311 and XSETFASTINT provides fast storage. This takes advantage of the
312 fact that Lisp_Int is 0. */
313 #define XFASTINT(a) ((a) + 0)
314 #define XSETFASTINT(a, b) ((a) = (b))
316 /* Extract the value of a Lisp_Object as a signed integer. */
318 #ifndef XINT /* Some machines need to do this differently. */
319 #define XINT(a) ((((EMACS_INT) (a)) << (BITS_PER_EMACS_INT - VALBITS)) \
320 >> (BITS_PER_EMACS_INT - VALBITS))
321 #endif
323 /* Extract the value as an unsigned integer. This is a basis
324 for extracting it as a pointer to a structure in storage. */
326 #ifndef XUINT
327 #define XUINT(a) ((EMACS_UINT) ((a) & VALMASK))
328 #endif
330 #ifndef XSET
331 #define XSET(var, type, ptr) \
332 ((var) = ((EMACS_INT)(type) << VALBITS) + ((EMACS_INT) (ptr) & VALMASK))
333 #endif
335 /* Convert a C integer into a Lisp_Object integer. */
337 #define make_number(N) \
338 ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
340 #define EQ(x, y) ((x) == (y))
342 #else /* not NO_UNION_TYPE */
344 #define XTYPE(a) ((enum Lisp_Type) (a).u.type)
346 /* For integers known to be positive, XFASTINT provides fast retrieval
347 and XSETFASTINT provides fast storage. This takes advantage of the
348 fact that Lisp_Int is 0. */
349 #define XFASTINT(a) ((a).i + 0)
350 #define XSETFASTINT(a, b) ((a).i = (b))
352 #ifdef EXPLICIT_SIGN_EXTEND
353 /* Make sure we sign-extend; compilers have been known to fail to do so. */
354 #define XINT(a) (((a).i << (BITS_PER_EMACS_INT - VALBITS)) \
355 >> (BITS_PER_EMACS_INT - VALBITS))
356 #else
357 #define XINT(a) ((a).s.val)
358 #endif /* EXPLICIT_SIGN_EXTEND */
360 #define XUINT(a) ((a).u.val)
362 #define XSET(var, vartype, ptr) \
363 (((var).s.val = ((EMACS_INT) (ptr))), ((var).s.type = ((char) (vartype))))
365 #if __GNUC__ >= 2 && defined (__OPTIMIZE__)
366 #define make_number(N) \
367 (__extension__ ({ Lisp_Object _l; _l.s.val = (N); _l.s.type = Lisp_Int; _l; }))
368 #else
369 extern Lisp_Object make_number ();
370 #endif
372 #define EQ(x, y) ((x).s.val == (y).s.val)
374 #endif /* NO_UNION_TYPE */
376 /* During garbage collection, XGCTYPE must be used for extracting types
377 so that the mark bit is ignored. XMARKBIT accesses the markbit.
378 Markbits are used only in particular slots of particular structure types.
379 Other markbits are always zero.
380 Outside of garbage collection, all mark bits are always zero. */
382 #ifndef XGCTYPE
383 /* The distinction does not exist now that the MARKBIT has been eliminated. */
384 #define XGCTYPE(a) XTYPE (a)
385 #endif
387 #ifndef XPNTR
388 #ifdef HAVE_SHM
389 /* In this representation, data is found in two widely separated segments. */
390 extern size_t pure_size;
391 #define XPNTR(a) \
392 (XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
393 #else /* not HAVE_SHM */
394 #ifdef DATA_SEG_BITS
395 /* This case is used for the rt-pc.
396 In the diffs I was given, it checked for ptr = 0
397 and did not adjust it in that case.
398 But I don't think that zero should ever be found
399 in a Lisp object whose data type says it points to something. */
400 #define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
401 #else
402 #define XPNTR(a) XUINT (a)
403 #endif
404 #endif /* not HAVE_SHM */
405 #endif /* no XPNTR */
407 /* Largest and smallest representable fixnum values. These are the C
408 values. */
410 #define MOST_NEGATIVE_FIXNUM - ((EMACS_INT) 1 << (VALBITS - 1))
411 #define MOST_POSITIVE_FIXNUM (((EMACS_INT) 1 << (VALBITS - 1)) - 1)
412 /* Mask indicating the significant bits of a Lisp_Int.
413 I.e. (x & INTMASK) == XUINT (make_number (x)). */
414 #define INTMASK ((((EMACS_INT) 1) << VALBITS) - 1)
416 /* Value is non-zero if C integer I doesn't fit into a Lisp fixnum. */
418 #define FIXNUM_OVERFLOW_P(i) \
419 ((EMACS_INT)(i) > MOST_POSITIVE_FIXNUM \
420 || (EMACS_INT) (i) < MOST_NEGATIVE_FIXNUM)
422 /* Extract a value or address from a Lisp_Object. */
424 #define XCONS(a) (eassert (GC_CONSP(a)),(struct Lisp_Cons *) XPNTR(a))
425 #define XVECTOR(a) (eassert (GC_VECTORLIKEP(a)),(struct Lisp_Vector *) XPNTR(a))
426 #define XSTRING(a) (eassert (GC_STRINGP(a)),(struct Lisp_String *) XPNTR(a))
427 #define XSYMBOL(a) (eassert (GC_SYMBOLP(a)),(struct Lisp_Symbol *) XPNTR(a))
428 #define XFLOAT(a) (eassert (GC_FLOATP(a)),(struct Lisp_Float *) XPNTR(a))
430 /* Misc types. */
432 #define XMISC(a) ((union Lisp_Misc *) XPNTR(a))
433 #define XMISCTYPE(a) (XMARKER (a)->type)
434 #define XMARKER(a) (&(XMISC(a)->u_marker))
435 #define XINTFWD(a) (&(XMISC(a)->u_intfwd))
436 #define XBOOLFWD(a) (&(XMISC(a)->u_boolfwd))
437 #define XOBJFWD(a) (&(XMISC(a)->u_objfwd))
438 #define XBUFFER_OBJFWD(a) (&(XMISC(a)->u_buffer_objfwd))
439 #define XBUFFER_LOCAL_VALUE(a) (&(XMISC(a)->u_buffer_local_value))
440 #define XOVERLAY(a) (&(XMISC(a)->u_overlay))
441 #define XKBOARD_OBJFWD(a) (&(XMISC(a)->u_kboard_objfwd))
442 #define XSAVE_VALUE(a) (&(XMISC(a)->u_save_value))
444 /* Pseudovector types. */
446 #define XPROCESS(a) (eassert (GC_PROCESSP(a)),(struct Lisp_Process *) XPNTR(a))
447 #define XWINDOW(a) (eassert (GC_WINDOWP(a)),(struct window *) XPNTR(a))
448 #define XSUBR(a) (eassert (GC_SUBRP(a)),(struct Lisp_Subr *) XPNTR(a))
449 #define XBUFFER(a) (eassert (GC_BUFFERP(a)),(struct buffer *) XPNTR(a))
450 #define XCHAR_TABLE(a) ((struct Lisp_Char_Table *) XPNTR(a))
451 #define XBOOL_VECTOR(a) ((struct Lisp_Bool_Vector *) XPNTR(a))
453 /* Construct a Lisp_Object from a value or address. */
455 #define XSETINT(a, b) (a) = make_number (b)
456 #define XSETCONS(a, b) XSET (a, Lisp_Cons, b)
457 #define XSETVECTOR(a, b) XSET (a, Lisp_Vectorlike, b)
458 #define XSETSTRING(a, b) XSET (a, Lisp_String, b)
459 #define XSETSYMBOL(a, b) XSET (a, Lisp_Symbol, b)
460 #define XSETFLOAT(a, b) XSET (a, Lisp_Float, b)
462 /* Misc types. */
464 #define XSETMISC(a, b) XSET (a, Lisp_Misc, b)
465 #define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
467 /* Pseudovector types. */
469 #define XSETPSEUDOVECTOR(a, b, code) \
470 (XSETVECTOR (a, b), XVECTOR (a)->size |= PSEUDOVECTOR_FLAG | (code))
471 #define XSETWINDOW_CONFIGURATION(a, b) \
472 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
473 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
474 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
475 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
476 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
477 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
478 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
479 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
481 /* Convenience macros for dealing with Lisp arrays. */
483 #define AREF(ARRAY, IDX) XVECTOR ((ARRAY))->contents[IDX]
484 #define ASET(ARRAY, IDX, VAL) (AREF ((ARRAY), (IDX)) = (VAL))
485 #define ASIZE(ARRAY) XVECTOR ((ARRAY))->size
487 /* Convenience macros for dealing with Lisp strings. */
489 #define SREF(string, index) (XSTRING (string)->data[index] + 0)
490 #define SSET(string, index, new) (XSTRING (string)->data[index] = (new))
491 #define SDATA(string) (XSTRING (string)->data + 0)
492 #define SCHARS(string) (XSTRING (string)->size + 0)
493 #define SBYTES(string) (STRING_BYTES (XSTRING (string)) + 0)
495 #define STRING_SET_CHARS(string, newsize) \
496 (XSTRING (string)->size = (newsize))
498 #define STRING_COPYIN(string, index, new, count) \
499 bcopy (new, XSTRING (string)->data + index, count)
502 /* See the macros in intervals.h. */
504 typedef struct interval *INTERVAL;
506 /* Complain if object is not string or buffer type */
507 #define CHECK_STRING_OR_BUFFER(x) \
508 { if (!STRINGP ((x)) && !BUFFERP ((x))) \
509 x = wrong_type_argument (Qbuffer_or_string_p, (x)); }
511 /* In a cons, the markbit of the car is the gc mark bit */
513 struct Lisp_Cons
515 /* Please do not use the names of these elements in code other
516 than the core lisp implementation. Use XCAR and XCDR below. */
517 #ifdef HIDE_LISP_IMPLEMENTATION
518 Lisp_Object car_, cdr_;
519 #else
520 Lisp_Object car, cdr;
521 #endif
524 /* Take the car or cdr of something known to be a cons cell. */
525 /* The _AS_LVALUE macros shouldn't be used outside of the minimal set
526 of code that has to know what a cons cell looks like. Other code not
527 part of the basic lisp implementation should assume that the car and cdr
528 fields are not accessible as lvalues. (What if we want to switch to
529 a copying collector someday? Cached cons cell field addresses may be
530 invalidated at arbitrary points.) */
531 #ifdef HIDE_LISP_IMPLEMENTATION
532 #define XCAR_AS_LVALUE(c) (XCONS ((c))->car_)
533 #define XCDR_AS_LVALUE(c) (XCONS ((c))->cdr_)
534 #else
535 #define XCAR_AS_LVALUE(c) (XCONS ((c))->car)
536 #define XCDR_AS_LVALUE(c) (XCONS ((c))->cdr)
537 #endif
539 /* Use these from normal code. */
540 #define XCAR(c) LISP_MAKE_RVALUE(XCAR_AS_LVALUE(c))
541 #define XCDR(c) LISP_MAKE_RVALUE(XCDR_AS_LVALUE(c))
543 /* Use these to set the fields of a cons cell.
545 Note that both arguments may refer to the same object, so 'n'
546 should not be read after 'c' is first modified. Also, neither
547 argument should be evaluated more than once; side effects are
548 especially common in the second argument. */
549 #define XSETCAR(c,n) (XCAR_AS_LVALUE(c) = (n))
550 #define XSETCDR(c,n) (XCDR_AS_LVALUE(c) = (n))
552 /* For performance: Fast storage of positive integers into the
553 fields of a cons cell. See above caveats. */
554 #define XSETCARFASTINT(c,n) XSETFASTINT(XCAR_AS_LVALUE(c),(n))
555 #define XSETCDRFASTINT(c,n) XSETFASTINT(XCDR_AS_LVALUE(c),(n))
557 /* Take the car or cdr of something whose type is not known. */
558 #define CAR(c) \
559 (CONSP ((c)) ? XCAR ((c)) \
560 : NILP ((c)) ? Qnil \
561 : wrong_type_argument (Qlistp, (c)))
563 #define CDR(c) \
564 (CONSP ((c)) ? XCDR ((c)) \
565 : NILP ((c)) ? Qnil \
566 : wrong_type_argument (Qlistp, (c)))
568 /* Nonzero if STR is a multibyte string. */
569 #define STRING_MULTIBYTE(STR) \
570 (XSTRING (STR)->size_byte >= 0)
572 /* Return the length in bytes of STR. */
574 #ifdef GC_CHECK_STRING_BYTES
576 struct Lisp_String;
577 extern int string_bytes P_ ((struct Lisp_String *));
578 #define STRING_BYTES(S) string_bytes ((S))
580 #else /* not GC_CHECK_STRING_BYTES */
582 #define STRING_BYTES(STR) \
583 ((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte)
585 #endif /* not GC_CHECK_STRING_BYTES */
587 /* Mark STR as a unibyte string. */
588 #define STRING_SET_UNIBYTE(STR) (XSTRING (STR)->size_byte = -1)
590 /* Get text properties. */
591 #define STRING_INTERVALS(STR) (XSTRING (STR)->intervals + 0)
593 /* Set text properties. */
594 #define STRING_SET_INTERVALS(STR, INT) (XSTRING (STR)->intervals = (INT))
596 /* In a string or vector, the sign bit of the `size' is the gc mark bit */
598 struct Lisp_String
600 EMACS_INT size;
601 EMACS_INT size_byte;
602 INTERVAL intervals; /* text properties in this string */
603 unsigned char *data;
606 /* If a struct is made to look like a vector, this macro returns the length
607 of the shortest vector that would hold that struct. */
608 #define VECSIZE(type) ((sizeof (type) - (sizeof (struct Lisp_Vector) \
609 - sizeof (Lisp_Object)) \
610 + sizeof(Lisp_Object) - 1) /* round up */ \
611 / sizeof (Lisp_Object))
613 struct Lisp_Vector
615 EMACS_INT size;
616 struct Lisp_Vector *next;
617 Lisp_Object contents[1];
620 /* A char table is a kind of vectorlike, with contents are like a
621 vector but with a few other slots. For some purposes, it makes
622 sense to handle a chartable with type struct Lisp_Vector. An
623 element of a char table can be any Lisp objects, but if it is a sub
624 char-table, we treat it a table that contains information of a
625 group of characters of the same charsets or a specific character of
626 a charset. A sub char-table has the same structure as a char table
627 except for that the former omits several slots at the tail. A sub
628 char table appears only in an element of a char table, and there's
629 no way to access it directly from Emacs Lisp program. */
631 /* This is the number of slots that apply to characters or character
632 sets. The first 128 are for ASCII, the next 128 are for 8-bit
633 European characters, and the last 128 are for multibyte characters.
634 The first 256 are indexed by the code itself, but the last 128 are
635 indexed by (charset-id + 128). */
636 #define CHAR_TABLE_ORDINARY_SLOTS 384
638 /* This is the number of slots that apply to characters of ASCII and
639 8-bit Europeans only. */
640 #define CHAR_TABLE_SINGLE_BYTE_SLOTS 256
642 /* This is the number of slots that every char table must have. This
643 counts the ordinary slots and the top, defalt, parent, and purpose
644 slots. */
645 #define CHAR_TABLE_STANDARD_SLOTS (CHAR_TABLE_ORDINARY_SLOTS + 4)
647 /* This is the number of slots that apply to position-code-1 and
648 position-code-2 of a multibyte character at the 2nd and 3rd level
649 sub char tables respectively. */
650 #define SUB_CHAR_TABLE_ORDINARY_SLOTS 128
652 /* This is the number of slots that every sub char table must have.
653 This counts the ordinary slots and the top and defalt slot. */
654 #define SUB_CHAR_TABLE_STANDARD_SLOTS (SUB_CHAR_TABLE_ORDINARY_SLOTS + 2)
656 /* Return the number of "extra" slots in the char table CT. */
658 #define CHAR_TABLE_EXTRA_SLOTS(CT) \
659 (((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
661 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
662 and 8-bit Europeans characters. For these characters, do not check
663 validity of CT. Do not follow parent. */
664 #define CHAR_TABLE_REF(CT, IDX) \
665 ((IDX) >= 0 && (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
666 ? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
667 ? XCHAR_TABLE (CT)->contents[IDX] \
668 : XCHAR_TABLE (CT)->defalt) \
669 : Faref (CT, make_number (IDX)))
671 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
672 and 8-bit Europeans characters. However, if the result is nil,
673 return IDX.
675 For these characters, do not check validity of CT
676 and do not follow parent. */
677 #define CHAR_TABLE_TRANSLATE(CT, IDX) \
678 ((IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
679 ? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
680 ? XINT (XCHAR_TABLE (CT)->contents[IDX]) \
681 : IDX) \
682 : char_table_translate (CT, IDX))
684 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
685 8-bit Europeans characters. Do not check validity of CT. */
686 #define CHAR_TABLE_SET(CT, IDX, VAL) \
687 do { \
688 if (XFASTINT (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS) \
689 XCHAR_TABLE (CT)->contents[XFASTINT (IDX)] = VAL; \
690 else \
691 Faset (CT, IDX, VAL); \
692 } while (0)
694 struct Lisp_Char_Table
696 /* This is the vector's size field, which also holds the
697 pseudovector type information. It holds the size, too.
698 The size counts the top, defalt, purpose, and parent slots.
699 The last three are not counted if this is a sub char table. */
700 EMACS_INT size;
701 struct Lisp_Vector *next;
702 /* This holds a flag to tell if this is a top level char table (t)
703 or a sub char table (nil). */
704 Lisp_Object top;
705 /* This holds a default value,
706 which is used whenever the value for a specific character is nil. */
707 Lisp_Object defalt;
708 /* This holds an actual value of each element. A sub char table
709 has only SUB_CHAR_TABLE_ORDINARY_SLOTS number of elements. */
710 Lisp_Object contents[CHAR_TABLE_ORDINARY_SLOTS];
712 /* A sub char table doesn't has the following slots. */
714 /* This points to another char table, which we inherit from
715 when the value for a specific character is nil.
716 The `defalt' slot takes precedence over this. */
717 Lisp_Object parent;
718 /* This should be a symbol which says what kind of use
719 this char-table is meant for.
720 Typically now the values can be `syntax-table' and `display-table'. */
721 Lisp_Object purpose;
722 /* These hold additional data. */
723 Lisp_Object extras[1];
726 /* A boolvector is a kind of vectorlike, with contents are like a string. */
727 struct Lisp_Bool_Vector
729 /* This is the vector's size field. It doesn't have the real size,
730 just the subtype information. */
731 EMACS_INT vector_size;
732 struct Lisp_Vector *next;
733 /* This is the size in bits. */
734 EMACS_INT size;
735 /* This contains the actual bits, packed into bytes. */
736 unsigned char data[1];
739 /* This structure describes a built-in function.
740 It is generated by the DEFUN macro only.
741 defsubr makes it into a Lisp object.
743 This type is treated in most respects as a pseudovector,
744 but since we never dynamically allocate or free them,
745 we don't need a next-vector field. */
747 struct Lisp_Subr
749 EMACS_INT size;
750 Lisp_Object (*function) ();
751 short min_args, max_args;
752 char *symbol_name;
753 char *prompt;
754 char *doc;
758 /***********************************************************************
759 Symbols
760 ***********************************************************************/
762 /* Interned state of a symbol. */
764 enum symbol_interned
766 SYMBOL_UNINTERNED = 0,
767 SYMBOL_INTERNED = 1,
768 SYMBOL_INTERNED_IN_INITIAL_OBARRAY = 2
771 /* In a symbol, the markbit of the plist is used as the gc mark bit */
773 struct Lisp_Symbol
775 unsigned gcmarkbit : 1;
777 /* Non-zero means symbol serves as a variable alias. The symbol
778 holding the real value is found in the value slot. */
779 unsigned indirect_variable : 1;
781 /* Non-zero means symbol is constant, i.e. changing its value
782 should signal an error. */
783 unsigned constant : 1;
785 /* Interned state of the symbol. This is an enumerator from
786 enum symbol_interned. */
787 unsigned interned : 2;
789 /* The symbol's name, as a Lisp string.
791 The name "xname" is used to intentionally break code referring to
792 the old field "name" of type pointer to struct Lisp_String. */
793 Lisp_Object xname;
795 /* Value of the symbol or Qunbound if unbound. If this symbol is a
796 defvaralias, `value' contains the symbol for which it is an
797 alias. Use the SYMBOL_VALUE and SET_SYMBOL_VALUE macros to get
798 and set a symbol's value, to take defvaralias into account. */
799 Lisp_Object value;
801 /* Function value of the symbol or Qunbound if not fboundp. */
802 Lisp_Object function;
804 /* The symbol's property list. */
805 Lisp_Object plist;
807 /* Next symbol in obarray bucket, if the symbol is interned. */
808 struct Lisp_Symbol *next;
811 /* Value is name of symbol. */
813 #define SYMBOL_NAME(sym) \
814 LISP_MAKE_RVALUE (XSYMBOL (sym)->xname)
816 /* Value is non-zero if SYM is an interned symbol. */
818 #define SYMBOL_INTERNED_P(sym) \
819 (XSYMBOL (sym)->interned != SYMBOL_UNINTERNED)
821 /* Value is non-zero if SYM is interned in initial_obarray. */
823 #define SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P(sym) \
824 (XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY)
826 /* Value is non-zero if symbol is considered a constant, i.e. its
827 value cannot be changed (there is an exception for keyword symbols,
828 whose value can be set to the keyword symbol itself). */
830 #define SYMBOL_CONSTANT_P(sym) XSYMBOL (sym)->constant
832 /* Value is the value of SYM, with defvaralias taken into
833 account. */
835 #define SYMBOL_VALUE(sym) \
836 (XSYMBOL (sym)->indirect_variable \
837 ? XSYMBOL (indirect_variable (sym))->value \
838 : XSYMBOL (sym)->value)
840 /* Set SYM's value to VAL, taking defvaralias into account. */
842 #define SET_SYMBOL_VALUE(sym, val) \
843 do { \
844 if (XSYMBOL (sym)->indirect_variable) \
845 XSYMBOL (indirect_variable ((sym)))->value = (val); \
846 else \
847 XSYMBOL (sym)->value = (val); \
848 } while (0)
851 /***********************************************************************
852 Hash Tables
853 ***********************************************************************/
855 /* The structure of a Lisp hash table. */
857 struct Lisp_Hash_Table
859 /* Vector fields. The hash table code doesn't refer to these. */
860 EMACS_INT size;
861 struct Lisp_Vector *vec_next;
863 /* Function used to compare keys. */
864 Lisp_Object test;
866 /* Nil if table is non-weak. Otherwise a symbol describing the
867 weakness of the table. */
868 Lisp_Object weak;
870 /* When the table is resized, and this is an integer, compute the
871 new size by adding this to the old size. If a float, compute the
872 new size by multiplying the old size with this factor. */
873 Lisp_Object rehash_size;
875 /* Resize hash table when number of entries/ table size is >= this
876 ratio, a float. */
877 Lisp_Object rehash_threshold;
879 /* Number of key/value entries in the table. */
880 Lisp_Object count;
882 /* Vector of keys and values. The key of item I is found at index
883 2 * I, the value is found at index 2 * I + 1. */
884 Lisp_Object key_and_value;
886 /* Vector of hash codes.. If hash[I] is nil, this means that that
887 entry I is unused. */
888 Lisp_Object hash;
890 /* Vector used to chain entries. If entry I is free, next[I] is the
891 entry number of the next free item. If entry I is non-free,
892 next[I] is the index of the next entry in the collision chain. */
893 Lisp_Object next;
895 /* Index of first free entry in free list. */
896 Lisp_Object next_free;
898 /* Bucket vector. A non-nil entry is the index of the first item in
899 a collision chain. This vector's size can be larger than the
900 hash table size to reduce collisions. */
901 Lisp_Object index;
903 /* Next weak hash table if this is a weak hash table. The head
904 of the list is in Vweak_hash_tables. */
905 Lisp_Object next_weak;
907 /* User-supplied hash function, or nil. */
908 Lisp_Object user_hash_function;
910 /* User-supplied key comparison function, or nil. */
911 Lisp_Object user_cmp_function;
913 /* C function to compare two keys. */
914 int (* cmpfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object,
915 unsigned, Lisp_Object, unsigned));
917 /* C function to compute hash code. */
918 unsigned (* hashfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object));
922 #define XHASH_TABLE(OBJ) \
923 ((struct Lisp_Hash_Table *) XPNTR (OBJ))
925 #define XSET_HASH_TABLE(VAR, PTR) \
926 (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
928 #define HASH_TABLE_P(OBJ) PSEUDOVECTORP (OBJ, PVEC_HASH_TABLE)
929 #define GC_HASH_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_HASH_TABLE)
931 #define CHECK_HASH_TABLE(x) \
932 do \
934 if (!HASH_TABLE_P ((x))) \
935 x = wrong_type_argument (Qhash_table_p, (x)); \
937 while (0)
939 /* Value is the key part of entry IDX in hash table H. */
941 #define HASH_KEY(H, IDX) AREF ((H)->key_and_value, 2 * (IDX))
943 /* Value is the value part of entry IDX in hash table H. */
945 #define HASH_VALUE(H, IDX) AREF ((H)->key_and_value, 2 * (IDX) + 1)
947 /* Value is the index of the next entry following the one at IDX
948 in hash table H. */
950 #define HASH_NEXT(H, IDX) AREF ((H)->next, (IDX))
952 /* Value is the hash code computed for entry IDX in hash table H. */
954 #define HASH_HASH(H, IDX) AREF ((H)->hash, (IDX))
956 /* Value is the index of the element in hash table H that is the
957 start of the collision list at index IDX in the index vector of H. */
959 #define HASH_INDEX(H, IDX) AREF ((H)->index, (IDX))
961 /* Value is the size of hash table H. */
963 #define HASH_TABLE_SIZE(H) XVECTOR ((H)->next)->size
965 /* Default size for hash tables if not specified. */
967 #define DEFAULT_HASH_SIZE 65
969 /* Default threshold specifying when to resize a hash table. The
970 value gives the ratio of current entries in the hash table and the
971 size of the hash table. */
973 #define DEFAULT_REHASH_THRESHOLD 0.8
975 /* Default factor by which to increase the size of a hash table. */
977 #define DEFAULT_REHASH_SIZE 1.5
980 /* These structures are used for various misc types. */
982 struct Lisp_Marker
984 int type : 16; /* = Lisp_Misc_Marker */
985 unsigned gcmarkbit : 1;
986 int spacer : 14;
987 /* 1 means normal insertion at the marker's position
988 leaves the marker after the inserted text. */
989 unsigned int insertion_type : 1;
990 /* This is the buffer that the marker points into,
991 or 0 if it points nowhere. */
992 struct buffer *buffer;
994 /* The remaining fields are meaningless in a marker that
995 does not point anywhere. */
997 /* For markers that point somewhere,
998 this is used to chain of all the markers in a given buffer. */
999 struct Lisp_Marker *next;
1000 /* This is the char position where the marker points. */
1001 EMACS_INT charpos;
1002 /* This is the byte position. */
1003 EMACS_INT bytepos;
1006 /* Forwarding pointer to an int variable.
1007 This is allowed only in the value cell of a symbol,
1008 and it means that the symbol's value really lives in the
1009 specified int variable. */
1010 struct Lisp_Intfwd
1012 int type : 16; /* = Lisp_Misc_Intfwd */
1013 unsigned gcmarkbit : 1;
1014 int spacer : 15;
1015 EMACS_INT *intvar;
1018 /* Boolean forwarding pointer to an int variable.
1019 This is like Lisp_Intfwd except that the ostensible
1020 "value" of the symbol is t if the int variable is nonzero,
1021 nil if it is zero. */
1022 struct Lisp_Boolfwd
1024 int type : 16; /* = Lisp_Misc_Boolfwd */
1025 unsigned gcmarkbit : 1;
1026 int spacer : 15;
1027 int *boolvar;
1030 /* Forwarding pointer to a Lisp_Object variable.
1031 This is allowed only in the value cell of a symbol,
1032 and it means that the symbol's value really lives in the
1033 specified variable. */
1034 struct Lisp_Objfwd
1036 int type : 16; /* = Lisp_Misc_Objfwd */
1037 unsigned gcmarkbit : 1;
1038 int spacer : 15;
1039 Lisp_Object *objvar;
1042 /* Like Lisp_Objfwd except that value lives in a slot in the
1043 current buffer. Value is byte index of slot within buffer. */
1044 struct Lisp_Buffer_Objfwd
1046 int type : 16; /* = Lisp_Misc_Buffer_Objfwd */
1047 unsigned gcmarkbit : 1;
1048 int spacer : 15;
1049 int offset;
1052 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
1053 the symbol has buffer-local or frame-local bindings. (Exception:
1054 some buffer-local variables are built-in, with their values stored
1055 in the buffer structure itself. They are handled differently,
1056 using struct Lisp_Buffer_Objfwd.)
1058 The `realvalue' slot holds the variable's current value, or a
1059 forwarding pointer to where that value is kept. This value is the
1060 one that corresponds to the loaded binding. To read or set the
1061 variable, you must first make sure the right binding is loaded;
1062 then you can access the value in (or through) `realvalue'.
1064 `buffer' and `frame' are the buffer and frame for which the loaded
1065 binding was found. If those have changed, to make sure the right
1066 binding is loaded it is necessary to find which binding goes with
1067 the current buffer and selected frame, then load it. To load it,
1068 first unload the previous binding, then copy the value of the new
1069 binding into `realvalue' (or through it). Also update
1070 LOADED-BINDING to point to the newly loaded binding.
1072 Lisp_Misc_Buffer_Local_Value and Lisp_Misc_Some_Buffer_Local_Value
1073 both use this kind of structure. With the former, merely setting
1074 the variable creates a local binding for the current buffer. With
1075 the latter, setting the variable does not do that; only
1076 make-local-variable does that. */
1078 struct Lisp_Buffer_Local_Value
1080 int type : 16; /* = Lisp_Misc_Buffer_Local_Value
1081 or Lisp_Misc_Some_Buffer_Local_Value */
1082 unsigned gcmarkbit : 1;
1083 int spacer : 12;
1085 /* 1 means this variable is allowed to have frame-local bindings,
1086 so check for them when looking for the proper binding. */
1087 unsigned int check_frame : 1;
1088 /* 1 means that the binding now loaded was found
1089 as a local binding for the buffer in the `buffer' slot. */
1090 unsigned int found_for_buffer : 1;
1091 /* 1 means that the binding now loaded was found
1092 as a local binding for the frame in the `frame' slot. */
1093 unsigned int found_for_frame : 1;
1094 Lisp_Object realvalue;
1095 /* The buffer and frame for which the loaded binding was found. */
1096 Lisp_Object buffer, frame;
1098 /* A cons cell, (LOADED-BINDING . DEFAULT-VALUE).
1100 LOADED-BINDING is the binding now loaded. It is a cons cell
1101 whose cdr is the binding's value. The cons cell may be an
1102 element of a buffer's local-variable alist, or an element of a
1103 frame's parameter alist, or it may be this cons cell.
1105 DEFAULT-VALUE is the variable's default value, seen when the
1106 current buffer and selected frame do not have their own
1107 bindings for the variable. When the default binding is loaded,
1108 LOADED-BINDING is actually this very cons cell; thus, its car
1109 points to itself. */
1110 Lisp_Object cdr;
1113 /* START and END are markers in the overlay's buffer, and
1114 PLIST is the overlay's property list. */
1115 struct Lisp_Overlay
1117 int type : 16; /* = Lisp_Misc_Overlay */
1118 unsigned gcmarkbit : 1;
1119 int spacer : 15;
1120 struct Lisp_Overlay *next;
1121 Lisp_Object start, end, plist;
1124 /* Like Lisp_Objfwd except that value lives in a slot in the
1125 current kboard. */
1126 struct Lisp_Kboard_Objfwd
1128 int type : 16; /* = Lisp_Misc_Kboard_Objfwd */
1129 unsigned gcmarkbit : 1;
1130 int spacer : 15;
1131 int offset;
1134 /* Hold a C pointer for later use.
1135 This type of object is used in the arg to record_unwind_protect. */
1136 struct Lisp_Save_Value
1138 int type : 16; /* = Lisp_Misc_Save_Value */
1139 unsigned gcmarkbit : 1;
1140 int spacer : 15;
1141 void *pointer;
1142 int integer;
1146 /* A miscellaneous object, when it's on the free list. */
1147 struct Lisp_Free
1149 int type : 16; /* = Lisp_Misc_Free */
1150 unsigned gcmarkbit : 1;
1151 int spacer : 15;
1152 union Lisp_Misc *chain;
1155 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
1156 It uses one of these struct subtypes to get the type field. */
1158 union Lisp_Misc
1160 struct Lisp_Free u_free;
1161 struct Lisp_Marker u_marker;
1162 struct Lisp_Intfwd u_intfwd;
1163 struct Lisp_Boolfwd u_boolfwd;
1164 struct Lisp_Objfwd u_objfwd;
1165 struct Lisp_Buffer_Objfwd u_buffer_objfwd;
1166 struct Lisp_Buffer_Local_Value u_buffer_local_value;
1167 struct Lisp_Overlay u_overlay;
1168 struct Lisp_Kboard_Objfwd u_kboard_objfwd;
1169 struct Lisp_Save_Value u_save_value;
1172 /* Lisp floating point type */
1173 struct Lisp_Float
1175 #ifdef HIDE_LISP_IMPLEMENTATION
1176 double data_;
1177 #else
1178 double data;
1179 #endif
1182 #ifdef HIDE_LISP_IMPLEMENTATION
1183 #define XFLOAT_DATA(f) (XFLOAT (f)->data_)
1184 #else
1185 #define XFLOAT_DATA(f) (XFLOAT (f)->data)
1186 #endif
1188 /* A character, declared with the following typedef, is a member
1189 of some character set associated with the current buffer. */
1190 #ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
1191 #define _UCHAR_T
1192 typedef unsigned char UCHAR;
1193 #endif
1195 /* Meanings of slots in a Lisp_Compiled: */
1197 #define COMPILED_ARGLIST 0
1198 #define COMPILED_BYTECODE 1
1199 #define COMPILED_CONSTANTS 2
1200 #define COMPILED_STACK_DEPTH 3
1201 #define COMPILED_DOC_STRING 4
1202 #define COMPILED_INTERACTIVE 5
1204 /* Flag bits in a character. These also get used in termhooks.h.
1205 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
1206 (MUlti-Lingual Emacs) might need 22 bits for the character value
1207 itself, so we probably shouldn't use any bits lower than 0x0400000. */
1208 #define CHAR_ALT (0x0400000)
1209 #define CHAR_SUPER (0x0800000)
1210 #define CHAR_HYPER (0x1000000)
1211 #define CHAR_SHIFT (0x2000000)
1212 #define CHAR_CTL (0x4000000)
1213 #define CHAR_META (0x8000000)
1215 #define CHAR_MODIFIER_MASK \
1216 (CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META)
1219 /* Actually, the current Emacs uses 19 bits for the character value
1220 itself. */
1221 #define CHARACTERBITS 19
1223 /* The maximum byte size consumed by push_key_description.
1224 All callers should assure that at least this size of memory is
1225 allocated at the place pointed by the second argument.
1227 Thers are 6 modifiers, each consumes 2 chars.
1228 The octal form of a character code consumes
1229 (1 + CHARACTERBITS / 3 + 1) chars (including backslash at the head).
1230 We need one more byte for string terminator `\0'. */
1231 #define KEY_DESCRIPTION_SIZE ((2 * 6) + 1 + (CHARACTERBITS / 3) + 1 + 1)
1233 #ifdef USE_X_TOOLKIT
1234 #ifdef NO_UNION_TYPE
1235 /* Use this for turning a (void *) into a Lisp_Object, as when the
1236 Lisp_Object is passed into a toolkit callback function. */
1237 #define VOID_TO_LISP(larg,varg) \
1238 do { ((larg) = ((Lisp_Object) (varg))); } while (0)
1239 #define CVOID_TO_LISP VOID_TO_LISP
1241 /* Use this for turning a Lisp_Object into a (void *), as when the
1242 Lisp_Object is passed into a toolkit callback function. */
1243 #define LISP_TO_VOID(larg) ((void *) (larg))
1244 #define LISP_TO_CVOID(varg) ((const void *) (larg))
1246 #else /* not NO_UNION_TYPE */
1247 /* Use this for turning a (void *) into a Lisp_Object, as when the
1248 Lisp_Object is passed into a toolkit callback function. */
1249 #define VOID_TO_LISP(larg,varg) \
1250 do { ((larg).v = (void *) (varg)); } while (0)
1251 #define CVOID_TO_LISP(larg,varg) \
1252 do { ((larg).cv = (const void *) (varg)); } while (0)
1254 /* Use this for turning a Lisp_Object into a (void *), as when the
1255 Lisp_Object is passed into a toolkit callback function. */
1256 #define LISP_TO_VOID(larg) ((larg).v)
1257 #define LISP_TO_CVOID(larg) ((larg).cv)
1258 #endif /* not NO_UNION_TYPE */
1259 #endif /* USE_X_TOOLKIT */
1262 /* The glyph datatype, used to represent characters on the display. */
1264 /* Glyph code to use as an index to the glyph table. If it is out of
1265 range for the glyph table, or the corresonding element in the table
1266 is nil, the low 8 bits are the single byte character code, and the
1267 bits above are the numeric face ID. If FID is the face ID of a
1268 glyph on a frame F, then F->display.x->faces[FID] contains the
1269 description of that face. This is an int instead of a short, so we
1270 can support a good bunch of face ID's (2^(31 - 8)); given that we
1271 have no mechanism for tossing unused frame face ID's yet, we'll
1272 probably run out of 255 pretty quickly.
1273 This is always -1 for a multibyte character. */
1274 #define GLYPH int
1276 /* Mask bits for face. */
1277 #define GLYPH_MASK_FACE 0x7FF80000
1278 /* Mask bits for character code. */
1279 #define GLYPH_MASK_CHAR 0x0007FFFF /* The lowest 19 bits */
1281 /* The FAST macros assume that we already know we're in an X window. */
1283 /* Set a character code and a face ID in a glyph G. */
1284 #define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << CHARACTERBITS))
1286 /* Return a glyph's character code. */
1287 #define FAST_GLYPH_CHAR(glyph) ((glyph) & GLYPH_MASK_CHAR)
1289 /* Return a glyph's face ID. */
1290 #define FAST_GLYPH_FACE(glyph) (((glyph) & GLYPH_MASK_FACE) >> CHARACTERBITS)
1292 /* Slower versions that test the frame type first. */
1293 #define MAKE_GLYPH(f, char, face) (FAST_MAKE_GLYPH (char, face))
1294 #define GLYPH_CHAR(f, g) (FAST_GLYPH_CHAR (g))
1295 #define GLYPH_FACE(f, g) (FAST_GLYPH_FACE (g))
1297 /* Return 1 iff GLYPH contains valid character code. */
1298 #define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (FAST_GLYPH_CHAR (glyph), 1)
1300 /* The ID of the mode line highlighting face. */
1301 #define GLYPH_MODE_LINE_FACE 1
1303 /* Data type checking */
1305 #define NILP(x) (XFASTINT (x) == XFASTINT (Qnil))
1306 #define GC_NILP(x) GC_EQ (x, Qnil)
1308 #define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
1309 #define GC_NUMBERP(x) (GC_INTEGERP (x) || GC_FLOATP (x))
1310 #define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
1311 #define GC_NATNUMP(x) (GC_INTEGERP (x) && XINT (x) >= 0)
1313 #define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
1314 #define GC_INTEGERP(x) INTEGERP (x)
1315 #define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
1316 #define GC_SYMBOLP(x) (XGCTYPE ((x)) == Lisp_Symbol)
1317 #define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
1318 #define GC_MISCP(x) (XGCTYPE ((x)) == Lisp_Misc)
1319 #define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
1320 #define GC_VECTORLIKEP(x) (XGCTYPE ((x)) == Lisp_Vectorlike)
1321 #define STRINGP(x) (XTYPE ((x)) == Lisp_String)
1322 #define GC_STRINGP(x) (XGCTYPE ((x)) == Lisp_String)
1323 #define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
1324 #define GC_CONSP(x) (XGCTYPE ((x)) == Lisp_Cons)
1326 #define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
1327 #define GC_FLOATP(x) (XGCTYPE ((x)) == Lisp_Float)
1328 #define VECTORP(x) (VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
1329 #define GC_VECTORP(x) (GC_VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
1330 #define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1331 #define GC_OVERLAYP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1332 #define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1333 #define GC_MARKERP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1334 #define INTFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
1335 #define GC_INTFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
1336 #define BOOLFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
1337 #define GC_BOOLFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
1338 #define OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
1339 #define GC_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
1340 #define BUFFER_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
1341 #define GC_BUFFER_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
1342 #define BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
1343 #define GC_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
1344 #define SOME_BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
1345 #define GC_SOME_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
1346 #define KBOARD_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
1347 #define GC_KBOARD_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
1350 /* True if object X is a pseudovector whose code is CODE. */
1351 #define PSEUDOVECTORP(x, code) \
1352 (VECTORLIKEP (x) \
1353 && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code)))) \
1354 == (PSEUDOVECTOR_FLAG | (code))))
1356 /* True if object X is a pseudovector whose code is CODE.
1357 This one works during GC. */
1358 #define GC_PSEUDOVECTORP(x, code) \
1359 (GC_VECTORLIKEP (x) \
1360 && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code)))) \
1361 == (PSEUDOVECTOR_FLAG | (code))))
1363 /* Test for specific pseudovector types. */
1364 #define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1365 #define GC_WINDOW_CONFIGURATIONP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1366 #define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
1367 #define GC_PROCESSP(x) GC_PSEUDOVECTORP (x, PVEC_PROCESS)
1368 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
1369 #define GC_WINDOWP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW)
1370 #define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
1371 #define GC_SUBRP(x) GC_PSEUDOVECTORP (x, PVEC_SUBR)
1372 #define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
1373 #define GC_COMPILEDP(x) GC_PSEUDOVECTORP (x, PVEC_COMPILED)
1374 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
1375 #define GC_BUFFERP(x) GC_PSEUDOVECTORP (x, PVEC_BUFFER)
1376 #define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1377 #define GC_CHAR_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1378 #define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
1379 #define GC_BOOL_VECTOR_P(x) GC_PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
1380 #define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
1381 #define GC_FRAMEP(x) GC_PSEUDOVECTORP (x, PVEC_FRAME)
1383 #define SUB_CHAR_TABLE_P(x) (CHAR_TABLE_P (x) && NILP (XCHAR_TABLE (x)->top))
1385 #define GC_EQ(x, y) EQ (x, y)
1387 #define CHECK_LIST(x) \
1388 do { if (!CONSP ((x)) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); } while (0)
1390 #define CHECK_STRING(x) \
1391 do { if (!STRINGP ((x))) x = wrong_type_argument (Qstringp, (x)); } while (0)
1393 #define CHECK_STRING_CAR(x) \
1394 do { if (!STRINGP (XCAR (x))) XSETCAR (x, wrong_type_argument (Qstringp, XCAR (x))); } while (0)
1396 #define CHECK_CONS(x) \
1397 do { if (!CONSP ((x))) x = wrong_type_argument (Qconsp, (x)); } while (0)
1399 #define CHECK_SYMBOL(x) \
1400 do { if (!SYMBOLP ((x))) x = wrong_type_argument (Qsymbolp, (x)); } while (0)
1402 #define CHECK_CHAR_TABLE(x) \
1403 do { if (!CHAR_TABLE_P ((x))) \
1404 x = wrong_type_argument (Qchar_table_p, (x)); } while (0)
1406 #define CHECK_VECTOR(x) \
1407 do { if (!VECTORP ((x))) x = wrong_type_argument (Qvectorp, (x)); } while (0)
1409 #define CHECK_VECTOR_OR_CHAR_TABLE(x) \
1410 do { if (!VECTORP ((x)) && !CHAR_TABLE_P ((x))) \
1411 x = wrong_type_argument (Qvector_or_char_table_p, (x)); \
1412 } while (0)
1414 #define CHECK_BUFFER(x) \
1415 do { if (!BUFFERP ((x))) x = wrong_type_argument (Qbufferp, (x)); } while (0)
1417 #define CHECK_WINDOW(x) \
1418 do { if (!WINDOWP ((x))) x = wrong_type_argument (Qwindowp, (x)); } while (0)
1420 /* This macro rejects windows on the interior of the window tree as
1421 "dead", which is what we want; this is an argument-checking macro, and
1422 the user should never get access to interior windows.
1424 A window of any sort, leaf or interior, is dead iff the buffer,
1425 vchild, and hchild members are all nil. */
1427 #define CHECK_LIVE_WINDOW(x) \
1428 do { \
1429 if (!WINDOWP ((x)) \
1430 || NILP (XWINDOW ((x))->buffer)) \
1431 x = wrong_type_argument (Qwindow_live_p, (x)); \
1432 } while (0)
1434 #define CHECK_PROCESS(x) \
1435 do { if (!PROCESSP ((x))) x = wrong_type_argument (Qprocessp, (x)); } while (0)
1437 #define CHECK_NUMBER(x) \
1438 do { if (!INTEGERP ((x))) x = wrong_type_argument (Qintegerp, (x)); } while (0)
1440 #define CHECK_NATNUM(x) \
1441 do { if (!NATNUMP (x)) x = wrong_type_argument (Qwholenump, (x)); } while (0)
1443 #define CHECK_MARKER(x) \
1444 do { if (!MARKERP ((x))) x = wrong_type_argument (Qmarkerp, (x)); } while (0)
1446 #define CHECK_NUMBER_COERCE_MARKER(x) \
1447 do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
1448 else if (!INTEGERP ((x))) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } while (0)
1450 #define XFLOATINT(n) extract_float((n))
1452 #define CHECK_FLOAT(x) \
1453 do { if (!FLOATP (x)) \
1454 x = wrong_type_argument (Qfloatp, (x)); } while (0)
1456 #define CHECK_NUMBER_OR_FLOAT(x) \
1457 do { if (!FLOATP (x) && !INTEGERP (x)) \
1458 x = wrong_type_argument (Qnumberp, (x)); } while (0)
1460 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
1461 do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \
1462 else if (!INTEGERP (x) && !FLOATP (x)) \
1463 x = wrong_type_argument (Qnumber_or_marker_p, (x)); } while (0)
1465 #define CHECK_OVERLAY(x) \
1466 do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
1468 /* Since we can't assign directly to the CAR or CDR fields of a cons
1469 cell, use these when checking that those fields contain numbers. */
1470 #define CHECK_NUMBER_CAR(x) \
1471 do { \
1472 Lisp_Object tmp = XCAR (x); \
1473 CHECK_NUMBER (tmp); \
1474 XSETCAR ((x), tmp); \
1475 } while (0)
1477 #define CHECK_NUMBER_CDR(x) \
1478 do { \
1479 Lisp_Object tmp = XCDR (x); \
1480 CHECK_NUMBER (tmp); \
1481 XSETCDR ((x), tmp); \
1482 } while (0)
1484 /* Cast pointers to this type to compare them. Some machines want int. */
1485 #ifndef PNTR_COMPARISON_TYPE
1486 #define PNTR_COMPARISON_TYPE EMACS_UINT
1487 #endif
1489 /* Define a built-in function for calling from Lisp.
1490 `lname' should be the name to give the function in Lisp,
1491 as a null-terminated C string.
1492 `fnname' should be the name of the function in C.
1493 By convention, it starts with F.
1494 `sname' should be the name for the C constant structure
1495 that records information on this function for internal use.
1496 By convention, it should be the same as `fnname' but with S instead of F.
1497 It's too bad that C macros can't compute this from `fnname'.
1498 `minargs' should be a number, the minimum number of arguments allowed.
1499 `maxargs' should be a number, the maximum number of arguments allowed,
1500 or else MANY or UNEVALLED.
1501 MANY means pass a vector of evaluated arguments,
1502 in the form of an integer number-of-arguments
1503 followed by the address of a vector of Lisp_Objects
1504 which contains the argument values.
1505 UNEVALLED means pass the list of unevaluated arguments
1506 `prompt' says how to read arguments for an interactive call.
1507 See the doc string for `interactive'.
1508 A null string means call interactively with no arguments.
1509 `doc' is documentation for the user. */
1511 #if (!defined (__STDC__) && !defined (PROTOTYPES)) \
1512 || defined (USE_NONANSI_DEFUN)
1514 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
1515 Lisp_Object fnname (); \
1516 struct Lisp_Subr sname = \
1517 { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
1518 fnname, minargs, maxargs, lname, prompt, 0}; \
1519 Lisp_Object fnname
1521 #else
1523 /* This version of DEFUN declares a function prototype with the right
1524 arguments, so we can catch errors with maxargs at compile-time. */
1525 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
1526 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
1527 struct Lisp_Subr sname = \
1528 { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
1529 fnname, minargs, maxargs, lname, prompt, 0}; \
1530 Lisp_Object fnname
1532 /* Note that the weird token-substitution semantics of ANSI C makes
1533 this work for MANY and UNEVALLED. */
1534 #define DEFUN_ARGS_MANY (int, Lisp_Object *)
1535 #define DEFUN_ARGS_UNEVALLED (Lisp_Object)
1536 #define DEFUN_ARGS_0 (void)
1537 #define DEFUN_ARGS_1 (Lisp_Object)
1538 #define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
1539 #define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
1540 #define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1541 #define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1542 Lisp_Object)
1543 #define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1544 Lisp_Object, Lisp_Object)
1545 #define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1546 Lisp_Object, Lisp_Object, Lisp_Object)
1547 #define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1548 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1549 #endif
1551 /* Non-zero if OBJ is a Lisp function. */
1553 #define FUNCTIONP(OBJ) \
1554 ((CONSP (OBJ) && EQ (XCAR (OBJ), Qlambda)) \
1555 || (SYMBOLP (OBJ) && !NILP (Ffboundp (OBJ))) \
1556 || COMPILEDP (OBJ) \
1557 || SUBRP (OBJ))
1559 /* defsubr (Sname);
1560 is how we define the symbol for function `name' at start-up time. */
1561 extern void defsubr P_ ((struct Lisp_Subr *));
1563 #define MANY -2
1564 #define UNEVALLED -1
1566 extern void defvar_lisp P_ ((char *, Lisp_Object *));
1567 extern void defvar_lisp_nopro P_ ((char *, Lisp_Object *));
1568 extern void defvar_bool P_ ((char *, int *));
1569 extern void defvar_int P_ ((char *, EMACS_INT *));
1570 extern void defvar_per_buffer P_ ((char *, Lisp_Object *, Lisp_Object, char *));
1571 extern void defvar_kboard P_ ((char *, int));
1573 /* Macros we use to define forwarded Lisp variables.
1574 These are used in the syms_of_FILENAME functions. */
1576 #define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
1577 #define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
1578 #define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
1579 #define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
1580 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
1581 defvar_per_buffer (lname, vname, type, 0)
1582 #define DEFVAR_KBOARD(lname, vname, doc) \
1583 defvar_kboard (lname, \
1584 (int)((char *)(&current_kboard->vname) \
1585 - (char *)current_kboard))
1589 /* Structure for recording Lisp call stack for backtrace purposes. */
1591 /* The special binding stack holds the outer values of variables while
1592 they are bound by a function application or a let form, stores the
1593 code to be executed for Lisp unwind-protect forms, and stores the C
1594 functions to be called for record_unwind_protect.
1596 If func is non-zero, undoing this binding applies func to old_value;
1597 This implements record_unwind_protect.
1599 Otherwise, the element is a variable binding.
1601 If the symbol field is a symbol, it is an ordinary variable binding.
1603 Otherwise, it should be a structure (SYMBOL WHERE
1604 . CURRENT-BUFFER), which means having bound a local value while
1605 CURRENT-BUFFER was active. If WHERE is nil this means we saw the
1606 default value when binding SYMBOL. WHERE being a buffer or frame
1607 means we saw a buffer-local or frame-local value. Other values of
1608 WHERE mean an internal error. */
1610 typedef Lisp_Object (*specbinding_func) P_ ((Lisp_Object));
1612 struct specbinding
1614 volatile Lisp_Object symbol, old_value;
1615 volatile specbinding_func func;
1616 Lisp_Object unused; /* Dividing by 16 is faster than by 12 */
1619 extern struct specbinding *specpdl;
1620 extern volatile struct specbinding *specpdl_ptr;
1621 extern int specpdl_size;
1623 extern EMACS_INT max_specpdl_size;
1625 #define SPECPDL_INDEX() (specpdl_ptr - specpdl)
1627 /* Everything needed to describe an active condition case. */
1628 struct handler
1630 /* The handler clauses and variable from the condition-case form. */
1631 /* For a handler set up in Lisp code, this is always a list.
1632 For an internal handler set up by internal_condition_case*,
1633 this can instead be the symbol t or `error'.
1634 t: handle all conditions.
1635 error: handle all conditions, and errors can run the debugger
1636 or display a backtrace. */
1637 Lisp_Object handler;
1638 Lisp_Object var;
1639 /* Fsignal stores here the condition-case clause that applies,
1640 and Fcondition_case thus knows which clause to run. */
1641 Lisp_Object chosen_clause;
1643 /* Used to effect the longjump out to the handler. */
1644 struct catchtag *tag;
1646 /* The next enclosing handler. */
1647 struct handler *next;
1650 extern struct handler *handlerlist;
1652 extern struct catchtag *catchlist;
1653 extern struct backtrace *backtrace_list;
1655 extern Lisp_Object memory_signal_data;
1657 /* An address near the bottom of the stack.
1658 Tells GC how to save a copy of the stack. */
1659 extern char *stack_bottom;
1661 /* Check quit-flag and quit if it is non-nil.
1662 Typing C-g does not directly cause a quit; it only sets Vquit_flag.
1663 So the program needs to do QUIT at times when it is safe to quit.
1664 Every loop that might run for a long time or might not exit
1665 ought to do QUIT at least once, at a safe place.
1666 Unless that is impossible, of course.
1667 But it is very desirable to avoid creating loops where QUIT is impossible.
1669 Exception: if you set immediate_quit to nonzero,
1670 then the handler that responds to the C-g does the quit itself.
1671 This is a good thing to do around a loop that has no side effects
1672 and (in particular) cannot call arbitrary Lisp code. */
1674 #define QUIT \
1675 do { \
1676 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
1678 Vquit_flag = Qnil; \
1679 Fsignal (Qquit, Qnil); \
1681 } while (0)
1683 /* Nonzero if ought to quit now. */
1685 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
1687 /* Variables used locally in the following case handling macros. */
1688 extern int case_temp1;
1689 extern Lisp_Object case_temp2;
1691 /* Current buffer's map from characters to lower-case characters. */
1693 #define DOWNCASE_TABLE current_buffer->downcase_table
1695 /* Current buffer's map from characters to upper-case characters. */
1697 #define UPCASE_TABLE current_buffer->upcase_table
1699 /* Downcase a character, or make no change if that cannot be done. */
1701 #define DOWNCASE(CH) \
1702 ((case_temp1 = (CH), \
1703 case_temp2 = CHAR_TABLE_REF (DOWNCASE_TABLE, case_temp1), \
1704 NATNUMP (case_temp2)) \
1705 ? XFASTINT (case_temp2) : case_temp1)
1707 /* 1 if CH is upper case. */
1709 #define UPPERCASEP(CH) (DOWNCASE (CH) != (CH))
1711 /* 1 if CH is neither upper nor lower case. */
1713 #define NOCASEP(CH) (UPCASE1 (CH) == (CH))
1715 /* 1 if CH is lower case. */
1717 #define LOWERCASEP(CH) (!UPPERCASEP (CH) && !NOCASEP(CH))
1719 /* Upcase a character, or make no change if that cannot be done. */
1721 #define UPCASE(CH) (!UPPERCASEP (CH) ? UPCASE1 (CH) : (CH))
1723 /* Upcase a character known to be not upper case. */
1725 #define UPCASE1(CH) \
1726 ((case_temp1 = (CH), \
1727 case_temp2 = CHAR_TABLE_REF (UPCASE_TABLE, case_temp1), \
1728 NATNUMP (case_temp2)) \
1729 ? XFASTINT (case_temp2) : case_temp1)
1731 extern Lisp_Object Vascii_downcase_table;
1733 /* Number of bytes of structure consed since last GC. */
1735 extern int consing_since_gc;
1737 /* Threshold for doing another gc. */
1739 extern EMACS_INT gc_cons_threshold;
1741 /* Structure for recording stack slots that need marking. */
1743 /* This is a chain of structures, each of which points at a Lisp_Object variable
1744 whose value should be marked in garbage collection.
1745 Normally every link of the chain is an automatic variable of a function,
1746 and its `val' points to some argument or local variable of the function.
1747 On exit to the function, the chain is set back to the value it had on entry.
1748 This way, no link remains in the chain when the stack frame containing the
1749 link disappears.
1751 Every function that can call Feval must protect in this fashion all
1752 Lisp_Object variables whose contents will be used again. */
1754 extern struct gcpro *gcprolist;
1756 struct gcpro
1758 struct gcpro *next;
1760 /* Address of first protected variable. */
1761 volatile Lisp_Object *var;
1763 /* Number of consecutive protected variables. */
1764 int nvars;
1766 #ifdef DEBUG_GCPRO
1767 int level;
1768 #endif
1771 /* Values of GC_MARK_STACK during compilation:
1773 0 Use GCPRO as before
1774 1 Do the real thing, make GCPROs and UNGCPRO no-ops.
1775 2 Mark the stack, and check that everything GCPRO'd is
1776 marked.
1777 3 Mark using GCPRO's, mark stack last, and count how many
1778 dead objects are kept alive. */
1781 #define GC_USE_GCPROS_AS_BEFORE 0
1782 #define GC_MAKE_GCPROS_NOOPS 1
1783 #define GC_MARK_STACK_CHECK_GCPROS 2
1784 #define GC_USE_GCPROS_CHECK_ZOMBIES 3
1786 #ifndef GC_MARK_STACK
1787 #define GC_MARK_STACK GC_USE_GCPROS_AS_BEFORE
1788 #endif
1790 #if GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS
1792 /* Do something silly with gcproN vars just so gcc shuts up. */
1793 /* You get warnings from MIPSPro... */
1795 #define GCPRO1(varname) ((void) gcpro1)
1796 #define GCPRO2(varname1, varname2)(((void) gcpro2, (void) gcpro1))
1797 #define GCPRO3(varname1, varname2, varname3) \
1798 (((void) gcpro3, (void) gcpro2, (void) gcpro1))
1799 #define GCPRO4(varname1, varname2, varname3, varname4) \
1800 (((void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
1801 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1802 (((void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
1803 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
1804 (((void) gcpro6, (void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
1805 #define UNGCPRO ((void) 0)
1807 #else /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
1809 #ifndef DEBUG_GCPRO
1811 #define GCPRO1(varname) \
1812 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
1813 gcprolist = &gcpro1; }
1815 #define GCPRO2(varname1, varname2) \
1816 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1817 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1818 gcprolist = &gcpro2; }
1820 #define GCPRO3(varname1, varname2, varname3) \
1821 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1822 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1823 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1824 gcprolist = &gcpro3; }
1826 #define GCPRO4(varname1, varname2, varname3, varname4) \
1827 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1828 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1829 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1830 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1831 gcprolist = &gcpro4; }
1833 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1834 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1835 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1836 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1837 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1838 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1839 gcprolist = &gcpro5; }
1841 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
1842 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1843 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1844 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1845 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1846 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1847 gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
1848 gcprolist = &gcpro6; }
1850 #define UNGCPRO (gcprolist = gcpro1.next)
1852 #else
1854 extern int gcpro_level;
1856 #define GCPRO1(varname) \
1857 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
1858 gcpro1.level = gcpro_level++; \
1859 gcprolist = &gcpro1; }
1861 #define GCPRO2(varname1, varname2) \
1862 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1863 gcpro1.level = gcpro_level; \
1864 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1865 gcpro2.level = gcpro_level++; \
1866 gcprolist = &gcpro2; }
1868 #define GCPRO3(varname1, varname2, varname3) \
1869 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1870 gcpro1.level = gcpro_level; \
1871 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1872 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1873 gcpro3.level = gcpro_level++; \
1874 gcprolist = &gcpro3; }
1876 #define GCPRO4(varname1, varname2, varname3, varname4) \
1877 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1878 gcpro1.level = gcpro_level; \
1879 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1880 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1881 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1882 gcpro4.level = gcpro_level++; \
1883 gcprolist = &gcpro4; }
1885 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1886 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1887 gcpro1.level = gcpro_level; \
1888 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1889 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1890 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1891 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1892 gcpro5.level = gcpro_level++; \
1893 gcprolist = &gcpro5; }
1895 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
1896 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1897 gcpro1.level = gcpro_level; \
1898 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1899 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1900 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1901 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1902 gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
1903 gcpro6.level = gcpro_level++; \
1904 gcprolist = &gcpro6; }
1906 #define UNGCPRO \
1907 ((--gcpro_level != gcpro1.level) \
1908 ? (abort (), 0) \
1909 : ((gcprolist = gcpro1.next), 0))
1911 #endif /* DEBUG_GCPRO */
1912 #endif /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
1915 /* Evaluate expr, UNGCPRO, and then return the value of expr. */
1916 #define RETURN_UNGCPRO(expr) \
1917 do \
1919 Lisp_Object ret_ungc_val; \
1920 ret_ungc_val = (expr); \
1921 UNGCPRO; \
1922 return ret_ungc_val; \
1924 while (0)
1926 /* Call staticpro (&var) to protect static variable `var'. */
1928 void staticpro P_ ((Lisp_Object *));
1930 /* Declare a Lisp-callable function. The MAXARGS parameter has the same
1931 meaning as in the DEFUN macro, and is used to construct a prototype. */
1932 #if (!defined (__STDC__) && !defined (PROTOTYPES)) \
1933 || defined (USE_NONANSI_DEFUN)
1934 #define EXFUN(fnname, maxargs) \
1935 extern Lisp_Object fnname ()
1936 #else
1937 /* We can use the same trick as in the DEFUN macro to generate the
1938 appropriate prototype. */
1939 #define EXFUN(fnname, maxargs) \
1940 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
1941 #endif
1943 /* Forward declarations for prototypes. */
1944 struct window;
1945 struct frame;
1947 /* Defined in data.c */
1948 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
1949 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
1950 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
1951 extern Lisp_Object Qvoid_variable, Qvoid_function;
1952 extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
1953 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
1954 extern Lisp_Object Qend_of_file, Qarith_error, Qmark_inactive;
1955 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
1956 extern Lisp_Object Qtext_read_only;
1958 extern Lisp_Object Qintegerp, Qnatnump, Qwholenump, Qsymbolp, Qlistp, Qconsp;
1959 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
1960 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qinteger_or_marker_p, Qvectorp;
1961 extern Lisp_Object Qbuffer_or_string_p;
1962 extern Lisp_Object Qboundp, Qfboundp;
1963 extern Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
1965 extern Lisp_Object Qcdr;
1967 extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
1968 extern Lisp_Object Qoverflow_error, Qunderflow_error;
1970 extern Lisp_Object Qfloatp;
1971 extern Lisp_Object Qnumberp, Qnumber_or_marker_p;
1973 extern Lisp_Object Qinteger;
1975 extern void circular_list_error P_ ((Lisp_Object));
1977 /* Defined in frame.c */
1978 extern Lisp_Object Qframep;
1980 EXFUN (Feq, 2);
1981 EXFUN (Fnull, 1);
1982 EXFUN (Flistp, 1);
1983 EXFUN (Fconsp, 1);
1984 EXFUN (Fatom, 1);
1985 EXFUN (Fnlistp, 1);
1986 EXFUN (Fintegerp, 1);
1987 EXFUN (Fnatnump, 1);
1988 EXFUN (Fsymbolp, 1);
1989 EXFUN (Fvectorp, 1);
1990 EXFUN (Fstringp, 1);
1991 EXFUN (Fmultibyte_string_p, 1);
1992 EXFUN (Farrayp, 1);
1993 EXFUN (Fsequencep, 1);
1994 EXFUN (Fbufferp, 1);
1995 EXFUN (Fmarkerp, 1);
1996 EXFUN (Fsubrp, 1);
1997 EXFUN (Fchar_or_string_p, 1);
1998 EXFUN (Finteger_or_marker_p, 1);
1999 EXFUN (Ffloatp, 1);
2000 EXFUN (Finteger_or_floatp, 1);
2001 EXFUN (Finteger_or_float_or_marker_p, 1);
2003 EXFUN (Fcar, 1);
2004 EXFUN (Fcar_safe, 1);
2005 EXFUN (Fcdr, 1);
2006 EXFUN (Fcdr_safe, 1);
2007 EXFUN (Fsetcar, 2);
2008 EXFUN (Fsetcdr, 2);
2009 EXFUN (Fboundp, 1);
2010 EXFUN (Ffboundp, 1);
2011 EXFUN (Fmakunbound, 1);
2012 EXFUN (Ffmakunbound, 1);
2013 EXFUN (Fsymbol_function, 1);
2014 EXFUN (Fsymbol_plist, 1);
2015 EXFUN (Fsymbol_name, 1);
2016 extern Lisp_Object indirect_function P_ ((Lisp_Object));
2017 EXFUN (Findirect_function, 1);
2018 EXFUN (Ffset, 2);
2019 EXFUN (Fsetplist, 2);
2020 EXFUN (Fsymbol_value, 1);
2021 extern Lisp_Object find_symbol_value P_ ((Lisp_Object));
2022 EXFUN (Fset, 2);
2023 EXFUN (Fdefault_value, 1);
2024 EXFUN (Fset_default, 2);
2025 EXFUN (Fdefault_boundp, 1);
2026 EXFUN (Fmake_local_variable, 1);
2027 EXFUN (Flocal_variable_p, 2);
2028 EXFUN (Flocal_variable_if_set_p, 2);
2030 EXFUN (Faref, 2);
2031 EXFUN (Faset, 3);
2033 EXFUN (Fstring_to_number, 2);
2034 EXFUN (Fnumber_to_string, 1);
2035 EXFUN (Feqlsign, 2);
2036 EXFUN (Fgtr, 2);
2037 EXFUN (Flss, 2);
2038 EXFUN (Fgeq, 2);
2039 EXFUN (Fleq, 2);
2040 EXFUN (Fneq, 2);
2041 EXFUN (Fzerop, 1);
2042 EXFUN (Fplus, MANY);
2043 EXFUN (Fminus, MANY);
2044 EXFUN (Ftimes, MANY);
2045 EXFUN (Fquo, MANY);
2046 EXFUN (Frem, 2);
2047 EXFUN (Fmax, MANY);
2048 EXFUN (Fmin, MANY);
2049 EXFUN (Flogand, MANY);
2050 EXFUN (Flogior, MANY);
2051 EXFUN (Flogxor, MANY);
2052 EXFUN (Flognot, 1);
2053 EXFUN (Flsh, 2);
2054 EXFUN (Fash, 2);
2056 EXFUN (Fadd1, 1);
2057 EXFUN (Fsub1, 1);
2058 EXFUN (Fmake_variable_buffer_local, 1);
2060 extern Lisp_Object indirect_variable P_ ((Lisp_Object));
2061 extern Lisp_Object long_to_cons P_ ((unsigned long));
2062 extern unsigned long cons_to_long P_ ((Lisp_Object));
2063 extern void args_out_of_range P_ ((Lisp_Object, Lisp_Object));
2064 extern void args_out_of_range_3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2065 extern Lisp_Object wrong_type_argument P_ ((Lisp_Object, Lisp_Object));
2066 extern void store_symval_forwarding P_ ((Lisp_Object, Lisp_Object,
2067 Lisp_Object, struct buffer *));
2068 extern Lisp_Object do_symval_forwarding P_ ((Lisp_Object));
2069 extern Lisp_Object set_internal P_ ((Lisp_Object, Lisp_Object, struct buffer *, int));
2070 extern void syms_of_data P_ ((void));
2071 extern void init_data P_ ((void));
2072 extern void swap_in_global_binding P_ ((Lisp_Object));
2074 /* Defined in cmds.c */
2075 EXFUN (Fend_of_line, 1);
2076 EXFUN (Fforward_char, 1);
2077 EXFUN (Fforward_line, 1);
2078 extern int internal_self_insert P_ ((int, int));
2079 extern void syms_of_cmds P_ ((void));
2080 extern void keys_of_cmds P_ ((void));
2082 /* Defined in coding.c */
2083 EXFUN (Fcoding_system_p, 1);
2084 EXFUN (Fcheck_coding_system, 1);
2085 EXFUN (Fread_coding_system, 2);
2086 EXFUN (Fread_non_nil_coding_system, 1);
2087 EXFUN (Ffind_operation_coding_system, MANY);
2088 EXFUN (Fupdate_coding_systems_internal, 0);
2089 EXFUN (Fencode_coding_string, 3);
2090 EXFUN (Fdecode_coding_string, 3);
2091 extern Lisp_Object detect_coding_system P_ ((const unsigned char *, int, int,
2092 int));
2093 extern void init_coding P_ ((void));
2094 extern void init_coding_once P_ ((void));
2095 extern void syms_of_coding P_ ((void));
2096 extern Lisp_Object code_convert_string_norecord P_ ((Lisp_Object, Lisp_Object,
2097 int));
2099 /* Defined in charset.c */
2100 extern EMACS_INT nonascii_insert_offset;
2101 extern Lisp_Object Vnonascii_translation_table;
2102 EXFUN (Fchar_bytes, 1);
2103 EXFUN (Fchar_width, 1);
2104 EXFUN (Fstring, MANY);
2105 extern int chars_in_text P_ ((const unsigned char *, int));
2106 extern int multibyte_chars_in_text P_ ((const unsigned char *, int));
2107 extern int unibyte_char_to_multibyte P_ ((int));
2108 extern int multibyte_char_to_unibyte P_ ((int, Lisp_Object));
2109 extern Lisp_Object Qcharset;
2110 extern void init_charset_once P_ ((void));
2111 extern void syms_of_charset P_ ((void));
2113 /* Defined in syntax.c */
2114 EXFUN (Fforward_word, 1);
2115 EXFUN (Fskip_chars_forward, 2);
2116 EXFUN (Fskip_chars_backward, 2);
2117 EXFUN (Fsyntax_table_p, 1);
2118 EXFUN (Fsyntax_table, 0);
2119 EXFUN (Fset_syntax_table, 1);
2120 extern void init_syntax_once P_ ((void));
2121 extern void syms_of_syntax P_ ((void));
2123 /* Defined in fns.c */
2124 extern int use_dialog_box;
2125 extern int next_almost_prime P_ ((int));
2126 extern Lisp_Object larger_vector P_ ((Lisp_Object, int, Lisp_Object));
2127 extern void sweep_weak_hash_tables P_ ((void));
2128 extern Lisp_Object Qstring_lessp;
2129 EXFUN (Foptimize_char_table, 1);
2130 extern Lisp_Object Vfeatures;
2131 extern Lisp_Object QCtest, QCweakness, Qequal;
2132 unsigned sxhash P_ ((Lisp_Object, int));
2133 Lisp_Object make_hash_table P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
2134 Lisp_Object, Lisp_Object, Lisp_Object,
2135 Lisp_Object));
2136 Lisp_Object copy_hash_table P_ ((struct Lisp_Hash_Table *));
2137 int hash_lookup P_ ((struct Lisp_Hash_Table *, Lisp_Object, unsigned *));
2138 int hash_put P_ ((struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
2139 unsigned));
2140 void hash_remove P_ ((struct Lisp_Hash_Table *, Lisp_Object));
2141 void hash_clear P_ ((struct Lisp_Hash_Table *));
2142 void remove_hash_entry P_ ((struct Lisp_Hash_Table *, int));
2143 extern void init_fns P_ ((void));
2144 EXFUN (Fsxhash, 1);
2145 EXFUN (Fmake_hash_table, MANY);
2146 EXFUN (Fcopy_hash_table, 1);
2147 EXFUN (Fhash_table_count, 1);
2148 EXFUN (Fhash_table_rehash_size, 1);
2149 EXFUN (Fhash_table_rehash_threshold, 1);
2150 EXFUN (Fhash_table_size, 1);
2151 EXFUN (Fhash_table_test, 1);
2152 EXFUN (Fhash_table_weak, 1);
2153 EXFUN (Fhash_table_p, 1);
2154 EXFUN (Fclrhash, 1);
2155 EXFUN (Fgethash, 3);
2156 EXFUN (Fputhash, 3);
2157 EXFUN (Fremhash, 2);
2158 EXFUN (Fmaphash, 2);
2159 EXFUN (Fdefine_hash_table_test, 3);
2161 EXFUN (Fidentity, 1);
2162 EXFUN (Frandom, 1);
2163 EXFUN (Flength, 1);
2164 EXFUN (Fsafe_length, 1);
2165 EXFUN (Fappend, MANY);
2166 EXFUN (Fconcat, MANY);
2167 EXFUN (Fvconcat, MANY);
2168 EXFUN (Fcopy_sequence, 1);
2169 EXFUN (Fstring_make_multibyte, 1);
2170 EXFUN (Fstring_make_unibyte, 1);
2171 EXFUN (Fstring_as_multibyte, 1);
2172 EXFUN (Fstring_as_unibyte, 1);
2173 EXFUN (Fstring_to_multibyte, 1);
2174 EXFUN (Fsubstring, 3);
2175 extern Lisp_Object substring_both P_ ((Lisp_Object, int, int, int, int));
2176 EXFUN (Fnth, 2);
2177 EXFUN (Fnthcdr, 2);
2178 EXFUN (Fmemq, 2);
2179 EXFUN (Fassq, 2);
2180 EXFUN (Fassoc, 2);
2181 EXFUN (Felt, 2);
2182 EXFUN (Fmember, 2);
2183 EXFUN (Frassq, 2);
2184 EXFUN (Fdelq, 2);
2185 EXFUN (Fsort, 2);
2186 EXFUN (Freverse, 1);
2187 EXFUN (Fnreverse, 1);
2188 EXFUN (Fget, 2);
2189 EXFUN (Fput, 3);
2190 EXFUN (Fequal, 2);
2191 EXFUN (Ffillarray, 2);
2192 EXFUN (Fnconc, MANY);
2193 EXFUN (Fmapcar, 2);
2194 EXFUN (Fmapconcat, 3);
2195 EXFUN (Fy_or_n_p, 1);
2196 extern Lisp_Object do_yes_or_no_p P_ ((Lisp_Object));
2197 EXFUN (Frequire, 3);
2198 EXFUN (Fprovide, 2);
2199 extern Lisp_Object concat2 P_ ((Lisp_Object, Lisp_Object));
2200 extern Lisp_Object concat3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2201 extern Lisp_Object nconc2 P_ ((Lisp_Object, Lisp_Object));
2202 extern Lisp_Object assq_no_quit P_ ((Lisp_Object, Lisp_Object));
2203 extern void clear_string_char_byte_cache P_ ((void));
2204 extern int string_char_to_byte P_ ((Lisp_Object, int));
2205 extern int string_byte_to_char P_ ((Lisp_Object, int));
2206 extern Lisp_Object string_make_multibyte P_ ((Lisp_Object));
2207 extern Lisp_Object string_make_unibyte P_ ((Lisp_Object));
2208 EXFUN (Fcopy_alist, 1);
2209 EXFUN (Fplist_get, 2);
2210 EXFUN (Fplist_put, 3);
2211 EXFUN (Fplist_member, 2);
2212 EXFUN (Fset_char_table_parent, 2);
2213 EXFUN (Fchar_table_extra_slot, 2);
2214 EXFUN (Fset_char_table_extra_slot, 3);
2215 EXFUN (Frassoc, 2);
2216 EXFUN (Fstring_equal, 2);
2217 EXFUN (Fcompare_strings, 7);
2218 EXFUN (Fstring_lessp, 2);
2219 extern int char_table_translate P_ ((Lisp_Object, int));
2220 extern void map_char_table P_ ((void (*) (Lisp_Object, Lisp_Object, Lisp_Object),
2221 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, int,
2222 Lisp_Object *));
2223 extern Lisp_Object char_table_ref_and_index P_ ((Lisp_Object, int, int *));
2224 extern void syms_of_fns P_ ((void));
2226 /* Defined in floatfns.c */
2227 extern double extract_float P_ ((Lisp_Object));
2228 EXFUN (Ffloat, 1);
2229 EXFUN (Ftruncate, 2);
2230 extern void init_floatfns P_ ((void));
2231 extern void syms_of_floatfns P_ ((void));
2233 /* Defined in insdel.c */
2234 extern Lisp_Object Qinhibit_modification_hooks;
2235 extern void move_gap P_ ((int));
2236 extern void move_gap_both P_ ((int, int));
2237 extern void make_gap P_ ((int));
2238 extern int copy_text P_ ((const unsigned char *, unsigned char *, int, int, int));
2239 extern int count_size_as_multibyte P_ ((const unsigned char *, int));
2240 extern int count_combining_before P_ ((const unsigned char *, int, int, int));
2241 extern int count_combining_after P_ ((const unsigned char *, int, int, int));
2242 extern void insert P_ ((const unsigned char *, int));
2243 extern void insert_and_inherit P_ ((const unsigned char *, int));
2244 extern void insert_1 P_ ((const unsigned char *, int, int, int, int));
2245 extern void insert_1_both P_ ((const unsigned char *, int, int, int, int, int));
2246 extern void insert_from_string P_ ((Lisp_Object, int, int, int, int, int));
2247 extern void insert_from_buffer P_ ((struct buffer *, int, int, int));
2248 extern void insert_char P_ ((int));
2249 extern void insert_string P_ ((const char *));
2250 extern void insert_before_markers P_ ((const unsigned char *, int));
2251 extern void insert_before_markers_and_inherit P_ ((const unsigned char *, int));
2252 extern void insert_from_string_before_markers P_ ((Lisp_Object, int, int, int, int, int));
2253 extern void del_range P_ ((int, int));
2254 extern Lisp_Object del_range_1 P_ ((int, int, int, int));
2255 extern void del_range_byte P_ ((int, int, int));
2256 extern void del_range_both P_ ((int, int, int, int, int));
2257 extern Lisp_Object del_range_2 P_ ((int, int, int, int, int));
2258 extern void modify_region P_ ((struct buffer *, int, int));
2259 extern void prepare_to_modify_buffer P_ ((int, int, int *));
2260 extern void signal_before_change P_ ((int, int, int *));
2261 extern void signal_after_change P_ ((int, int, int));
2262 extern void adjust_after_replace P_ ((int, int, Lisp_Object, int, int));
2263 extern void adjust_after_replace_noundo P_ ((int, int, int, int, int, int));
2264 extern void adjust_after_insert P_ ((int, int, int, int, int));
2265 extern void replace_range P_ ((int, int, Lisp_Object, int, int, int));
2266 extern void syms_of_insdel P_ ((void));
2268 /* Defined in dispnew.c */
2269 extern Lisp_Object selected_frame;
2270 extern EMACS_INT baud_rate;
2271 EXFUN (Fding, 1);
2272 EXFUN (Fredraw_frame, 1);
2273 EXFUN (Fredraw_display, 0);
2274 EXFUN (Fsleep_for, 2);
2275 EXFUN (Fsit_for, 3);
2276 extern Lisp_Object sit_for P_ ((int, int, int, int, int));
2277 extern void init_display P_ ((void));
2278 extern void syms_of_display P_ ((void));
2279 extern void safe_bcopy P_ ((const char *, char *, int));
2281 /* Defined in xdisp.c */
2282 extern Lisp_Object Qinhibit_point_motion_hooks;
2283 extern Lisp_Object Qinhibit_redisplay, Qdisplay;
2284 extern Lisp_Object Qinhibit_eval_during_redisplay;
2285 extern Lisp_Object Qmessage_truncate_lines;
2286 extern Lisp_Object Vmessage_log_max;
2287 extern int message_enable_multibyte;
2288 extern Lisp_Object echo_area_buffer[2];
2289 extern void check_message_stack P_ ((void));
2290 extern void setup_echo_area_for_printing P_ ((int));
2291 extern int push_message P_ ((void));
2292 extern Lisp_Object pop_message_unwind P_ ((Lisp_Object));
2293 extern Lisp_Object restore_message_unwind P_ ((Lisp_Object));
2294 extern void pop_message P_ ((void));
2295 extern void restore_message P_ ((void));
2296 extern Lisp_Object current_message P_ ((void));
2297 extern void set_message P_ ((const char *s, Lisp_Object, int, int));
2298 extern void clear_message P_ ((int, int));
2299 extern void message P_ ((/* char *, ... */));
2300 extern void message_nolog P_ ((/* char *, ... */));
2301 extern void message1 P_ ((char *));
2302 extern void message1_nolog P_ ((char *));
2303 extern void message2 P_ ((const char *, int, int));
2304 extern void message2_nolog P_ ((const char *, int, int));
2305 extern void message3 P_ ((Lisp_Object, int, int));
2306 extern void message3_nolog P_ ((Lisp_Object, int, int));
2307 extern void message_dolog P_ ((const char *, int, int, int));
2308 extern void message_with_string P_ ((char *, Lisp_Object, int));
2309 extern void message_log_maybe_newline P_ ((void));
2310 extern void update_echo_area P_ ((void));
2311 extern void truncate_echo_area P_ ((int));
2312 extern void redisplay P_ ((void));
2313 extern int check_point_in_composition
2314 P_ ((struct buffer *, int, struct buffer *, int));
2315 extern void redisplay_preserve_echo_area P_ ((int));
2316 extern void mark_window_display_accurate P_ ((Lisp_Object, int));
2317 extern void prepare_menu_bars P_ ((void));
2319 void set_frame_cursor_types P_ ((struct frame *, Lisp_Object));
2320 extern void syms_of_xdisp P_ ((void));
2321 extern void init_xdisp P_ ((void));
2322 extern Lisp_Object safe_eval P_ ((Lisp_Object));
2323 extern int pos_visible_p P_ ((struct window *, int, int *, int));
2325 /* Defined in vm-limit.c. */
2326 extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
2328 /* Defined in alloc.c */
2329 extern void check_pure_size P_ ((void));
2330 extern void allocate_string_data P_ ((struct Lisp_String *, int, int));
2331 extern void uninterrupt_malloc P_ ((void));
2332 extern void malloc_warning P_ ((char *));
2333 extern void memory_full P_ ((void));
2334 extern void buffer_memory_full P_ ((void));
2335 extern int survives_gc_p P_ ((Lisp_Object));
2336 extern void mark_object P_ ((Lisp_Object));
2337 extern Lisp_Object Vpurify_flag;
2338 extern Lisp_Object Vmemory_full;
2339 EXFUN (Fcons, 2);
2340 EXFUN (list2, 2);
2341 EXFUN (list3, 3);
2342 EXFUN (list4, 4);
2343 EXFUN (list5, 5);
2344 EXFUN (Flist, MANY);
2345 EXFUN (Fmake_list, 2);
2346 extern Lisp_Object allocate_misc P_ ((void));
2347 EXFUN (Fmake_vector, 2);
2348 EXFUN (Fvector, MANY);
2349 EXFUN (Fmake_symbol, 1);
2350 EXFUN (Fmake_marker, 0);
2351 EXFUN (Fmake_string, 2);
2352 extern Lisp_Object build_string P_ ((const char *));
2353 extern Lisp_Object make_string P_ ((const char *, int));
2354 extern Lisp_Object make_unibyte_string P_ ((const char *, int));
2355 extern Lisp_Object make_multibyte_string P_ ((const char *, int, int));
2356 extern Lisp_Object make_event_array P_ ((int, Lisp_Object *));
2357 extern Lisp_Object make_uninit_string P_ ((int));
2358 extern Lisp_Object make_uninit_multibyte_string P_ ((int, int));
2359 extern Lisp_Object make_string_from_bytes P_ ((const char *, int, int));
2360 extern Lisp_Object make_specified_string P_ ((const char *, int, int, int));
2361 EXFUN (Fpurecopy, 1);
2362 extern Lisp_Object make_pure_string P_ ((char *, int, int, int));
2363 extern Lisp_Object pure_cons P_ ((Lisp_Object, Lisp_Object));
2364 extern Lisp_Object make_pure_vector P_ ((EMACS_INT));
2365 EXFUN (Fgarbage_collect, 0);
2366 EXFUN (Fmake_byte_code, MANY);
2367 EXFUN (Fmake_bool_vector, 2);
2368 EXFUN (Fmake_char_table, 2);
2369 extern Lisp_Object make_sub_char_table P_ ((Lisp_Object));
2370 extern Lisp_Object Qchar_table_extra_slots;
2371 extern struct Lisp_Vector *allocate_vector P_ ((EMACS_INT));
2372 extern struct Lisp_Vector *allocate_other_vector P_ ((EMACS_INT));
2373 extern struct Lisp_Hash_Table *allocate_hash_table P_ ((void));
2374 extern struct window *allocate_window P_ ((void));
2375 extern struct frame *allocate_frame P_ ((void));
2376 extern struct Lisp_Process *allocate_process P_ ((void));
2377 extern int gc_in_progress;
2378 extern int abort_on_gc;
2379 extern Lisp_Object make_float P_ ((double));
2380 extern void display_malloc_warning P_ ((void));
2381 extern int inhibit_garbage_collection P_ ((void));
2382 extern Lisp_Object make_save_value P_ ((void *, int));
2383 extern void free_marker P_ ((Lisp_Object));
2384 extern void free_cons P_ ((struct Lisp_Cons *));
2385 extern void init_alloc_once P_ ((void));
2386 extern void init_alloc P_ ((void));
2387 extern void syms_of_alloc P_ ((void));
2388 extern struct buffer * allocate_buffer P_ ((void));
2390 /* Defined in print.c */
2391 extern Lisp_Object Vprin1_to_string_buffer;
2392 extern void debug_print P_ ((Lisp_Object));
2393 EXFUN (Fprin1, 2);
2394 EXFUN (Fprin1_to_string, 2);
2395 EXFUN (Fprinc, 2);
2396 EXFUN (Fterpri, 1);
2397 EXFUN (Fprint, 2);
2398 EXFUN (Ferror_message_string, 1);
2399 extern Lisp_Object Vstandard_output, Qstandard_output;
2400 extern Lisp_Object Qexternal_debugging_output;
2401 extern void temp_output_buffer_setup P_ ((const char *));
2402 extern int print_level, print_escape_newlines;
2403 extern Lisp_Object Qprint_escape_newlines;
2404 extern void write_string P_ ((char *, int));
2405 extern void write_string_1 P_ ((char *, int, Lisp_Object));
2406 extern void print_error_message P_ ((Lisp_Object, Lisp_Object, char *, Lisp_Object));
2407 extern Lisp_Object internal_with_output_to_temp_buffer
2408 P_ ((const char *, Lisp_Object (*) (Lisp_Object), Lisp_Object));
2409 extern void float_to_string P_ ((unsigned char *, double));
2410 extern void syms_of_print P_ ((void));
2412 /* Defined in doprnt.c */
2413 extern int doprnt P_ ((char *, int, char *, char *, int, char **));
2414 extern int doprnt_lisp P_ ((char *, int, char *, char *, int, char **));
2416 /* Defined in lread.c */
2417 extern Lisp_Object Qvariable_documentation, Qstandard_input;
2418 extern Lisp_Object Vobarray, initial_obarray, Vstandard_input;
2419 EXFUN (Fread, 1);
2420 EXFUN (Fread_from_string, 3);
2421 EXFUN (Fintern, 2);
2422 EXFUN (Fintern_soft, 2);
2423 EXFUN (Fload, 5);
2424 EXFUN (Fget_file_char, 0);
2425 EXFUN (Fread_char, 2);
2426 EXFUN (Fread_event, 2);
2427 extern Lisp_Object read_filtered_event P_ ((int, int, int, int));
2428 EXFUN (Feval_region, 4);
2429 extern Lisp_Object intern P_ ((const char *));
2430 extern Lisp_Object make_symbol P_ ((char *));
2431 extern Lisp_Object oblookup P_ ((Lisp_Object, const char *, int, int));
2432 #define LOADHIST_ATTACH(x) \
2433 if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
2434 extern Lisp_Object Vcurrent_load_list;
2435 extern Lisp_Object Vload_history, Vload_suffixes;
2436 extern int openp P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
2437 Lisp_Object *, Lisp_Object));
2438 extern int isfloat_string P_ ((char *));
2439 extern void map_obarray P_ ((Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
2440 Lisp_Object));
2441 extern void dir_warning P_ ((char *, Lisp_Object));
2442 extern void close_load_descs P_ ((void));
2443 extern void init_obarray P_ ((void));
2444 extern void init_lread P_ ((void));
2445 extern void syms_of_lread P_ ((void));
2447 /* Defined in eval.c */
2448 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
2449 extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
2450 extern Lisp_Object Vautoload_queue;
2451 extern Lisp_Object Vdebug_on_error;
2452 extern Lisp_Object Vsignaling_function;
2453 extern int handling_signal;
2454 extern int interactive_p P_ ((int));
2456 /* To run a normal hook, use the appropriate function from the list below.
2457 The calling convention:
2459 if (!NILP (Vrun_hooks))
2460 call1 (Vrun_hooks, Qmy_funny_hook);
2462 should no longer be used. */
2463 extern Lisp_Object Vrun_hooks;
2464 EXFUN (Frun_hooks, MANY);
2465 EXFUN (Frun_hook_with_args, MANY);
2466 EXFUN (Frun_hook_with_args_until_success, MANY);
2467 EXFUN (Frun_hook_with_args_until_failure, MANY);
2468 extern Lisp_Object run_hook_list_with_args P_ ((Lisp_Object, int, Lisp_Object *));
2469 extern void run_hook_with_args_2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2470 EXFUN (Fand, UNEVALLED);
2471 EXFUN (For, UNEVALLED);
2472 EXFUN (Fif, UNEVALLED);
2473 EXFUN (Fprogn, UNEVALLED);
2474 EXFUN (Fprog1, UNEVALLED);
2475 EXFUN (Fprog2, UNEVALLED);
2476 EXFUN (Fsetq, UNEVALLED);
2477 EXFUN (Fquote, UNEVALLED);
2478 EXFUN (Fuser_variable_p, 1);
2479 EXFUN (Finteractive_p, 0);
2480 EXFUN (Fdefun, UNEVALLED);
2481 EXFUN (Flet, UNEVALLED);
2482 EXFUN (FletX, UNEVALLED);
2483 EXFUN (Fwhile, UNEVALLED);
2484 EXFUN (Fcatch, UNEVALLED);
2485 EXFUN (Fthrow, 2) NO_RETURN;
2486 EXFUN (Funwind_protect, UNEVALLED);
2487 EXFUN (Fcondition_case, UNEVALLED);
2488 EXFUN (Fsignal, 2);
2489 EXFUN (Fautoload, 5);
2490 EXFUN (Fcommandp, 2);
2491 EXFUN (Feval, 1);
2492 EXFUN (Fapply, MANY);
2493 EXFUN (Ffuncall, MANY);
2494 EXFUN (Fbacktrace, 0);
2495 extern Lisp_Object apply1 P_ ((Lisp_Object, Lisp_Object));
2496 extern Lisp_Object call0 P_ ((Lisp_Object));
2497 extern Lisp_Object call1 P_ ((Lisp_Object, Lisp_Object));
2498 extern Lisp_Object call2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2499 extern Lisp_Object call3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2500 extern Lisp_Object call4 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2501 extern Lisp_Object call5 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2502 extern Lisp_Object call6 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2503 EXFUN (Fdo_auto_save, 2);
2504 extern Lisp_Object apply_lambda P_ ((Lisp_Object, Lisp_Object, int));
2505 extern Lisp_Object internal_catch P_ ((Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object));
2506 extern Lisp_Object internal_condition_case P_ ((Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2507 extern Lisp_Object internal_condition_case_1 P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2508 extern Lisp_Object internal_condition_case_2 P_ ((Lisp_Object (*) (int, Lisp_Object *), int, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2509 extern void specbind P_ ((Lisp_Object, Lisp_Object));
2510 extern void record_unwind_protect P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object));
2511 extern Lisp_Object unbind_to P_ ((int, Lisp_Object));
2512 extern void error P_ ((/* char *, ... */)) NO_RETURN;
2513 extern void do_autoload P_ ((Lisp_Object, Lisp_Object));
2514 extern Lisp_Object un_autoload P_ ((Lisp_Object));
2515 EXFUN (Ffetch_bytecode, 1);
2516 extern void init_eval_once P_ ((void));
2517 extern Lisp_Object safe_call P_ ((int, Lisp_Object *));
2518 extern Lisp_Object safe_call1 P_ ((Lisp_Object, Lisp_Object));
2519 extern void init_eval P_ ((void));
2520 extern void syms_of_eval P_ ((void));
2522 /* Defined in editfns.c */
2523 EXFUN (Fpropertize, MANY);
2524 EXFUN (Fcurrent_message, 0);
2525 EXFUN (Fgoto_char, 1);
2526 EXFUN (Fpoint_min_marker, 0);
2527 EXFUN (Fpoint_max_marker, 0);
2528 EXFUN (Fpoint_min, 0);
2529 EXFUN (Fpoint_max, 0);
2530 EXFUN (Fpoint, 0);
2531 EXFUN (Fpoint_marker, 0);
2532 EXFUN (Fmark_marker, 0);
2533 EXFUN (Fline_beginning_position, 1);
2534 EXFUN (Fline_end_position, 1);
2535 EXFUN (Ffollowing_char, 0);
2536 EXFUN (Fprevious_char, 0);
2537 EXFUN (Fchar_after, 1);
2538 EXFUN (Finsert, MANY);
2539 EXFUN (Finsert_and_inherit, MANY);
2540 EXFUN (Finsert_before_markers, MANY);
2541 EXFUN (Finsert_buffer_substring, 3);
2542 EXFUN (Finsert_char, 3);
2543 extern void insert1 P_ ((Lisp_Object));
2544 EXFUN (Feolp, 0);
2545 EXFUN (Feobp, 0);
2546 EXFUN (Fbolp, 0);
2547 EXFUN (Fbobp, 0);
2548 EXFUN (Fformat, MANY);
2549 EXFUN (Fmessage, MANY);
2550 extern Lisp_Object format2 P_ ((char *, Lisp_Object, Lisp_Object));
2551 extern Lisp_Object make_buffer_string P_ ((int, int, int));
2552 EXFUN (Fbuffer_substring, 2);
2553 EXFUN (Fbuffer_string, 0);
2554 extern Lisp_Object save_excursion_save P_ ((void));
2555 extern Lisp_Object save_restriction_save P_ ((void));
2556 extern Lisp_Object save_excursion_restore P_ ((Lisp_Object));
2557 extern Lisp_Object save_restriction_restore P_ ((Lisp_Object));
2558 EXFUN (Fchar_to_string, 1);
2559 EXFUN (Fdelete_region, 2);
2560 EXFUN (Fnarrow_to_region, 2);
2561 EXFUN (Fwiden, 0);
2562 EXFUN (Fuser_login_name, 1);
2563 EXFUN (Fsystem_name, 0);
2564 EXFUN (Fcurrent_time, 0);
2565 extern int clip_to_bounds P_ ((int, int, int));
2566 extern Lisp_Object make_buffer_string P_ ((int, int, int));
2567 extern Lisp_Object make_buffer_string_both P_ ((int, int, int, int, int));
2568 extern void init_editfns P_ ((void));
2569 extern void syms_of_editfns P_ ((void));
2570 EXFUN (Fcurrent_message, 0);
2571 extern Lisp_Object Vinhibit_field_text_motion;
2572 EXFUN (Fconstrain_to_field, 5);
2573 EXFUN (Ffield_string, 1);
2574 EXFUN (Fdelete_field, 1);
2575 EXFUN (Ffield_beginning, 3);
2576 EXFUN (Ffield_end, 3);
2577 EXFUN (Ffield_string_no_properties, 1);
2578 extern void set_time_zone_rule P_ ((char *));
2580 /* defined in buffer.c */
2581 extern int mouse_face_overlay_overlaps P_ ((Lisp_Object));
2582 extern void nsberror P_ ((Lisp_Object));
2583 extern char *no_switch_window P_ ((Lisp_Object window));
2584 EXFUN (Fset_buffer_multibyte, 1);
2585 EXFUN (Foverlay_start, 1);
2586 EXFUN (Foverlay_end, 1);
2587 extern void adjust_overlays_for_insert P_ ((EMACS_INT, EMACS_INT));
2588 extern void adjust_overlays_for_delete P_ ((EMACS_INT, EMACS_INT));
2589 extern void fix_overlays_in_range P_ ((int, int));
2590 extern void report_overlay_modification P_ ((Lisp_Object, Lisp_Object, int,
2591 Lisp_Object, Lisp_Object, Lisp_Object));
2592 extern int overlay_touches_p P_ ((int));
2593 extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
2594 EXFUN (Fget_buffer, 1);
2595 EXFUN (Fget_buffer_create, 1);
2596 EXFUN (Fset_buffer, 1);
2597 EXFUN (set_buffer_if_live, 1);
2598 EXFUN (Fbarf_if_buffer_read_only, 0);
2599 EXFUN (Fcurrent_buffer, 0);
2600 EXFUN (Fswitch_to_buffer, 2);
2601 EXFUN (Fpop_to_buffer, 3);
2602 EXFUN (Fother_buffer, 3);
2603 EXFUN (Foverlay_get, 2);
2604 EXFUN (Fbuffer_modified_p, 1);
2605 EXFUN (Fset_buffer_modified_p, 1);
2606 EXFUN (Fkill_buffer, 1);
2607 EXFUN (Fkill_all_local_variables, 0);
2608 EXFUN (Fbuffer_disable_undo, 1);
2609 EXFUN (Fbuffer_enable_undo, 1);
2610 EXFUN (Ferase_buffer, 0);
2611 extern Lisp_Object Qoverlayp;
2612 extern Lisp_Object get_truename_buffer P_ ((Lisp_Object));
2613 extern struct buffer *all_buffers;
2614 EXFUN (Fprevious_overlay_change, 1);
2615 EXFUN (Fbuffer_file_name, 1);
2616 extern void init_buffer_once P_ ((void));
2617 extern void init_buffer P_ ((void));
2618 extern void syms_of_buffer P_ ((void));
2619 extern void keys_of_buffer P_ ((void));
2621 /* defined in marker.c */
2623 EXFUN (Fmarker_position, 1);
2624 EXFUN (Fmarker_buffer, 1);
2625 EXFUN (Fcopy_marker, 2);
2626 EXFUN (Fset_marker, 3);
2627 extern int marker_position P_ ((Lisp_Object));
2628 extern int marker_byte_position P_ ((Lisp_Object));
2629 extern void clear_charpos_cache P_ ((struct buffer *));
2630 extern int charpos_to_bytepos P_ ((int));
2631 extern int buf_charpos_to_bytepos P_ ((struct buffer *, int));
2632 extern int buf_bytepos_to_charpos P_ ((struct buffer *, int));
2633 extern void unchain_marker P_ ((struct Lisp_Marker *marker));
2634 extern Lisp_Object set_marker_restricted P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2635 extern Lisp_Object set_marker_both P_ ((Lisp_Object, Lisp_Object, int, int));
2636 extern Lisp_Object set_marker_restricted_both P_ ((Lisp_Object, Lisp_Object,
2637 int, int));
2638 extern void syms_of_marker P_ ((void));
2640 /* Defined in fileio.c */
2642 extern Lisp_Object Qfile_error;
2643 EXFUN (Ffind_file_name_handler, 2);
2644 EXFUN (Ffile_name_as_directory, 1);
2645 EXFUN (Fmake_temp_name, 1);
2646 EXFUN (Fexpand_file_name, 2);
2647 EXFUN (Ffile_name_nondirectory, 1);
2648 EXFUN (Fsubstitute_in_file_name, 1);
2649 EXFUN (Ffile_symlink_p, 1);
2650 EXFUN (Fverify_visited_file_modtime, 1);
2651 EXFUN (Ffile_exists_p, 1);
2652 EXFUN (Ffile_name_absolute_p, 1);
2653 EXFUN (Fdirectory_file_name, 1);
2654 EXFUN (Ffile_name_directory, 1);
2655 extern Lisp_Object expand_and_dir_to_file P_ ((Lisp_Object, Lisp_Object));
2656 EXFUN (Ffile_accessible_directory_p, 1);
2657 EXFUN (Funhandled_file_name_directory, 1);
2658 EXFUN (Ffile_directory_p, 1);
2659 EXFUN (Fwrite_region, 7);
2660 EXFUN (Ffile_readable_p, 1);
2661 EXFUN (Ffile_executable_p, 1);
2662 EXFUN (Fread_file_name, 6);
2663 extern Lisp_Object close_file_unwind P_ ((Lisp_Object));
2664 extern void report_file_error P_ ((const char *, Lisp_Object));
2665 extern int internal_delete_file P_ ((Lisp_Object));
2666 extern void syms_of_fileio P_ ((void));
2667 EXFUN (Fmake_temp_name, 1);
2668 extern void init_fileio_once P_ ((void));
2669 extern Lisp_Object make_temp_name P_ ((Lisp_Object, int));
2671 /* Defined in abbrev.c */
2673 extern void syms_of_abbrev P_ ((void));
2675 /* defined in search.c */
2676 extern void shrink_regexp_cache P_ ((void));
2677 EXFUN (Fstring_match, 3);
2678 extern void restore_match_data P_ ((void));
2679 EXFUN (Fmatch_data, 2);
2680 EXFUN (Fset_match_data, 1);
2681 EXFUN (Fmatch_beginning, 1);
2682 EXFUN (Fmatch_end, 1);
2683 EXFUN (Flooking_at, 1);
2684 extern int fast_string_match P_ ((Lisp_Object, Lisp_Object));
2685 extern int fast_c_string_match_ignore_case P_ ((Lisp_Object, const char *));
2686 extern int scan_buffer P_ ((int, int, int, int, int *, int));
2687 extern int scan_newline P_ ((int, int, int, int, int, int));
2688 extern int find_next_newline P_ ((int, int));
2689 extern int find_next_newline_no_quit P_ ((int, int));
2690 extern int find_before_next_newline P_ ((int, int, int));
2691 extern void syms_of_search P_ ((void));
2693 /* defined in minibuf.c */
2695 extern Lisp_Object last_minibuf_string;
2696 extern void choose_minibuf_frame P_ ((void));
2697 EXFUN (Fcompleting_read, 8);
2698 EXFUN (Fread_from_minibuffer, 7);
2699 EXFUN (Fread_variable, 2);
2700 EXFUN (Fread_buffer, 3);
2701 EXFUN (Fread_minibuffer, 2);
2702 EXFUN (Feval_minibuffer, 2);
2703 EXFUN (Fread_string, 5);
2704 EXFUN (Fread_no_blanks_input, 3);
2705 extern Lisp_Object get_minibuffer P_ ((int));
2706 extern void temp_echo_area_glyphs P_ ((Lisp_Object));
2707 extern void init_minibuf_once P_ ((void));
2708 extern void syms_of_minibuf P_ ((void));
2709 extern void keys_of_minibuf P_ ((void));
2711 /* Defined in callint.c */
2713 extern Lisp_Object Qminus, Qplus, Vcurrent_prefix_arg;
2714 extern Lisp_Object Vcommand_history;
2715 extern Lisp_Object Qcall_interactively, Qmouse_leave_buffer_hook;
2716 EXFUN (Fcall_interactively, 3);
2717 EXFUN (Fprefix_numeric_value, 1);
2718 extern void syms_of_callint P_ ((void));
2720 /* defined in casefiddle.c */
2722 EXFUN (Fdowncase, 1);
2723 EXFUN (Fupcase, 1);
2724 EXFUN (Fcapitalize, 1);
2725 EXFUN (Fupcase_region, 2);
2726 EXFUN (Fupcase_initials, 1);
2727 EXFUN (Fupcase_initials_region, 2);
2728 extern void syms_of_casefiddle P_ ((void));
2729 extern void keys_of_casefiddle P_ ((void));
2731 /* defined in casetab.c */
2733 EXFUN (Fset_case_table, 1);
2734 EXFUN (Fset_standard_case_table, 1);
2735 extern void init_casetab_once P_ ((void));
2736 extern void syms_of_casetab P_ ((void));
2738 /* defined in keyboard.c */
2740 extern int echoing;
2741 extern Lisp_Object echo_message_buffer;
2742 extern struct kboard *echo_kboard;
2743 extern void cancel_echoing P_ ((void));
2744 extern Lisp_Object Qdisabled, QCfilter;
2745 extern Lisp_Object Vtty_erase_char, Vhelp_form, Vtop_level;
2746 extern int input_pending;
2747 EXFUN (Fdiscard_input, 0);
2748 EXFUN (Frecursive_edit, 0);
2749 EXFUN (Ftop_level, 0);
2750 EXFUN (Fcommand_execute, 4);
2751 EXFUN (Finput_pending_p, 0);
2752 extern Lisp_Object menu_bar_items P_ ((Lisp_Object));
2753 extern Lisp_Object tool_bar_items P_ ((Lisp_Object, int *));
2754 extern Lisp_Object Qvertical_scroll_bar;
2755 extern void discard_mouse_events P_ ((void));
2756 EXFUN (Fevent_convert_list, 1);
2757 EXFUN (Fread_key_sequence, 5);
2758 EXFUN (Fset_input_mode, 4);
2759 extern int detect_input_pending P_ ((void));
2760 extern int detect_input_pending_run_timers P_ ((int));
2761 extern void safe_run_hooks P_ ((Lisp_Object));
2762 extern void cmd_error_internal P_ ((Lisp_Object, char *));
2763 extern Lisp_Object command_loop_1 P_ ((void));
2764 extern Lisp_Object recursive_edit_1 P_ ((void));
2765 extern void record_auto_save P_ ((void));
2766 extern void init_keyboard P_ ((void));
2767 extern void syms_of_keyboard P_ ((void));
2768 extern void keys_of_keyboard P_ ((void));
2769 extern char *push_key_description P_ ((unsigned int, char *, int));
2772 /* defined in indent.c */
2773 EXFUN (Fvertical_motion, 2);
2774 EXFUN (Findent_to, 2);
2775 EXFUN (Fcurrent_column, 0);
2776 EXFUN (Fmove_to_column, 2);
2777 extern double current_column P_ ((void));
2778 extern void invalidate_current_column P_ ((void));
2779 extern int indented_beyond_p P_ ((int, int, double));
2780 extern void syms_of_indent P_ ((void));
2782 /* defined in frame.c */
2783 extern Lisp_Object Qvisible;
2784 extern void store_frame_param P_ ((struct frame *, Lisp_Object, Lisp_Object));
2785 extern void store_in_alist P_ ((Lisp_Object *, Lisp_Object, Lisp_Object));
2786 extern Lisp_Object do_switch_frame P_ ((Lisp_Object, int, int));
2787 extern Lisp_Object get_frame_param P_ ((struct frame *, Lisp_Object));
2788 extern Lisp_Object frame_buffer_predicate P_ ((Lisp_Object));
2789 EXFUN (Fframep, 1);
2790 EXFUN (Fselect_frame, 2);
2791 EXFUN (Fselected_frame, 0);
2792 EXFUN (Fwindow_frame, 1);
2793 EXFUN (Fframe_root_window, 1);
2794 EXFUN (Fframe_first_window, 1);
2795 EXFUN (Fframe_selected_window, 1);
2796 EXFUN (Fframe_list, 0);
2797 EXFUN (Fnext_frame, 2);
2798 EXFUN (Fdelete_frame, 2);
2799 EXFUN (Fset_mouse_position, 3);
2800 EXFUN (Fmake_frame_visible, 1);
2801 EXFUN (Fmake_frame_invisible, 2);
2802 EXFUN (Ficonify_frame, 1);
2803 EXFUN (Fframe_visible_p, 1);
2804 EXFUN (Fvisible_frame_list, 0);
2805 EXFUN (Fframe_parameter, 2);
2806 EXFUN (Fframe_parameters, 1);
2807 EXFUN (Fmodify_frame_parameters, 2);
2808 EXFUN (Fset_frame_height, 3);
2809 EXFUN (Fset_frame_width, 3);
2810 EXFUN (Fset_frame_size, 3);
2811 EXFUN (Fset_frame_position, 3);
2812 EXFUN (Fraise_frame, 1);
2813 EXFUN (Fredirect_frame_focus, 2);
2814 EXFUN (Fset_frame_selected_window, 2);
2815 extern Lisp_Object frame_buffer_list P_ ((Lisp_Object));
2816 extern void frames_discard_buffer P_ ((Lisp_Object));
2817 extern void set_frame_buffer_list P_ ((Lisp_Object, Lisp_Object));
2818 extern void frames_bury_buffer P_ ((Lisp_Object));
2819 extern void syms_of_frame P_ ((void));
2821 /* defined in emacs.c */
2822 extern Lisp_Object decode_env_path P_ ((char *, char *));
2823 extern Lisp_Object Vinvocation_name, Vinvocation_directory;
2824 extern Lisp_Object Vinstallation_directory, empty_string;
2825 EXFUN (Fkill_emacs, 1);
2826 #if HAVE_SETLOCALE
2827 void fixup_locale P_ ((void));
2828 void synchronize_system_messages_locale P_ ((void));
2829 void synchronize_system_time_locale P_ ((void));
2830 #else
2831 #define setlocale(category, locale)
2832 #define fixup_locale()
2833 #define synchronize_system_messages_locale()
2834 #define synchronize_system_time_locale()
2835 #endif
2836 void shut_down_emacs P_ ((int, int, Lisp_Object));
2837 /* Nonzero means don't do interactive redisplay and don't change tty modes */
2838 extern int noninteractive;
2839 /* Nonzero means don't do use window-system-specific display code */
2840 extern int inhibit_window_system;
2841 /* Nonzero means that a filter or a sentinel is running. */
2842 extern int running_asynch_code;
2844 /* defined in process.c */
2845 EXFUN (Fget_process, 1);
2846 EXFUN (Fget_buffer_process, 1);
2847 EXFUN (Fprocessp, 1);
2848 EXFUN (Fprocess_status, 1);
2849 EXFUN (Fkill_process, 2);
2850 EXFUN (Fprocess_send_eof, 1);
2851 EXFUN (Fwaiting_for_user_input_p, 0);
2852 extern Lisp_Object Qprocessp;
2853 extern void kill_buffer_processes P_ ((Lisp_Object));
2854 extern int wait_reading_process_input P_ ((int, int, Lisp_Object, int));
2855 extern void deactivate_process P_ ((Lisp_Object));
2856 extern void add_keyboard_wait_descriptor P_ ((int));
2857 extern void delete_keyboard_wait_descriptor P_ ((int));
2858 extern void close_process_descs P_ ((void));
2859 extern void status_notify P_ ((void));
2860 extern int read_process_output P_ ((Lisp_Object, int));
2861 extern void init_process P_ ((void));
2862 extern void syms_of_process P_ ((void));
2863 extern void setup_process_coding_systems P_ ((Lisp_Object));
2865 /* defined in callproc.c */
2866 extern Lisp_Object Vexec_path, Vexec_suffixes,
2867 Vexec_directory, Vdata_directory;
2868 extern Lisp_Object Vdoc_directory;
2869 EXFUN (Fcall_process, MANY);
2870 extern int child_setup P_ ((int, int, int, char **, int, Lisp_Object));
2871 extern void init_callproc_1 P_ ((void));
2872 extern void init_callproc P_ ((void));
2873 extern void set_process_environment P_ ((void));
2874 extern void syms_of_callproc P_ ((void));
2876 /* defined in doc.c */
2877 extern Lisp_Object Vdoc_file_name;
2878 EXFUN (Fsubstitute_command_keys, 1);
2879 EXFUN (Fdocumentation, 2);
2880 EXFUN (Fdocumentation_property, 3);
2881 extern Lisp_Object read_doc_string P_ ((Lisp_Object));
2882 extern Lisp_Object get_doc_string P_ ((Lisp_Object, int, int));
2883 extern void syms_of_doc P_ ((void));
2884 extern int read_bytecode_char P_ ((int));
2886 /* defined in bytecode.c */
2887 extern Lisp_Object Qbytecode;
2888 EXFUN (Fbyte_code, 3);
2889 extern void syms_of_bytecode P_ ((void));
2890 extern struct byte_stack *byte_stack_list;
2891 extern void mark_byte_stack P_ ((void));
2892 extern void unmark_byte_stack P_ ((void));
2894 /* defined in macros.c */
2895 extern Lisp_Object Qexecute_kbd_macro;
2896 EXFUN (Fexecute_kbd_macro, 3);
2897 EXFUN (Fcancel_kbd_macro_events, 0);
2898 extern void init_macros P_ ((void));
2899 extern void syms_of_macros P_ ((void));
2901 /* defined in undo.c */
2902 extern Lisp_Object Qinhibit_read_only;
2903 EXFUN (Fundo_boundary, 0);
2904 extern Lisp_Object truncate_undo_list P_ ((Lisp_Object, int, int));
2905 extern void record_marker_adjustment P_ ((Lisp_Object, int));
2906 extern void record_insert P_ ((int, int));
2907 extern void record_delete P_ ((int, Lisp_Object));
2908 extern void record_first_change P_ ((void));
2909 extern void record_change P_ ((int, int));
2910 extern void record_property_change P_ ((int, int, Lisp_Object, Lisp_Object,
2911 Lisp_Object));
2912 extern void syms_of_undo P_ ((void));
2914 /* defined in textprop.c */
2915 extern Lisp_Object Qfont, Qmouse_face;
2916 extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
2917 EXFUN (Fnext_single_property_change, 4);
2918 EXFUN (Fnext_single_char_property_change, 4);
2919 EXFUN (Fprevious_single_property_change, 4);
2920 EXFUN (Fput_text_property, 5);
2921 EXFUN (Fprevious_char_property_change, 2);
2922 EXFUN (Fnext_char_property_change, 2);
2923 extern void report_interval_modification P_ ((Lisp_Object, Lisp_Object));
2924 extern Lisp_Object next_single_char_property_change P_ ((Lisp_Object,
2925 Lisp_Object,
2926 Lisp_Object,
2927 Lisp_Object));
2929 /* defined in xmenu.c */
2930 EXFUN (Fx_popup_menu, 2);
2931 EXFUN (Fx_popup_dialog, 2);
2932 extern void syms_of_xmenu P_ ((void));
2934 /* defined in sysdep.c */
2935 extern void stuff_char P_ ((char c));
2936 extern void init_sigio P_ ((int));
2937 extern void request_sigio P_ ((void));
2938 extern void unrequest_sigio P_ ((void));
2939 extern void reset_sys_modes P_ ((void));
2940 extern void sys_subshell P_ ((void));
2941 extern void sys_suspend P_ ((void));
2942 extern void discard_tty_input P_ ((void));
2943 extern void init_sys_modes P_ ((void));
2944 extern void reset_sys_modes P_ ((void));
2945 extern void get_frame_size P_ ((int *, int *));
2946 extern void wait_for_termination P_ ((int));
2947 extern void flush_pending_output P_ ((int));
2948 extern void child_setup_tty P_ ((int));
2949 extern void setup_pty P_ ((int));
2950 extern int set_window_size P_ ((int, int, int));
2951 extern void create_process P_ ((Lisp_Object, char **, Lisp_Object));
2952 extern int tabs_safe_p P_ ((void));
2953 extern void init_baud_rate P_ ((void));
2954 extern int emacs_open P_ ((const char *, int, int));
2955 extern int emacs_close P_ ((int));
2956 extern int emacs_read P_ ((int, char *, unsigned int));
2957 extern int emacs_write P_ ((int, const char *, unsigned int));
2959 /* defined in filelock.c */
2960 EXFUN (Funlock_buffer, 0);
2961 EXFUN (Ffile_locked_p, 1);
2962 extern void unlock_all_files P_ ((void));
2963 extern void lock_file P_ ((Lisp_Object));
2964 extern void unlock_file P_ ((Lisp_Object));
2965 extern void unlock_buffer P_ ((struct buffer *));
2966 extern void syms_of_filelock P_ ((void));
2967 extern void init_filelock P_ ((void));
2969 /* Defined in sound.c */
2970 extern void syms_of_sound P_ ((void));
2971 extern void init_sound P_ ((void));
2973 /* Defined in category.c */
2974 extern void init_category_once P_ ((void));
2975 extern void syms_of_category P_ ((void));
2977 /* Defined in ccl.c */
2978 extern void syms_of_ccl P_ ((void));
2980 /* Defined in dired.c */
2981 EXFUN (Ffile_attributes, 2);
2982 extern void syms_of_dired P_ ((void));
2984 /* Defined in term.c */
2985 extern void syms_of_term P_ ((void));
2986 extern void fatal () NO_RETURN;
2988 #ifdef HAVE_X_WINDOWS
2989 /* Defined in fontset.c */
2990 extern void syms_of_fontset P_ ((void));
2991 EXFUN (Fset_fontset_font, 4);
2992 #endif
2994 /* Defined in xfaces.c */
2995 extern void syms_of_xfaces P_ ((void));
2997 /* Defined in getloadavg.c */
2998 extern int getloadavg P_ ((double *, int));
3000 #ifdef HAVE_X_WINDOWS
3001 /* Defined in xfns.c */
3002 extern void syms_of_xfns P_ ((void));
3003 extern void init_xfns P_ ((void));
3004 extern Lisp_Object Vx_resource_name;
3005 extern Lisp_Object Vx_resource_class;
3006 EXFUN (Fxw_display_color_p, 1);
3007 EXFUN (Fx_file_dialog, 4);
3008 #endif /* HAVE_X_WINDOWS */
3010 /* Defined in xsmfns.c */
3011 extern void syms_of_xsmfns P_ ((void));
3013 /* Defined in xselect.c */
3014 extern void syms_of_xselect P_ ((void));
3016 /* Defined in xterm.c */
3017 extern void syms_of_xterm P_ ((void));
3019 /* Defined in getloadavg.c */
3020 extern int getloadavg P_ ((double [], int));
3022 /* Nonzero means Emacs has already been initialized.
3023 Used during startup to detect startup of dumped Emacs. */
3024 extern int initialized;
3026 extern int immediate_quit; /* Nonzero means ^G can quit instantly */
3028 extern POINTER_TYPE *xmalloc P_ ((size_t));
3029 extern POINTER_TYPE *xrealloc P_ ((POINTER_TYPE *, size_t));
3030 extern void xfree P_ ((POINTER_TYPE *));
3032 extern char *xstrdup P_ ((const char *));
3034 #ifndef USE_CRT_DLL
3035 extern char *egetenv P_ ((char *));
3036 #endif
3038 /* Set up the name of the machine we're running on. */
3039 extern void init_system_name P_ ((void));
3041 /* Some systems (e.g., NT) use a different path separator than Unix,
3042 in addition to a device separator. Default the path separator
3043 to '/', and don't test for a device separator in IS_ANY_SEP. */
3045 #ifdef WINDOWSNT
3046 extern Lisp_Object Vdirectory_sep_char;
3047 #endif
3049 #ifndef DIRECTORY_SEP
3050 #define DIRECTORY_SEP '/'
3051 #endif
3052 #ifndef IS_DIRECTORY_SEP
3053 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
3054 #endif
3055 #ifndef IS_DEVICE_SEP
3056 #ifndef DEVICE_SEP
3057 #define IS_DEVICE_SEP(_c_) 0
3058 #else
3059 #define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
3060 #endif
3061 #endif
3062 #ifndef IS_ANY_SEP
3063 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
3064 #endif
3066 #ifdef SWITCH_ENUM_BUG
3067 #define SWITCH_ENUM_CAST(x) ((int)(x))
3068 #else
3069 #define SWITCH_ENUM_CAST(x) (x)
3070 #endif
3072 /* Loop over Lisp list LIST. Signal an error if LIST is not a proper
3073 list, or if it contains circles.
3075 HARE and TORTOISE should be the names of Lisp_Object variables, and
3076 N should be the name of an EMACS_INT variable declared in the
3077 function where the macro is used. Each nested loop should use
3078 its own variables.
3080 In the loop body, HARE is set to each cons of LIST, and N is the
3081 length of the list processed so far. */
3083 #define LIST_END_P(list, obj) \
3084 (NILP (obj) \
3085 ? 1 \
3086 : (CONSP (obj) \
3087 ? 0 \
3088 : (wrong_type_argument (Qlistp, (list))), 1))
3090 #define FOREACH(hare, list, tortoise, n) \
3091 for (tortoise = hare = (list), n = 0; \
3092 !LIST_END_P (list, hare); \
3093 (hare = XCDR (hare), ++n, \
3094 ((n & 1) != 0 \
3095 ? (tortoise = XCDR (tortoise), \
3096 (EQ (hare, tortoise) \
3097 && (circular_list_error ((list)), 1))) \
3098 : 0)))
3100 /* The ubiquitous min and max macros. */
3102 #ifdef max
3103 #undef max
3104 #undef min
3105 #endif
3106 #define min(a, b) ((a) < (b) ? (a) : (b))
3107 #define max(a, b) ((a) > (b) ? (a) : (b))
3109 /* Return a fixnum or float, depending on whether VAL fits in a Lisp
3110 fixnum. */
3112 #define make_fixnum_or_float(val) \
3113 (FIXNUM_OVERFLOW_P (val) \
3114 ? make_float (val) \
3115 : make_number ((EMACS_INT)(val)))
3117 #endif /* EMACS_LISP_H */
3119 /* arch-tag: 9b2ed020-70eb-47ac-94ee-e1c2a5107d5e
3120 (do not change this comment) */