* etc/NEWS, doc/lispref/tips.texi (Coding Conventions): Mention
[emacs.git] / src / lisp.h
blobbcb866b4cc4401626f5f9a82157e05444ec06a34
1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
3 Copyright (C) 1985-1987, 1993-1995, 1997-2013 Free Software Foundation,
4 Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #ifndef EMACS_LISP_H
22 #define EMACS_LISP_H
24 #include <setjmp.h>
25 #include <stdalign.h>
26 #include <stdarg.h>
27 #include <stdbool.h>
28 #include <stddef.h>
29 #include <float.h>
30 #include <inttypes.h>
31 #include <limits.h>
33 #include <intprops.h>
35 INLINE_HEADER_BEGIN
36 #ifndef LISP_INLINE
37 # define LISP_INLINE INLINE
38 #endif
40 /* The ubiquitous max and min macros. */
41 #undef min
42 #undef max
43 #define max(a, b) ((a) > (b) ? (a) : (b))
44 #define min(a, b) ((a) < (b) ? (a) : (b))
46 /* EMACS_INT - signed integer wide enough to hold an Emacs value
47 EMACS_INT_MAX - maximum value of EMACS_INT; can be used in #if
48 pI - printf length modifier for EMACS_INT
49 EMACS_UINT - unsigned variant of EMACS_INT */
50 #ifndef EMACS_INT_MAX
51 # if LONG_MAX < LLONG_MAX && defined WIDE_EMACS_INT
52 typedef long long int EMACS_INT;
53 typedef unsigned long long int EMACS_UINT;
54 # define EMACS_INT_MAX LLONG_MAX
55 # define pI "ll"
56 # elif INT_MAX < LONG_MAX
57 typedef long int EMACS_INT;
58 typedef unsigned long int EMACS_UINT;
59 # define EMACS_INT_MAX LONG_MAX
60 # define pI "l"
61 # else
62 typedef int EMACS_INT;
63 typedef unsigned int EMACS_UINT;
64 # define EMACS_INT_MAX INT_MAX
65 # define pI ""
66 # endif
67 #endif
69 /* Number of bits in some machine integer types. */
70 enum
72 BITS_PER_CHAR = CHAR_BIT,
73 BITS_PER_SHORT = CHAR_BIT * sizeof (short),
74 BITS_PER_INT = CHAR_BIT * sizeof (int),
75 BITS_PER_LONG = CHAR_BIT * sizeof (long int),
76 BITS_PER_EMACS_INT = CHAR_BIT * sizeof (EMACS_INT)
79 /* printmax_t and uprintmax_t are types for printing large integers.
80 These are the widest integers that are supported for printing.
81 pMd etc. are conversions for printing them.
82 On C99 hosts, there's no problem, as even the widest integers work.
83 Fall back on EMACS_INT on pre-C99 hosts. */
84 #ifdef PRIdMAX
85 typedef intmax_t printmax_t;
86 typedef uintmax_t uprintmax_t;
87 # define pMd PRIdMAX
88 # define pMu PRIuMAX
89 #else
90 typedef EMACS_INT printmax_t;
91 typedef EMACS_UINT uprintmax_t;
92 # define pMd pI"d"
93 # define pMu pI"u"
94 #endif
96 /* Use pD to format ptrdiff_t values, which suffice for indexes into
97 buffers and strings. Emacs never allocates objects larger than
98 PTRDIFF_MAX bytes, as they cause problems with pointer subtraction.
99 In C99, pD can always be "t"; configure it here for the sake of
100 pre-C99 libraries such as glibc 2.0 and Solaris 8. */
101 #if PTRDIFF_MAX == INT_MAX
102 # define pD ""
103 #elif PTRDIFF_MAX == LONG_MAX
104 # define pD "l"
105 #elif PTRDIFF_MAX == LLONG_MAX
106 # define pD "ll"
107 #else
108 # define pD "t"
109 #endif
111 /* Extra internal type checking? */
113 /* Define an Emacs version of 'assert (COND)', since some
114 system-defined 'assert's are flaky. COND should be free of side
115 effects; it may or may not be evaluated. */
116 #ifndef ENABLE_CHECKING
117 # define eassert(X) ((void) (0 && (X))) /* Check that X compiles. */
118 #else /* ENABLE_CHECKING */
120 extern _Noreturn void die (const char *, const char *, int);
122 /* The suppress_checking variable is initialized to 0 in alloc.c. Set
123 it to 1 using a debugger to temporarily disable aborting on
124 detected internal inconsistencies or error conditions.
126 In some cases, a good compiler may be able to optimize away the
127 eassert macro altogether, e.g., if XSTRING (x) uses eassert to test
128 STRINGP (x), but a particular use of XSTRING is invoked only after
129 testing that STRINGP (x) is true, making the test redundant. */
130 extern bool suppress_checking EXTERNALLY_VISIBLE;
132 # define eassert(cond) \
133 ((cond) || suppress_checking \
134 ? (void) 0 \
135 : die ("assertion failed: " # cond, __FILE__, __LINE__))
136 #endif /* ENABLE_CHECKING */
138 /* Use the configure flag --enable-check-lisp-object-type to make
139 Lisp_Object use a struct type instead of the default int. The flag
140 causes CHECK_LISP_OBJECT_TYPE to be defined. */
142 /***** Select the tagging scheme. *****/
143 /* The following option controls the tagging scheme:
144 - USE_LSB_TAG means that we can assume the least 3 bits of pointers are
145 always 0, and we can thus use them to hold tag bits, without
146 restricting our addressing space.
148 If ! USE_LSB_TAG, then use the top 3 bits for tagging, thus
149 restricting our possible address range.
151 USE_LSB_TAG not only requires the least 3 bits of pointers returned by
152 malloc to be 0 but also needs to be able to impose a mult-of-8 alignment
153 on the few static Lisp_Objects used: all the defsubr as well
154 as the two special buffers buffer_defaults and buffer_local_symbols. */
156 enum Lisp_Bits
158 /* Number of bits in a Lisp_Object tag. This can be used in #if,
159 and for GDB's sake also as a regular symbol. */
160 GCTYPEBITS =
161 #define GCTYPEBITS 3
162 GCTYPEBITS,
164 /* 2**GCTYPEBITS. This must be a macro that expands to a literal
165 integer constant, for MSVC. */
166 #define GCALIGNMENT 8
168 /* Number of bits in a Lisp_Object value, not counting the tag. */
169 VALBITS = BITS_PER_EMACS_INT - GCTYPEBITS,
171 /* Number of bits in a Lisp fixnum tag. */
172 INTTYPEBITS = GCTYPEBITS - 1,
174 /* Number of bits in a Lisp fixnum value, not counting the tag. */
175 FIXNUM_BITS = VALBITS + 1
178 #if GCALIGNMENT != 1 << GCTYPEBITS
179 # error "GCALIGNMENT and GCTYPEBITS are inconsistent"
180 #endif
182 /* The maximum value that can be stored in a EMACS_INT, assuming all
183 bits other than the type bits contribute to a nonnegative signed value.
184 This can be used in #if, e.g., '#if VAL_MAX < UINTPTR_MAX' below. */
185 #define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1))
187 /* Unless otherwise specified, use USE_LSB_TAG on systems where: */
188 #ifndef USE_LSB_TAG
189 /* 1. We know malloc returns a multiple of 8. */
190 # if (defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ \
191 || defined DARWIN_OS || defined __sun)
192 /* 2. We can specify multiple-of-8 alignment on static variables. */
193 # ifdef alignas
194 /* 3. Pointers-as-ints exceed VAL_MAX.
195 On hosts where pointers-as-ints do not exceed VAL_MAX, USE_LSB_TAG is:
196 a. unnecessary, because the top bits of an EMACS_INT are unused, and
197 b. slower, because it typically requires extra masking.
198 So, default USE_LSB_TAG to 1 only on hosts where it might be useful. */
199 # if VAL_MAX < UINTPTR_MAX
200 # define USE_LSB_TAG 1
201 # endif
202 # endif
203 # endif
204 #endif
205 #ifdef USE_LSB_TAG
206 # undef USE_LSB_TAG
207 enum enum_USE_LSB_TAG { USE_LSB_TAG = 1 };
208 # define USE_LSB_TAG 1
209 #else
210 enum enum_USE_LSB_TAG { USE_LSB_TAG = 0 };
211 # define USE_LSB_TAG 0
212 #endif
214 #ifndef alignas
215 # define alignas(alignment) /* empty */
216 # if USE_LSB_TAG
217 # error "USE_LSB_TAG requires alignas"
218 # endif
219 #endif
222 /* Define the fundamental Lisp data structures. */
224 /* This is the set of Lisp data types. If you want to define a new
225 data type, read the comments after Lisp_Fwd_Type definition
226 below. */
228 /* Lisp integers use 2 tags, to give them one extra bit, thus
229 extending their range from, e.g., -2^28..2^28-1 to -2^29..2^29-1. */
230 #define INTMASK (EMACS_INT_MAX >> (INTTYPEBITS - 1))
231 #define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
232 #define LISP_INT_TAG_P(x) (((x) & ~Lisp_Int1) == 0)
234 /* Stolen from GDB. The only known compiler that doesn't support
235 enums in bitfields is MSVC. */
236 #ifdef _MSC_VER
237 #define ENUM_BF(TYPE) unsigned int
238 #else
239 #define ENUM_BF(TYPE) enum TYPE
240 #endif
243 enum Lisp_Type
245 /* Integer. XINT (obj) is the integer value. */
246 Lisp_Int0 = 0,
247 Lisp_Int1 = USE_LSB_TAG ? 1 << INTTYPEBITS : 1,
249 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
250 Lisp_Symbol = 2,
252 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
253 whose first member indicates the subtype. */
254 Lisp_Misc = 3,
256 /* String. XSTRING (object) points to a struct Lisp_String.
257 The length of the string, and its contents, are stored therein. */
258 Lisp_String = USE_LSB_TAG ? 1 : 1 << INTTYPEBITS,
260 /* Vector of Lisp objects, or something resembling it.
261 XVECTOR (object) points to a struct Lisp_Vector, which contains
262 the size and contents. The size field also contains the type
263 information, if it's not a real vector object. */
264 Lisp_Vectorlike = 5,
266 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
267 Lisp_Cons = 6,
269 Lisp_Float = 7,
272 /* This is the set of data types that share a common structure.
273 The first member of the structure is a type code from this set.
274 The enum values are arbitrary, but we'll use large numbers to make it
275 more likely that we'll spot the error if a random word in memory is
276 mistakenly interpreted as a Lisp_Misc. */
277 enum Lisp_Misc_Type
279 Lisp_Misc_Free = 0x5eab,
280 Lisp_Misc_Marker,
281 Lisp_Misc_Overlay,
282 Lisp_Misc_Save_Value,
283 /* Currently floats are not a misc type,
284 but let's define this in case we want to change that. */
285 Lisp_Misc_Float,
286 /* This is not a type code. It is for range checking. */
287 Lisp_Misc_Limit
290 /* These are the types of forwarding objects used in the value slot
291 of symbols for special built-in variables whose value is stored in
292 C variables. */
293 enum Lisp_Fwd_Type
295 Lisp_Fwd_Int, /* Fwd to a C `int' variable. */
296 Lisp_Fwd_Bool, /* Fwd to a C boolean var. */
297 Lisp_Fwd_Obj, /* Fwd to a C Lisp_Object variable. */
298 Lisp_Fwd_Buffer_Obj, /* Fwd to a Lisp_Object field of buffers. */
299 Lisp_Fwd_Kboard_Obj, /* Fwd to a Lisp_Object field of kboards. */
302 /* If you want to define a new Lisp data type, here are some
303 instructions. See the thread at
304 http://lists.gnu.org/archive/html/emacs-devel/2012-10/msg00561.html
305 for more info.
307 First, there are already a couple of Lisp types that can be used if
308 your new type does not need to be exposed to Lisp programs nor
309 displayed to users. These are Lisp_Save_Value, a Lisp_Misc
310 subtype; and PVEC_OTHER, a kind of vectorlike object. The former
311 is suitable for temporarily stashing away pointers and integers in
312 a Lisp object (see the existing uses of make_save_value and
313 XSAVE_VALUE). The latter is useful for vector-like Lisp objects
314 that need to be used as part of other objects, but which are never
315 shown to users or Lisp code (search for PVEC_OTHER in xterm.c for
316 an example).
318 These two types don't look pretty when printed, so they are
319 unsuitable for Lisp objects that can be exposed to users.
321 To define a new data type, add one more Lisp_Misc subtype or one
322 more pseudovector subtype. Pseudovectors are more suitable for
323 objects with several slots that need to support fast random access,
324 while Lisp_Misc types are for everything else. A pseudovector object
325 provides one or more slots for Lisp objects, followed by struct
326 members that are accessible only from C. A Lisp_Misc object is a
327 wrapper for a C struct that can contain anything you like.
329 Explicit freeing is discouraged for Lisp objects in general. But if
330 you really need to exploit this, use Lisp_Misc (check free_misc in
331 alloc.c to see why). There is no way to free a vectorlike object.
333 To add a new pseudovector type, extend the pvec_type enumeration;
334 to add a new Lisp_Misc, extend the Lisp_Misc_Type enumeration.
336 For a Lisp_Misc, you will also need to add your entry to union
337 Lisp_Misc (but make sure the first word has the same structure as
338 the others, starting with a 16-bit member of the Lisp_Misc_Type
339 enumeration and a 1-bit GC markbit) and make sure the overall size
340 of the union is not increased by your addition.
342 For a new pseudovector, it's highly desirable to limit the size
343 of your data type by VBLOCK_BYTES_MAX bytes (defined in alloc.c).
344 Otherwise you will need to change sweep_vectors (also in alloc.c).
346 Then you will need to add switch branches in print.c (in
347 print_object, to print your object, and possibly also in
348 print_preprocess) and to alloc.c, to mark your object (in
349 mark_object) and to free it (in gc_sweep). The latter is also the
350 right place to call any code specific to your data type that needs
351 to run when the object is recycled -- e.g., free any additional
352 resources allocated for it that are not Lisp objects. You can even
353 make a pointer to the function that frees the resources a slot in
354 your object -- this way, the same object could be used to represent
355 several disparate C structures. */
357 #ifdef CHECK_LISP_OBJECT_TYPE
359 typedef struct { EMACS_INT i; } Lisp_Object;
361 #define XLI(o) (o).i
362 LISP_INLINE Lisp_Object
363 XIL (EMACS_INT i)
365 Lisp_Object o = { i };
366 return o;
369 LISP_INLINE Lisp_Object
370 LISP_MAKE_RVALUE (Lisp_Object o)
372 return o;
375 #define LISP_INITIALLY_ZERO {0}
377 #undef CHECK_LISP_OBJECT_TYPE
378 enum CHECK_LISP_OBJECT_TYPE { CHECK_LISP_OBJECT_TYPE = 1 };
379 #else /* CHECK_LISP_OBJECT_TYPE */
381 /* If a struct type is not wanted, define Lisp_Object as just a number. */
383 typedef EMACS_INT Lisp_Object;
384 #define XLI(o) (o)
385 #define XIL(i) (i)
386 #define LISP_MAKE_RVALUE(o) (0 + (o))
387 #define LISP_INITIALLY_ZERO 0
388 enum CHECK_LISP_OBJECT_TYPE { CHECK_LISP_OBJECT_TYPE = 0 };
389 #endif /* CHECK_LISP_OBJECT_TYPE */
391 /* In the size word of a vector, this bit means the vector has been marked. */
393 static ptrdiff_t const ARRAY_MARK_FLAG
394 #define ARRAY_MARK_FLAG PTRDIFF_MIN
395 = ARRAY_MARK_FLAG;
397 /* In the size word of a struct Lisp_Vector, this bit means it's really
398 some other vector-like object. */
399 static ptrdiff_t const PSEUDOVECTOR_FLAG
400 #define PSEUDOVECTOR_FLAG (PTRDIFF_MAX - PTRDIFF_MAX / 2)
401 = PSEUDOVECTOR_FLAG;
403 /* In a pseudovector, the size field actually contains a word with one
404 PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
405 with PVEC_TYPE_MASK to indicate the actual type. */
406 enum pvec_type
408 PVEC_NORMAL_VECTOR,
409 PVEC_FREE,
410 PVEC_PROCESS,
411 PVEC_FRAME,
412 PVEC_WINDOW,
413 PVEC_BOOL_VECTOR,
414 PVEC_BUFFER,
415 PVEC_HASH_TABLE,
416 PVEC_TERMINAL,
417 PVEC_WINDOW_CONFIGURATION,
418 PVEC_SUBR,
419 PVEC_OTHER,
420 /* These should be last, check internal_equal to see why. */
421 PVEC_COMPILED,
422 PVEC_CHAR_TABLE,
423 PVEC_SUB_CHAR_TABLE,
424 PVEC_FONT /* Should be last because it's used for range checking. */
427 /* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
428 which were stored in a Lisp_Object. */
429 #ifndef DATA_SEG_BITS
430 # define DATA_SEG_BITS 0
431 #endif
432 enum { gdb_DATA_SEG_BITS = DATA_SEG_BITS };
433 #undef DATA_SEG_BITS
435 enum More_Lisp_Bits
437 DATA_SEG_BITS = gdb_DATA_SEG_BITS,
439 /* For convenience, we also store the number of elements in these bits.
440 Note that this size is not necessarily the memory-footprint size, but
441 only the number of Lisp_Object fields (that need to be traced by GC).
442 The distinction is used, e.g., by Lisp_Process, which places extra
443 non-Lisp_Object fields at the end of the structure. */
444 PSEUDOVECTOR_SIZE_BITS = 12,
445 PSEUDOVECTOR_SIZE_MASK = (1 << PSEUDOVECTOR_SIZE_BITS) - 1,
447 /* To calculate the memory footprint of the pseudovector, it's useful
448 to store the size of non-Lisp area in word_size units here. */
449 PSEUDOVECTOR_REST_BITS = 12,
450 PSEUDOVECTOR_REST_MASK = (((1 << PSEUDOVECTOR_REST_BITS) - 1)
451 << PSEUDOVECTOR_SIZE_BITS),
453 /* Used to extract pseudovector subtype information. */
454 PSEUDOVECTOR_AREA_BITS = PSEUDOVECTOR_SIZE_BITS + PSEUDOVECTOR_REST_BITS,
455 PVEC_TYPE_MASK = 0x3f << PSEUDOVECTOR_AREA_BITS,
457 /* Number of bits to put in each character in the internal representation
458 of bool vectors. This should not vary across implementations. */
459 BOOL_VECTOR_BITS_PER_CHAR = 8
462 /* These macros extract various sorts of values from a Lisp_Object.
463 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
464 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */
466 #if USE_LSB_TAG
468 enum lsb_bits
470 TYPEMASK = (1 << GCTYPEBITS) - 1,
471 VALMASK = ~ TYPEMASK
473 #define XTYPE(a) ((enum Lisp_Type) (XLI (a) & TYPEMASK))
474 #define XINT(a) (XLI (a) >> INTTYPEBITS)
475 #define XUINT(a) ((EMACS_UINT) XLI (a) >> INTTYPEBITS)
476 #define make_number(N) XIL ((EMACS_INT) (N) << INTTYPEBITS)
477 #define make_lisp_ptr(ptr, type) \
478 (eassert (XTYPE (XIL ((intptr_t) (ptr))) == 0), /* Check alignment. */ \
479 XIL ((type) | (intptr_t) (ptr)))
481 #define XPNTR(a) ((intptr_t) (XLI (a) & ~TYPEMASK))
482 #define XUNTAG(a, type) ((intptr_t) (XLI (a) - (type)))
484 #else /* not USE_LSB_TAG */
486 static EMACS_INT const VALMASK
487 #define VALMASK VAL_MAX
488 = VALMASK;
490 #define XTYPE(a) ((enum Lisp_Type) ((EMACS_UINT) XLI (a) >> VALBITS))
492 /* For integers known to be positive, XFASTINT provides fast retrieval
493 and XSETFASTINT provides fast storage. This takes advantage of the
494 fact that Lisp integers have zero-bits in their tags. */
495 #define XFASTINT(a) (XLI (a) + 0)
496 #define XSETFASTINT(a, b) ((a) = XIL (b))
498 /* Extract the value of a Lisp_Object as a (un)signed integer. */
500 #define XINT(a) (XLI (a) << INTTYPEBITS >> INTTYPEBITS)
501 #define XUINT(a) ((EMACS_UINT) (XLI (a) & INTMASK))
502 #define make_number(N) XIL ((EMACS_INT) (N) & INTMASK)
504 #define make_lisp_ptr(ptr, type) \
505 (XIL ((EMACS_INT) ((EMACS_UINT) (type) << VALBITS) \
506 + ((intptr_t) (ptr) & VALMASK)))
508 /* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
509 which were stored in a Lisp_Object. */
510 #define XPNTR(a) ((uintptr_t) ((XLI (a) & VALMASK) | DATA_SEG_BITS))
512 #endif /* not USE_LSB_TAG */
514 /* Return a (Lisp-integer sized) hash of the Lisp_Object value. Happens to be
515 like XUINT right now, but XUINT should only be applied to objects we know
516 are integers. */
517 #define XHASH(a) XUINT (a)
519 /* For integers known to be positive, XFASTINT sometimes provides
520 faster retrieval and XSETFASTINT provides faster storage.
521 If not, fallback on the non-accelerated path. */
522 #ifndef XFASTINT
523 # define XFASTINT(a) (XINT (a))
524 # define XSETFASTINT(a, b) (XSETINT (a, b))
525 #endif
527 /* Extract the pointer value of the Lisp object A, under the
528 assumption that A's type is TYPE. This is a fallback
529 implementation if nothing faster is available. */
530 #ifndef XUNTAG
531 # define XUNTAG(a, type) XPNTR (a)
532 #endif
534 #define EQ(x, y) (XLI (x) == XLI (y))
536 /* Largest and smallest representable fixnum values. These are the C
537 values. They are macros for use in static initializers. */
538 #define MOST_POSITIVE_FIXNUM (EMACS_INT_MAX >> INTTYPEBITS)
539 #define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_FIXNUM)
541 /* Value is non-zero if I doesn't fit into a Lisp fixnum. It is
542 written this way so that it also works if I is of unsigned
543 type or if I is a NaN. */
545 #define FIXNUM_OVERFLOW_P(i) \
546 (! ((0 <= (i) || MOST_NEGATIVE_FIXNUM <= (i)) && (i) <= MOST_POSITIVE_FIXNUM))
548 LISP_INLINE ptrdiff_t
549 clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
551 return num < lower ? lower : num <= upper ? num : upper;
555 /* Extract a value or address from a Lisp_Object. */
557 #define XCONS(a) (eassert (CONSP (a)), \
558 (struct Lisp_Cons *) XUNTAG (a, Lisp_Cons))
559 #define XVECTOR(a) (eassert (VECTORLIKEP (a)), \
560 (struct Lisp_Vector *) XUNTAG (a, Lisp_Vectorlike))
561 #define XSTRING(a) (eassert (STRINGP (a)), \
562 (struct Lisp_String *) XUNTAG (a, Lisp_String))
563 #define XSYMBOL(a) (eassert (SYMBOLP (a)), \
564 (struct Lisp_Symbol *) XUNTAG (a, Lisp_Symbol))
565 #define XFLOAT(a) (eassert (FLOATP (a)), \
566 (struct Lisp_Float *) XUNTAG (a, Lisp_Float))
568 /* Misc types. */
570 #define XMISC(a) ((union Lisp_Misc *) XUNTAG (a, Lisp_Misc))
571 #define XMISCANY(a) (eassert (MISCP (a)), &(XMISC (a)->u_any))
572 #define XMISCTYPE(a) (XMISCANY (a)->type)
573 #define XMARKER(a) (eassert (MARKERP (a)), &(XMISC (a)->u_marker))
574 #define XOVERLAY(a) (eassert (OVERLAYP (a)), &(XMISC (a)->u_overlay))
576 /* Forwarding object types. */
578 #define XFWDTYPE(a) (a->u_intfwd.type)
579 #define XINTFWD(a) (eassert (INTFWDP (a)), &((a)->u_intfwd))
580 #define XBOOLFWD(a) (eassert (BOOLFWDP (a)), &((a)->u_boolfwd))
581 #define XOBJFWD(a) (eassert (OBJFWDP (a)), &((a)->u_objfwd))
582 #define XBUFFER_OBJFWD(a) \
583 (eassert (BUFFER_OBJFWDP (a)), &((a)->u_buffer_objfwd))
584 #define XKBOARD_OBJFWD(a) \
585 (eassert (KBOARD_OBJFWDP (a)), &((a)->u_kboard_objfwd))
587 /* Pseudovector types. */
589 #define XPROCESS(a) (eassert (PROCESSP (a)), \
590 (struct Lisp_Process *) XUNTAG (a, Lisp_Vectorlike))
591 #define XWINDOW(a) (eassert (WINDOWP (a)), \
592 (struct window *) XUNTAG (a, Lisp_Vectorlike))
593 #define XTERMINAL(a) (eassert (TERMINALP (a)), \
594 (struct terminal *) XUNTAG (a, Lisp_Vectorlike))
595 #define XSUBR(a) (eassert (SUBRP (a)), \
596 (struct Lisp_Subr *) XUNTAG (a, Lisp_Vectorlike))
597 #define XBUFFER(a) (eassert (BUFFERP (a)), \
598 (struct buffer *) XUNTAG (a, Lisp_Vectorlike))
599 #define XCHAR_TABLE(a) (eassert (CHAR_TABLE_P (a)), \
600 (struct Lisp_Char_Table *) XUNTAG (a, Lisp_Vectorlike))
601 #define XSUB_CHAR_TABLE(a) (eassert (SUB_CHAR_TABLE_P (a)), \
602 ((struct Lisp_Sub_Char_Table *) \
603 XUNTAG (a, Lisp_Vectorlike)))
604 #define XBOOL_VECTOR(a) (eassert (BOOL_VECTOR_P (a)), \
605 ((struct Lisp_Bool_Vector *) \
606 XUNTAG (a, Lisp_Vectorlike)))
608 /* Construct a Lisp_Object from a value or address. */
610 #define XSETINT(a, b) ((a) = make_number (b))
611 #define XSETCONS(a, b) ((a) = make_lisp_ptr (b, Lisp_Cons))
612 #define XSETVECTOR(a, b) ((a) = make_lisp_ptr (b, Lisp_Vectorlike))
613 #define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
614 #define XSETSYMBOL(a, b) ((a) = make_lisp_ptr (b, Lisp_Symbol))
615 #define XSETFLOAT(a, b) ((a) = make_lisp_ptr (b, Lisp_Float))
617 /* Misc types. */
619 #define XSETMISC(a, b) ((a) = make_lisp_ptr (b, Lisp_Misc))
620 #define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
622 /* Pseudovector types. */
624 #define XSETPVECTYPE(v, code) \
625 ((v)->header.size |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS))
626 #define XSETPVECTYPESIZE(v, code, lispsize, restsize) \
627 ((v)->header.size = (PSEUDOVECTOR_FLAG \
628 | ((code) << PSEUDOVECTOR_AREA_BITS) \
629 | ((restsize) << PSEUDOVECTOR_SIZE_BITS) \
630 | (lispsize)))
632 /* The cast to struct vectorlike_header * avoids aliasing issues. */
633 #define XSETPSEUDOVECTOR(a, b, code) \
634 XSETTYPED_PSEUDOVECTOR (a, b, \
635 (((struct vectorlike_header *) \
636 XUNTAG (a, Lisp_Vectorlike)) \
637 ->size), \
638 code)
639 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code) \
640 (XSETVECTOR (a, b), \
641 eassert ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) \
642 == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS))))
644 #define XSETWINDOW_CONFIGURATION(a, b) \
645 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
646 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
647 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
648 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
649 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
650 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
651 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
652 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
653 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
654 #define XSETSUB_CHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUB_CHAR_TABLE))
656 /* Convenience macros for dealing with Lisp arrays. */
658 #define AREF(ARRAY, IDX) XVECTOR ((ARRAY))->contents[IDX]
659 #define ASIZE(ARRAY) XVECTOR ((ARRAY))->header.size
660 #define ASET(ARRAY, IDX, VAL) \
661 (eassert (0 <= (IDX) && (IDX) < ASIZE (ARRAY)), \
662 XVECTOR (ARRAY)->contents[IDX] = (VAL))
664 /* Convenience macros for dealing with Lisp strings. */
666 #define SDATA(string) (XSTRING (string)->data + 0)
667 #define SREF(string, index) (SDATA (string)[index] + 0)
668 #define SSET(string, index, new) (SDATA (string)[index] = (new))
669 #define SCHARS(string) (XSTRING (string)->size + 0)
670 #define SBYTES(string) (STRING_BYTES (XSTRING (string)) + 0)
672 /* Avoid "differ in sign" warnings. */
673 #define SSDATA(x) ((char *) SDATA (x))
675 #define STRING_SET_CHARS(string, newsize) \
676 (XSTRING (string)->size = (newsize))
678 #define STRING_COPYIN(string, index, new, count) \
679 memcpy (SDATA (string) + index, new, count)
681 /* Type checking. */
683 #define CHECK_TYPE(ok, Qxxxp, x) \
684 do { if (!(ok)) wrong_type_argument (Qxxxp, (x)); } while (0)
686 /* Deprecated and will be removed soon. */
688 #define INTERNAL_FIELD(field) field ## _
690 /* See the macros in intervals.h. */
692 typedef struct interval *INTERVAL;
694 /* Complain if object is not string or buffer type. */
695 #define CHECK_STRING_OR_BUFFER(x) \
696 CHECK_TYPE (STRINGP (x) || BUFFERP (x), Qbuffer_or_string_p, x)
698 struct Lisp_Cons
700 /* Car of this cons cell. */
701 Lisp_Object car;
703 union
705 /* Cdr of this cons cell. */
706 Lisp_Object cdr;
708 /* Used to chain conses on a free list. */
709 struct Lisp_Cons *chain;
710 } u;
713 /* Take the car or cdr of something known to be a cons cell. */
714 /* The _AS_LVALUE macros shouldn't be used outside of the minimal set
715 of code that has to know what a cons cell looks like. Other code not
716 part of the basic lisp implementation should assume that the car and cdr
717 fields are not accessible as lvalues. (What if we want to switch to
718 a copying collector someday? Cached cons cell field addresses may be
719 invalidated at arbitrary points.) */
720 #define XCAR_AS_LVALUE(c) (XCONS (c)->car)
721 #define XCDR_AS_LVALUE(c) (XCONS (c)->u.cdr)
723 /* Use these from normal code. */
724 #define XCAR(c) LISP_MAKE_RVALUE (XCAR_AS_LVALUE (c))
725 #define XCDR(c) LISP_MAKE_RVALUE (XCDR_AS_LVALUE (c))
727 /* Use these to set the fields of a cons cell.
729 Note that both arguments may refer to the same object, so 'n'
730 should not be read after 'c' is first modified. Also, neither
731 argument should be evaluated more than once; side effects are
732 especially common in the second argument. */
733 #define XSETCAR(c,n) (XCAR_AS_LVALUE (c) = (n))
734 #define XSETCDR(c,n) (XCDR_AS_LVALUE (c) = (n))
736 /* Take the car or cdr of something whose type is not known. */
737 #define CAR(c) \
738 (CONSP ((c)) ? XCAR ((c)) \
739 : NILP ((c)) ? Qnil \
740 : wrong_type_argument (Qlistp, (c)))
742 #define CDR(c) \
743 (CONSP ((c)) ? XCDR ((c)) \
744 : NILP ((c)) ? Qnil \
745 : wrong_type_argument (Qlistp, (c)))
747 /* Take the car or cdr of something whose type is not known. */
748 #define CAR_SAFE(c) \
749 (CONSP ((c)) ? XCAR ((c)) : Qnil)
751 #define CDR_SAFE(c) \
752 (CONSP ((c)) ? XCDR ((c)) : Qnil)
754 /* True if STR is a multibyte string. */
755 #define STRING_MULTIBYTE(STR) \
756 (XSTRING (STR)->size_byte >= 0)
758 /* Return the length in bytes of STR. */
760 #ifdef GC_CHECK_STRING_BYTES
762 struct Lisp_String;
763 extern ptrdiff_t string_bytes (struct Lisp_String *);
764 #define STRING_BYTES(S) string_bytes ((S))
766 #else /* not GC_CHECK_STRING_BYTES */
768 #define STRING_BYTES(STR) \
769 ((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte)
771 #endif /* not GC_CHECK_STRING_BYTES */
773 /* An upper bound on the number of bytes in a Lisp string, not
774 counting the terminating null. This a tight enough bound to
775 prevent integer overflow errors that would otherwise occur during
776 string size calculations. A string cannot contain more bytes than
777 a fixnum can represent, nor can it be so long that C pointer
778 arithmetic stops working on the string plus its terminating null.
779 Although the actual size limit (see STRING_BYTES_MAX in alloc.c)
780 may be a bit smaller than STRING_BYTES_BOUND, calculating it here
781 would expose alloc.c internal details that we'd rather keep
782 private.
784 This is a macro for use in static initializers. The cast to
785 ptrdiff_t ensures that the macro is signed. */
786 #define STRING_BYTES_BOUND \
787 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1))
789 /* Mark STR as a unibyte string. */
790 #define STRING_SET_UNIBYTE(STR) \
791 do { if (EQ (STR, empty_multibyte_string)) \
792 (STR) = empty_unibyte_string; \
793 else XSTRING (STR)->size_byte = -1; } while (0)
795 /* Mark STR as a multibyte string. Assure that STR contains only
796 ASCII characters in advance. */
797 #define STRING_SET_MULTIBYTE(STR) \
798 do { if (EQ (STR, empty_unibyte_string)) \
799 (STR) = empty_multibyte_string; \
800 else XSTRING (STR)->size_byte = XSTRING (STR)->size; } while (0)
802 /* In a string or vector, the sign bit of the `size' is the gc mark bit. */
804 struct Lisp_String
806 ptrdiff_t size;
807 ptrdiff_t size_byte;
808 INTERVAL intervals; /* Text properties in this string. */
809 unsigned char *data;
812 /* Header of vector-like objects. This documents the layout constraints on
813 vectors and pseudovectors (objects of PVEC_xxx subtype). It also prevents
814 compilers from being fooled by Emacs's type punning: the XSETPSEUDOVECTOR
815 and PSEUDOVECTORP macros cast their pointers to struct vectorlike_header *,
816 because when two such pointers potentially alias, a compiler won't
817 incorrectly reorder loads and stores to their size fields. See
818 <http://debbugs.gnu.org/cgi/bugreport.cgi?bug=8546>. */
819 struct vectorlike_header
821 /* The only field contains various pieces of information:
822 - The MSB (ARRAY_MARK_FLAG) holds the gcmarkbit.
823 - The next bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
824 vector (0) or a pseudovector (1).
825 - If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
826 of slots) of the vector.
827 - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
828 - a) pseudovector subtype held in PVEC_TYPE_MASK field;
829 - b) number of Lisp_Objects slots at the beginning of the object
830 held in PSEUDOVECTOR_SIZE_MASK field. These objects are always
831 traced by the GC;
832 - c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
833 measured in word_size units. Rest fields may also include
834 Lisp_Objects, but these objects usually needs some special treatment
835 during GC.
836 There are some exceptions. For PVEC_FREE, b) is always zero. For
837 PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
838 Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
839 4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots. */
840 ptrdiff_t size;
843 /* Regular vector is just a header plus array of Lisp_Objects. */
845 struct Lisp_Vector
847 struct vectorlike_header header;
848 Lisp_Object contents[1];
851 /* A boolvector is a kind of vectorlike, with contents are like a string. */
853 struct Lisp_Bool_Vector
855 /* HEADER.SIZE is the vector's size field. It doesn't have the real size,
856 just the subtype information. */
857 struct vectorlike_header header;
858 /* This is the size in bits. */
859 EMACS_INT size;
860 /* This contains the actual bits, packed into bytes. */
861 unsigned char data[1];
864 /* Some handy constants for calculating sizes
865 and offsets, mostly of vectorlike objects. */
867 enum
869 header_size = offsetof (struct Lisp_Vector, contents),
870 bool_header_size = offsetof (struct Lisp_Bool_Vector, data),
871 word_size = sizeof (Lisp_Object)
874 /* If a struct is made to look like a vector, this macro returns the length
875 of the shortest vector that would hold that struct. */
877 #define VECSIZE(type) \
878 ((sizeof (type) - header_size + word_size - 1) / word_size)
880 /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields
881 at the end and we need to compute the number of Lisp_Object fields (the
882 ones that the GC needs to trace). */
884 #define PSEUDOVECSIZE(type, nonlispfield) \
885 ((offsetof (type, nonlispfield) - header_size) / word_size)
887 /* A char-table is a kind of vectorlike, with contents are like a
888 vector but with a few other slots. For some purposes, it makes
889 sense to handle a char-table with type struct Lisp_Vector. An
890 element of a char table can be any Lisp objects, but if it is a sub
891 char-table, we treat it a table that contains information of a
892 specific range of characters. A sub char-table has the same
893 structure as a vector. A sub char table appears only in an element
894 of a char-table, and there's no way to access it directly from
895 Emacs Lisp program. */
897 #ifdef __GNUC__
899 #define CHAR_TABLE_REF_ASCII(CT, IDX) \
900 ({struct Lisp_Char_Table *_tbl = NULL; \
901 Lisp_Object _val; \
902 do { \
903 _tbl = _tbl ? XCHAR_TABLE (_tbl->parent) : XCHAR_TABLE (CT); \
904 _val = (! SUB_CHAR_TABLE_P (_tbl->ascii) ? _tbl->ascii \
905 : XSUB_CHAR_TABLE (_tbl->ascii)->contents[IDX]); \
906 if (NILP (_val)) \
907 _val = _tbl->defalt; \
908 } while (NILP (_val) && ! NILP (_tbl->parent)); \
909 _val; })
911 #else /* not __GNUC__ */
913 #define CHAR_TABLE_REF_ASCII(CT, IDX) \
914 (! NILP (XCHAR_TABLE (CT)->ascii) \
915 ? (! SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii) \
916 ? XCHAR_TABLE (CT)->ascii \
917 : ! NILP (XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX]) \
918 ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] \
919 : char_table_ref ((CT), (IDX))) \
920 : char_table_ref ((CT), (IDX)))
922 #endif /* not __GNUC__ */
924 /* Compute A OP B, using the unsigned comparison operator OP. A and B
925 should be integer expressions. This is not the same as
926 mathematical comparison; for example, UNSIGNED_CMP (0, <, -1)
927 returns 1. For efficiency, prefer plain unsigned comparison if A
928 and B's sizes both fit (after integer promotion). */
929 #define UNSIGNED_CMP(a, op, b) \
930 (max (sizeof ((a) + 0), sizeof ((b) + 0)) <= sizeof (unsigned) \
931 ? ((a) + (unsigned) 0) op ((b) + (unsigned) 0) \
932 : ((a) + (uintmax_t) 0) op ((b) + (uintmax_t) 0))
934 /* Nonzero iff C is an ASCII character. */
935 #define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80)
937 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
938 characters. Do not check validity of CT. */
939 #define CHAR_TABLE_REF(CT, IDX) \
940 (ASCII_CHAR_P (IDX) ? CHAR_TABLE_REF_ASCII ((CT), (IDX)) \
941 : char_table_ref ((CT), (IDX)))
943 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
944 8-bit European characters. Do not check validity of CT. */
945 #define CHAR_TABLE_SET(CT, IDX, VAL) \
946 (ASCII_CHAR_P (IDX) && SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii) \
947 ? set_sub_char_table_contents (XCHAR_TABLE (CT)->ascii, IDX, VAL) \
948 : char_table_set (CT, IDX, VAL))
950 enum CHARTAB_SIZE_BITS
952 CHARTAB_SIZE_BITS_0 = 6,
953 CHARTAB_SIZE_BITS_1 = 4,
954 CHARTAB_SIZE_BITS_2 = 5,
955 CHARTAB_SIZE_BITS_3 = 7
958 extern const int chartab_size[4];
960 struct Lisp_Char_Table
962 /* HEADER.SIZE is the vector's size field, which also holds the
963 pseudovector type information. It holds the size, too.
964 The size counts the defalt, parent, purpose, ascii,
965 contents, and extras slots. */
966 struct vectorlike_header header;
968 /* This holds a default value,
969 which is used whenever the value for a specific character is nil. */
970 Lisp_Object defalt;
972 /* This points to another char table, which we inherit from when the
973 value for a specific character is nil. The `defalt' slot takes
974 precedence over this. */
975 Lisp_Object parent;
977 /* This is a symbol which says what kind of use this char-table is
978 meant for. */
979 Lisp_Object purpose;
981 /* The bottom sub char-table for characters of the range 0..127. It
982 is nil if none of ASCII character has a specific value. */
983 Lisp_Object ascii;
985 Lisp_Object contents[(1 << CHARTAB_SIZE_BITS_0)];
987 /* These hold additional data. It is a vector. */
988 Lisp_Object extras[1];
991 struct Lisp_Sub_Char_Table
993 /* HEADER.SIZE is the vector's size field, which also holds the
994 pseudovector type information. It holds the size, too. */
995 struct vectorlike_header header;
997 /* Depth of this sub char-table. It should be 1, 2, or 3. A sub
998 char-table of depth 1 contains 16 elements, and each element
999 covers 4096 (128*32) characters. A sub char-table of depth 2
1000 contains 32 elements, and each element covers 128 characters. A
1001 sub char-table of depth 3 contains 128 elements, and each element
1002 is for one character. */
1003 Lisp_Object depth;
1005 /* Minimum character covered by the sub char-table. */
1006 Lisp_Object min_char;
1008 /* Use set_sub_char_table_contents to set this. */
1009 Lisp_Object contents[1];
1012 /* This structure describes a built-in function.
1013 It is generated by the DEFUN macro only.
1014 defsubr makes it into a Lisp object. */
1016 struct Lisp_Subr
1018 struct vectorlike_header header;
1019 union {
1020 Lisp_Object (*a0) (void);
1021 Lisp_Object (*a1) (Lisp_Object);
1022 Lisp_Object (*a2) (Lisp_Object, Lisp_Object);
1023 Lisp_Object (*a3) (Lisp_Object, Lisp_Object, Lisp_Object);
1024 Lisp_Object (*a4) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
1025 Lisp_Object (*a5) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
1026 Lisp_Object (*a6) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
1027 Lisp_Object (*a7) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
1028 Lisp_Object (*a8) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
1029 Lisp_Object (*aUNEVALLED) (Lisp_Object args);
1030 Lisp_Object (*aMANY) (ptrdiff_t, Lisp_Object *);
1031 } function;
1032 short min_args, max_args;
1033 const char *symbol_name;
1034 const char *intspec;
1035 const char *doc;
1038 /* This is the number of slots that every char table must have. This
1039 counts the ordinary slots and the top, defalt, parent, and purpose
1040 slots. */
1041 enum CHAR_TABLE_STANDARD_SLOTS
1043 CHAR_TABLE_STANDARD_SLOTS = VECSIZE (struct Lisp_Char_Table) - 1
1046 /* Return the number of "extra" slots in the char table CT. */
1048 #define CHAR_TABLE_EXTRA_SLOTS(CT) \
1049 (((CT)->header.size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
1052 /***********************************************************************
1053 Symbols
1054 ***********************************************************************/
1056 /* Interned state of a symbol. */
1058 enum symbol_interned
1060 SYMBOL_UNINTERNED = 0,
1061 SYMBOL_INTERNED = 1,
1062 SYMBOL_INTERNED_IN_INITIAL_OBARRAY = 2
1065 enum symbol_redirect
1067 SYMBOL_PLAINVAL = 4,
1068 SYMBOL_VARALIAS = 1,
1069 SYMBOL_LOCALIZED = 2,
1070 SYMBOL_FORWARDED = 3
1073 struct Lisp_Symbol
1075 unsigned gcmarkbit : 1;
1077 /* Indicates where the value can be found:
1078 0 : it's a plain var, the value is in the `value' field.
1079 1 : it's a varalias, the value is really in the `alias' symbol.
1080 2 : it's a localized var, the value is in the `blv' object.
1081 3 : it's a forwarding variable, the value is in `forward'. */
1082 ENUM_BF (symbol_redirect) redirect : 3;
1084 /* Non-zero means symbol is constant, i.e. changing its value
1085 should signal an error. If the value is 3, then the var
1086 can be changed, but only by `defconst'. */
1087 unsigned constant : 2;
1089 /* Interned state of the symbol. This is an enumerator from
1090 enum symbol_interned. */
1091 unsigned interned : 2;
1093 /* Non-zero means that this variable has been explicitly declared
1094 special (with `defvar' etc), and shouldn't be lexically bound. */
1095 unsigned declared_special : 1;
1097 /* The symbol's name, as a Lisp string. */
1098 Lisp_Object name;
1100 /* Value of the symbol or Qunbound if unbound. Which alternative of the
1101 union is used depends on the `redirect' field above. */
1102 union {
1103 Lisp_Object value;
1104 struct Lisp_Symbol *alias;
1105 struct Lisp_Buffer_Local_Value *blv;
1106 union Lisp_Fwd *fwd;
1107 } val;
1109 /* Function value of the symbol or Qnil if not fboundp. */
1110 Lisp_Object function;
1112 /* The symbol's property list. */
1113 Lisp_Object plist;
1115 /* Next symbol in obarray bucket, if the symbol is interned. */
1116 struct Lisp_Symbol *next;
1119 /* Value is name of symbol. */
1121 #define SYMBOL_VAL(sym) \
1122 (eassert ((sym)->redirect == SYMBOL_PLAINVAL), sym->val.value)
1123 #define SYMBOL_ALIAS(sym) \
1124 (eassert ((sym)->redirect == SYMBOL_VARALIAS), (sym)->val.alias)
1125 #define SYMBOL_BLV(sym) \
1126 (eassert ((sym)->redirect == SYMBOL_LOCALIZED), (sym)->val.blv)
1127 #define SYMBOL_FWD(sym) \
1128 (eassert ((sym)->redirect == SYMBOL_FORWARDED), (sym)->val.fwd)
1129 #define SET_SYMBOL_VAL(sym, v) \
1130 (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v))
1131 #define SET_SYMBOL_ALIAS(sym, v) \
1132 (eassert ((sym)->redirect == SYMBOL_VARALIAS), (sym)->val.alias = (v))
1133 #define SET_SYMBOL_BLV(sym, v) \
1134 (eassert ((sym)->redirect == SYMBOL_LOCALIZED), (sym)->val.blv = (v))
1135 #define SET_SYMBOL_FWD(sym, v) \
1136 (eassert ((sym)->redirect == SYMBOL_FORWARDED), (sym)->val.fwd = (v))
1138 #define SYMBOL_NAME(sym) XSYMBOL (sym)->name
1140 /* Value is non-zero if SYM is an interned symbol. */
1142 #define SYMBOL_INTERNED_P(sym) \
1143 (XSYMBOL (sym)->interned != SYMBOL_UNINTERNED)
1145 /* Value is non-zero if SYM is interned in initial_obarray. */
1147 #define SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P(sym) \
1148 (XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY)
1150 /* Value is non-zero if symbol is considered a constant, i.e. its
1151 value cannot be changed (there is an exception for keyword symbols,
1152 whose value can be set to the keyword symbol itself). */
1154 #define SYMBOL_CONSTANT_P(sym) XSYMBOL (sym)->constant
1156 #define DEFSYM(sym, name) \
1157 do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0)
1160 /***********************************************************************
1161 Hash Tables
1162 ***********************************************************************/
1164 /* The structure of a Lisp hash table. */
1166 struct hash_table_test
1168 /* Name of the function used to compare keys. */
1169 Lisp_Object name;
1171 /* User-supplied hash function, or nil. */
1172 Lisp_Object user_hash_function;
1174 /* User-supplied key comparison function, or nil. */
1175 Lisp_Object user_cmp_function;
1177 /* C function to compare two keys. */
1178 bool (*cmpfn) (struct hash_table_test *t, Lisp_Object, Lisp_Object);
1180 /* C function to compute hash code. */
1181 EMACS_UINT (*hashfn) (struct hash_table_test *t, Lisp_Object);
1184 struct Lisp_Hash_Table
1186 /* This is for Lisp; the hash table code does not refer to it. */
1187 struct vectorlike_header header;
1189 /* Nil if table is non-weak. Otherwise a symbol describing the
1190 weakness of the table. */
1191 Lisp_Object weak;
1193 /* When the table is resized, and this is an integer, compute the
1194 new size by adding this to the old size. If a float, compute the
1195 new size by multiplying the old size with this factor. */
1196 Lisp_Object rehash_size;
1198 /* Resize hash table when number of entries/ table size is >= this
1199 ratio, a float. */
1200 Lisp_Object rehash_threshold;
1202 /* Vector of hash codes.. If hash[I] is nil, this means that that
1203 entry I is unused. */
1204 Lisp_Object hash;
1206 /* Vector used to chain entries. If entry I is free, next[I] is the
1207 entry number of the next free item. If entry I is non-free,
1208 next[I] is the index of the next entry in the collision chain. */
1209 Lisp_Object next;
1211 /* Index of first free entry in free list. */
1212 Lisp_Object next_free;
1214 /* Bucket vector. A non-nil entry is the index of the first item in
1215 a collision chain. This vector's size can be larger than the
1216 hash table size to reduce collisions. */
1217 Lisp_Object index;
1219 /* Only the fields above are traced normally by the GC. The ones below
1220 `count' are special and are either ignored by the GC or traced in
1221 a special way (e.g. because of weakness). */
1223 /* Number of key/value entries in the table. */
1224 ptrdiff_t count;
1226 /* Vector of keys and values. The key of item I is found at index
1227 2 * I, the value is found at index 2 * I + 1.
1228 This is gc_marked specially if the table is weak. */
1229 Lisp_Object key_and_value;
1231 /* The comparison and hash functions. */
1232 struct hash_table_test test;
1234 /* Next weak hash table if this is a weak hash table. The head
1235 of the list is in weak_hash_tables. */
1236 struct Lisp_Hash_Table *next_weak;
1240 #define XHASH_TABLE(OBJ) \
1241 ((struct Lisp_Hash_Table *) XUNTAG (OBJ, Lisp_Vectorlike))
1243 #define XSET_HASH_TABLE(VAR, PTR) \
1244 (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
1246 #define HASH_TABLE_P(OBJ) PSEUDOVECTORP (OBJ, PVEC_HASH_TABLE)
1248 #define CHECK_HASH_TABLE(x) \
1249 CHECK_TYPE (HASH_TABLE_P (x), Qhash_table_p, x)
1251 /* Value is the key part of entry IDX in hash table H. */
1253 #define HASH_KEY(H, IDX) AREF ((H)->key_and_value, 2 * (IDX))
1255 /* Value is the value part of entry IDX in hash table H. */
1257 #define HASH_VALUE(H, IDX) AREF ((H)->key_and_value, 2 * (IDX) + 1)
1259 /* Value is the index of the next entry following the one at IDX
1260 in hash table H. */
1262 #define HASH_NEXT(H, IDX) AREF ((H)->next, (IDX))
1264 /* Value is the hash code computed for entry IDX in hash table H. */
1266 #define HASH_HASH(H, IDX) AREF ((H)->hash, (IDX))
1268 /* Value is the index of the element in hash table H that is the
1269 start of the collision list at index IDX in the index vector of H. */
1271 #define HASH_INDEX(H, IDX) AREF ((H)->index, (IDX))
1273 /* Value is the size of hash table H. */
1275 #define HASH_TABLE_SIZE(H) ASIZE ((H)->next)
1277 /* Default size for hash tables if not specified. */
1279 enum DEFAULT_HASH_SIZE { DEFAULT_HASH_SIZE = 65 };
1281 /* Default threshold specifying when to resize a hash table. The
1282 value gives the ratio of current entries in the hash table and the
1283 size of the hash table. */
1285 static double const DEFAULT_REHASH_THRESHOLD = 0.8;
1287 /* Default factor by which to increase the size of a hash table. */
1289 static double const DEFAULT_REHASH_SIZE = 1.5;
1291 /* Combine two integers X and Y for hashing. The result might not fit
1292 into a Lisp integer. */
1294 LISP_INLINE EMACS_UINT
1295 sxhash_combine (EMACS_UINT x, EMACS_UINT y)
1297 return (x << 4) + (x >> (BITS_PER_EMACS_INT - 4)) + y;
1300 /* Hash X, returning a value that fits into a fixnum. */
1302 LISP_INLINE EMACS_UINT
1303 SXHASH_REDUCE (EMACS_UINT x)
1305 return (x ^ x >> (BITS_PER_EMACS_INT - FIXNUM_BITS)) & INTMASK;
1308 /* These structures are used for various misc types. */
1310 struct Lisp_Misc_Any /* Supertype of all Misc types. */
1312 ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_??? */
1313 unsigned gcmarkbit : 1;
1314 int spacer : 15;
1317 struct Lisp_Marker
1319 ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Marker */
1320 unsigned gcmarkbit : 1;
1321 int spacer : 13;
1322 /* This flag is temporarily used in the functions
1323 decode/encode_coding_object to record that the marker position
1324 must be adjusted after the conversion. */
1325 unsigned int need_adjustment : 1;
1326 /* 1 means normal insertion at the marker's position
1327 leaves the marker after the inserted text. */
1328 unsigned int insertion_type : 1;
1329 /* This is the buffer that the marker points into, or 0 if it points nowhere.
1330 Note: a chain of markers can contain markers pointing into different
1331 buffers (the chain is per buffer_text rather than per buffer, so it's
1332 shared between indirect buffers). */
1333 /* This is used for (other than NULL-checking):
1334 - Fmarker_buffer
1335 - Fset_marker: check eq(oldbuf, newbuf) to avoid unchain+rechain.
1336 - unchain_marker: to find the list from which to unchain.
1337 - Fkill_buffer: to only unchain the markers of current indirect buffer.
1339 struct buffer *buffer;
1341 /* The remaining fields are meaningless in a marker that
1342 does not point anywhere. */
1344 /* For markers that point somewhere,
1345 this is used to chain of all the markers in a given buffer. */
1346 /* We could remove it and use an array in buffer_text instead.
1347 That would also allow to preserve it ordered. */
1348 struct Lisp_Marker *next;
1349 /* This is the char position where the marker points. */
1350 ptrdiff_t charpos;
1351 /* This is the byte position.
1352 It's mostly used as a charpos<->bytepos cache (i.e. it's not directly
1353 used to implement the functionality of markers, but rather to (ab)use
1354 markers as a cache for char<->byte mappings). */
1355 ptrdiff_t bytepos;
1358 /* START and END are markers in the overlay's buffer, and
1359 PLIST is the overlay's property list. */
1360 struct Lisp_Overlay
1361 /* An overlay's real data content is:
1362 - plist
1363 - buffer (really there are two buffer pointers, one per marker,
1364 and both points to the same buffer)
1365 - insertion type of both ends (per-marker fields)
1366 - start & start byte (of start marker)
1367 - end & end byte (of end marker)
1368 - next (singly linked list of overlays)
1369 - next fields of start and end markers (singly linked list of markers).
1370 I.e. 9words plus 2 bits, 3words of which are for external linked lists.
1373 ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Overlay */
1374 unsigned gcmarkbit : 1;
1375 int spacer : 15;
1376 struct Lisp_Overlay *next;
1377 Lisp_Object start;
1378 Lisp_Object end;
1379 Lisp_Object plist;
1382 /* Types of data which may be saved in a Lisp_Save_Value. */
1384 enum
1386 SAVE_UNUSED,
1387 SAVE_INTEGER,
1388 SAVE_POINTER,
1389 SAVE_OBJECT
1392 /* Number of bits needed to store one of the above values. */
1393 enum { SAVE_SLOT_BITS = 2 };
1395 /* Number of slots in a save value where save_type is nonzero. */
1396 enum { SAVE_VALUE_SLOTS = 4 };
1398 /* Bit-width and values for struct Lisp_Save_Value's save_type member. */
1400 enum { SAVE_TYPE_BITS = SAVE_VALUE_SLOTS * SAVE_SLOT_BITS + 1 };
1402 enum Lisp_Save_Type
1404 SAVE_TYPE_INT_INT = SAVE_INTEGER + (SAVE_INTEGER << SAVE_SLOT_BITS),
1405 SAVE_TYPE_INT_INT_INT
1406 = (SAVE_INTEGER + (SAVE_TYPE_INT_INT << SAVE_SLOT_BITS)),
1407 SAVE_TYPE_OBJ_OBJ = SAVE_OBJECT + (SAVE_OBJECT << SAVE_SLOT_BITS),
1408 SAVE_TYPE_OBJ_OBJ_OBJ = SAVE_OBJECT + (SAVE_TYPE_OBJ_OBJ << SAVE_SLOT_BITS),
1409 SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
1410 = SAVE_OBJECT + (SAVE_TYPE_OBJ_OBJ_OBJ << SAVE_SLOT_BITS),
1411 SAVE_TYPE_PTR_INT = SAVE_POINTER + (SAVE_INTEGER << SAVE_SLOT_BITS),
1412 SAVE_TYPE_PTR_OBJ = SAVE_POINTER + (SAVE_OBJECT << SAVE_SLOT_BITS),
1413 SAVE_TYPE_PTR_PTR = SAVE_POINTER + (SAVE_POINTER << SAVE_SLOT_BITS),
1414 SAVE_TYPE_PTR_PTR_OBJ
1415 = SAVE_POINTER + (SAVE_TYPE_PTR_OBJ << SAVE_SLOT_BITS),
1417 /* This has an extra bit indicating it's raw memory. */
1418 SAVE_TYPE_MEMORY = SAVE_TYPE_PTR_INT + (1 << (SAVE_TYPE_BITS - 1))
1421 /* Special object used to hold a different values for later use.
1423 This is mostly used to package C integers and pointers to call
1424 record_unwind_protect. Typical task is to pass just one C pointer
1425 to unwind function. You should pack pointer with make_save_pointer
1426 and then get it back with XSAVE_POINTER, e.g.:
1429 struct my_data *md = get_my_data ();
1430 record_unwind_protect (my_unwind, make_save_pointer (md));
1433 Lisp_Object my_unwind (Lisp_Object arg)
1435 struct my_data *md = XSAVE_POINTER (arg, 0);
1439 If yon need to pass more than just one C pointer, you should
1440 use make_save_value. This function allows you to pack up to
1441 SAVE_VALUE_SLOTS integers, pointers or Lisp_Objects and
1442 conveniently get them back with XSAVE_POINTER, XSAVE_INTEGER and
1443 XSAVE_OBJECT macros:
1446 struct my_data *md = get_my_data ();
1447 Lisp_Object my_object = get_my_object ();
1448 record_unwind_protect
1449 (my_unwind, make_save_value (SAVE_TYPE_PTR_OBJ, md, my_object));
1452 Lisp_Object my_unwind (Lisp_Object arg)
1454 struct my_data *md = XSAVE_POINTER (arg, 0);
1455 Lisp_Object my_object = XSAVE_OBJECT (arg, 1);
1459 If ENABLE_CHECKING is in effect, XSAVE_xxx macros do type checking of the
1460 saved objects and raise eassert if type of the saved object doesn't match
1461 the type which is extracted. In the example above, XSAVE_INTEGER (arg, 2)
1462 or XSAVE_OBJECT (arg, 0) are wrong because nothing was saved in slot 2 and
1463 Lisp_Object was saved in slot 1 of ARG. */
1465 struct Lisp_Save_Value
1467 ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
1468 unsigned gcmarkbit : 1;
1469 int spacer : 32 - (16 + 1 + SAVE_TYPE_BITS);
1471 /* DATA[N] may hold up to SAVE_VALUE_SLOTS entries. The type of
1472 V's Ith entry is given by save_type (V, I). E.g., if save_type
1473 (V, 3) == SAVE_INTEGER, V->data[3].integer is in use.
1475 If SAVE_TYPE == SAVE_TYPE_MEMORY, DATA[0].pointer is the address of
1476 a memory area containing DATA[1].integer potential Lisp_Objects. */
1477 ENUM_BF (Lisp_Save_Type) save_type : SAVE_TYPE_BITS;
1478 union {
1479 void *pointer;
1480 ptrdiff_t integer;
1481 Lisp_Object object;
1482 } data[SAVE_VALUE_SLOTS];
1485 /* A miscellaneous object, when it's on the free list. */
1486 struct Lisp_Free
1488 ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Free */
1489 unsigned gcmarkbit : 1;
1490 int spacer : 15;
1491 union Lisp_Misc *chain;
1494 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
1495 It uses one of these struct subtypes to get the type field. */
1497 union Lisp_Misc
1499 struct Lisp_Misc_Any u_any; /* Supertype of all Misc types. */
1500 struct Lisp_Free u_free;
1501 struct Lisp_Marker u_marker;
1502 struct Lisp_Overlay u_overlay;
1503 struct Lisp_Save_Value u_save_value;
1506 /* Forwarding pointer to an int variable.
1507 This is allowed only in the value cell of a symbol,
1508 and it means that the symbol's value really lives in the
1509 specified int variable. */
1510 struct Lisp_Intfwd
1512 enum Lisp_Fwd_Type type; /* = Lisp_Fwd_Int */
1513 EMACS_INT *intvar;
1516 /* Boolean forwarding pointer to an int variable.
1517 This is like Lisp_Intfwd except that the ostensible
1518 "value" of the symbol is t if the int variable is nonzero,
1519 nil if it is zero. */
1520 struct Lisp_Boolfwd
1522 enum Lisp_Fwd_Type type; /* = Lisp_Fwd_Bool */
1523 bool *boolvar;
1526 /* Forwarding pointer to a Lisp_Object variable.
1527 This is allowed only in the value cell of a symbol,
1528 and it means that the symbol's value really lives in the
1529 specified variable. */
1530 struct Lisp_Objfwd
1532 enum Lisp_Fwd_Type type; /* = Lisp_Fwd_Obj */
1533 Lisp_Object *objvar;
1536 /* Like Lisp_Objfwd except that value lives in a slot in the
1537 current buffer. Value is byte index of slot within buffer. */
1538 struct Lisp_Buffer_Objfwd
1540 enum Lisp_Fwd_Type type; /* = Lisp_Fwd_Buffer_Obj */
1541 int offset;
1542 /* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp. */
1543 Lisp_Object predicate;
1546 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
1547 the symbol has buffer-local or frame-local bindings. (Exception:
1548 some buffer-local variables are built-in, with their values stored
1549 in the buffer structure itself. They are handled differently,
1550 using struct Lisp_Buffer_Objfwd.)
1552 The `realvalue' slot holds the variable's current value, or a
1553 forwarding pointer to where that value is kept. This value is the
1554 one that corresponds to the loaded binding. To read or set the
1555 variable, you must first make sure the right binding is loaded;
1556 then you can access the value in (or through) `realvalue'.
1558 `buffer' and `frame' are the buffer and frame for which the loaded
1559 binding was found. If those have changed, to make sure the right
1560 binding is loaded it is necessary to find which binding goes with
1561 the current buffer and selected frame, then load it. To load it,
1562 first unload the previous binding, then copy the value of the new
1563 binding into `realvalue' (or through it). Also update
1564 LOADED-BINDING to point to the newly loaded binding.
1566 `local_if_set' indicates that merely setting the variable creates a
1567 local binding for the current buffer. Otherwise the latter, setting
1568 the variable does not do that; only make-local-variable does that. */
1570 struct Lisp_Buffer_Local_Value
1572 /* 1 means that merely setting the variable creates a local
1573 binding for the current buffer. */
1574 unsigned int local_if_set : 1;
1575 /* 1 means this variable can have frame-local bindings, otherwise, it is
1576 can have buffer-local bindings. The two cannot be combined. */
1577 unsigned int frame_local : 1;
1578 /* 1 means that the binding now loaded was found.
1579 Presumably equivalent to (defcell!=valcell). */
1580 unsigned int found : 1;
1581 /* If non-NULL, a forwarding to the C var where it should also be set. */
1582 union Lisp_Fwd *fwd; /* Should never be (Buffer|Kboard)_Objfwd. */
1583 /* The buffer or frame for which the loaded binding was found. */
1584 Lisp_Object where;
1585 /* A cons cell that holds the default value. It has the form
1586 (SYMBOL . DEFAULT-VALUE). */
1587 Lisp_Object defcell;
1588 /* The cons cell from `where's parameter alist.
1589 It always has the form (SYMBOL . VALUE)
1590 Note that if `forward' is non-nil, VALUE may be out of date.
1591 Also if the currently loaded binding is the default binding, then
1592 this is `eq'ual to defcell. */
1593 Lisp_Object valcell;
1596 /* Like Lisp_Objfwd except that value lives in a slot in the
1597 current kboard. */
1598 struct Lisp_Kboard_Objfwd
1600 enum Lisp_Fwd_Type type; /* = Lisp_Fwd_Kboard_Obj */
1601 int offset;
1604 union Lisp_Fwd
1606 struct Lisp_Intfwd u_intfwd;
1607 struct Lisp_Boolfwd u_boolfwd;
1608 struct Lisp_Objfwd u_objfwd;
1609 struct Lisp_Buffer_Objfwd u_buffer_objfwd;
1610 struct Lisp_Kboard_Objfwd u_kboard_objfwd;
1613 /* Lisp floating point type. */
1614 struct Lisp_Float
1616 union
1618 double data;
1619 struct Lisp_Float *chain;
1620 } u;
1623 #define XFLOAT_DATA(f) (0 ? XFLOAT (f)->u.data : XFLOAT (f)->u.data)
1624 #define XFLOAT_INIT(f, n) (XFLOAT (f)->u.data = (n))
1626 /* Most hosts nowadays use IEEE floating point, so they use IEC 60559
1627 representations, have infinities and NaNs, and do not trap on
1628 exceptions. Define IEEE_FLOATING_POINT if this host is one of the
1629 typical ones. The C11 macro __STDC_IEC_559__ is close to what is
1630 wanted here, but is not quite right because Emacs does not require
1631 all the features of C11 Annex F (and does not require C11 at all,
1632 for that matter). */
1633 #define IEEE_FLOATING_POINT (FLT_RADIX == 2 && FLT_MANT_DIG == 24 \
1634 && FLT_MIN_EXP == -125 && FLT_MAX_EXP == 128)
1636 /* A character, declared with the following typedef, is a member
1637 of some character set associated with the current buffer. */
1638 #ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
1639 #define _UCHAR_T
1640 typedef unsigned char UCHAR;
1641 #endif
1643 /* Meanings of slots in a Lisp_Compiled: */
1645 enum Lisp_Compiled
1647 COMPILED_ARGLIST = 0,
1648 COMPILED_BYTECODE = 1,
1649 COMPILED_CONSTANTS = 2,
1650 COMPILED_STACK_DEPTH = 3,
1651 COMPILED_DOC_STRING = 4,
1652 COMPILED_INTERACTIVE = 5
1655 /* Flag bits in a character. These also get used in termhooks.h.
1656 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
1657 (MUlti-Lingual Emacs) might need 22 bits for the character value
1658 itself, so we probably shouldn't use any bits lower than 0x0400000. */
1659 enum char_bits
1661 CHAR_ALT = 0x0400000,
1662 CHAR_SUPER = 0x0800000,
1663 CHAR_HYPER = 0x1000000,
1664 CHAR_SHIFT = 0x2000000,
1665 CHAR_CTL = 0x4000000,
1666 CHAR_META = 0x8000000,
1668 CHAR_MODIFIER_MASK =
1669 CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META,
1671 /* Actually, the current Emacs uses 22 bits for the character value
1672 itself. */
1673 CHARACTERBITS = 22
1679 /* The glyph datatype, used to represent characters on the display.
1680 It consists of a char code and a face id. */
1682 typedef struct {
1683 int ch;
1684 int face_id;
1685 } GLYPH;
1687 /* Return a glyph's character code. */
1688 #define GLYPH_CHAR(glyph) ((glyph).ch)
1690 /* Return a glyph's face ID. */
1691 #define GLYPH_FACE(glyph) ((glyph).face_id)
1693 #define SET_GLYPH_CHAR(glyph, char) ((glyph).ch = (char))
1694 #define SET_GLYPH_FACE(glyph, face) ((glyph).face_id = (face))
1695 #define SET_GLYPH(glyph, char, face) ((glyph).ch = (char), (glyph).face_id = (face))
1697 /* Return 1 if GLYPH contains valid character code. */
1698 #define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (GLYPH_CHAR (glyph))
1701 /* Glyph Code from a display vector may either be an integer which
1702 encodes a char code in the lower CHARACTERBITS bits and a (very small)
1703 face-id in the upper bits, or it may be a cons (CHAR . FACE-ID). */
1705 #define GLYPH_CODE_P(gc) \
1706 (CONSP (gc) \
1707 ? (CHARACTERP (XCAR (gc)) \
1708 && RANGED_INTEGERP (0, XCDR (gc), MAX_FACE_ID)) \
1709 : (RANGED_INTEGERP \
1710 (0, gc, \
1711 (MAX_FACE_ID < TYPE_MAXIMUM (EMACS_INT) >> CHARACTERBITS \
1712 ? ((EMACS_INT) MAX_FACE_ID << CHARACTERBITS) | MAX_CHAR \
1713 : TYPE_MAXIMUM (EMACS_INT)))))
1715 /* The following are valid only if GLYPH_CODE_P (gc). */
1717 #define GLYPH_CODE_CHAR(gc) \
1718 (CONSP (gc) ? XINT (XCAR (gc)) : XINT (gc) & ((1 << CHARACTERBITS) - 1))
1720 #define GLYPH_CODE_FACE(gc) \
1721 (CONSP (gc) ? XINT (XCDR (gc)) : XINT (gc) >> CHARACTERBITS)
1723 #define SET_GLYPH_FROM_GLYPH_CODE(glyph, gc) \
1724 do \
1726 if (CONSP (gc)) \
1727 SET_GLYPH (glyph, XINT (XCAR (gc)), XINT (XCDR (gc))); \
1728 else \
1729 SET_GLYPH (glyph, (XINT (gc) & ((1 << CHARACTERBITS)-1)), \
1730 (XINT (gc) >> CHARACTERBITS)); \
1732 while (0)
1734 /* Structure to hold mouse highlight data. This is here because other
1735 header files need it for defining struct x_output etc. */
1736 typedef struct {
1737 /* These variables describe the range of text currently shown in its
1738 mouse-face, together with the window they apply to. As long as
1739 the mouse stays within this range, we need not redraw anything on
1740 its account. Rows and columns are glyph matrix positions in
1741 MOUSE_FACE_WINDOW. */
1742 int mouse_face_beg_row, mouse_face_beg_col;
1743 int mouse_face_beg_x, mouse_face_beg_y;
1744 int mouse_face_end_row, mouse_face_end_col;
1745 int mouse_face_end_x, mouse_face_end_y;
1746 Lisp_Object mouse_face_window;
1747 int mouse_face_face_id;
1748 Lisp_Object mouse_face_overlay;
1750 /* FRAME and X, Y position of mouse when last checked for
1751 highlighting. X and Y can be negative or out of range for the frame. */
1752 struct frame *mouse_face_mouse_frame;
1753 int mouse_face_mouse_x, mouse_face_mouse_y;
1755 /* Nonzero if part of the text currently shown in
1756 its mouse-face is beyond the window end. */
1757 unsigned mouse_face_past_end : 1;
1759 /* Nonzero means defer mouse-motion highlighting. */
1760 unsigned mouse_face_defer : 1;
1762 /* Nonzero means that the mouse highlight should not be shown. */
1763 unsigned mouse_face_hidden : 1;
1764 } Mouse_HLInfo;
1766 /* Data type checking. */
1768 #define NILP(x) EQ (x, Qnil)
1770 #define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
1771 #define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
1773 #define RANGED_INTEGERP(lo, x, hi) \
1774 (INTEGERP (x) && (lo) <= XINT (x) && XINT (x) <= (hi))
1775 #define TYPE_RANGED_INTEGERP(type, x) \
1776 (TYPE_SIGNED (type) \
1777 ? RANGED_INTEGERP (TYPE_MINIMUM (type), x, TYPE_MAXIMUM (type)) \
1778 : RANGED_INTEGERP (0, x, TYPE_MAXIMUM (type)))
1780 #define INTEGERP(x) (LISP_INT_TAG_P (XTYPE ((x))))
1781 #define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
1782 #define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
1783 #define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
1784 #define STRINGP(x) (XTYPE ((x)) == Lisp_String)
1785 #define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
1787 #define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
1788 #define VECTORP(x) (VECTORLIKEP (x) && !(ASIZE (x) & PSEUDOVECTOR_FLAG))
1789 #define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1790 #define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1792 LISP_INLINE bool
1793 SAVE_VALUEP (Lisp_Object x)
1795 return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Save_Value;
1798 LISP_INLINE struct Lisp_Save_Value *
1799 XSAVE_VALUE (Lisp_Object a)
1801 eassert (SAVE_VALUEP (a));
1802 return & XMISC (a)->u_save_value;
1805 /* Return the type of V's Nth saved value. */
1806 LISP_INLINE int
1807 save_type (struct Lisp_Save_Value *v, int n)
1809 eassert (0 <= n && n < SAVE_VALUE_SLOTS);
1810 return (v->save_type >> (SAVE_SLOT_BITS * n) & ((1 << SAVE_SLOT_BITS) - 1));
1813 /* Get and set the Nth saved pointer. */
1815 LISP_INLINE void *
1816 XSAVE_POINTER (Lisp_Object obj, int n)
1818 eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
1819 return XSAVE_VALUE (obj)->data[n].pointer;;
1821 LISP_INLINE void
1822 set_save_pointer (Lisp_Object obj, int n, void *val)
1824 eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
1825 XSAVE_VALUE (obj)->data[n].pointer = val;
1828 /* Likewise for the saved integer. */
1830 LISP_INLINE ptrdiff_t
1831 XSAVE_INTEGER (Lisp_Object obj, int n)
1833 eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_INTEGER);
1834 return XSAVE_VALUE (obj)->data[n].integer;
1836 LISP_INLINE void
1837 set_save_integer (Lisp_Object obj, int n, ptrdiff_t val)
1839 eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_INTEGER);
1840 XSAVE_VALUE (obj)->data[n].integer = val;
1843 /* Extract Nth saved object. */
1845 LISP_INLINE Lisp_Object
1846 XSAVE_OBJECT (Lisp_Object obj, int n)
1848 eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_OBJECT);
1849 return XSAVE_VALUE (obj)->data[n].object;
1852 #define AUTOLOADP(x) (CONSP (x) && EQ (Qautoload, XCAR (x)))
1854 #define INTFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Int)
1855 #define BOOLFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Bool)
1856 #define OBJFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Obj)
1857 #define BUFFER_OBJFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Buffer_Obj)
1858 #define KBOARD_OBJFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Kboard_Obj)
1860 /* True if object X is a pseudovector whose code is CODE. The cast to struct
1861 vectorlike_header * avoids aliasing issues. */
1862 #define PSEUDOVECTORP(x, code) \
1863 TYPED_PSEUDOVECTORP (x, vectorlike_header, code)
1865 #define PSEUDOVECTOR_TYPEP(v, code) \
1866 (((v)->size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) \
1867 == (PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS)))
1869 /* True if object X, with internal type struct T *, is a pseudovector whose
1870 code is CODE. */
1871 #define TYPED_PSEUDOVECTORP(x, t, code) \
1872 (VECTORLIKEP (x) \
1873 && PSEUDOVECTOR_TYPEP ((struct t *) XUNTAG (x, Lisp_Vectorlike), code))
1875 /* Test for specific pseudovector types. */
1876 #define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1877 #define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
1878 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
1879 #define TERMINALP(x) PSEUDOVECTORP (x, PVEC_TERMINAL)
1880 #define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
1881 #define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
1882 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
1883 #define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1884 #define SUB_CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_SUB_CHAR_TABLE)
1885 #define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
1886 #define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
1888 /* Test for image (image . spec) */
1889 #define IMAGEP(x) (CONSP (x) && EQ (XCAR (x), Qimage))
1891 /* Array types. */
1893 #define ARRAYP(x) \
1894 (VECTORP (x) || STRINGP (x) || CHAR_TABLE_P (x) || BOOL_VECTOR_P (x))
1896 #define CHECK_LIST(x) \
1897 CHECK_TYPE (CONSP (x) || NILP (x), Qlistp, x)
1899 #define CHECK_LIST_CONS(x, y) \
1900 CHECK_TYPE (CONSP (x), Qlistp, y)
1902 #define CHECK_LIST_END(x, y) \
1903 CHECK_TYPE (NILP (x), Qlistp, y)
1905 #define CHECK_STRING(x) \
1906 CHECK_TYPE (STRINGP (x), Qstringp, x)
1908 #define CHECK_STRING_CAR(x) \
1909 CHECK_TYPE (STRINGP (XCAR (x)), Qstringp, XCAR (x))
1911 #define CHECK_CONS(x) \
1912 CHECK_TYPE (CONSP (x), Qconsp, x)
1914 #define CHECK_SYMBOL(x) \
1915 CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
1917 #define CHECK_CHAR_TABLE(x) \
1918 CHECK_TYPE (CHAR_TABLE_P (x), Qchar_table_p, x)
1920 #define CHECK_VECTOR(x) \
1921 CHECK_TYPE (VECTORP (x), Qvectorp, x)
1923 #define CHECK_VECTOR_OR_STRING(x) \
1924 CHECK_TYPE (VECTORP (x) || STRINGP (x), Qarrayp, x)
1926 #define CHECK_ARRAY(x, Qxxxp) \
1927 CHECK_TYPE (ARRAYP (x), Qxxxp, x)
1929 #define CHECK_VECTOR_OR_CHAR_TABLE(x) \
1930 CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x)
1932 #define CHECK_BUFFER(x) \
1933 CHECK_TYPE (BUFFERP (x), Qbufferp, x)
1935 #define CHECK_WINDOW(x) \
1936 CHECK_TYPE (WINDOWP (x), Qwindowp, x)
1938 #define CHECK_WINDOW_CONFIGURATION(x) \
1939 CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x)
1941 #define CHECK_PROCESS(x) \
1942 CHECK_TYPE (PROCESSP (x), Qprocessp, x)
1944 #define CHECK_SUBR(x) \
1945 CHECK_TYPE (SUBRP (x), Qsubrp, x)
1947 #define CHECK_NUMBER(x) \
1948 CHECK_TYPE (INTEGERP (x), Qintegerp, x)
1950 #define CHECK_NATNUM(x) \
1951 CHECK_TYPE (NATNUMP (x), Qwholenump, x)
1953 #define CHECK_RANGED_INTEGER(x, lo, hi) \
1954 do { \
1955 CHECK_NUMBER (x); \
1956 if (! ((lo) <= XINT (x) && XINT (x) <= (hi))) \
1957 args_out_of_range_3 \
1958 (x, \
1959 make_number ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM \
1960 ? MOST_NEGATIVE_FIXNUM \
1961 : (lo)), \
1962 make_number (min (hi, MOST_POSITIVE_FIXNUM))); \
1963 } while (0)
1964 #define CHECK_TYPE_RANGED_INTEGER(type, x) \
1965 do { \
1966 if (TYPE_SIGNED (type)) \
1967 CHECK_RANGED_INTEGER (x, TYPE_MINIMUM (type), TYPE_MAXIMUM (type)); \
1968 else \
1969 CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type)); \
1970 } while (0)
1972 #define CHECK_MARKER(x) \
1973 CHECK_TYPE (MARKERP (x), Qmarkerp, x)
1975 #define CHECK_NUMBER_COERCE_MARKER(x) \
1976 do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
1977 else CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); } while (0)
1979 #define XFLOATINT(n) extract_float((n))
1981 #define CHECK_FLOAT(x) \
1982 CHECK_TYPE (FLOATP (x), Qfloatp, x)
1984 #define CHECK_NUMBER_OR_FLOAT(x) \
1985 CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x)
1987 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
1988 do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \
1989 else CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x); } while (0)
1991 #define CHECK_OVERLAY(x) \
1992 CHECK_TYPE (OVERLAYP (x), Qoverlayp, x)
1994 /* Since we can't assign directly to the CAR or CDR fields of a cons
1995 cell, use these when checking that those fields contain numbers. */
1996 #define CHECK_NUMBER_CAR(x) \
1997 do { \
1998 Lisp_Object tmp = XCAR (x); \
1999 CHECK_NUMBER (tmp); \
2000 XSETCAR ((x), tmp); \
2001 } while (0)
2003 #define CHECK_NUMBER_CDR(x) \
2004 do { \
2005 Lisp_Object tmp = XCDR (x); \
2006 CHECK_NUMBER (tmp); \
2007 XSETCDR ((x), tmp); \
2008 } while (0)
2010 #define CHECK_NATNUM_CAR(x) \
2011 do { \
2012 Lisp_Object tmp = XCAR (x); \
2013 CHECK_NATNUM (tmp); \
2014 XSETCAR ((x), tmp); \
2015 } while (0)
2017 #define CHECK_NATNUM_CDR(x) \
2018 do { \
2019 Lisp_Object tmp = XCDR (x); \
2020 CHECK_NATNUM (tmp); \
2021 XSETCDR ((x), tmp); \
2022 } while (0)
2024 /* Define a built-in function for calling from Lisp.
2025 `lname' should be the name to give the function in Lisp,
2026 as a null-terminated C string.
2027 `fnname' should be the name of the function in C.
2028 By convention, it starts with F.
2029 `sname' should be the name for the C constant structure
2030 that records information on this function for internal use.
2031 By convention, it should be the same as `fnname' but with S instead of F.
2032 It's too bad that C macros can't compute this from `fnname'.
2033 `minargs' should be a number, the minimum number of arguments allowed.
2034 `maxargs' should be a number, the maximum number of arguments allowed,
2035 or else MANY or UNEVALLED.
2036 MANY means pass a vector of evaluated arguments,
2037 in the form of an integer number-of-arguments
2038 followed by the address of a vector of Lisp_Objects
2039 which contains the argument values.
2040 UNEVALLED means pass the list of unevaluated arguments
2041 `intspec' says how interactive arguments are to be fetched.
2042 If the string starts with a `(', `intspec' is evaluated and the resulting
2043 list is the list of arguments.
2044 If it's a string that doesn't start with `(', the value should follow
2045 the one of the doc string for `interactive'.
2046 A null string means call interactively with no arguments.
2047 `doc' is documentation for the user. */
2049 /* This version of DEFUN declares a function prototype with the right
2050 arguments, so we can catch errors with maxargs at compile-time. */
2051 #ifdef _MSC_VER
2052 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
2053 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
2054 static struct Lisp_Subr alignas (GCALIGNMENT) sname = \
2055 { { (PVEC_SUBR << PSEUDOVECTOR_AREA_BITS) \
2056 | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)) }, \
2057 { (Lisp_Object (__cdecl *)(void))fnname }, \
2058 minargs, maxargs, lname, intspec, 0}; \
2059 Lisp_Object fnname
2060 #else /* not _MSC_VER */
2061 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
2062 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
2063 static struct Lisp_Subr alignas (GCALIGNMENT) sname = \
2064 { { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS }, \
2065 { .a ## maxargs = fnname }, \
2066 minargs, maxargs, lname, intspec, 0}; \
2067 Lisp_Object fnname
2068 #endif
2070 /* Note that the weird token-substitution semantics of ANSI C makes
2071 this work for MANY and UNEVALLED. */
2072 #define DEFUN_ARGS_MANY (ptrdiff_t, Lisp_Object *)
2073 #define DEFUN_ARGS_UNEVALLED (Lisp_Object)
2074 #define DEFUN_ARGS_0 (void)
2075 #define DEFUN_ARGS_1 (Lisp_Object)
2076 #define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
2077 #define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
2078 #define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
2079 #define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
2080 Lisp_Object)
2081 #define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
2082 Lisp_Object, Lisp_Object)
2083 #define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
2084 Lisp_Object, Lisp_Object, Lisp_Object)
2085 #define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
2086 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
2088 /* Non-zero if OBJ is a Lisp function. */
2089 #define FUNCTIONP(OBJ) functionp(OBJ)
2091 /* defsubr (Sname);
2092 is how we define the symbol for function `name' at start-up time. */
2093 extern void defsubr (struct Lisp_Subr *);
2095 enum maxargs
2097 MANY = -2,
2098 UNEVALLED = -1
2101 extern void defvar_lisp (struct Lisp_Objfwd *, const char *, Lisp_Object *);
2102 extern void defvar_lisp_nopro (struct Lisp_Objfwd *, const char *, Lisp_Object *);
2103 extern void defvar_bool (struct Lisp_Boolfwd *, const char *, bool *);
2104 extern void defvar_int (struct Lisp_Intfwd *, const char *, EMACS_INT *);
2105 extern void defvar_kboard (struct Lisp_Kboard_Objfwd *, const char *, int);
2107 /* Macros we use to define forwarded Lisp variables.
2108 These are used in the syms_of_FILENAME functions.
2110 An ordinary (not in buffer_defaults, per-buffer, or per-keyboard)
2111 lisp variable is actually a field in `struct emacs_globals'. The
2112 field's name begins with "f_", which is a convention enforced by
2113 these macros. Each such global has a corresponding #define in
2114 globals.h; the plain name should be used in the code.
2116 E.g., the global "cons_cells_consed" is declared as "int
2117 f_cons_cells_consed" in globals.h, but there is a define:
2119 #define cons_cells_consed globals.f_cons_cells_consed
2121 All C code uses the `cons_cells_consed' name. This is all done
2122 this way to support indirection for multi-threaded Emacs. */
2124 #define DEFVAR_LISP(lname, vname, doc) \
2125 do { \
2126 static struct Lisp_Objfwd o_fwd; \
2127 defvar_lisp (&o_fwd, lname, &globals.f_ ## vname); \
2128 } while (0)
2129 #define DEFVAR_LISP_NOPRO(lname, vname, doc) \
2130 do { \
2131 static struct Lisp_Objfwd o_fwd; \
2132 defvar_lisp_nopro (&o_fwd, lname, &globals.f_ ## vname); \
2133 } while (0)
2134 #define DEFVAR_BOOL(lname, vname, doc) \
2135 do { \
2136 static struct Lisp_Boolfwd b_fwd; \
2137 defvar_bool (&b_fwd, lname, &globals.f_ ## vname); \
2138 } while (0)
2139 #define DEFVAR_INT(lname, vname, doc) \
2140 do { \
2141 static struct Lisp_Intfwd i_fwd; \
2142 defvar_int (&i_fwd, lname, &globals.f_ ## vname); \
2143 } while (0)
2145 #define DEFVAR_BUFFER_DEFAULTS(lname, vname, doc) \
2146 do { \
2147 static struct Lisp_Objfwd o_fwd; \
2148 defvar_lisp_nopro (&o_fwd, lname, &BVAR (&buffer_defaults, vname)); \
2149 } while (0)
2151 #define DEFVAR_KBOARD(lname, vname, doc) \
2152 do { \
2153 static struct Lisp_Kboard_Objfwd ko_fwd; \
2154 defvar_kboard (&ko_fwd, lname, offsetof (KBOARD, vname ## _)); \
2155 } while (0)
2157 /* Save and restore the instruction and environment pointers,
2158 without affecting the signal mask. */
2160 #ifdef HAVE__SETJMP
2161 typedef jmp_buf sys_jmp_buf;
2162 # define sys_setjmp(j) _setjmp (j)
2163 # define sys_longjmp(j, v) _longjmp (j, v)
2164 #elif defined HAVE_SIGSETJMP
2165 typedef sigjmp_buf sys_jmp_buf;
2166 # define sys_setjmp(j) sigsetjmp (j, 0)
2167 # define sys_longjmp(j, v) siglongjmp (j, v)
2168 #else
2169 /* A platform that uses neither _longjmp nor siglongjmp; assume
2170 longjmp does not affect the sigmask. */
2171 typedef jmp_buf sys_jmp_buf;
2172 # define sys_setjmp(j) setjmp (j)
2173 # define sys_longjmp(j, v) longjmp (j, v)
2174 #endif
2177 /* Structure for recording Lisp call stack for backtrace purposes. */
2179 /* The special binding stack holds the outer values of variables while
2180 they are bound by a function application or a let form, stores the
2181 code to be executed for Lisp unwind-protect forms, and stores the C
2182 functions to be called for record_unwind_protect.
2184 If func is non-zero, undoing this binding applies func to old_value;
2185 This implements record_unwind_protect.
2187 Otherwise, the element is a variable binding.
2189 If the symbol field is a symbol, it is an ordinary variable binding.
2191 Otherwise, it should be a structure (SYMBOL WHERE . CURRENT-BUFFER),
2192 which means having bound a local value while CURRENT-BUFFER was active.
2193 If WHERE is nil this means we saw the default value when binding SYMBOL.
2194 WHERE being a buffer or frame means we saw a buffer-local or frame-local
2195 value. Other values of WHERE mean an internal error. */
2197 typedef Lisp_Object (*specbinding_func) (Lisp_Object);
2199 struct specbinding
2201 Lisp_Object symbol, old_value;
2202 specbinding_func func;
2203 Lisp_Object unused; /* Dividing by 16 is faster than by 12. */
2206 extern struct specbinding *specpdl;
2207 extern struct specbinding *specpdl_ptr;
2208 extern ptrdiff_t specpdl_size;
2210 #define SPECPDL_INDEX() (specpdl_ptr - specpdl)
2212 struct backtrace
2214 struct backtrace *next;
2215 Lisp_Object function;
2216 Lisp_Object *args; /* Points to vector of args. */
2217 ptrdiff_t nargs; /* Length of vector. */
2218 /* Nonzero means call value of debugger when done with this operation. */
2219 unsigned int debug_on_exit : 1;
2222 extern struct backtrace *backtrace_list;
2224 /* Everything needed to describe an active condition case.
2226 Members are volatile if their values need to survive _longjmp when
2227 a 'struct handler' is a local variable. */
2228 struct handler
2230 /* The handler clauses and variable from the condition-case form. */
2231 /* For a handler set up in Lisp code, this is always a list.
2232 For an internal handler set up by internal_condition_case*,
2233 this can instead be the symbol t or `error'.
2234 t: handle all conditions.
2235 error: handle all conditions, and errors can run the debugger
2236 or display a backtrace. */
2237 Lisp_Object handler;
2239 Lisp_Object volatile var;
2241 /* Fsignal stores here the condition-case clause that applies,
2242 and Fcondition_case thus knows which clause to run. */
2243 Lisp_Object volatile chosen_clause;
2245 /* Used to effect the longjump out to the handler. */
2246 struct catchtag *tag;
2248 /* The next enclosing handler. */
2249 struct handler *next;
2252 /* This structure helps implement the `catch' and `throw' control
2253 structure. A struct catchtag contains all the information needed
2254 to restore the state of the interpreter after a non-local jump.
2256 Handlers for error conditions (represented by `struct handler'
2257 structures) just point to a catch tag to do the cleanup required
2258 for their jumps.
2260 catchtag structures are chained together in the C calling stack;
2261 the `next' member points to the next outer catchtag.
2263 A call like (throw TAG VAL) searches for a catchtag whose `tag'
2264 member is TAG, and then unbinds to it. The `val' member is used to
2265 hold VAL while the stack is unwound; `val' is returned as the value
2266 of the catch form.
2268 All the other members are concerned with restoring the interpreter
2269 state.
2271 Members are volatile if their values need to survive _longjmp when
2272 a 'struct catchtag' is a local variable. */
2273 struct catchtag
2275 Lisp_Object tag;
2276 Lisp_Object volatile val;
2277 struct catchtag *volatile next;
2278 struct gcpro *gcpro;
2279 sys_jmp_buf jmp;
2280 struct backtrace *backlist;
2281 struct handler *handlerlist;
2282 EMACS_INT lisp_eval_depth;
2283 ptrdiff_t volatile pdlcount;
2284 int poll_suppress_count;
2285 int interrupt_input_blocked;
2286 struct byte_stack *byte_stack;
2289 extern Lisp_Object memory_signal_data;
2291 /* An address near the bottom of the stack.
2292 Tells GC how to save a copy of the stack. */
2293 extern char *stack_bottom;
2295 /* Check quit-flag and quit if it is non-nil.
2296 Typing C-g does not directly cause a quit; it only sets Vquit_flag.
2297 So the program needs to do QUIT at times when it is safe to quit.
2298 Every loop that might run for a long time or might not exit
2299 ought to do QUIT at least once, at a safe place.
2300 Unless that is impossible, of course.
2301 But it is very desirable to avoid creating loops where QUIT is impossible.
2303 Exception: if you set immediate_quit to nonzero,
2304 then the handler that responds to the C-g does the quit itself.
2305 This is a good thing to do around a loop that has no side effects
2306 and (in particular) cannot call arbitrary Lisp code.
2308 If quit-flag is set to `kill-emacs' the SIGINT handler has received
2309 a request to exit Emacs when it is safe to do. */
2311 extern void process_pending_signals (void);
2312 extern bool volatile pending_signals;
2314 extern void process_quit_flag (void);
2315 #define QUIT \
2316 do { \
2317 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
2318 process_quit_flag (); \
2319 else if (pending_signals) \
2320 process_pending_signals (); \
2321 } while (0)
2324 /* Nonzero if ought to quit now. */
2326 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
2328 extern Lisp_Object Vascii_downcase_table;
2329 extern Lisp_Object Vascii_canon_table;
2331 /* Structure for recording stack slots that need marking. */
2333 /* This is a chain of structures, each of which points at a Lisp_Object
2334 variable whose value should be marked in garbage collection.
2335 Normally every link of the chain is an automatic variable of a function,
2336 and its `val' points to some argument or local variable of the function.
2337 On exit to the function, the chain is set back to the value it had on entry.
2338 This way, no link remains in the chain when the stack frame containing the
2339 link disappears.
2341 Every function that can call Feval must protect in this fashion all
2342 Lisp_Object variables whose contents will be used again. */
2344 extern struct gcpro *gcprolist;
2346 struct gcpro
2348 struct gcpro *next;
2350 /* Address of first protected variable. */
2351 volatile Lisp_Object *var;
2353 /* Number of consecutive protected variables. */
2354 ptrdiff_t nvars;
2356 #ifdef DEBUG_GCPRO
2357 int level;
2358 #endif
2361 /* Values of GC_MARK_STACK during compilation:
2363 0 Use GCPRO as before
2364 1 Do the real thing, make GCPROs and UNGCPRO no-ops.
2365 2 Mark the stack, and check that everything GCPRO'd is
2366 marked.
2367 3 Mark using GCPRO's, mark stack last, and count how many
2368 dead objects are kept alive.
2370 Formerly, method 0 was used. Currently, method 1 is used unless
2371 otherwise specified by hand when building, e.g.,
2372 "make CPPFLAGS='-DGC_MARK_STACK=GC_USE_GCPROS_AS_BEFORE'".
2373 Methods 2 and 3 are present mainly to debug the transition from 0 to 1. */
2375 #define GC_USE_GCPROS_AS_BEFORE 0
2376 #define GC_MAKE_GCPROS_NOOPS 1
2377 #define GC_MARK_STACK_CHECK_GCPROS 2
2378 #define GC_USE_GCPROS_CHECK_ZOMBIES 3
2380 #ifndef GC_MARK_STACK
2381 #define GC_MARK_STACK GC_MAKE_GCPROS_NOOPS
2382 #endif
2384 /* Whether we do the stack marking manually. */
2385 #define BYTE_MARK_STACK !(GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS \
2386 || GC_MARK_STACK == GC_MARK_STACK_CHECK_GCPROS)
2389 #if GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS
2391 /* Do something silly with gcproN vars just so gcc shuts up. */
2392 /* You get warnings from MIPSPro... */
2394 #define GCPRO1(varname) ((void) gcpro1)
2395 #define GCPRO2(varname1, varname2) ((void) gcpro2, (void) gcpro1)
2396 #define GCPRO3(varname1, varname2, varname3) \
2397 ((void) gcpro3, (void) gcpro2, (void) gcpro1)
2398 #define GCPRO4(varname1, varname2, varname3, varname4) \
2399 ((void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1)
2400 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
2401 ((void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1)
2402 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
2403 ((void) gcpro6, (void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, \
2404 (void) gcpro1)
2405 #define UNGCPRO ((void) 0)
2407 #else /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
2409 #ifndef DEBUG_GCPRO
2411 #define GCPRO1(varname) \
2412 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
2413 gcprolist = &gcpro1; }
2415 #define GCPRO2(varname1, varname2) \
2416 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2417 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2418 gcprolist = &gcpro2; }
2420 #define GCPRO3(varname1, varname2, varname3) \
2421 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2422 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2423 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2424 gcprolist = &gcpro3; }
2426 #define GCPRO4(varname1, varname2, varname3, varname4) \
2427 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2428 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2429 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2430 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2431 gcprolist = &gcpro4; }
2433 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
2434 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2435 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2436 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2437 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2438 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
2439 gcprolist = &gcpro5; }
2441 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
2442 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2443 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2444 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2445 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2446 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
2447 gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
2448 gcprolist = &gcpro6; }
2450 #define UNGCPRO (gcprolist = gcpro1.next)
2452 #else
2454 extern int gcpro_level;
2456 #define GCPRO1(varname) \
2457 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
2458 gcpro1.level = gcpro_level++; \
2459 gcprolist = &gcpro1; }
2461 #define GCPRO2(varname1, varname2) \
2462 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2463 gcpro1.level = gcpro_level; \
2464 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2465 gcpro2.level = gcpro_level++; \
2466 gcprolist = &gcpro2; }
2468 #define GCPRO3(varname1, varname2, varname3) \
2469 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2470 gcpro1.level = gcpro_level; \
2471 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2472 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2473 gcpro3.level = gcpro_level++; \
2474 gcprolist = &gcpro3; }
2476 #define GCPRO4(varname1, varname2, varname3, varname4) \
2477 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2478 gcpro1.level = gcpro_level; \
2479 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2480 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2481 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2482 gcpro4.level = gcpro_level++; \
2483 gcprolist = &gcpro4; }
2485 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
2486 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2487 gcpro1.level = gcpro_level; \
2488 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2489 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2490 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2491 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
2492 gcpro5.level = gcpro_level++; \
2493 gcprolist = &gcpro5; }
2495 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
2496 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
2497 gcpro1.level = gcpro_level; \
2498 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
2499 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
2500 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
2501 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
2502 gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
2503 gcpro6.level = gcpro_level++; \
2504 gcprolist = &gcpro6; }
2506 #define UNGCPRO \
2507 ((--gcpro_level != gcpro1.level) \
2508 ? (emacs_abort (), 0) \
2509 : ((gcprolist = gcpro1.next), 0))
2511 #endif /* DEBUG_GCPRO */
2512 #endif /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
2515 /* Evaluate expr, UNGCPRO, and then return the value of expr. */
2516 #define RETURN_UNGCPRO(expr) \
2517 do \
2519 Lisp_Object ret_ungc_val; \
2520 ret_ungc_val = (expr); \
2521 UNGCPRO; \
2522 return ret_ungc_val; \
2524 while (0)
2526 /* Call staticpro (&var) to protect static variable `var'. */
2528 void staticpro (Lisp_Object *);
2530 /* Declare a Lisp-callable function. The MAXARGS parameter has the same
2531 meaning as in the DEFUN macro, and is used to construct a prototype. */
2532 /* We can use the same trick as in the DEFUN macro to generate the
2533 appropriate prototype. */
2534 #define EXFUN(fnname, maxargs) \
2535 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
2537 /* Forward declarations for prototypes. */
2538 struct window;
2539 struct frame;
2541 /* Simple access functions. */
2543 LISP_INLINE Lisp_Object *
2544 aref_addr (Lisp_Object array, ptrdiff_t idx)
2546 return & XVECTOR (array)->contents[idx];
2549 LISP_INLINE void
2550 gc_aset (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
2552 /* Like ASET, but also can be used in the garbage collector:
2553 sweep_weak_table calls set_hash_key etc. while the table is marked. */
2554 eassert (0 <= idx && idx < (ASIZE (array) & ~ARRAY_MARK_FLAG));
2555 XVECTOR (array)->contents[idx] = val;
2558 /* Copy COUNT Lisp_Objects from ARGS to contents of V starting from OFFSET. */
2560 LISP_INLINE void
2561 vcopy (Lisp_Object v, ptrdiff_t offset, Lisp_Object *args, ptrdiff_t count)
2563 eassert (0 <= offset && 0 <= count && offset + count <= ASIZE (v));
2564 memcpy (XVECTOR (v)->contents + offset, args, count * sizeof *args);
2567 /* Functions to modify hash tables. */
2569 LISP_INLINE void
2570 set_hash_key_and_value (struct Lisp_Hash_Table *h, Lisp_Object key_and_value)
2572 h->key_and_value = key_and_value;
2575 LISP_INLINE void
2576 set_hash_key_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)
2578 gc_aset (h->key_and_value, 2 * idx, val);
2581 LISP_INLINE void
2582 set_hash_value_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)
2584 gc_aset (h->key_and_value, 2 * idx + 1, val);
2587 LISP_INLINE void
2588 set_hash_next (struct Lisp_Hash_Table *h, Lisp_Object next)
2590 h->next = next;
2593 LISP_INLINE void
2594 set_hash_next_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)
2596 gc_aset (h->next, idx, val);
2599 LISP_INLINE void
2600 set_hash_hash (struct Lisp_Hash_Table *h, Lisp_Object hash)
2602 h->hash = hash;
2605 LISP_INLINE void
2606 set_hash_hash_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)
2608 gc_aset (h->hash, idx, val);
2611 LISP_INLINE void
2612 set_hash_index (struct Lisp_Hash_Table *h, Lisp_Object index)
2614 h->index = index;
2617 LISP_INLINE void
2618 set_hash_index_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)
2620 gc_aset (h->index, idx, val);
2623 /* Use these functions to set Lisp_Object
2624 or pointer slots of struct Lisp_Symbol. */
2626 LISP_INLINE void
2627 set_symbol_name (Lisp_Object sym, Lisp_Object name)
2629 XSYMBOL (sym)->name = name;
2632 LISP_INLINE void
2633 set_symbol_function (Lisp_Object sym, Lisp_Object function)
2635 XSYMBOL (sym)->function = function;
2638 LISP_INLINE void
2639 set_symbol_plist (Lisp_Object sym, Lisp_Object plist)
2641 XSYMBOL (sym)->plist = plist;
2644 LISP_INLINE void
2645 set_symbol_next (Lisp_Object sym, struct Lisp_Symbol *next)
2647 XSYMBOL (sym)->next = next;
2650 /* Buffer-local (also frame-local) variable access functions. */
2652 LISP_INLINE int
2653 blv_found (struct Lisp_Buffer_Local_Value *blv)
2655 eassert (blv->found == !EQ (blv->defcell, blv->valcell));
2656 return blv->found;
2659 LISP_INLINE void
2660 set_blv_found (struct Lisp_Buffer_Local_Value *blv, int found)
2662 eassert (found == !EQ (blv->defcell, blv->valcell));
2663 blv->found = found;
2666 LISP_INLINE Lisp_Object
2667 blv_value (struct Lisp_Buffer_Local_Value *blv)
2669 return XCDR (blv->valcell);
2672 LISP_INLINE void
2673 set_blv_value (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val)
2675 XSETCDR (blv->valcell, val);
2678 LISP_INLINE void
2679 set_blv_where (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val)
2681 blv->where = val;
2684 LISP_INLINE void
2685 set_blv_defcell (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val)
2687 blv->defcell = val;
2690 LISP_INLINE void
2691 set_blv_valcell (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val)
2693 blv->valcell = val;
2696 /* Set overlay's property list. */
2698 LISP_INLINE void
2699 set_overlay_plist (Lisp_Object overlay, Lisp_Object plist)
2701 XOVERLAY (overlay)->plist = plist;
2704 /* Get text properties of S. */
2706 LISP_INLINE INTERVAL
2707 string_intervals (Lisp_Object s)
2709 return XSTRING (s)->intervals;
2712 /* Set text properties of S to I. */
2714 LISP_INLINE void
2715 set_string_intervals (Lisp_Object s, INTERVAL i)
2717 XSTRING (s)->intervals = i;
2720 /* Set a Lisp slot in TABLE to VAL. Most code should use this instead
2721 of setting slots directly. */
2723 LISP_INLINE void
2724 set_char_table_ascii (Lisp_Object table, Lisp_Object val)
2726 XCHAR_TABLE (table)->ascii = val;
2728 LISP_INLINE void
2729 set_char_table_defalt (Lisp_Object table, Lisp_Object val)
2731 XCHAR_TABLE (table)->defalt = val;
2733 LISP_INLINE void
2734 set_char_table_parent (Lisp_Object table, Lisp_Object val)
2736 XCHAR_TABLE (table)->parent = val;
2738 LISP_INLINE void
2739 set_char_table_purpose (Lisp_Object table, Lisp_Object val)
2741 XCHAR_TABLE (table)->purpose = val;
2744 /* Set different slots in (sub)character tables. */
2746 LISP_INLINE void
2747 set_char_table_extras (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
2749 eassert (0 <= idx && idx < CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (table)));
2750 XCHAR_TABLE (table)->extras[idx] = val;
2753 LISP_INLINE void
2754 set_char_table_contents (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
2756 eassert (0 <= idx && idx < (1 << CHARTAB_SIZE_BITS_0));
2757 XCHAR_TABLE (table)->contents[idx] = val;
2760 LISP_INLINE void
2761 set_sub_char_table_contents (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
2763 XSUB_CHAR_TABLE (table)->contents[idx] = val;
2766 /* Defined in data.c. */
2767 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qunbound;
2768 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
2769 extern Lisp_Object Qerror, Qquit, Qargs_out_of_range;
2770 extern Lisp_Object Qvoid_variable, Qvoid_function;
2771 extern Lisp_Object Qinvalid_read_syntax;
2772 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
2773 extern Lisp_Object Quser_error, Qend_of_file, Qarith_error, Qmark_inactive;
2774 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
2775 extern Lisp_Object Qtext_read_only;
2776 extern Lisp_Object Qinteractive_form;
2777 extern Lisp_Object Qcircular_list;
2778 extern Lisp_Object Qintegerp, Qwholenump, Qsymbolp, Qlistp, Qconsp;
2779 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
2780 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qinteger_or_marker_p, Qvectorp;
2781 extern Lisp_Object Qbuffer_or_string_p;
2782 extern Lisp_Object Qfboundp;
2783 extern Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
2785 extern Lisp_Object Qcdr;
2787 extern Lisp_Object Qrange_error, Qoverflow_error;
2789 extern Lisp_Object Qfloatp;
2790 extern Lisp_Object Qnumberp, Qnumber_or_marker_p;
2792 extern Lisp_Object Qbuffer, Qinteger, Qsymbol;
2794 extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
2796 EXFUN (Fbyteorder, 0) ATTRIBUTE_CONST;
2798 /* Defined in data.c. */
2799 extern Lisp_Object indirect_function (Lisp_Object);
2800 extern Lisp_Object find_symbol_value (Lisp_Object);
2802 /* Convert the integer I to an Emacs representation, either the integer
2803 itself, or a cons of two or three integers, or if all else fails a float.
2804 I should not have side effects. */
2805 #define INTEGER_TO_CONS(i) \
2806 (! FIXNUM_OVERFLOW_P (i) \
2807 ? make_number (i) \
2808 : ! ((FIXNUM_OVERFLOW_P (INTMAX_MIN >> 16) \
2809 || FIXNUM_OVERFLOW_P (UINTMAX_MAX >> 16)) \
2810 && FIXNUM_OVERFLOW_P ((i) >> 16)) \
2811 ? Fcons (make_number ((i) >> 16), make_number ((i) & 0xffff)) \
2812 : ! ((FIXNUM_OVERFLOW_P (INTMAX_MIN >> 16 >> 24) \
2813 || FIXNUM_OVERFLOW_P (UINTMAX_MAX >> 16 >> 24)) \
2814 && FIXNUM_OVERFLOW_P ((i) >> 16 >> 24)) \
2815 ? Fcons (make_number ((i) >> 16 >> 24), \
2816 Fcons (make_number ((i) >> 16 & 0xffffff), \
2817 make_number ((i) & 0xffff))) \
2818 : make_float (i))
2820 /* Convert the Emacs representation CONS back to an integer of type
2821 TYPE, storing the result the variable VAR. Signal an error if CONS
2822 is not a valid representation or is out of range for TYPE. */
2823 #define CONS_TO_INTEGER(cons, type, var) \
2824 (TYPE_SIGNED (type) \
2825 ? ((var) = cons_to_signed (cons, TYPE_MINIMUM (type), TYPE_MAXIMUM (type))) \
2826 : ((var) = cons_to_unsigned (cons, TYPE_MAXIMUM (type))))
2827 extern intmax_t cons_to_signed (Lisp_Object, intmax_t, intmax_t);
2828 extern uintmax_t cons_to_unsigned (Lisp_Object, uintmax_t);
2830 extern struct Lisp_Symbol *indirect_variable (struct Lisp_Symbol *);
2831 extern _Noreturn void args_out_of_range (Lisp_Object, Lisp_Object);
2832 extern _Noreturn void args_out_of_range_3 (Lisp_Object, Lisp_Object,
2833 Lisp_Object);
2834 extern _Noreturn Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object);
2835 extern Lisp_Object do_symval_forwarding (union Lisp_Fwd *);
2836 extern void set_internal (Lisp_Object, Lisp_Object, Lisp_Object, bool);
2837 extern void syms_of_data (void);
2838 extern void swap_in_global_binding (struct Lisp_Symbol *);
2840 /* Defined in cmds.c */
2841 extern void syms_of_cmds (void);
2842 extern void keys_of_cmds (void);
2844 /* Defined in coding.c. */
2845 extern Lisp_Object Qcharset;
2846 extern Lisp_Object detect_coding_system (const unsigned char *, ptrdiff_t,
2847 ptrdiff_t, bool, bool, Lisp_Object);
2848 extern void init_coding (void);
2849 extern void init_coding_once (void);
2850 extern void syms_of_coding (void);
2852 /* Defined in character.c. */
2853 EXFUN (Fmax_char, 0) ATTRIBUTE_CONST;
2854 extern ptrdiff_t chars_in_text (const unsigned char *, ptrdiff_t);
2855 extern ptrdiff_t multibyte_chars_in_text (const unsigned char *, ptrdiff_t);
2856 extern int multibyte_char_to_unibyte (int) ATTRIBUTE_CONST;
2857 extern int multibyte_char_to_unibyte_safe (int) ATTRIBUTE_CONST;
2858 extern void syms_of_character (void);
2860 /* Defined in charset.c. */
2861 extern void init_charset (void);
2862 extern void init_charset_once (void);
2863 extern void syms_of_charset (void);
2864 /* Structure forward declarations. */
2865 struct charset;
2867 /* Defined in composite.c. */
2868 extern void syms_of_composite (void);
2870 /* Defined in syntax.c. */
2871 extern void init_syntax_once (void);
2872 extern void syms_of_syntax (void);
2874 /* Defined in fns.c. */
2875 extern Lisp_Object QCrehash_size, QCrehash_threshold;
2876 enum { NEXT_ALMOST_PRIME_LIMIT = 11 };
2877 EXFUN (Fidentity, 1) ATTRIBUTE_CONST;
2878 extern EMACS_INT next_almost_prime (EMACS_INT) ATTRIBUTE_CONST;
2879 extern Lisp_Object larger_vector (Lisp_Object, ptrdiff_t, ptrdiff_t);
2880 extern void sweep_weak_hash_tables (void);
2881 extern Lisp_Object Qcursor_in_echo_area;
2882 extern Lisp_Object Qstring_lessp;
2883 extern Lisp_Object QCsize, QCtest, QCweakness, Qequal, Qeq;
2884 EMACS_UINT hash_string (char const *, ptrdiff_t);
2885 EMACS_UINT sxhash (Lisp_Object, int);
2886 Lisp_Object make_hash_table (struct hash_table_test, Lisp_Object, Lisp_Object,
2887 Lisp_Object, Lisp_Object);
2888 ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, EMACS_UINT *);
2889 ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
2890 EMACS_UINT);
2891 extern struct hash_table_test hashtest_eql, hashtest_equal;
2893 extern Lisp_Object substring_both (Lisp_Object, ptrdiff_t, ptrdiff_t,
2894 ptrdiff_t, ptrdiff_t);
2895 extern Lisp_Object do_yes_or_no_p (Lisp_Object);
2896 extern Lisp_Object concat2 (Lisp_Object, Lisp_Object);
2897 extern Lisp_Object concat3 (Lisp_Object, Lisp_Object, Lisp_Object);
2898 extern Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
2899 extern Lisp_Object assq_no_quit (Lisp_Object, Lisp_Object);
2900 extern Lisp_Object assoc_no_quit (Lisp_Object, Lisp_Object);
2901 extern void clear_string_char_byte_cache (void);
2902 extern ptrdiff_t string_char_to_byte (Lisp_Object, ptrdiff_t);
2903 extern ptrdiff_t string_byte_to_char (Lisp_Object, ptrdiff_t);
2904 extern Lisp_Object string_to_multibyte (Lisp_Object);
2905 extern Lisp_Object string_make_unibyte (Lisp_Object);
2906 extern void syms_of_fns (void);
2908 /* Defined in floatfns.c. */
2909 extern double extract_float (Lisp_Object);
2910 extern void syms_of_floatfns (void);
2911 extern Lisp_Object fmod_float (Lisp_Object x, Lisp_Object y);
2913 /* Defined in fringe.c. */
2914 extern void syms_of_fringe (void);
2915 extern void init_fringe (void);
2916 #ifdef HAVE_WINDOW_SYSTEM
2917 extern void mark_fringe_data (void);
2918 extern void init_fringe_once (void);
2919 #endif /* HAVE_WINDOW_SYSTEM */
2921 /* Defined in image.c. */
2922 extern Lisp_Object QCascent, QCmargin, QCrelief;
2923 extern Lisp_Object QCconversion;
2924 extern int x_bitmap_mask (struct frame *, ptrdiff_t);
2925 extern void reset_image_types (void);
2926 extern void syms_of_image (void);
2928 /* Defined in insdel.c. */
2929 extern Lisp_Object Qinhibit_modification_hooks;
2930 extern void move_gap_both (ptrdiff_t, ptrdiff_t);
2931 extern _Noreturn void buffer_overflow (void);
2932 extern void make_gap (ptrdiff_t);
2933 extern void make_gap_1 (struct buffer *, ptrdiff_t);
2934 extern ptrdiff_t copy_text (const unsigned char *, unsigned char *,
2935 ptrdiff_t, bool, bool);
2936 extern int count_combining_before (const unsigned char *,
2937 ptrdiff_t, ptrdiff_t, ptrdiff_t);
2938 extern int count_combining_after (const unsigned char *,
2939 ptrdiff_t, ptrdiff_t, ptrdiff_t);
2940 extern void insert (const char *, ptrdiff_t);
2941 extern void insert_and_inherit (const char *, ptrdiff_t);
2942 extern void insert_1_both (const char *, ptrdiff_t, ptrdiff_t,
2943 bool, bool, bool);
2944 extern void insert_from_gap (ptrdiff_t, ptrdiff_t, bool text_at_gap_tail);
2945 extern void insert_from_string (Lisp_Object, ptrdiff_t, ptrdiff_t,
2946 ptrdiff_t, ptrdiff_t, bool);
2947 extern void insert_from_buffer (struct buffer *, ptrdiff_t, ptrdiff_t, bool);
2948 extern void insert_char (int);
2949 extern void insert_string (const char *);
2950 extern void insert_before_markers (const char *, ptrdiff_t);
2951 extern void insert_before_markers_and_inherit (const char *, ptrdiff_t);
2952 extern void insert_from_string_before_markers (Lisp_Object, ptrdiff_t,
2953 ptrdiff_t, ptrdiff_t,
2954 ptrdiff_t, bool);
2955 extern void del_range (ptrdiff_t, ptrdiff_t);
2956 extern Lisp_Object del_range_1 (ptrdiff_t, ptrdiff_t, bool, bool);
2957 extern void del_range_byte (ptrdiff_t, ptrdiff_t, bool);
2958 extern void del_range_both (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, bool);
2959 extern Lisp_Object del_range_2 (ptrdiff_t, ptrdiff_t,
2960 ptrdiff_t, ptrdiff_t, bool);
2961 extern void modify_region_1 (ptrdiff_t, ptrdiff_t, bool);
2962 extern void prepare_to_modify_buffer (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
2963 extern void signal_after_change (ptrdiff_t, ptrdiff_t, ptrdiff_t);
2964 extern void adjust_after_insert (ptrdiff_t, ptrdiff_t, ptrdiff_t,
2965 ptrdiff_t, ptrdiff_t);
2966 extern void adjust_markers_for_delete (ptrdiff_t, ptrdiff_t,
2967 ptrdiff_t, ptrdiff_t);
2968 extern void replace_range (ptrdiff_t, ptrdiff_t, Lisp_Object, bool, bool, bool);
2969 extern void replace_range_2 (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
2970 const char *, ptrdiff_t, ptrdiff_t, bool);
2971 extern void syms_of_insdel (void);
2973 /* Defined in dispnew.c. */
2974 #if (defined PROFILING \
2975 && (defined __FreeBSD__ || defined GNU_LINUX || defined __MINGW32__))
2976 _Noreturn void __executable_start (void);
2977 #endif
2978 extern Lisp_Object selected_frame;
2979 extern Lisp_Object Vwindow_system;
2980 extern Lisp_Object sit_for (Lisp_Object, bool, int);
2981 extern void init_display (void);
2982 extern void syms_of_display (void);
2984 /* Defined in xdisp.c. */
2985 extern Lisp_Object Qinhibit_point_motion_hooks;
2986 extern Lisp_Object Qinhibit_redisplay, Qdisplay;
2987 extern Lisp_Object Qmenu_bar_update_hook;
2988 extern Lisp_Object Qwindow_scroll_functions;
2989 extern Lisp_Object Qoverriding_local_map, Qoverriding_terminal_local_map;
2990 extern Lisp_Object Qimage, Qtext, Qboth, Qboth_horiz, Qtext_image_horiz;
2991 extern Lisp_Object Qspace, Qcenter, QCalign_to;
2992 extern Lisp_Object Qbar, Qhbar, Qbox, Qhollow;
2993 extern Lisp_Object Qleft_margin, Qright_margin;
2994 extern Lisp_Object Qglyphless_char;
2995 extern Lisp_Object QCdata, QCfile;
2996 extern Lisp_Object QCmap;
2997 extern Lisp_Object Qrisky_local_variable;
2998 extern struct frame *last_glyphless_glyph_frame;
2999 extern int last_glyphless_glyph_face_id;
3000 extern int last_glyphless_glyph_merged_face_id;
3001 extern int noninteractive_need_newline;
3002 extern Lisp_Object echo_area_buffer[2];
3003 extern void add_to_log (const char *, Lisp_Object, Lisp_Object);
3004 extern void check_message_stack (void);
3005 extern void setup_echo_area_for_printing (int);
3006 extern bool push_message (void);
3007 extern Lisp_Object pop_message_unwind (Lisp_Object);
3008 extern Lisp_Object restore_message_unwind (Lisp_Object);
3009 extern void restore_message (void);
3010 extern Lisp_Object current_message (void);
3011 extern void clear_message (int, int);
3012 extern void message (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3013 extern void message1 (const char *);
3014 extern void message1_nolog (const char *);
3015 extern void message3 (Lisp_Object);
3016 extern void message3_nolog (Lisp_Object);
3017 extern void message_dolog (const char *, ptrdiff_t, bool, bool);
3018 extern void message_with_string (const char *, Lisp_Object, int);
3019 extern void message_log_maybe_newline (void);
3020 extern void update_echo_area (void);
3021 extern void truncate_echo_area (ptrdiff_t);
3022 extern void redisplay (void);
3023 extern void redisplay_preserve_echo_area (int);
3024 extern void prepare_menu_bars (void);
3026 void set_frame_cursor_types (struct frame *, Lisp_Object);
3027 extern void syms_of_xdisp (void);
3028 extern void init_xdisp (void);
3029 extern Lisp_Object safe_eval (Lisp_Object);
3030 extern int pos_visible_p (struct window *, ptrdiff_t, int *,
3031 int *, int *, int *, int *, int *);
3033 /* Defined in xsettings.c. */
3034 extern void syms_of_xsettings (void);
3036 /* Defined in vm-limit.c. */
3037 extern void memory_warnings (void *, void (*warnfun) (const char *));
3039 /* Defined in alloc.c. */
3040 extern void check_pure_size (void);
3041 extern void free_misc (Lisp_Object);
3042 extern void allocate_string_data (struct Lisp_String *, EMACS_INT, EMACS_INT);
3043 extern void malloc_warning (const char *);
3044 extern _Noreturn void memory_full (size_t);
3045 extern _Noreturn void buffer_memory_full (ptrdiff_t);
3046 extern bool survives_gc_p (Lisp_Object);
3047 extern void mark_object (Lisp_Object);
3048 #if defined REL_ALLOC && !defined SYSTEM_MALLOC
3049 extern void refill_memory_reserve (void);
3050 #endif
3051 extern const char *pending_malloc_warning;
3052 extern Lisp_Object zero_vector;
3053 extern Lisp_Object *stack_base;
3054 extern EMACS_INT consing_since_gc;
3055 extern EMACS_INT gc_relative_threshold;
3056 extern EMACS_INT memory_full_cons_threshold;
3057 extern Lisp_Object list1 (Lisp_Object);
3058 extern Lisp_Object list2 (Lisp_Object, Lisp_Object);
3059 extern Lisp_Object list3 (Lisp_Object, Lisp_Object, Lisp_Object);
3060 extern Lisp_Object list4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
3061 extern Lisp_Object list5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
3062 Lisp_Object);
3063 enum constype {CONSTYPE_HEAP, CONSTYPE_PURE};
3064 extern Lisp_Object listn (enum constype, ptrdiff_t, Lisp_Object, ...);
3066 /* Build a frequently used 2/3/4-integer lists. */
3068 LISP_INLINE Lisp_Object
3069 list2i (EMACS_INT x, EMACS_INT y)
3071 return list2 (make_number (x), make_number (y));
3074 LISP_INLINE Lisp_Object
3075 list3i (EMACS_INT x, EMACS_INT y, EMACS_INT w)
3077 return list3 (make_number (x), make_number (y), make_number (w));
3080 LISP_INLINE Lisp_Object
3081 list4i (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
3083 return list4 (make_number (x), make_number (y),
3084 make_number (w), make_number (h));
3087 extern _Noreturn void string_overflow (void);
3088 extern Lisp_Object make_string (const char *, ptrdiff_t);
3089 extern Lisp_Object make_formatted_string (char *, const char *, ...)
3090 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3091 extern Lisp_Object make_unibyte_string (const char *, ptrdiff_t);
3093 /* Make unibyte string from C string when the length isn't known. */
3095 LISP_INLINE Lisp_Object
3096 build_unibyte_string (const char *str)
3098 return make_unibyte_string (str, strlen (str));
3101 extern Lisp_Object make_multibyte_string (const char *, ptrdiff_t, ptrdiff_t);
3102 extern Lisp_Object make_event_array (int, Lisp_Object *);
3103 extern Lisp_Object make_uninit_string (EMACS_INT);
3104 extern Lisp_Object make_uninit_multibyte_string (EMACS_INT, EMACS_INT);
3105 extern Lisp_Object make_string_from_bytes (const char *, ptrdiff_t, ptrdiff_t);
3106 extern Lisp_Object make_specified_string (const char *,
3107 ptrdiff_t, ptrdiff_t, bool);
3108 extern Lisp_Object make_pure_string (const char *, ptrdiff_t, ptrdiff_t, bool);
3109 extern Lisp_Object make_pure_c_string (const char *, ptrdiff_t);
3111 /* Make a string allocated in pure space, use STR as string data. */
3113 LISP_INLINE Lisp_Object
3114 build_pure_c_string (const char *str)
3116 return make_pure_c_string (str, strlen (str));
3119 /* Make a string from the data at STR, treating it as multibyte if the
3120 data warrants. */
3122 LISP_INLINE Lisp_Object
3123 build_string (const char *str)
3125 return make_string (str, strlen (str));
3128 extern Lisp_Object pure_cons (Lisp_Object, Lisp_Object);
3129 extern void make_byte_code (struct Lisp_Vector *);
3130 extern Lisp_Object Qautomatic_gc;
3131 extern Lisp_Object Qchar_table_extra_slots;
3132 extern struct Lisp_Vector *allocate_vector (EMACS_INT);
3134 /* Make an uninitialized vector for SIZE objects. NOTE: you must
3135 be sure that GC cannot happen until the vector is completely
3136 initialized. E.g. the following code is likely to crash:
3138 v = make_uninit_vector (3);
3139 ASET (v, 0, obj0);
3140 ASET (v, 1, Ffunction_can_gc ());
3141 ASET (v, 2, obj1); */
3143 LISP_INLINE Lisp_Object
3144 make_uninit_vector (ptrdiff_t size)
3146 Lisp_Object v;
3147 struct Lisp_Vector *p;
3149 p = allocate_vector (size);
3150 XSETVECTOR (v, p);
3151 return v;
3154 extern struct Lisp_Vector *allocate_pseudovector (int, int, enum pvec_type);
3155 #define ALLOCATE_PSEUDOVECTOR(typ,field,tag) \
3156 ((typ*) \
3157 allocate_pseudovector \
3158 (VECSIZE (typ), PSEUDOVECSIZE (typ, field), tag))
3159 extern struct Lisp_Hash_Table *allocate_hash_table (void);
3160 extern struct window *allocate_window (void);
3161 extern struct frame *allocate_frame (void);
3162 extern struct Lisp_Process *allocate_process (void);
3163 extern struct terminal *allocate_terminal (void);
3164 extern bool gc_in_progress;
3165 extern bool abort_on_gc;
3166 extern Lisp_Object make_float (double);
3167 extern void display_malloc_warning (void);
3168 extern ptrdiff_t inhibit_garbage_collection (void);
3169 extern Lisp_Object make_save_value (enum Lisp_Save_Type, ...);
3170 extern Lisp_Object make_save_pointer (void *);
3171 extern Lisp_Object build_overlay (Lisp_Object, Lisp_Object, Lisp_Object);
3172 extern void free_marker (Lisp_Object);
3173 extern void free_cons (struct Lisp_Cons *);
3174 extern void init_alloc_once (void);
3175 extern void init_alloc (void);
3176 extern void syms_of_alloc (void);
3177 extern struct buffer * allocate_buffer (void);
3178 extern int valid_lisp_object_p (Lisp_Object);
3179 #ifdef GC_CHECK_CONS_LIST
3180 extern void check_cons_list (void);
3181 #else
3182 #define check_cons_list() ((void) 0)
3183 #endif
3185 #ifdef REL_ALLOC
3186 /* Defined in ralloc.c. */
3187 extern void *r_alloc (void **, size_t);
3188 extern void r_alloc_free (void **);
3189 extern void *r_re_alloc (void **, size_t);
3190 extern void r_alloc_reset_variable (void **, void **);
3191 extern void r_alloc_inhibit_buffer_relocation (int);
3192 #endif
3194 /* Defined in chartab.c. */
3195 extern Lisp_Object copy_char_table (Lisp_Object);
3196 extern Lisp_Object char_table_ref (Lisp_Object, int);
3197 extern Lisp_Object char_table_ref_and_range (Lisp_Object, int,
3198 int *, int *);
3199 extern void char_table_set (Lisp_Object, int, Lisp_Object);
3200 extern void char_table_set_range (Lisp_Object, int, int, Lisp_Object);
3201 extern int char_table_translate (Lisp_Object, int);
3202 extern void map_char_table (void (*) (Lisp_Object, Lisp_Object,
3203 Lisp_Object),
3204 Lisp_Object, Lisp_Object, Lisp_Object);
3205 extern void map_char_table_for_charset (void (*c_function) (Lisp_Object, Lisp_Object),
3206 Lisp_Object, Lisp_Object,
3207 Lisp_Object, struct charset *,
3208 unsigned, unsigned);
3209 extern Lisp_Object uniprop_table (Lisp_Object);
3210 extern void syms_of_chartab (void);
3212 /* Defined in print.c. */
3213 extern Lisp_Object Vprin1_to_string_buffer;
3214 extern void debug_print (Lisp_Object) EXTERNALLY_VISIBLE;
3215 extern Lisp_Object Qstandard_output;
3216 extern Lisp_Object Qexternal_debugging_output;
3217 extern void temp_output_buffer_setup (const char *);
3218 extern int print_level;
3219 extern Lisp_Object Qprint_escape_newlines;
3220 extern void write_string (const char *, int);
3221 extern void print_error_message (Lisp_Object, Lisp_Object, const char *,
3222 Lisp_Object);
3223 extern Lisp_Object internal_with_output_to_temp_buffer
3224 (const char *, Lisp_Object (*) (Lisp_Object), Lisp_Object);
3225 enum FLOAT_TO_STRING_BUFSIZE { FLOAT_TO_STRING_BUFSIZE = 350 };
3226 extern int float_to_string (char *, double);
3227 extern void init_print_once (void);
3228 extern void syms_of_print (void);
3230 /* Defined in doprnt.c. */
3231 extern ptrdiff_t doprnt (char *, ptrdiff_t, const char *, const char *,
3232 va_list);
3233 extern ptrdiff_t esprintf (char *, char const *, ...)
3234 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3235 extern ptrdiff_t exprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3236 char const *, ...)
3237 ATTRIBUTE_FORMAT_PRINTF (5, 6);
3238 extern ptrdiff_t evxprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3239 char const *, va_list)
3240 ATTRIBUTE_FORMAT_PRINTF (5, 0);
3242 /* Defined in lread.c. */
3243 extern Lisp_Object Qvariable_documentation, Qstandard_input;
3244 extern Lisp_Object Qbackquote, Qcomma, Qcomma_at, Qcomma_dot, Qfunction;
3245 extern Lisp_Object Qlexical_binding;
3246 extern Lisp_Object check_obarray (Lisp_Object);
3247 extern Lisp_Object intern_1 (const char *, ptrdiff_t);
3248 extern Lisp_Object intern_c_string_1 (const char *, ptrdiff_t);
3249 extern Lisp_Object oblookup (Lisp_Object, const char *, ptrdiff_t, ptrdiff_t);
3250 #define LOADHIST_ATTACH(x) \
3251 do { \
3252 if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list); \
3253 } while (0)
3254 extern int openp (Lisp_Object, Lisp_Object, Lisp_Object,
3255 Lisp_Object *, Lisp_Object);
3256 extern Lisp_Object string_to_number (char const *, int, bool);
3257 extern void map_obarray (Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
3258 Lisp_Object);
3259 extern void dir_warning (const char *, Lisp_Object);
3260 extern void close_load_descs (void);
3261 extern void init_obarray (void);
3262 extern void init_lread (void);
3263 extern void syms_of_lread (void);
3265 LISP_INLINE Lisp_Object
3266 intern (const char *str)
3268 return intern_1 (str, strlen (str));
3271 LISP_INLINE Lisp_Object
3272 intern_c_string (const char *str)
3274 return intern_c_string_1 (str, strlen (str));
3277 /* Defined in eval.c. */
3278 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qmacro;
3279 extern Lisp_Object Qinhibit_quit, Qinternal_interpreter_environment, Qclosure;
3280 extern Lisp_Object Qand_rest;
3281 extern Lisp_Object Vautoload_queue;
3282 extern Lisp_Object Vsignaling_function;
3283 extern Lisp_Object inhibit_lisp_code;
3284 #if BYTE_MARK_STACK
3285 extern struct catchtag *catchlist;
3286 extern struct handler *handlerlist;
3287 #endif
3288 /* To run a normal hook, use the appropriate function from the list below.
3289 The calling convention:
3291 if (!NILP (Vrun_hooks))
3292 call1 (Vrun_hooks, Qmy_funny_hook);
3294 should no longer be used. */
3295 extern Lisp_Object Vrun_hooks;
3296 extern void run_hook_with_args_2 (Lisp_Object, Lisp_Object, Lisp_Object);
3297 extern Lisp_Object run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args,
3298 Lisp_Object (*funcall)
3299 (ptrdiff_t nargs, Lisp_Object *args));
3300 extern _Noreturn void xsignal (Lisp_Object, Lisp_Object);
3301 extern _Noreturn void xsignal0 (Lisp_Object);
3302 extern _Noreturn void xsignal1 (Lisp_Object, Lisp_Object);
3303 extern _Noreturn void xsignal2 (Lisp_Object, Lisp_Object, Lisp_Object);
3304 extern _Noreturn void xsignal3 (Lisp_Object, Lisp_Object, Lisp_Object,
3305 Lisp_Object);
3306 extern _Noreturn void signal_error (const char *, Lisp_Object);
3307 extern Lisp_Object eval_sub (Lisp_Object form);
3308 extern Lisp_Object apply1 (Lisp_Object, Lisp_Object);
3309 extern Lisp_Object call0 (Lisp_Object);
3310 extern Lisp_Object call1 (Lisp_Object, Lisp_Object);
3311 extern Lisp_Object call2 (Lisp_Object, Lisp_Object, Lisp_Object);
3312 extern Lisp_Object call3 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
3313 extern Lisp_Object call4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
3314 extern Lisp_Object call5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
3315 extern Lisp_Object call6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
3316 extern Lisp_Object call7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
3317 extern Lisp_Object internal_catch (Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object);
3318 extern Lisp_Object internal_lisp_condition_case (Lisp_Object, Lisp_Object, Lisp_Object);
3319 extern Lisp_Object internal_condition_case (Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object));
3320 extern Lisp_Object internal_condition_case_1 (Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object));
3321 extern Lisp_Object internal_condition_case_2 (Lisp_Object (*) (Lisp_Object, Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object));
3322 extern Lisp_Object internal_condition_case_n
3323 (Lisp_Object (*) (ptrdiff_t, Lisp_Object *), ptrdiff_t, Lisp_Object *,
3324 Lisp_Object, Lisp_Object (*) (Lisp_Object, ptrdiff_t, Lisp_Object *));
3325 extern void specbind (Lisp_Object, Lisp_Object);
3326 extern void record_unwind_protect (Lisp_Object (*) (Lisp_Object), Lisp_Object);
3327 extern Lisp_Object unbind_to (ptrdiff_t, Lisp_Object);
3328 extern _Noreturn void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3329 extern _Noreturn void verror (const char *, va_list)
3330 ATTRIBUTE_FORMAT_PRINTF (1, 0);
3331 extern Lisp_Object un_autoload (Lisp_Object);
3332 extern Lisp_Object call_debugger (Lisp_Object arg);
3333 extern void init_eval_once (void);
3334 extern Lisp_Object safe_call (ptrdiff_t, Lisp_Object, ...);
3335 extern Lisp_Object safe_call1 (Lisp_Object, Lisp_Object);
3336 extern Lisp_Object safe_call2 (Lisp_Object, Lisp_Object, Lisp_Object);
3337 extern void init_eval (void);
3338 #if BYTE_MARK_STACK
3339 extern void mark_backtrace (void);
3340 #endif
3341 extern void syms_of_eval (void);
3343 /* Defined in editfns.c. */
3344 extern Lisp_Object Qfield;
3345 extern void insert1 (Lisp_Object);
3346 extern Lisp_Object format2 (const char *, Lisp_Object, Lisp_Object);
3347 extern Lisp_Object save_excursion_save (void);
3348 extern Lisp_Object save_restriction_save (void);
3349 extern Lisp_Object save_excursion_restore (Lisp_Object);
3350 extern Lisp_Object save_restriction_restore (Lisp_Object);
3351 extern _Noreturn void time_overflow (void);
3352 extern Lisp_Object make_buffer_string (ptrdiff_t, ptrdiff_t, bool);
3353 extern Lisp_Object make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3354 ptrdiff_t, bool);
3355 extern void init_editfns (void);
3356 extern void syms_of_editfns (void);
3357 extern void set_time_zone_rule (const char *);
3359 /* Defined in buffer.c. */
3360 extern bool mouse_face_overlay_overlaps (Lisp_Object);
3361 extern _Noreturn void nsberror (Lisp_Object);
3362 extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
3363 extern void adjust_overlays_for_delete (ptrdiff_t, ptrdiff_t);
3364 extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
3365 extern void report_overlay_modification (Lisp_Object, Lisp_Object, bool,
3366 Lisp_Object, Lisp_Object, Lisp_Object);
3367 extern bool overlay_touches_p (ptrdiff_t);
3368 extern Lisp_Object Vbuffer_alist;
3369 extern Lisp_Object set_buffer_if_live (Lisp_Object);
3370 extern Lisp_Object other_buffer_safely (Lisp_Object);
3371 extern Lisp_Object Qpriority, Qwindow, Qbefore_string, Qafter_string;
3372 extern Lisp_Object get_truename_buffer (Lisp_Object);
3373 extern void init_buffer_once (void);
3374 extern void init_buffer (void);
3375 extern void syms_of_buffer (void);
3376 extern void keys_of_buffer (void);
3378 /* Defined in marker.c. */
3380 extern ptrdiff_t marker_position (Lisp_Object);
3381 extern ptrdiff_t marker_byte_position (Lisp_Object);
3382 extern void clear_charpos_cache (struct buffer *);
3383 extern ptrdiff_t buf_charpos_to_bytepos (struct buffer *, ptrdiff_t);
3384 extern ptrdiff_t buf_bytepos_to_charpos (struct buffer *, ptrdiff_t);
3385 extern void unchain_marker (struct Lisp_Marker *marker);
3386 extern Lisp_Object set_marker_restricted (Lisp_Object, Lisp_Object, Lisp_Object);
3387 extern Lisp_Object set_marker_both (Lisp_Object, Lisp_Object, ptrdiff_t, ptrdiff_t);
3388 extern Lisp_Object set_marker_restricted_both (Lisp_Object, Lisp_Object,
3389 ptrdiff_t, ptrdiff_t);
3390 extern Lisp_Object build_marker (struct buffer *, ptrdiff_t, ptrdiff_t);
3391 extern void syms_of_marker (void);
3393 /* Defined in fileio.c. */
3395 extern Lisp_Object Qfile_error;
3396 extern Lisp_Object Qfile_exists_p;
3397 extern Lisp_Object Qfile_directory_p;
3398 extern Lisp_Object Qinsert_file_contents;
3399 extern Lisp_Object Qfile_name_history;
3400 extern Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object);
3401 EXFUN (Fread_file_name, 6); /* Not a normal DEFUN. */
3402 extern Lisp_Object close_file_unwind (Lisp_Object);
3403 extern Lisp_Object restore_point_unwind (Lisp_Object);
3404 extern _Noreturn void report_file_error (const char *, Lisp_Object);
3405 extern bool internal_delete_file (Lisp_Object);
3406 extern Lisp_Object emacs_readlinkat (int, const char *);
3407 extern bool file_directory_p (const char *);
3408 extern bool file_accessible_directory_p (const char *);
3409 extern void init_fileio (void);
3410 extern void syms_of_fileio (void);
3411 extern Lisp_Object make_temp_name (Lisp_Object, bool);
3412 extern Lisp_Object Qdelete_file;
3413 extern bool check_existing (const char *);
3415 /* Defined in search.c. */
3416 extern void shrink_regexp_cache (void);
3417 extern void restore_search_regs (void);
3418 extern void record_unwind_save_match_data (void);
3419 struct re_registers;
3420 extern struct re_pattern_buffer *compile_pattern (Lisp_Object,
3421 struct re_registers *,
3422 Lisp_Object, bool, bool);
3423 extern ptrdiff_t fast_string_match (Lisp_Object, Lisp_Object);
3424 extern ptrdiff_t fast_c_string_match_ignore_case (Lisp_Object, const char *,
3425 ptrdiff_t);
3426 extern ptrdiff_t fast_string_match_ignore_case (Lisp_Object, Lisp_Object);
3427 extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t,
3428 ptrdiff_t, ptrdiff_t, Lisp_Object);
3429 extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
3430 ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
3431 extern EMACS_INT scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
3432 EMACS_INT, bool);
3433 extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t,
3434 ptrdiff_t, ptrdiff_t *);
3435 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
3436 ptrdiff_t, ptrdiff_t *);
3437 extern void syms_of_search (void);
3438 extern void clear_regexp_cache (void);
3440 /* Defined in minibuf.c. */
3442 extern Lisp_Object Qcompletion_ignore_case;
3443 extern Lisp_Object Vminibuffer_list;
3444 extern Lisp_Object last_minibuf_string;
3445 extern Lisp_Object get_minibuffer (EMACS_INT);
3446 extern void init_minibuf_once (void);
3447 extern void syms_of_minibuf (void);
3449 /* Defined in callint.c. */
3451 extern Lisp_Object Qminus, Qplus;
3452 extern Lisp_Object Qwhen;
3453 extern Lisp_Object Qmouse_leave_buffer_hook;
3454 extern void syms_of_callint (void);
3456 /* Defined in casefiddle.c. */
3458 extern Lisp_Object Qidentity;
3459 extern void syms_of_casefiddle (void);
3460 extern void keys_of_casefiddle (void);
3462 /* Defined in casetab.c. */
3464 extern void init_casetab_once (void);
3465 extern void syms_of_casetab (void);
3467 /* Defined in keyboard.c. */
3469 extern Lisp_Object echo_message_buffer;
3470 extern struct kboard *echo_kboard;
3471 extern void cancel_echoing (void);
3472 extern Lisp_Object Qdisabled, QCfilter;
3473 extern Lisp_Object Qup, Qdown, Qbottom;
3474 extern Lisp_Object Qtop;
3475 extern Lisp_Object last_undo_boundary;
3476 extern bool input_pending;
3477 extern Lisp_Object menu_bar_items (Lisp_Object);
3478 extern Lisp_Object tool_bar_items (Lisp_Object, int *);
3479 extern void discard_mouse_events (void);
3480 #ifdef USABLE_SIGIO
3481 void handle_input_available_signal (int);
3482 #endif
3483 extern Lisp_Object pending_funcalls;
3484 extern bool detect_input_pending (void);
3485 extern bool detect_input_pending_ignore_squeezables (void);
3486 extern bool detect_input_pending_run_timers (bool);
3487 extern void safe_run_hooks (Lisp_Object);
3488 extern void cmd_error_internal (Lisp_Object, const char *);
3489 extern Lisp_Object command_loop_1 (void);
3490 extern Lisp_Object recursive_edit_1 (void);
3491 extern void record_auto_save (void);
3492 extern void force_auto_save_soon (void);
3493 extern void init_keyboard (void);
3494 extern void syms_of_keyboard (void);
3495 extern void keys_of_keyboard (void);
3497 /* Defined in indent.c. */
3498 extern ptrdiff_t current_column (void);
3499 extern void invalidate_current_column (void);
3500 extern bool indented_beyond_p (ptrdiff_t, ptrdiff_t, EMACS_INT);
3501 extern void syms_of_indent (void);
3503 /* Defined in frame.c. */
3504 extern Lisp_Object Qonly, Qnone;
3505 extern Lisp_Object Qvisible;
3506 extern void store_frame_param (struct frame *, Lisp_Object, Lisp_Object);
3507 extern void store_in_alist (Lisp_Object *, Lisp_Object, Lisp_Object);
3508 extern Lisp_Object do_switch_frame (Lisp_Object, int, int, Lisp_Object);
3509 #if HAVE_NS || defined(WINDOWSNT)
3510 extern Lisp_Object get_frame_param (struct frame *, Lisp_Object);
3511 #endif
3512 extern void frames_discard_buffer (Lisp_Object);
3513 extern void syms_of_frame (void);
3515 /* Defined in emacs.c. */
3516 extern char **initial_argv;
3517 extern int initial_argc;
3518 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS)
3519 extern bool display_arg;
3520 #endif
3521 extern Lisp_Object decode_env_path (const char *, const char *);
3522 extern Lisp_Object empty_unibyte_string, empty_multibyte_string;
3523 extern Lisp_Object Qfile_name_handler_alist;
3524 extern _Noreturn void terminate_due_to_signal (int, int);
3525 extern Lisp_Object Qkill_emacs;
3526 #ifdef WINDOWSNT
3527 extern Lisp_Object Vlibrary_cache;
3528 #endif
3529 #if HAVE_SETLOCALE
3530 void fixup_locale (void);
3531 void synchronize_system_messages_locale (void);
3532 void synchronize_system_time_locale (void);
3533 #else
3534 #define setlocale(category, locale)
3535 #define fixup_locale()
3536 #define synchronize_system_messages_locale()
3537 #define synchronize_system_time_locale()
3538 #endif
3539 extern void shut_down_emacs (int, Lisp_Object);
3541 /* True means don't do interactive redisplay and don't change tty modes. */
3542 extern bool noninteractive;
3544 /* True means remove site-lisp directories from load-path. */
3545 extern bool no_site_lisp;
3547 /* Pipe used to send exit notification to the daemon parent at
3548 startup. */
3549 extern int daemon_pipe[2];
3550 #define IS_DAEMON (daemon_pipe[1] != 0)
3552 /* True if handling a fatal error already. */
3553 extern bool fatal_error_in_progress;
3555 /* True means don't do use window-system-specific display code. */
3556 extern bool inhibit_window_system;
3557 /* True means that a filter or a sentinel is running. */
3558 extern bool running_asynch_code;
3560 /* Defined in process.c. */
3561 extern Lisp_Object QCtype, Qlocal;
3562 extern Lisp_Object Qprocessp;
3563 extern void kill_buffer_processes (Lisp_Object);
3564 extern bool wait_reading_process_output (intmax_t, int, int, bool,
3565 Lisp_Object,
3566 struct Lisp_Process *,
3567 int);
3568 /* Max value for the first argument of wait_reading_process_output. */
3569 #if __GNUC__ == 3 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 5)
3570 /* Work around a bug in GCC 3.4.2, known to be fixed in GCC 4.6.3.
3571 The bug merely causes a bogus warning, but the warning is annoying. */
3572 # define WAIT_READING_MAX min (TYPE_MAXIMUM (time_t), INTMAX_MAX)
3573 #else
3574 # define WAIT_READING_MAX INTMAX_MAX
3575 #endif
3576 extern void add_keyboard_wait_descriptor (int);
3577 extern void delete_keyboard_wait_descriptor (int);
3578 #ifdef HAVE_GPM
3579 extern void add_gpm_wait_descriptor (int);
3580 extern void delete_gpm_wait_descriptor (int);
3581 #endif
3582 extern void close_process_descs (void);
3583 extern void init_process_emacs (void);
3584 extern void syms_of_process (void);
3585 extern void setup_process_coding_systems (Lisp_Object);
3587 #ifndef DOS_NT
3588 _Noreturn
3589 #endif
3590 extern int child_setup (int, int, int, char **, bool, Lisp_Object);
3591 extern void init_callproc_1 (void);
3592 extern void init_callproc (void);
3593 extern void set_initial_environment (void);
3594 extern void syms_of_callproc (void);
3596 /* Defined in doc.c. */
3597 extern Lisp_Object Qfunction_documentation;
3598 extern Lisp_Object read_doc_string (Lisp_Object);
3599 extern Lisp_Object get_doc_string (Lisp_Object, bool, bool);
3600 extern void syms_of_doc (void);
3601 extern int read_bytecode_char (bool);
3603 /* Defined in bytecode.c. */
3604 extern void syms_of_bytecode (void);
3605 extern struct byte_stack *byte_stack_list;
3606 #if BYTE_MARK_STACK
3607 extern void mark_byte_stack (void);
3608 #endif
3609 extern void unmark_byte_stack (void);
3610 extern Lisp_Object exec_byte_code (Lisp_Object, Lisp_Object, Lisp_Object,
3611 Lisp_Object, ptrdiff_t, Lisp_Object *);
3613 /* Defined in macros.c. */
3614 extern void init_macros (void);
3615 extern void syms_of_macros (void);
3617 /* Defined in undo.c. */
3618 extern Lisp_Object Qapply;
3619 extern Lisp_Object Qinhibit_read_only;
3620 extern void truncate_undo_list (struct buffer *);
3621 extern void record_marker_adjustment (Lisp_Object, ptrdiff_t);
3622 extern void record_insert (ptrdiff_t, ptrdiff_t);
3623 extern void record_delete (ptrdiff_t, Lisp_Object);
3624 extern void record_first_change (void);
3625 extern void record_change (ptrdiff_t, ptrdiff_t);
3626 extern void record_property_change (ptrdiff_t, ptrdiff_t,
3627 Lisp_Object, Lisp_Object,
3628 Lisp_Object);
3629 extern void syms_of_undo (void);
3630 /* Defined in textprop.c. */
3631 extern Lisp_Object Qfont, Qmouse_face;
3632 extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
3633 extern Lisp_Object Qfront_sticky, Qrear_nonsticky;
3634 extern Lisp_Object Qminibuffer_prompt;
3636 extern void report_interval_modification (Lisp_Object, Lisp_Object);
3638 /* Defined in menu.c. */
3639 extern void syms_of_menu (void);
3641 /* Defined in xmenu.c. */
3642 extern void syms_of_xmenu (void);
3644 /* Defined in termchar.h. */
3645 struct tty_display_info;
3647 /* Defined in termhooks.h. */
3648 struct terminal;
3650 /* Defined in sysdep.c. */
3651 #ifndef HAVE_GET_CURRENT_DIR_NAME
3652 extern char *get_current_dir_name (void);
3653 #endif
3654 extern void stuff_char (char c);
3655 extern void init_foreground_group (void);
3656 extern void init_sigio (int);
3657 extern void sys_subshell (void);
3658 extern void sys_suspend (void);
3659 extern void discard_tty_input (void);
3660 extern void block_tty_out_signal (void);
3661 extern void unblock_tty_out_signal (void);
3662 extern void init_sys_modes (struct tty_display_info *);
3663 extern void reset_sys_modes (struct tty_display_info *);
3664 extern void init_all_sys_modes (void);
3665 extern void reset_all_sys_modes (void);
3666 extern void flush_pending_output (int) ATTRIBUTE_CONST;
3667 extern void child_setup_tty (int);
3668 extern void setup_pty (int);
3669 extern int set_window_size (int, int, int);
3670 extern EMACS_INT get_random (void);
3671 extern void seed_random (void *, ptrdiff_t);
3672 extern void init_random (void);
3673 extern void emacs_backtrace (int);
3674 extern _Noreturn void emacs_abort (void) NO_INLINE;
3675 extern int emacs_open (const char *, int, int);
3676 extern int emacs_close (int);
3677 extern ptrdiff_t emacs_read (int, char *, ptrdiff_t);
3678 extern ptrdiff_t emacs_write (int, const char *, ptrdiff_t);
3680 extern void unlock_all_files (void);
3681 extern void lock_file (Lisp_Object);
3682 extern void unlock_file (Lisp_Object);
3683 extern void unlock_buffer (struct buffer *);
3684 extern void syms_of_filelock (void);
3686 /* Defined in sound.c. */
3687 extern void syms_of_sound (void);
3689 /* Defined in category.c. */
3690 extern void init_category_once (void);
3691 extern Lisp_Object char_category_set (int);
3692 extern void syms_of_category (void);
3694 /* Defined in ccl.c. */
3695 extern void syms_of_ccl (void);
3697 /* Defined in dired.c. */
3698 extern void syms_of_dired (void);
3699 extern Lisp_Object directory_files_internal (Lisp_Object, Lisp_Object,
3700 Lisp_Object, Lisp_Object,
3701 bool, Lisp_Object);
3703 /* Defined in term.c. */
3704 extern int *char_ins_del_vector;
3705 extern void syms_of_term (void);
3706 extern _Noreturn void fatal (const char *msgid, ...)
3707 ATTRIBUTE_FORMAT_PRINTF (1, 2);
3709 /* Defined in terminal.c. */
3710 extern void syms_of_terminal (void);
3712 /* Defined in font.c. */
3713 extern void syms_of_font (void);
3714 extern void init_font (void);
3716 #ifdef HAVE_WINDOW_SYSTEM
3717 /* Defined in fontset.c. */
3718 extern void syms_of_fontset (void);
3720 /* Defined in xfns.c, w32fns.c, or macfns.c. */
3721 extern Lisp_Object Qfont_param;
3722 #endif
3724 #ifdef WINDOWSNT
3725 /* Defined on w32notify.c. */
3726 extern void syms_of_w32notify (void);
3727 #endif
3729 /* Defined in inotify.c */
3730 #ifdef HAVE_INOTIFY
3731 extern void syms_of_inotify (void);
3732 #endif
3734 /* Defined in xfaces.c. */
3735 extern Lisp_Object Qdefault, Qtool_bar, Qfringe;
3736 extern Lisp_Object Qheader_line, Qscroll_bar, Qcursor;
3737 extern Lisp_Object Qmode_line_inactive;
3738 extern Lisp_Object Qface;
3739 extern Lisp_Object Qnormal;
3740 extern Lisp_Object QCfamily, QCweight, QCslant;
3741 extern Lisp_Object QCheight, QCname, QCwidth, QCforeground, QCbackground;
3742 extern Lisp_Object Qextra_light, Qlight, Qsemi_light, Qsemi_bold;
3743 extern Lisp_Object Qbold, Qextra_bold, Qultra_bold;
3744 extern Lisp_Object Qoblique, Qitalic;
3745 extern Lisp_Object Vface_alternative_font_family_alist;
3746 extern Lisp_Object Vface_alternative_font_registry_alist;
3747 extern void syms_of_xfaces (void);
3749 #ifdef HAVE_X_WINDOWS
3750 /* Defined in xfns.c. */
3751 extern void syms_of_xfns (void);
3753 /* Defined in xsmfns.c. */
3754 extern void syms_of_xsmfns (void);
3756 /* Defined in xselect.c. */
3757 extern void syms_of_xselect (void);
3759 /* Defined in xterm.c. */
3760 extern void syms_of_xterm (void);
3761 #endif /* HAVE_X_WINDOWS */
3763 #ifdef HAVE_WINDOW_SYSTEM
3764 /* Defined in xterm.c, nsterm.m, w32term.c. */
3765 extern char *x_get_keysym_name (int);
3766 #endif /* HAVE_WINDOW_SYSTEM */
3768 #ifdef HAVE_LIBXML2
3769 /* Defined in xml.c. */
3770 extern void syms_of_xml (void);
3771 extern void xml_cleanup_parser (void);
3772 #endif
3774 #ifdef HAVE_DBUS
3775 /* Defined in dbusbind.c. */
3776 void syms_of_dbusbind (void);
3777 #endif
3780 /* Defined in profiler.c. */
3781 extern bool profiler_memory_running;
3782 extern void malloc_probe (size_t);
3783 extern void syms_of_profiler (void);
3786 #ifdef DOS_NT
3787 /* Defined in msdos.c, w32.c. */
3788 extern char *emacs_root_dir (void);
3789 #endif /* DOS_NT */
3791 /* True means Emacs has already been initialized.
3792 Used during startup to detect startup of dumped Emacs. */
3793 extern bool initialized;
3795 /* True means ^G can quit instantly. */
3796 extern bool immediate_quit;
3798 extern void *xmalloc (size_t);
3799 extern void *xzalloc (size_t);
3800 extern void *xrealloc (void *, size_t);
3801 extern void xfree (void *);
3802 extern void *xnmalloc (ptrdiff_t, ptrdiff_t);
3803 extern void *xnrealloc (void *, ptrdiff_t, ptrdiff_t);
3804 extern void *xpalloc (void *, ptrdiff_t *, ptrdiff_t, ptrdiff_t, ptrdiff_t);
3806 extern char *xstrdup (const char *);
3807 extern void xputenv (const char *);
3809 extern char *egetenv (const char *);
3811 /* Set up the name of the machine we're running on. */
3812 extern void init_system_name (void);
3814 /* Return the absolute value of X. X should be a signed integer
3815 expression without side effects, and X's absolute value should not
3816 exceed the maximum for its promoted type. This is called 'eabs'
3817 because 'abs' is reserved by the C standard. */
3818 #define eabs(x) ((x) < 0 ? -(x) : (x))
3820 /* Return a fixnum or float, depending on whether VAL fits in a Lisp
3821 fixnum. */
3823 #define make_fixnum_or_float(val) \
3824 (FIXNUM_OVERFLOW_P (val) ? make_float (val) : make_number (val))
3826 /* SAFE_ALLOCA normally allocates memory on the stack, but if size is
3827 larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack. */
3829 enum MAX_ALLOCA { MAX_ALLOCA = 16 * 1024 };
3831 extern Lisp_Object safe_alloca_unwind (Lisp_Object);
3832 extern void *record_xmalloc (size_t);
3834 #define USE_SAFE_ALLOCA \
3835 ptrdiff_t sa_count = SPECPDL_INDEX (); bool sa_must_free = 0
3837 /* SAFE_ALLOCA allocates a simple buffer. */
3839 #define SAFE_ALLOCA(size) ((size) < MAX_ALLOCA \
3840 ? alloca (size) \
3841 : (sa_must_free = 1, record_xmalloc (size)))
3843 /* SAFE_NALLOCA sets BUF to a newly allocated array of MULTIPLIER *
3844 NITEMS items, each of the same type as *BUF. MULTIPLIER must
3845 positive. The code is tuned for MULTIPLIER being a constant. */
3847 #define SAFE_NALLOCA(buf, multiplier, nitems) \
3848 do { \
3849 if ((nitems) <= MAX_ALLOCA / sizeof *(buf) / (multiplier)) \
3850 (buf) = alloca (sizeof *(buf) * (multiplier) * (nitems)); \
3851 else \
3853 (buf) = xnmalloc (nitems, sizeof *(buf) * (multiplier)); \
3854 sa_must_free = 1; \
3855 record_unwind_protect (safe_alloca_unwind, \
3856 make_save_pointer (buf)); \
3858 } while (0)
3860 /* SAFE_FREE frees xmalloced memory and enables GC as needed. */
3862 #define SAFE_FREE() \
3863 do { \
3864 if (sa_must_free) { \
3865 sa_must_free = 0; \
3866 unbind_to (sa_count, Qnil); \
3868 } while (0)
3871 /* SAFE_ALLOCA_LISP allocates an array of Lisp_Objects. */
3873 #define SAFE_ALLOCA_LISP(buf, nelt) \
3874 do { \
3875 if ((nelt) < MAX_ALLOCA / word_size) \
3876 buf = alloca ((nelt) * word_size); \
3877 else if ((nelt) < min (PTRDIFF_MAX, SIZE_MAX) / word_size) \
3879 Lisp_Object arg_; \
3880 buf = xmalloc ((nelt) * word_size); \
3881 arg_ = make_save_value (SAVE_TYPE_MEMORY, buf, nelt); \
3882 sa_must_free = 1; \
3883 record_unwind_protect (safe_alloca_unwind, arg_); \
3885 else \
3886 memory_full (SIZE_MAX); \
3887 } while (0)
3890 #include "globals.h"
3892 /* Check whether it's time for GC, and run it if so. */
3894 LISP_INLINE void
3895 maybe_gc (void)
3897 if ((consing_since_gc > gc_cons_threshold
3898 && consing_since_gc > gc_relative_threshold)
3899 || (!NILP (Vmemory_full)
3900 && consing_since_gc > memory_full_cons_threshold))
3901 Fgarbage_collect ();
3904 LISP_INLINE int
3905 functionp (Lisp_Object object)
3907 if (SYMBOLP (object) && !NILP (Ffboundp (object)))
3909 object = Findirect_function (object, Qt);
3911 if (CONSP (object) && EQ (XCAR (object), Qautoload))
3913 /* Autoloaded symbols are functions, except if they load
3914 macros or keymaps. */
3915 int i;
3916 for (i = 0; i < 4 && CONSP (object); i++)
3917 object = XCDR (object);
3919 return ! (CONSP (object) && !NILP (XCAR (object)));
3923 if (SUBRP (object))
3924 return XSUBR (object)->max_args != UNEVALLED;
3925 else if (COMPILEDP (object))
3926 return 1;
3927 else if (CONSP (object))
3929 Lisp_Object car = XCAR (object);
3930 return EQ (car, Qlambda) || EQ (car, Qclosure);
3932 else
3933 return 0;
3936 INLINE_HEADER_END
3938 #endif /* EMACS_LISP_H */