1 /* Fundamental definitions for GNU Emacs Lisp interpreter. -*- coding: utf-8 -*-
3 Copyright (C) 1985-1987, 1993-1995, 1997-2018 Free Software Foundation,
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 (at
11 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 <https://www.gnu.org/licenses/>. */
39 /* Define a TYPE constant ID as an externally visible name. Use like this:
41 DEFINE_GDB_SYMBOL_BEGIN (TYPE, ID)
42 # define ID (some integer preprocessor expression of type TYPE)
43 DEFINE_GDB_SYMBOL_END (ID)
45 This hack is for the benefit of compilers that do not make macro
46 definitions or enums visible to the debugger. It's used for symbols
47 that .gdbinit needs. */
49 #define DECLARE_GDB_SYM(type, id) type const id EXTERNALLY_VISIBLE
51 # define DEFINE_GDB_SYMBOL_BEGIN(type, id) DECLARE_GDB_SYM (type, id)
52 # define DEFINE_GDB_SYMBOL_END(id) = id;
54 # define DEFINE_GDB_SYMBOL_BEGIN(type, id) extern DECLARE_GDB_SYM (type, id)
55 # define DEFINE_GDB_SYMBOL_END(val) ;
58 /* The ubiquitous max and min macros. */
61 #define max(a, b) ((a) > (b) ? (a) : (b))
62 #define min(a, b) ((a) < (b) ? (a) : (b))
64 /* Number of elements in an array. */
65 #define ARRAYELTS(arr) (sizeof (arr) / sizeof (arr)[0])
67 /* Number of bits in a Lisp_Object tag. */
68 DEFINE_GDB_SYMBOL_BEGIN (int, GCTYPEBITS
)
70 DEFINE_GDB_SYMBOL_END (GCTYPEBITS
)
72 /* EMACS_INT - signed integer wide enough to hold an Emacs value
73 EMACS_INT_WIDTH - width in bits of EMACS_INT
74 EMACS_INT_MAX - maximum value of EMACS_INT; can be used in #if
75 pI - printf length modifier for EMACS_INT
76 EMACS_UINT - unsigned variant of EMACS_INT */
79 # error "INTPTR_MAX misconfigured"
80 # elif INTPTR_MAX <= INT_MAX && !defined WIDE_EMACS_INT
81 typedef int EMACS_INT
;
82 typedef unsigned int EMACS_UINT
;
83 enum { EMACS_INT_WIDTH
= INT_WIDTH
, EMACS_UINT_WIDTH
= UINT_WIDTH
};
84 # define EMACS_INT_MAX INT_MAX
86 # elif INTPTR_MAX <= LONG_MAX && !defined WIDE_EMACS_INT
87 typedef long int EMACS_INT
;
88 typedef unsigned long EMACS_UINT
;
89 enum { EMACS_INT_WIDTH
= LONG_WIDTH
, EMACS_UINT_WIDTH
= ULONG_WIDTH
};
90 # define EMACS_INT_MAX LONG_MAX
92 # elif INTPTR_MAX <= LLONG_MAX
93 typedef long long int EMACS_INT
;
94 typedef unsigned long long int EMACS_UINT
;
95 enum { EMACS_INT_WIDTH
= LLONG_WIDTH
, EMACS_UINT_WIDTH
= ULLONG_WIDTH
};
96 # define EMACS_INT_MAX LLONG_MAX
97 /* MinGW supports %lld only if __USE_MINGW_ANSI_STDIO is non-zero,
98 which is arranged by config.h, and (for mingw.org) if GCC is 6.0 or
99 later and the runtime version is 5.0.0 or later. Otherwise,
100 printf-like functions are declared with __ms_printf__ attribute,
101 which will cause a warning for %lld etc. */
102 # if defined __MINGW32__ \
103 && (!defined __USE_MINGW_ANSI_STDIO \
104 || (!defined MINGW_W64 \
105 && !(GNUC_PREREQ (6, 0, 0) && __MINGW32_MAJOR_VERSION >= 5)))
111 # error "INTPTR_MAX too large"
115 /* Number of bits to put in each character in the internal representation
116 of bool vectors. This should not vary across implementations. */
117 enum { BOOL_VECTOR_BITS_PER_CHAR
=
118 #define BOOL_VECTOR_BITS_PER_CHAR 8
119 BOOL_VECTOR_BITS_PER_CHAR
122 /* An unsigned integer type representing a fixed-length bit sequence,
123 suitable for bool vector words, GC mark bits, etc. Normally it is size_t
124 for speed, but on weird platforms it is unsigned char and not all
125 its bits are used. */
126 #if BOOL_VECTOR_BITS_PER_CHAR == CHAR_BIT
127 typedef size_t bits_word
;
128 # define BITS_WORD_MAX SIZE_MAX
129 enum { BITS_PER_BITS_WORD
= SIZE_WIDTH
};
131 typedef unsigned char bits_word
;
132 # define BITS_WORD_MAX ((1u << BOOL_VECTOR_BITS_PER_CHAR) - 1)
133 enum { BITS_PER_BITS_WORD
= BOOL_VECTOR_BITS_PER_CHAR
};
135 verify (BITS_WORD_MAX
>> (BITS_PER_BITS_WORD
- 1) == 1);
137 /* printmax_t and uprintmax_t are types for printing large integers.
138 These are the widest integers that are supported for printing.
139 pMd etc. are conversions for printing them.
140 On C99 hosts, there's no problem, as even the widest integers work.
141 Fall back on EMACS_INT on pre-C99 hosts. */
143 typedef intmax_t printmax_t
;
144 typedef uintmax_t uprintmax_t
;
148 typedef EMACS_INT printmax_t
;
149 typedef EMACS_UINT uprintmax_t
;
154 /* Use pD to format ptrdiff_t values, which suffice for indexes into
155 buffers and strings. Emacs never allocates objects larger than
156 PTRDIFF_MAX bytes, as they cause problems with pointer subtraction.
157 In C99, pD can always be "t"; configure it here for the sake of
158 pre-C99 libraries such as glibc 2.0 and Solaris 8. */
159 #if PTRDIFF_MAX == INT_MAX
161 #elif PTRDIFF_MAX == LONG_MAX
163 #elif PTRDIFF_MAX == LLONG_MAX
169 /* Extra internal type checking? */
171 /* Define Emacs versions of <assert.h>'s 'assert (COND)' and <verify.h>'s
172 'assume (COND)'. COND should be free of side effects, as it may or
173 may not be evaluated.
175 'eassert (COND)' checks COND at runtime if ENABLE_CHECKING is
176 defined and suppress_checking is false, and does nothing otherwise.
177 Emacs dies if COND is checked and is false. The suppress_checking
178 variable is initialized to 0 in alloc.c. Set it to 1 using a
179 debugger to temporarily disable aborting on detected internal
180 inconsistencies or error conditions.
182 In some cases, a good compiler may be able to optimize away the
183 eassert macro even if ENABLE_CHECKING is true, e.g., if XSTRING (x)
184 uses eassert to test STRINGP (x), but a particular use of XSTRING
185 is invoked only after testing that STRINGP (x) is true, making the
188 eassume is like eassert except that it also causes the compiler to
189 assume that COND is true afterwards, regardless of whether runtime
190 checking is enabled. This can improve performance in some cases,
191 though it can degrade performance in others. It's often suboptimal
192 for COND to call external functions or access volatile storage. */
194 #ifndef ENABLE_CHECKING
195 # define eassert(cond) ((void) (false && (cond))) /* Check COND compiles. */
196 # define eassume(cond) assume (cond)
197 #else /* ENABLE_CHECKING */
199 extern _Noreturn
void die (const char *, const char *, int);
201 extern bool suppress_checking EXTERNALLY_VISIBLE
;
203 # define eassert(cond) \
204 (suppress_checking || (cond) \
206 : die (# cond, __FILE__, __LINE__))
207 # define eassume(cond) \
212 : die (# cond, __FILE__, __LINE__))
213 #endif /* ENABLE_CHECKING */
216 /* Use the configure flag --enable-check-lisp-object-type to make
217 Lisp_Object use a struct type instead of the default int. The flag
218 causes CHECK_LISP_OBJECT_TYPE to be defined. */
220 /***** Select the tagging scheme. *****/
221 /* The following option controls the tagging scheme:
222 - USE_LSB_TAG means that we can assume the least 3 bits of pointers are
223 always 0, and we can thus use them to hold tag bits, without
224 restricting our addressing space.
226 If ! USE_LSB_TAG, then use the top 3 bits for tagging, thus
227 restricting our possible address range.
229 USE_LSB_TAG not only requires the least 3 bits of pointers returned by
230 malloc to be 0 but also needs to be able to impose a mult-of-8 alignment
231 on some non-GC Lisp_Objects, all of which are aligned via
232 GCALIGNED_UNION at the end of a union. */
236 /* Number of bits in a Lisp_Object value, not counting the tag. */
237 VALBITS
= EMACS_INT_WIDTH
- GCTYPEBITS
,
239 /* Number of bits in a Lisp fixnum tag. */
240 INTTYPEBITS
= GCTYPEBITS
- 1,
242 /* Number of bits in a Lisp fixnum value, not counting the tag. */
243 FIXNUM_BITS
= VALBITS
+ 1
246 /* The maximum value that can be stored in a EMACS_INT, assuming all
247 bits other than the type bits contribute to a nonnegative signed value.
248 This can be used in #if, e.g., '#if USE_LSB_TAG' below expands to an
249 expression involving VAL_MAX. */
250 #define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1))
252 /* Whether the least-significant bits of an EMACS_INT contain the tag.
253 On hosts where pointers-as-ints do not exceed VAL_MAX / 2, USE_LSB_TAG is:
254 a. unnecessary, because the top bits of an EMACS_INT are unused, and
255 b. slower, because it typically requires extra masking.
256 So, USE_LSB_TAG is true only on hosts where it might be useful. */
257 DEFINE_GDB_SYMBOL_BEGIN (bool, USE_LSB_TAG
)
258 #define USE_LSB_TAG (VAL_MAX / 2 < INTPTR_MAX)
259 DEFINE_GDB_SYMBOL_END (USE_LSB_TAG
)
261 /* Mask for the value (as opposed to the type bits) of a Lisp object. */
262 DEFINE_GDB_SYMBOL_BEGIN (EMACS_INT
, VALMASK
)
263 # define VALMASK (USE_LSB_TAG ? - (1 << GCTYPEBITS) : VAL_MAX)
264 DEFINE_GDB_SYMBOL_END (VALMASK
)
266 #if !USE_LSB_TAG && !defined WIDE_EMACS_INT
267 # error "USE_LSB_TAG not supported on this platform; please report this." \
268 "Try 'configure --with-wide-int' to work around the problem."
272 /* Minimum alignment requirement for Lisp objects, imposed by the
273 internal representation of tagged pointers. It is 2**GCTYPEBITS if
274 USE_LSB_TAG, 1 otherwise. It must be a literal integer constant,
275 for older versions of GCC (through at least 4.9). */
277 # define GCALIGNMENT 8
278 # if GCALIGNMENT != 1 << GCTYPEBITS
279 # error "GCALIGNMENT and GCTYPEBITS are inconsistent"
282 # define GCALIGNMENT 1
285 #define GCALIGNED_UNION char alignas (GCALIGNMENT) gcaligned;
287 /* Lisp_Word is a scalar word suitable for holding a tagged pointer or
288 integer. Usually it is a pointer to a deliberately-incomplete type
289 'union Lisp_X'. However, it is EMACS_INT when Lisp_Objects and
290 pointers differ in width. */
292 #define LISP_WORDS_ARE_POINTERS (EMACS_INT_MAX == INTPTR_MAX)
293 #if LISP_WORDS_ARE_POINTERS
294 typedef union Lisp_X
*Lisp_Word
;
296 typedef EMACS_INT Lisp_Word
;
299 /* Some operations are so commonly executed that they are implemented
300 as macros, not functions, because otherwise runtime performance would
301 suffer too much when compiling with GCC without optimization.
302 There's no need to inline everything, just the operations that
303 would otherwise cause a serious performance problem.
305 For each such operation OP, define a macro lisp_h_OP that contains
306 the operation's implementation. That way, OP can be implemented
307 via a macro definition like this:
309 #define OP(x) lisp_h_OP (x)
311 and/or via a function definition like this:
313 Lisp_Object (OP) (Lisp_Object x) { return lisp_h_OP (x); }
315 without worrying about the implementations diverging, since
316 lisp_h_OP defines the actual implementation. The lisp_h_OP macros
317 are intended to be private to this include file, and should not be
320 FIXME: Remove the lisp_h_OP macros, and define just the inline OP
321 functions, once "gcc -Og" (new to GCC 4.8) works well enough for
322 Emacs developers. Maybe in the year 2020. See Bug#11935.
324 For the macros that have corresponding functions (defined later),
325 see these functions for commentary. */
327 /* Convert among the various Lisp-related types: I for EMACS_INT, L
328 for Lisp_Object, P for void *. */
329 #if !CHECK_LISP_OBJECT_TYPE
330 # if LISP_WORDS_ARE_POINTERS
331 # define lisp_h_XLI(o) ((EMACS_INT) (o))
332 # define lisp_h_XIL(i) ((Lisp_Object) (i))
333 # define lisp_h_XLP(o) ((void *) (o))
334 # define lisp_h_XPL(p) ((Lisp_Object) (p))
336 # define lisp_h_XLI(o) (o)
337 # define lisp_h_XIL(i) (i)
338 # define lisp_h_XLP(o) ((void *) (uintptr_t) (o))
339 # define lisp_h_XPL(p) ((Lisp_Object) (uintptr_t) (p))
342 # if LISP_WORDS_ARE_POINTERS
343 # define lisp_h_XLI(o) ((EMACS_INT) (o).i)
344 # define lisp_h_XIL(i) ((Lisp_Object) {(Lisp_Word) (i)})
345 # define lisp_h_XLP(o) ((void *) (o).i)
346 # define lisp_h_XPL(p) lisp_h_XIL (p)
348 # define lisp_h_XLI(o) ((o).i)
349 # define lisp_h_XIL(i) ((Lisp_Object) {i})
350 # define lisp_h_XLP(o) ((void *) (uintptr_t) (o).i)
351 # define lisp_h_XPL(p) ((Lisp_Object) {(uintptr_t) (p)})
355 #define lisp_h_CHECK_NUMBER(x) CHECK_TYPE (INTEGERP (x), Qintegerp, x)
356 #define lisp_h_CHECK_SYMBOL(x) CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
357 #define lisp_h_CHECK_TYPE(ok, predicate, x) \
358 ((ok) ? (void) 0 : wrong_type_argument (predicate, x))
359 #define lisp_h_CONSP(x) (XTYPE (x) == Lisp_Cons)
360 #define lisp_h_EQ(x, y) (XLI (x) == XLI (y))
361 #define lisp_h_FLOATP(x) (XTYPE (x) == Lisp_Float)
362 #define lisp_h_INTEGERP(x) ((XTYPE (x) & (Lisp_Int0 | ~Lisp_Int1)) == Lisp_Int0)
363 #define lisp_h_MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
364 #define lisp_h_MISCP(x) (XTYPE (x) == Lisp_Misc)
365 #define lisp_h_NILP(x) EQ (x, Qnil)
366 #define lisp_h_SET_SYMBOL_VAL(sym, v) \
367 (eassert ((sym)->u.s.redirect == SYMBOL_PLAINVAL), \
368 (sym)->u.s.val.value = (v))
369 #define lisp_h_SYMBOL_CONSTANT_P(sym) \
370 (XSYMBOL (sym)->u.s.trapped_write == SYMBOL_NOWRITE)
371 #define lisp_h_SYMBOL_TRAPPED_WRITE_P(sym) (XSYMBOL (sym)->u.s.trapped_write)
372 #define lisp_h_SYMBOL_VAL(sym) \
373 (eassert ((sym)->u.s.redirect == SYMBOL_PLAINVAL), (sym)->u.s.val.value)
374 #define lisp_h_SYMBOLP(x) (XTYPE (x) == Lisp_Symbol)
375 #define lisp_h_VECTORLIKEP(x) (XTYPE (x) == Lisp_Vectorlike)
376 #define lisp_h_XCAR(c) XCONS (c)->u.s.car
377 #define lisp_h_XCDR(c) XCONS (c)->u.s.u.cdr
378 #define lisp_h_XCONS(a) \
379 (eassert (CONSP (a)), XUNTAG (a, Lisp_Cons, struct Lisp_Cons))
380 #define lisp_h_XHASH(a) XUINT (a)
381 #ifndef GC_CHECK_CONS_LIST
382 # define lisp_h_check_cons_list() ((void) 0)
385 # define lisp_h_make_number(n) \
386 XIL ((EMACS_INT) (((EMACS_UINT) (n) << INTTYPEBITS) + Lisp_Int0))
387 # define lisp_h_XFASTINT(a) XINT (a)
388 # define lisp_h_XINT(a) (XLI (a) >> INTTYPEBITS)
390 # define lisp_h_XSYMBOL(a) \
391 (eassert (SYMBOLP (a)), \
392 (struct Lisp_Symbol *) ((char *) XUNTAG (a, Lisp_Symbol, \
393 struct Lisp_Symbol) \
394 + (intptr_t) lispsym))
396 /* If !__CHKP__ this is equivalent, and is a bit faster as of GCC 7. */
397 # define lisp_h_XSYMBOL(a) \
398 (eassert (SYMBOLP (a)), \
399 (struct Lisp_Symbol *) ((intptr_t) XLI (a) - Lisp_Symbol \
402 # define lisp_h_XTYPE(a) ((enum Lisp_Type) (XLI (a) & ~VALMASK))
405 /* When compiling via gcc -O0, define the key operations as macros, as
406 Emacs is too slow otherwise. To disable this optimization, compile
407 with -DINLINING=false. */
408 #if (defined __NO_INLINE__ \
409 && ! defined __OPTIMIZE__ && ! defined __OPTIMIZE_SIZE__ \
410 && ! (defined INLINING && ! INLINING))
411 # define DEFINE_KEY_OPS_AS_MACROS true
413 # define DEFINE_KEY_OPS_AS_MACROS false
416 #if DEFINE_KEY_OPS_AS_MACROS
417 # define XLI(o) lisp_h_XLI (o)
418 # define XIL(i) lisp_h_XIL (i)
419 # define XLP(o) lisp_h_XLP (o)
420 # define XPL(p) lisp_h_XPL (p)
421 # define CHECK_NUMBER(x) lisp_h_CHECK_NUMBER (x)
422 # define CHECK_SYMBOL(x) lisp_h_CHECK_SYMBOL (x)
423 # define CHECK_TYPE(ok, predicate, x) lisp_h_CHECK_TYPE (ok, predicate, x)
424 # define CONSP(x) lisp_h_CONSP (x)
425 # define EQ(x, y) lisp_h_EQ (x, y)
426 # define FLOATP(x) lisp_h_FLOATP (x)
427 # define INTEGERP(x) lisp_h_INTEGERP (x)
428 # define MARKERP(x) lisp_h_MARKERP (x)
429 # define MISCP(x) lisp_h_MISCP (x)
430 # define NILP(x) lisp_h_NILP (x)
431 # define SET_SYMBOL_VAL(sym, v) lisp_h_SET_SYMBOL_VAL (sym, v)
432 # define SYMBOL_CONSTANT_P(sym) lisp_h_SYMBOL_CONSTANT_P (sym)
433 # define SYMBOL_TRAPPED_WRITE_P(sym) lisp_h_SYMBOL_TRAPPED_WRITE_P (sym)
434 # define SYMBOL_VAL(sym) lisp_h_SYMBOL_VAL (sym)
435 # define SYMBOLP(x) lisp_h_SYMBOLP (x)
436 # define VECTORLIKEP(x) lisp_h_VECTORLIKEP (x)
437 # define XCAR(c) lisp_h_XCAR (c)
438 # define XCDR(c) lisp_h_XCDR (c)
439 # define XCONS(a) lisp_h_XCONS (a)
440 # define XHASH(a) lisp_h_XHASH (a)
441 # ifndef GC_CHECK_CONS_LIST
442 # define check_cons_list() lisp_h_check_cons_list ()
445 # define make_number(n) lisp_h_make_number (n)
446 # define XFASTINT(a) lisp_h_XFASTINT (a)
447 # define XINT(a) lisp_h_XINT (a)
448 # define XSYMBOL(a) lisp_h_XSYMBOL (a)
449 # define XTYPE(a) lisp_h_XTYPE (a)
454 /* Define the fundamental Lisp data structures. */
456 /* This is the set of Lisp data types. If you want to define a new
457 data type, read the comments after Lisp_Fwd_Type definition
460 /* Lisp integers use 2 tags, to give them one extra bit, thus
461 extending their range from, e.g., -2^28..2^28-1 to -2^29..2^29-1. */
462 #define INTMASK (EMACS_INT_MAX >> (INTTYPEBITS - 1))
463 #define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
465 /* Idea stolen from GDB. Pedantic GCC complains about enum bitfields,
466 and xlc and Oracle Studio c99 complain vociferously about them. */
467 #if (defined __STRICT_ANSI__ || defined __IBMC__ \
468 || (defined __SUNPRO_C && __STDC__))
469 #define ENUM_BF(TYPE) unsigned int
471 #define ENUM_BF(TYPE) enum TYPE
477 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
480 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
481 whose first member indicates the subtype. */
484 /* Integer. XINT (obj) is the integer value. */
486 Lisp_Int1
= USE_LSB_TAG
? 6 : 3,
488 /* String. XSTRING (object) points to a struct Lisp_String.
489 The length of the string, and its contents, are stored therein. */
492 /* Vector of Lisp objects, or something resembling it.
493 XVECTOR (object) points to a struct Lisp_Vector, which contains
494 the size and contents. The size field also contains the type
495 information, if it's not a real vector object. */
498 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
499 Lisp_Cons
= USE_LSB_TAG
? 3 : 6,
504 /* This is the set of data types that share a common structure.
505 The first member of the structure is a type code from this set.
506 The enum values are arbitrary, but we'll use large numbers to make it
507 more likely that we'll spot the error if a random word in memory is
508 mistakenly interpreted as a Lisp_Misc. */
511 Lisp_Misc_Free
= 0x5eab,
519 /* This is not a type code. It is for range checking. */
523 /* These are the types of forwarding objects used in the value slot
524 of symbols for special built-in variables whose value is stored in
528 Lisp_Fwd_Int
, /* Fwd to a C `int' variable. */
529 Lisp_Fwd_Bool
, /* Fwd to a C boolean var. */
530 Lisp_Fwd_Obj
, /* Fwd to a C Lisp_Object variable. */
531 Lisp_Fwd_Buffer_Obj
, /* Fwd to a Lisp_Object field of buffers. */
532 Lisp_Fwd_Kboard_Obj
/* Fwd to a Lisp_Object field of kboards. */
535 /* If you want to define a new Lisp data type, here are some
536 instructions. See the thread at
537 https://lists.gnu.org/r/emacs-devel/2012-10/msg00561.html
540 First, there are already a couple of Lisp types that can be used if
541 your new type does not need to be exposed to Lisp programs nor
542 displayed to users. These are Lisp_Misc_Ptr, a Lisp_Misc
543 subtype; and PVEC_OTHER, a kind of vectorlike object. The former
544 is suitable for stashing a pointer in a Lisp object; the pointer
545 might be to some low-level C object that contains auxiliary
546 information. The latter is useful for vector-like Lisp objects
547 that need to be used as part of other objects, but which are never
548 shown to users or Lisp code (search for PVEC_OTHER in xterm.c for
551 These two types don't look pretty when printed, so they are
552 unsuitable for Lisp objects that can be exposed to users.
554 To define a new data type, add one more Lisp_Misc subtype or one
555 more pseudovector subtype. Pseudovectors are more suitable for
556 objects with several slots that need to support fast random access,
557 while Lisp_Misc types are for everything else. A pseudovector object
558 provides one or more slots for Lisp objects, followed by struct
559 members that are accessible only from C. A Lisp_Misc object is a
560 wrapper for a C struct that can contain anything you like.
562 There is no way to explicitly free a Lisp Object; only the garbage
563 collector frees them.
565 To add a new pseudovector type, extend the pvec_type enumeration;
566 to add a new Lisp_Misc, extend the Lisp_Misc_Type enumeration.
568 For a Lisp_Misc, you will also need to add your entry to union
569 Lisp_Misc, but make sure the first word has the same structure as
570 the others, starting with a 16-bit member of the Lisp_Misc_Type
571 enumeration and a 1-bit GC markbit. Also make sure the overall
572 size of the union is not increased by your addition. The latter
573 requirement is to keep Lisp_Misc objects small enough, so they
574 are handled faster: since all Lisp_Misc types use the same space,
575 enlarging any of them will affect all the rest. If you really
576 need a larger object, it is best to use Lisp_Vectorlike instead.
578 For a new pseudovector, it's highly desirable to limit the size
579 of your data type by VBLOCK_BYTES_MAX bytes (defined in alloc.c).
580 Otherwise you will need to change sweep_vectors (also in alloc.c).
582 Then you will need to add switch branches in print.c (in
583 print_object, to print your object, and possibly also in
584 print_preprocess) and to alloc.c, to mark your object (in
585 mark_object) and to free it (in gc_sweep). The latter is also the
586 right place to call any code specific to your data type that needs
587 to run when the object is recycled -- e.g., free any additional
588 resources allocated for it that are not Lisp objects. You can even
589 make a pointer to the function that frees the resources a slot in
590 your object -- this way, the same object could be used to represent
591 several disparate C structures.
593 You also need to add the new type to the constant
594 `cl--typeof-types' in lisp/emacs-lisp/cl-preloaded.el. */
597 /* A Lisp_Object is a tagged pointer or integer. Ordinarily it is a
598 Lisp_Word. However, if CHECK_LISP_OBJECT_TYPE, it is a wrapper
599 around Lisp_Word, to help catch thinkos like 'Lisp_Object x = 0;'.
601 LISP_INITIALLY (W) initializes a Lisp object with a tagged value
602 that is a Lisp_Word W. It can be used in a static initializer. */
604 #ifdef CHECK_LISP_OBJECT_TYPE
605 typedef struct Lisp_Object
{ Lisp_Word i
; } Lisp_Object
;
606 # define LISP_INITIALLY(w) {w}
607 # undef CHECK_LISP_OBJECT_TYPE
608 enum CHECK_LISP_OBJECT_TYPE
{ CHECK_LISP_OBJECT_TYPE
= true };
610 typedef Lisp_Word Lisp_Object
;
611 # define LISP_INITIALLY(w) (w)
612 enum CHECK_LISP_OBJECT_TYPE
{ CHECK_LISP_OBJECT_TYPE
= false };
615 /* Forward declarations. */
617 /* Defined in this file. */
618 INLINE
void set_sub_char_table_contents (Lisp_Object
, ptrdiff_t,
621 /* Defined in chartab.c. */
622 extern Lisp_Object
char_table_ref (Lisp_Object
, int);
623 extern void char_table_set (Lisp_Object
, int, Lisp_Object
);
625 /* Defined in data.c. */
626 extern _Noreturn
void wrong_type_argument (Lisp_Object
, Lisp_Object
);
630 enum { might_dump
= false };
631 #elif defined DOUG_LEA_MALLOC
632 /* Defined in emacs.c. */
633 extern bool might_dump
;
635 /* True means Emacs has already been initialized.
636 Used during startup to detect startup of dumped Emacs. */
637 extern bool initialized
;
639 /* Defined in floatfns.c. */
640 extern double extract_float (Lisp_Object
);
643 /* Low-level conversion and type checking. */
645 /* Convert among various types use to implement Lisp_Object. At the
646 machine level, these operations may widen or narrow their arguments
647 if pointers differ in width from EMACS_INT; otherwise they are
651 (XLI
) (Lisp_Object o
)
653 return lisp_h_XLI (o
);
659 return lisp_h_XIL (i
);
663 (XLP
) (Lisp_Object o
)
665 return lisp_h_XLP (o
);
671 return lisp_h_XPL (p
);
674 /* Extract A's type. */
676 INLINE
enum Lisp_Type
677 (XTYPE
) (Lisp_Object a
)
680 return lisp_h_XTYPE (a
);
682 EMACS_UINT i
= XLI (a
);
683 return USE_LSB_TAG
? i
& ~VALMASK
: i
>> VALBITS
;
688 (CHECK_TYPE
) (int ok
, Lisp_Object predicate
, Lisp_Object x
)
690 lisp_h_CHECK_TYPE (ok
, predicate
, x
);
693 /* Extract A's pointer value, assuming A's Lisp type is TYPE and the
694 extracted pointer's type is CTYPE *. */
696 #define XUNTAG(a, type, ctype) ((ctype *) \
697 ((char *) XLP (a) - LISP_WORD_TAG (type)))
699 /* Interned state of a symbol. */
703 SYMBOL_UNINTERNED
= 0,
705 SYMBOL_INTERNED_IN_INITIAL_OBARRAY
= 2
712 SYMBOL_LOCALIZED
= 2,
716 enum symbol_trapped_write
718 SYMBOL_UNTRAPPED_WRITE
= 0,
720 SYMBOL_TRAPPED_WRITE
= 2
729 bool_bf gcmarkbit
: 1;
731 /* Indicates where the value can be found:
732 0 : it's a plain var, the value is in the `value' field.
733 1 : it's a varalias, the value is really in the `alias' symbol.
734 2 : it's a localized var, the value is in the `blv' object.
735 3 : it's a forwarding variable, the value is in `forward'. */
736 ENUM_BF (symbol_redirect
) redirect
: 3;
738 /* 0 : normal case, just set the value
739 1 : constant, cannot set, e.g. nil, t, :keywords.
740 2 : trap the write, call watcher functions. */
741 ENUM_BF (symbol_trapped_write
) trapped_write
: 2;
743 /* Interned state of the symbol. This is an enumerator from
744 enum symbol_interned. */
745 unsigned interned
: 2;
747 /* True means that this variable has been explicitly declared
748 special (with `defvar' etc), and shouldn't be lexically bound. */
749 bool_bf declared_special
: 1;
751 /* True if pointed to from purespace and hence can't be GC'd. */
754 /* The symbol's name, as a Lisp string. */
757 /* Value of the symbol or Qunbound if unbound. Which alternative of the
758 union is used depends on the `redirect' field above. */
761 struct Lisp_Symbol
*alias
;
762 struct Lisp_Buffer_Local_Value
*blv
;
766 /* Function value of the symbol or Qnil if not fboundp. */
767 Lisp_Object function
;
769 /* The symbol's property list. */
772 /* Next symbol in obarray bucket, if the symbol is interned. */
773 struct Lisp_Symbol
*next
;
778 verify (alignof (struct Lisp_Symbol
) % GCALIGNMENT
== 0);
780 /* Declare a Lisp-callable function. The MAXARGS parameter has the same
781 meaning as in the DEFUN macro, and is used to construct a prototype. */
782 /* We can use the same trick as in the DEFUN macro to generate the
783 appropriate prototype. */
784 #define EXFUN(fnname, maxargs) \
785 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
787 /* Note that the weird token-substitution semantics of ANSI C makes
788 this work for MANY and UNEVALLED. */
789 #define DEFUN_ARGS_MANY (ptrdiff_t, Lisp_Object *)
790 #define DEFUN_ARGS_UNEVALLED (Lisp_Object)
791 #define DEFUN_ARGS_0 (void)
792 #define DEFUN_ARGS_1 (Lisp_Object)
793 #define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
794 #define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
795 #define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
796 #define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
798 #define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
799 Lisp_Object, Lisp_Object)
800 #define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
801 Lisp_Object, Lisp_Object, Lisp_Object)
802 #define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
803 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
805 /* untagged_ptr represents a pointer before tagging, and Lisp_Word_tag
806 contains a possibly-shifted tag to be added to an untagged_ptr to
807 convert it to a Lisp_Word. */
808 #if LISP_WORDS_ARE_POINTERS
809 /* untagged_ptr is a pointer so that the compiler knows that TAG_PTR
810 yields a pointer; this can help with gcc -fcheck-pointer-bounds.
811 It is char * so that adding a tag uses simple machine addition. */
812 typedef char *untagged_ptr
;
813 typedef uintptr_t Lisp_Word_tag
;
815 /* untagged_ptr is an unsigned integer instead of a pointer, so that
816 it can be added to the possibly-wider Lisp_Word_tag type without
817 losing information. */
818 typedef uintptr_t untagged_ptr
;
819 typedef EMACS_UINT Lisp_Word_tag
;
822 /* A integer value tagged with TAG, and otherwise all zero. */
823 #define LISP_WORD_TAG(tag) \
824 ((Lisp_Word_tag) (tag) << (USE_LSB_TAG ? 0 : VALBITS))
826 /* An initializer for a Lisp_Object that contains TAG along with PTR. */
827 #define TAG_PTR(tag, ptr) \
828 LISP_INITIALLY ((Lisp_Word) ((untagged_ptr) (ptr) + LISP_WORD_TAG (tag)))
830 /* LISPSYM_INITIALLY (Qfoo) is equivalent to Qfoo except it is
831 designed for use as an initializer, even for a constant initializer. */
832 #define LISPSYM_INITIALLY(name) \
833 TAG_PTR (Lisp_Symbol, (char *) (intptr_t) ((i##name) * sizeof *lispsym))
835 /* Declare extern constants for Lisp symbols. These can be helpful
836 when using a debugger like GDB, on older platforms where the debug
837 format does not represent C macros. However, they are unbounded
838 and would just be asking for trouble if checking pointer bounds. */
840 # define DEFINE_LISP_SYMBOL(name)
842 # define DEFINE_LISP_SYMBOL(name) \
843 DEFINE_GDB_SYMBOL_BEGIN (Lisp_Object, name) \
844 DEFINE_GDB_SYMBOL_END (LISPSYM_INITIALLY (name))
847 /* The index of the C-defined Lisp symbol SYM.
848 This can be used in a static initializer. */
849 #define SYMBOL_INDEX(sym) i##sym
851 /* By default, define macros for Qt, etc., as this leads to a bit
852 better performance in the core Emacs interpreter. A plugin can
853 define DEFINE_NON_NIL_Q_SYMBOL_MACROS to be false, to be portable to
854 other Emacs instances that assign different values to Qt, etc. */
855 #ifndef DEFINE_NON_NIL_Q_SYMBOL_MACROS
856 # define DEFINE_NON_NIL_Q_SYMBOL_MACROS true
861 /* Header of vector-like objects. This documents the layout constraints on
862 vectors and pseudovectors (objects of PVEC_xxx subtype). It also prevents
863 compilers from being fooled by Emacs's type punning: XSETPSEUDOVECTOR
864 and PSEUDOVECTORP cast their pointers to union vectorlike_header *,
865 because when two such pointers potentially alias, a compiler won't
866 incorrectly reorder loads and stores to their size fields. See
868 union vectorlike_header
870 /* The main member contains various pieces of information:
871 - The MSB (ARRAY_MARK_FLAG) holds the gcmarkbit.
872 - The next bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
873 vector (0) or a pseudovector (1).
874 - If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
875 of slots) of the vector.
876 - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
877 - a) pseudovector subtype held in PVEC_TYPE_MASK field;
878 - b) number of Lisp_Objects slots at the beginning of the object
879 held in PSEUDOVECTOR_SIZE_MASK field. These objects are always
881 - c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
882 measured in word_size units. Rest fields may also include
883 Lisp_Objects, but these objects usually needs some special treatment
885 There are some exceptions. For PVEC_FREE, b) is always zero. For
886 PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
887 Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
888 4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots. */
892 verify (alignof (union vectorlike_header
) % GCALIGNMENT
== 0);
895 (SYMBOLP
) (Lisp_Object x
)
897 return lisp_h_SYMBOLP (x
);
900 INLINE
struct Lisp_Symbol
* ATTRIBUTE_NO_SANITIZE_UNDEFINED
901 (XSYMBOL
) (Lisp_Object a
)
904 return lisp_h_XSYMBOL (a
);
906 eassert (SYMBOLP (a
));
907 intptr_t i
= (intptr_t) XUNTAG (a
, Lisp_Symbol
, struct Lisp_Symbol
);
908 void *p
= (char *) lispsym
+ i
;
910 /* Bypass pointer checking. Although this could be improved it is
911 probably not worth the trouble. */
912 p
= __builtin___bnd_set_ptr_bounds (p
, sizeof (struct Lisp_Symbol
));
919 make_lisp_symbol (struct Lisp_Symbol
*sym
)
922 /* Although '__builtin___bnd_narrow_ptr_bounds (sym, sym, sizeof *sym)'
923 should be more efficient, it runs afoul of GCC bug 83251
924 <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83251>.
925 Also, attempting to call __builtin___bnd_chk_ptr_bounds (sym, sizeof *sym)
926 here seems to trigger a GCC bug, as yet undiagnosed. */
927 char *addr
= __builtin___bnd_set_ptr_bounds (sym
, sizeof *sym
);
928 char *symoffset
= addr
- (intptr_t) lispsym
;
930 /* If !__CHKP__, GCC 7 x86-64 generates faster code if lispsym is
931 cast to char * rather than to intptr_t. */
932 char *symoffset
= (char *) ((char *) sym
- (char *) lispsym
);
934 Lisp_Object a
= TAG_PTR (Lisp_Symbol
, symoffset
);
935 eassert (XSYMBOL (a
) == sym
);
940 builtin_lisp_symbol (int index
)
942 return make_lisp_symbol (&lispsym
[index
]);
946 (CHECK_SYMBOL
) (Lisp_Object x
)
948 lisp_h_CHECK_SYMBOL (x
);
951 /* In the size word of a vector, this bit means the vector has been marked. */
953 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, ARRAY_MARK_FLAG
)
954 # define ARRAY_MARK_FLAG PTRDIFF_MIN
955 DEFINE_GDB_SYMBOL_END (ARRAY_MARK_FLAG
)
957 /* In the size word of a struct Lisp_Vector, this bit means it's really
958 some other vector-like object. */
959 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, PSEUDOVECTOR_FLAG
)
960 # define PSEUDOVECTOR_FLAG (PTRDIFF_MAX - PTRDIFF_MAX / 2)
961 DEFINE_GDB_SYMBOL_END (PSEUDOVECTOR_FLAG
)
963 /* In a pseudovector, the size field actually contains a word with one
964 PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
965 with PVEC_TYPE_MASK to indicate the actual type. */
977 PVEC_WINDOW_CONFIGURATION
,
979 PVEC_OTHER
, /* Should never be visible to Elisp code. */
985 PVEC_MODULE_FUNCTION
,
987 /* These should be last, check internal_equal to see why. */
992 PVEC_FONT
/* Should be last because it's used for range checking. */
997 /* For convenience, we also store the number of elements in these bits.
998 Note that this size is not necessarily the memory-footprint size, but
999 only the number of Lisp_Object fields (that need to be traced by GC).
1000 The distinction is used, e.g., by Lisp_Process, which places extra
1001 non-Lisp_Object fields at the end of the structure. */
1002 PSEUDOVECTOR_SIZE_BITS
= 12,
1003 PSEUDOVECTOR_SIZE_MASK
= (1 << PSEUDOVECTOR_SIZE_BITS
) - 1,
1005 /* To calculate the memory footprint of the pseudovector, it's useful
1006 to store the size of non-Lisp area in word_size units here. */
1007 PSEUDOVECTOR_REST_BITS
= 12,
1008 PSEUDOVECTOR_REST_MASK
= (((1 << PSEUDOVECTOR_REST_BITS
) - 1)
1009 << PSEUDOVECTOR_SIZE_BITS
),
1011 /* Used to extract pseudovector subtype information. */
1012 PSEUDOVECTOR_AREA_BITS
= PSEUDOVECTOR_SIZE_BITS
+ PSEUDOVECTOR_REST_BITS
,
1013 PVEC_TYPE_MASK
= 0x3f << PSEUDOVECTOR_AREA_BITS
1016 /* These functions extract various sorts of values from a Lisp_Object.
1017 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
1018 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for
1021 /* Largest and smallest representable fixnum values. These are the C
1022 values. They are macros for use in static initializers. */
1023 #define MOST_POSITIVE_FIXNUM (EMACS_INT_MAX >> INTTYPEBITS)
1024 #define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_FIXNUM)
1029 (make_number
) (EMACS_INT n
)
1031 return lisp_h_make_number (n
);
1035 (XINT
) (Lisp_Object a
)
1037 return lisp_h_XINT (a
);
1041 (XFASTINT
) (Lisp_Object a
)
1043 EMACS_INT n
= lisp_h_XFASTINT (a
);
1048 #else /* ! USE_LSB_TAG */
1050 /* Although compiled only if ! USE_LSB_TAG, the following functions
1051 also work when USE_LSB_TAG; this is to aid future maintenance when
1052 the lisp_h_* macros are eventually removed. */
1054 /* Make a Lisp integer representing the value of the low order
1057 make_number (EMACS_INT n
)
1059 EMACS_INT int0
= Lisp_Int0
;
1063 n
= u
<< INTTYPEBITS
;
1069 n
+= (int0
<< VALBITS
);
1074 /* Extract A's value as a signed integer. */
1076 XINT (Lisp_Object a
)
1078 EMACS_INT i
= XLI (a
);
1082 i
= u
<< INTTYPEBITS
;
1084 return i
>> INTTYPEBITS
;
1087 /* Like XINT (A), but may be faster. A must be nonnegative.
1088 If ! USE_LSB_TAG, this takes advantage of the fact that Lisp
1089 integers have zero-bits in their tags. */
1091 XFASTINT (Lisp_Object a
)
1093 EMACS_INT int0
= Lisp_Int0
;
1094 EMACS_INT n
= USE_LSB_TAG
? XINT (a
) : XLI (a
) - (int0
<< VALBITS
);
1099 #endif /* ! USE_LSB_TAG */
1101 /* Extract A's value as an unsigned integer. */
1103 XUINT (Lisp_Object a
)
1105 EMACS_UINT i
= XLI (a
);
1106 return USE_LSB_TAG
? i
>> INTTYPEBITS
: i
& INTMASK
;
1109 /* Return A's (Lisp-integer sized) hash. Happens to be like XUINT
1110 right now, but XUINT should only be applied to objects we know are
1114 (XHASH
) (Lisp_Object a
)
1116 return lisp_h_XHASH (a
);
1119 /* Like make_number (N), but may be faster. N must be in nonnegative range. */
1121 make_natnum (EMACS_INT n
)
1123 eassert (0 <= n
&& n
<= MOST_POSITIVE_FIXNUM
);
1124 EMACS_INT int0
= Lisp_Int0
;
1125 return USE_LSB_TAG
? make_number (n
) : XIL (n
+ (int0
<< VALBITS
));
1128 /* Return true if X and Y are the same object. */
1131 (EQ
) (Lisp_Object x
, Lisp_Object y
)
1133 return lisp_h_EQ (x
, y
);
1136 /* True if the possibly-unsigned integer I doesn't fit in a Lisp fixnum. */
1138 #define FIXNUM_OVERFLOW_P(i) \
1139 (! ((0 <= (i) || MOST_NEGATIVE_FIXNUM <= (i)) && (i) <= MOST_POSITIVE_FIXNUM))
1142 clip_to_bounds (ptrdiff_t lower
, EMACS_INT num
, ptrdiff_t upper
)
1144 return num
< lower
? lower
: num
<= upper
? num
: upper
;
1147 /* Construct a Lisp_Object from a value or address. */
1150 make_lisp_ptr (void *ptr
, enum Lisp_Type type
)
1152 Lisp_Object a
= TAG_PTR (type
, ptr
);
1153 eassert (XTYPE (a
) == type
&& XUNTAG (a
, type
, char) == ptr
);
1158 (INTEGERP
) (Lisp_Object x
)
1160 return lisp_h_INTEGERP (x
);
1163 #define XSETINT(a, b) ((a) = make_number (b))
1164 #define XSETFASTINT(a, b) ((a) = make_natnum (b))
1165 #define XSETCONS(a, b) ((a) = make_lisp_ptr (b, Lisp_Cons))
1166 #define XSETVECTOR(a, b) ((a) = make_lisp_ptr (b, Lisp_Vectorlike))
1167 #define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
1168 #define XSETSYMBOL(a, b) ((a) = make_lisp_symbol (b))
1169 #define XSETFLOAT(a, b) ((a) = make_lisp_ptr (b, Lisp_Float))
1170 #define XSETMISC(a, b) ((a) = make_lisp_ptr (b, Lisp_Misc))
1172 /* Pseudovector types. */
1174 #define XSETPVECTYPE(v, code) \
1175 ((v)->header.size |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS))
1176 #define XSETPVECTYPESIZE(v, code, lispsize, restsize) \
1177 ((v)->header.size = (PSEUDOVECTOR_FLAG \
1178 | ((code) << PSEUDOVECTOR_AREA_BITS) \
1179 | ((restsize) << PSEUDOVECTOR_SIZE_BITS) \
1182 /* The cast to union vectorlike_header * avoids aliasing issues. */
1183 #define XSETPSEUDOVECTOR(a, b, code) \
1184 XSETTYPED_PSEUDOVECTOR (a, b, \
1185 (XUNTAG (a, Lisp_Vectorlike, \
1186 union vectorlike_header) \
1189 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code) \
1190 (XSETVECTOR (a, b), \
1191 eassert ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) \
1192 == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS))))
1194 #define XSETWINDOW_CONFIGURATION(a, b) \
1195 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
1196 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
1197 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
1198 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
1199 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
1200 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
1201 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
1202 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
1203 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
1204 #define XSETSUB_CHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUB_CHAR_TABLE))
1205 #define XSETTHREAD(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_THREAD))
1206 #define XSETMUTEX(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_MUTEX))
1207 #define XSETCONDVAR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CONDVAR))
1209 /* Efficiently convert a pointer to a Lisp object and back. The
1210 pointer is represented as a Lisp integer, so the garbage collector
1211 does not know about it. The pointer should not have both Lisp_Int1
1212 bits set, which makes this conversion inherently unportable. */
1215 XINTPTR (Lisp_Object a
)
1217 return XUNTAG (a
, Lisp_Int0
, char);
1221 make_pointer_integer (void *p
)
1223 Lisp_Object a
= TAG_PTR (Lisp_Int0
, p
);
1224 eassert (INTEGERP (a
) && XINTPTR (a
) == p
);
1228 /* See the macros in intervals.h. */
1230 typedef struct interval
*INTERVAL
;
1238 /* Car of this cons cell. */
1243 /* Cdr of this cons cell. */
1246 /* Used to chain conses on a free list. */
1247 struct Lisp_Cons
*chain
;
1253 verify (alignof (struct Lisp_Cons
) % GCALIGNMENT
== 0);
1256 (NILP
) (Lisp_Object x
)
1258 return lisp_h_NILP (x
);
1262 (CONSP
) (Lisp_Object x
)
1264 return lisp_h_CONSP (x
);
1268 CHECK_CONS (Lisp_Object x
)
1270 CHECK_TYPE (CONSP (x
), Qconsp
, x
);
1273 INLINE
struct Lisp_Cons
*
1274 (XCONS
) (Lisp_Object a
)
1276 return lisp_h_XCONS (a
);
1279 /* Take the car or cdr of something known to be a cons cell. */
1280 /* The _addr functions shouldn't be used outside of the minimal set
1281 of code that has to know what a cons cell looks like. Other code not
1282 part of the basic lisp implementation should assume that the car and cdr
1283 fields are not accessible. (What if we want to switch to
1284 a copying collector someday? Cached cons cell field addresses may be
1285 invalidated at arbitrary points.) */
1286 INLINE Lisp_Object
*
1287 xcar_addr (Lisp_Object c
)
1289 return &XCONS (c
)->u
.s
.car
;
1291 INLINE Lisp_Object
*
1292 xcdr_addr (Lisp_Object c
)
1294 return &XCONS (c
)->u
.s
.u
.cdr
;
1297 /* Use these from normal code. */
1300 (XCAR
) (Lisp_Object c
)
1302 return lisp_h_XCAR (c
);
1306 (XCDR
) (Lisp_Object c
)
1308 return lisp_h_XCDR (c
);
1311 /* Use these to set the fields of a cons cell.
1313 Note that both arguments may refer to the same object, so 'n'
1314 should not be read after 'c' is first modified. */
1316 XSETCAR (Lisp_Object c
, Lisp_Object n
)
1321 XSETCDR (Lisp_Object c
, Lisp_Object n
)
1326 /* Take the car or cdr of something whose type is not known. */
1333 wrong_type_argument (Qlistp
, c
);
1342 wrong_type_argument (Qlistp
, c
);
1346 /* Take the car or cdr of something whose type is not known. */
1348 CAR_SAFE (Lisp_Object c
)
1350 return CONSP (c
) ? XCAR (c
) : Qnil
;
1353 CDR_SAFE (Lisp_Object c
)
1355 return CONSP (c
) ? XCDR (c
) : Qnil
;
1358 /* In a string or vector, the sign bit of u.s.size is the gc mark bit. */
1367 ptrdiff_t size_byte
;
1368 INTERVAL intervals
; /* Text properties in this string. */
1369 unsigned char *data
;
1371 struct Lisp_String
*next
;
1375 verify (alignof (struct Lisp_String
) % GCALIGNMENT
== 0);
1378 STRINGP (Lisp_Object x
)
1380 return XTYPE (x
) == Lisp_String
;
1384 CHECK_STRING (Lisp_Object x
)
1386 CHECK_TYPE (STRINGP (x
), Qstringp
, x
);
1389 INLINE
struct Lisp_String
*
1390 XSTRING (Lisp_Object a
)
1392 eassert (STRINGP (a
));
1393 return XUNTAG (a
, Lisp_String
, struct Lisp_String
);
1396 /* True if STR is a multibyte string. */
1398 STRING_MULTIBYTE (Lisp_Object str
)
1400 return 0 <= XSTRING (str
)->u
.s
.size_byte
;
1403 /* An upper bound on the number of bytes in a Lisp string, not
1404 counting the terminating null. This a tight enough bound to
1405 prevent integer overflow errors that would otherwise occur during
1406 string size calculations. A string cannot contain more bytes than
1407 a fixnum can represent, nor can it be so long that C pointer
1408 arithmetic stops working on the string plus its terminating null.
1409 Although the actual size limit (see STRING_BYTES_MAX in alloc.c)
1410 may be a bit smaller than STRING_BYTES_BOUND, calculating it here
1411 would expose alloc.c internal details that we'd rather keep
1414 This is a macro for use in static initializers. The cast to
1415 ptrdiff_t ensures that the macro is signed. */
1416 #define STRING_BYTES_BOUND \
1417 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1))
1419 /* Mark STR as a unibyte string. */
1420 #define STRING_SET_UNIBYTE(STR) \
1422 if (XSTRING (STR)->u.s.size == 0) \
1423 (STR) = empty_unibyte_string; \
1425 XSTRING (STR)->u.s.size_byte = -1; \
1428 /* Mark STR as a multibyte string. Assure that STR contains only
1429 ASCII characters in advance. */
1430 #define STRING_SET_MULTIBYTE(STR) \
1432 if (XSTRING (STR)->u.s.size == 0) \
1433 (STR) = empty_multibyte_string; \
1435 XSTRING (STR)->u.s.size_byte = XSTRING (STR)->u.s.size; \
1438 /* Convenience functions for dealing with Lisp strings. */
1440 INLINE
unsigned char *
1441 SDATA (Lisp_Object string
)
1443 return XSTRING (string
)->u
.s
.data
;
1446 SSDATA (Lisp_Object string
)
1448 /* Avoid "differ in sign" warnings. */
1449 return (char *) SDATA (string
);
1451 INLINE
unsigned char
1452 SREF (Lisp_Object string
, ptrdiff_t index
)
1454 return SDATA (string
)[index
];
1457 SSET (Lisp_Object string
, ptrdiff_t index
, unsigned char new)
1459 SDATA (string
)[index
] = new;
1462 SCHARS (Lisp_Object string
)
1464 ptrdiff_t nchars
= XSTRING (string
)->u
.s
.size
;
1465 eassume (0 <= nchars
);
1469 #ifdef GC_CHECK_STRING_BYTES
1470 extern ptrdiff_t string_bytes (struct Lisp_String
*);
1473 STRING_BYTES (struct Lisp_String
*s
)
1475 #ifdef GC_CHECK_STRING_BYTES
1476 ptrdiff_t nbytes
= string_bytes (s
);
1478 ptrdiff_t nbytes
= s
->u
.s
.size_byte
< 0 ? s
->u
.s
.size
: s
->u
.s
.size_byte
;
1480 eassume (0 <= nbytes
);
1485 SBYTES (Lisp_Object string
)
1487 return STRING_BYTES (XSTRING (string
));
1490 STRING_SET_CHARS (Lisp_Object string
, ptrdiff_t newsize
)
1492 /* This function cannot change the size of data allocated for the
1493 string when it was created. */
1494 eassert (STRING_MULTIBYTE (string
)
1495 ? 0 <= newsize
&& newsize
<= SBYTES (string
)
1496 : newsize
== SCHARS (string
));
1497 XSTRING (string
)->u
.s
.size
= newsize
;
1500 /* A regular vector is just a header plus an array of Lisp_Objects. */
1504 union vectorlike_header header
;
1505 Lisp_Object contents
[FLEXIBLE_ARRAY_MEMBER
];
1509 (VECTORLIKEP
) (Lisp_Object x
)
1511 return lisp_h_VECTORLIKEP (x
);
1514 INLINE
struct Lisp_Vector
*
1515 XVECTOR (Lisp_Object a
)
1517 eassert (VECTORLIKEP (a
));
1518 return XUNTAG (a
, Lisp_Vectorlike
, struct Lisp_Vector
);
1522 ASIZE (Lisp_Object array
)
1524 ptrdiff_t size
= XVECTOR (array
)->header
.size
;
1525 eassume (0 <= size
);
1530 PVSIZE (Lisp_Object pv
)
1532 return ASIZE (pv
) & PSEUDOVECTOR_SIZE_MASK
;
1536 VECTORP (Lisp_Object x
)
1538 return VECTORLIKEP (x
) && ! (ASIZE (x
) & PSEUDOVECTOR_FLAG
);
1542 CHECK_VECTOR (Lisp_Object x
)
1544 CHECK_TYPE (VECTORP (x
), Qvectorp
, x
);
1548 /* A pseudovector is like a vector, but has other non-Lisp components. */
1550 INLINE
enum pvec_type
1551 PSEUDOVECTOR_TYPE (struct Lisp_Vector
*v
)
1553 ptrdiff_t size
= v
->header
.size
;
1554 return (size
& PSEUDOVECTOR_FLAG
1555 ? (size
& PVEC_TYPE_MASK
) >> PSEUDOVECTOR_AREA_BITS
1556 : PVEC_NORMAL_VECTOR
);
1559 /* Can't be used with PVEC_NORMAL_VECTOR. */
1561 PSEUDOVECTOR_TYPEP (union vectorlike_header
*a
, enum pvec_type code
)
1563 /* We don't use PSEUDOVECTOR_TYPE here so as to avoid a shift
1564 * operation when `code' is known. */
1565 return ((a
->size
& (PSEUDOVECTOR_FLAG
| PVEC_TYPE_MASK
))
1566 == (PSEUDOVECTOR_FLAG
| (code
<< PSEUDOVECTOR_AREA_BITS
)));
1569 /* True if A is a pseudovector whose code is CODE. */
1571 PSEUDOVECTORP (Lisp_Object a
, int code
)
1573 if (! VECTORLIKEP (a
))
1577 /* Converting to union vectorlike_header * avoids aliasing issues. */
1578 return PSEUDOVECTOR_TYPEP (XUNTAG (a
, Lisp_Vectorlike
,
1579 union vectorlike_header
),
1584 /* A boolvector is a kind of vectorlike, with contents like a string. */
1586 struct Lisp_Bool_Vector
1588 /* HEADER.SIZE is the vector's size field. It doesn't have the real size,
1589 just the subtype information. */
1590 union vectorlike_header header
;
1591 /* This is the size in bits. */
1593 /* The actual bits, packed into bytes.
1594 Zeros fill out the last word if needed.
1595 The bits are in little-endian order in the bytes, and
1596 the bytes are in little-endian order in the words. */
1597 bits_word data
[FLEXIBLE_ARRAY_MEMBER
];
1600 /* Some handy constants for calculating sizes
1601 and offsets, mostly of vectorlike objects. */
1605 header_size
= offsetof (struct Lisp_Vector
, contents
),
1606 bool_header_size
= offsetof (struct Lisp_Bool_Vector
, data
),
1607 word_size
= sizeof (Lisp_Object
)
1610 /* The number of data words and bytes in a bool vector with SIZE bits. */
1613 bool_vector_words (EMACS_INT size
)
1615 eassume (0 <= size
&& size
<= EMACS_INT_MAX
- (BITS_PER_BITS_WORD
- 1));
1616 return (size
+ BITS_PER_BITS_WORD
- 1) / BITS_PER_BITS_WORD
;
1620 bool_vector_bytes (EMACS_INT size
)
1622 eassume (0 <= size
&& size
<= EMACS_INT_MAX
- (BITS_PER_BITS_WORD
- 1));
1623 return (size
+ BOOL_VECTOR_BITS_PER_CHAR
- 1) / BOOL_VECTOR_BITS_PER_CHAR
;
1627 BOOL_VECTOR_P (Lisp_Object a
)
1629 return PSEUDOVECTORP (a
, PVEC_BOOL_VECTOR
);
1633 CHECK_BOOL_VECTOR (Lisp_Object x
)
1635 CHECK_TYPE (BOOL_VECTOR_P (x
), Qbool_vector_p
, x
);
1638 INLINE
struct Lisp_Bool_Vector
*
1639 XBOOL_VECTOR (Lisp_Object a
)
1641 eassert (BOOL_VECTOR_P (a
));
1642 return XUNTAG (a
, Lisp_Vectorlike
, struct Lisp_Bool_Vector
);
1646 bool_vector_size (Lisp_Object a
)
1648 EMACS_INT size
= XBOOL_VECTOR (a
)->size
;
1649 eassume (0 <= size
);
1654 bool_vector_data (Lisp_Object a
)
1656 return XBOOL_VECTOR (a
)->data
;
1659 INLINE
unsigned char *
1660 bool_vector_uchar_data (Lisp_Object a
)
1662 return (unsigned char *) bool_vector_data (a
);
1665 /* True if A's Ith bit is set. */
1668 bool_vector_bitref (Lisp_Object a
, EMACS_INT i
)
1670 eassume (0 <= i
&& i
< bool_vector_size (a
));
1671 return !! (bool_vector_uchar_data (a
)[i
/ BOOL_VECTOR_BITS_PER_CHAR
]
1672 & (1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
)));
1676 bool_vector_ref (Lisp_Object a
, EMACS_INT i
)
1678 return bool_vector_bitref (a
, i
) ? Qt
: Qnil
;
1681 /* Set A's Ith bit to B. */
1684 bool_vector_set (Lisp_Object a
, EMACS_INT i
, bool b
)
1686 unsigned char *addr
;
1688 eassume (0 <= i
&& i
< bool_vector_size (a
));
1689 addr
= &bool_vector_uchar_data (a
)[i
/ BOOL_VECTOR_BITS_PER_CHAR
];
1692 *addr
|= 1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
);
1694 *addr
&= ~ (1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
));
1697 /* Conveniences for dealing with Lisp arrays. */
1700 AREF (Lisp_Object array
, ptrdiff_t idx
)
1702 return XVECTOR (array
)->contents
[idx
];
1705 INLINE Lisp_Object
*
1706 aref_addr (Lisp_Object array
, ptrdiff_t idx
)
1708 return & XVECTOR (array
)->contents
[idx
];
1712 gc_asize (Lisp_Object array
)
1714 /* Like ASIZE, but also can be used in the garbage collector. */
1715 return XVECTOR (array
)->header
.size
& ~ARRAY_MARK_FLAG
;
1719 ASET (Lisp_Object array
, ptrdiff_t idx
, Lisp_Object val
)
1721 eassert (0 <= idx
&& idx
< ASIZE (array
));
1722 XVECTOR (array
)->contents
[idx
] = val
;
1726 gc_aset (Lisp_Object array
, ptrdiff_t idx
, Lisp_Object val
)
1728 /* Like ASET, but also can be used in the garbage collector:
1729 sweep_weak_table calls set_hash_key etc. while the table is marked. */
1730 eassert (0 <= idx
&& idx
< gc_asize (array
));
1731 XVECTOR (array
)->contents
[idx
] = val
;
1734 /* True, since Qnil's representation is zero. Every place in the code
1735 that assumes Qnil is zero should verify (NIL_IS_ZERO), to make it easy
1736 to find such assumptions later if we change Qnil to be nonzero.
1737 Test iQnil and Lisp_Symbol instead of Qnil directly, since the latter
1738 is not suitable for use in an integer constant expression. */
1739 enum { NIL_IS_ZERO
= iQnil
== 0 && Lisp_Symbol
== 0 };
1741 /* Clear the object addressed by P, with size NBYTES, so that all its
1742 bytes are zero and all its Lisp values are nil. */
1744 memclear (void *p
, ptrdiff_t nbytes
)
1746 eassert (0 <= nbytes
);
1747 verify (NIL_IS_ZERO
);
1748 /* Since Qnil is zero, memset suffices. */
1749 memset (p
, 0, nbytes
);
1752 /* If a struct is made to look like a vector, this macro returns the length
1753 of the shortest vector that would hold that struct. */
1755 #define VECSIZE(type) \
1756 ((sizeof (type) - header_size + word_size - 1) / word_size)
1758 /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields
1759 at the end and we need to compute the number of Lisp_Object fields (the
1760 ones that the GC needs to trace). */
1762 #define PSEUDOVECSIZE(type, nonlispfield) \
1763 ((offsetof (type, nonlispfield) - header_size) / word_size)
1765 /* Compute A OP B, using the unsigned comparison operator OP. A and B
1766 should be integer expressions. This is not the same as
1767 mathematical comparison; for example, UNSIGNED_CMP (0, <, -1)
1768 returns true. For efficiency, prefer plain unsigned comparison if A
1769 and B's sizes both fit (after integer promotion). */
1770 #define UNSIGNED_CMP(a, op, b) \
1771 (max (sizeof ((a) + 0), sizeof ((b) + 0)) <= sizeof (unsigned) \
1772 ? ((a) + (unsigned) 0) op ((b) + (unsigned) 0) \
1773 : ((a) + (uintmax_t) 0) op ((b) + (uintmax_t) 0))
1775 /* True iff C is an ASCII character. */
1776 #define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80)
1778 /* A char-table is a kind of vectorlike, with contents are like a
1779 vector but with a few other slots. For some purposes, it makes
1780 sense to handle a char-table with type struct Lisp_Vector. An
1781 element of a char table can be any Lisp objects, but if it is a sub
1782 char-table, we treat it a table that contains information of a
1783 specific range of characters. A sub char-table is like a vector but
1784 with two integer fields between the header and Lisp data, which means
1785 that it has to be marked with some precautions (see mark_char_table
1786 in alloc.c). A sub char-table appears only in an element of a char-table,
1787 and there's no way to access it directly from Emacs Lisp program. */
1789 enum CHARTAB_SIZE_BITS
1791 CHARTAB_SIZE_BITS_0
= 6,
1792 CHARTAB_SIZE_BITS_1
= 4,
1793 CHARTAB_SIZE_BITS_2
= 5,
1794 CHARTAB_SIZE_BITS_3
= 7
1797 extern const int chartab_size
[4];
1799 struct Lisp_Char_Table
1801 /* HEADER.SIZE is the vector's size field, which also holds the
1802 pseudovector type information. It holds the size, too.
1803 The size counts the defalt, parent, purpose, ascii,
1804 contents, and extras slots. */
1805 union vectorlike_header header
;
1807 /* This holds a default value,
1808 which is used whenever the value for a specific character is nil. */
1811 /* This points to another char table, which we inherit from when the
1812 value for a specific character is nil. The `defalt' slot takes
1813 precedence over this. */
1816 /* This is a symbol which says what kind of use this char-table is
1818 Lisp_Object purpose
;
1820 /* The bottom sub char-table for characters of the range 0..127. It
1821 is nil if none of ASCII character has a specific value. */
1824 Lisp_Object contents
[(1 << CHARTAB_SIZE_BITS_0
)];
1826 /* These hold additional data. It is a vector. */
1827 Lisp_Object extras
[FLEXIBLE_ARRAY_MEMBER
];
1831 CHAR_TABLE_P (Lisp_Object a
)
1833 return PSEUDOVECTORP (a
, PVEC_CHAR_TABLE
);
1836 INLINE
struct Lisp_Char_Table
*
1837 XCHAR_TABLE (Lisp_Object a
)
1839 eassert (CHAR_TABLE_P (a
));
1840 return XUNTAG (a
, Lisp_Vectorlike
, struct Lisp_Char_Table
);
1843 struct Lisp_Sub_Char_Table
1845 /* HEADER.SIZE is the vector's size field, which also holds the
1846 pseudovector type information. It holds the size, too. */
1847 union vectorlike_header header
;
1849 /* Depth of this sub char-table. It should be 1, 2, or 3. A sub
1850 char-table of depth 1 contains 16 elements, and each element
1851 covers 4096 (128*32) characters. A sub char-table of depth 2
1852 contains 32 elements, and each element covers 128 characters. A
1853 sub char-table of depth 3 contains 128 elements, and each element
1854 is for one character. */
1857 /* Minimum character covered by the sub char-table. */
1860 /* Use set_sub_char_table_contents to set this. */
1861 Lisp_Object contents
[FLEXIBLE_ARRAY_MEMBER
];
1865 SUB_CHAR_TABLE_P (Lisp_Object a
)
1867 return PSEUDOVECTORP (a
, PVEC_SUB_CHAR_TABLE
);
1870 INLINE
struct Lisp_Sub_Char_Table
*
1871 XSUB_CHAR_TABLE (Lisp_Object a
)
1873 eassert (SUB_CHAR_TABLE_P (a
));
1874 return XUNTAG (a
, Lisp_Vectorlike
, struct Lisp_Sub_Char_Table
);
1878 CHAR_TABLE_REF_ASCII (Lisp_Object ct
, ptrdiff_t idx
)
1880 struct Lisp_Char_Table
*tbl
= NULL
;
1884 tbl
= tbl
? XCHAR_TABLE (tbl
->parent
) : XCHAR_TABLE (ct
);
1885 val
= (! SUB_CHAR_TABLE_P (tbl
->ascii
) ? tbl
->ascii
1886 : XSUB_CHAR_TABLE (tbl
->ascii
)->contents
[idx
]);
1890 while (NILP (val
) && ! NILP (tbl
->parent
));
1895 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
1896 characters. Do not check validity of CT. */
1898 CHAR_TABLE_REF (Lisp_Object ct
, int idx
)
1900 return (ASCII_CHAR_P (idx
)
1901 ? CHAR_TABLE_REF_ASCII (ct
, idx
)
1902 : char_table_ref (ct
, idx
));
1905 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
1906 8-bit European characters. Do not check validity of CT. */
1908 CHAR_TABLE_SET (Lisp_Object ct
, int idx
, Lisp_Object val
)
1910 if (ASCII_CHAR_P (idx
) && SUB_CHAR_TABLE_P (XCHAR_TABLE (ct
)->ascii
))
1911 set_sub_char_table_contents (XCHAR_TABLE (ct
)->ascii
, idx
, val
);
1913 char_table_set (ct
, idx
, val
);
1916 /* This structure describes a built-in function.
1917 It is generated by the DEFUN macro only.
1918 defsubr makes it into a Lisp object. */
1922 union vectorlike_header header
;
1924 Lisp_Object (*a0
) (void);
1925 Lisp_Object (*a1
) (Lisp_Object
);
1926 Lisp_Object (*a2
) (Lisp_Object
, Lisp_Object
);
1927 Lisp_Object (*a3
) (Lisp_Object
, Lisp_Object
, Lisp_Object
);
1928 Lisp_Object (*a4
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1929 Lisp_Object (*a5
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1930 Lisp_Object (*a6
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1931 Lisp_Object (*a7
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1932 Lisp_Object (*a8
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1933 Lisp_Object (*aUNEVALLED
) (Lisp_Object args
);
1934 Lisp_Object (*aMANY
) (ptrdiff_t, Lisp_Object
*);
1936 short min_args
, max_args
;
1937 const char *symbol_name
;
1938 const char *intspec
;
1943 SUBRP (Lisp_Object a
)
1945 return PSEUDOVECTORP (a
, PVEC_SUBR
);
1948 INLINE
struct Lisp_Subr
*
1949 XSUBR (Lisp_Object a
)
1951 eassert (SUBRP (a
));
1952 return XUNTAG (a
, Lisp_Vectorlike
, struct Lisp_Subr
);
1955 enum char_table_specials
1957 /* This is the number of slots that every char table must have. This
1958 counts the ordinary slots and the top, defalt, parent, and purpose
1960 CHAR_TABLE_STANDARD_SLOTS
= PSEUDOVECSIZE (struct Lisp_Char_Table
, extras
),
1962 /* This is an index of first Lisp_Object field in Lisp_Sub_Char_Table
1963 when the latter is treated as an ordinary Lisp_Vector. */
1964 SUB_CHAR_TABLE_OFFSET
= PSEUDOVECSIZE (struct Lisp_Sub_Char_Table
, contents
)
1967 /* Return the number of "extra" slots in the char table CT. */
1970 CHAR_TABLE_EXTRA_SLOTS (struct Lisp_Char_Table
*ct
)
1972 return ((ct
->header
.size
& PSEUDOVECTOR_SIZE_MASK
)
1973 - CHAR_TABLE_STANDARD_SLOTS
);
1976 /* Make sure that sub char-table contents slot is where we think it is. */
1977 verify (offsetof (struct Lisp_Sub_Char_Table
, contents
)
1978 == (offsetof (struct Lisp_Vector
, contents
)
1979 + SUB_CHAR_TABLE_OFFSET
* sizeof (Lisp_Object
)));
1982 /* Save and restore the instruction and environment pointers,
1983 without affecting the signal mask. */
1986 typedef jmp_buf sys_jmp_buf
;
1987 # define sys_setjmp(j) _setjmp (j)
1988 # define sys_longjmp(j, v) _longjmp (j, v)
1989 #elif defined HAVE_SIGSETJMP
1990 typedef sigjmp_buf sys_jmp_buf
;
1991 # define sys_setjmp(j) sigsetjmp (j, 0)
1992 # define sys_longjmp(j, v) siglongjmp (j, v)
1994 /* A platform that uses neither _longjmp nor siglongjmp; assume
1995 longjmp does not affect the sigmask. */
1996 typedef jmp_buf sys_jmp_buf
;
1997 # define sys_setjmp(j) setjmp (j)
1998 # define sys_longjmp(j, v) longjmp (j, v)
2003 /***********************************************************************
2005 ***********************************************************************/
2007 /* Value is name of symbol. */
2010 (SYMBOL_VAL
) (struct Lisp_Symbol
*sym
)
2012 return lisp_h_SYMBOL_VAL (sym
);
2015 INLINE
struct Lisp_Symbol
*
2016 SYMBOL_ALIAS (struct Lisp_Symbol
*sym
)
2018 eassume (sym
->u
.s
.redirect
== SYMBOL_VARALIAS
&& sym
->u
.s
.val
.alias
);
2019 return sym
->u
.s
.val
.alias
;
2021 INLINE
struct Lisp_Buffer_Local_Value
*
2022 SYMBOL_BLV (struct Lisp_Symbol
*sym
)
2024 eassume (sym
->u
.s
.redirect
== SYMBOL_LOCALIZED
&& sym
->u
.s
.val
.blv
);
2025 return sym
->u
.s
.val
.blv
;
2027 INLINE
union Lisp_Fwd
*
2028 SYMBOL_FWD (struct Lisp_Symbol
*sym
)
2030 eassume (sym
->u
.s
.redirect
== SYMBOL_FORWARDED
&& sym
->u
.s
.val
.fwd
);
2031 return sym
->u
.s
.val
.fwd
;
2035 (SET_SYMBOL_VAL
) (struct Lisp_Symbol
*sym
, Lisp_Object v
)
2037 lisp_h_SET_SYMBOL_VAL (sym
, v
);
2041 SET_SYMBOL_ALIAS (struct Lisp_Symbol
*sym
, struct Lisp_Symbol
*v
)
2043 eassume (sym
->u
.s
.redirect
== SYMBOL_VARALIAS
&& v
);
2044 sym
->u
.s
.val
.alias
= v
;
2047 SET_SYMBOL_BLV (struct Lisp_Symbol
*sym
, struct Lisp_Buffer_Local_Value
*v
)
2049 eassume (sym
->u
.s
.redirect
== SYMBOL_LOCALIZED
&& v
);
2050 sym
->u
.s
.val
.blv
= v
;
2053 SET_SYMBOL_FWD (struct Lisp_Symbol
*sym
, union Lisp_Fwd
*v
)
2055 eassume (sym
->u
.s
.redirect
== SYMBOL_FORWARDED
&& v
);
2056 sym
->u
.s
.val
.fwd
= v
;
2060 SYMBOL_NAME (Lisp_Object sym
)
2062 return XSYMBOL (sym
)->u
.s
.name
;
2065 /* Value is true if SYM is an interned symbol. */
2068 SYMBOL_INTERNED_P (Lisp_Object sym
)
2070 return XSYMBOL (sym
)->u
.s
.interned
!= SYMBOL_UNINTERNED
;
2073 /* Value is true if SYM is interned in initial_obarray. */
2076 SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P (Lisp_Object sym
)
2078 return XSYMBOL (sym
)->u
.s
.interned
== SYMBOL_INTERNED_IN_INITIAL_OBARRAY
;
2081 /* Value is non-zero if symbol cannot be changed through a simple set,
2082 i.e. it's a constant (e.g. nil, t, :keywords), or it has some
2083 watching functions. */
2086 (SYMBOL_TRAPPED_WRITE_P
) (Lisp_Object sym
)
2088 return lisp_h_SYMBOL_TRAPPED_WRITE_P (sym
);
2091 /* Value is non-zero if symbol cannot be changed at all, i.e. it's a
2092 constant (e.g. nil, t, :keywords). Code that actually wants to
2093 write to SYM, should also check whether there are any watching
2097 (SYMBOL_CONSTANT_P
) (Lisp_Object sym
)
2099 return lisp_h_SYMBOL_CONSTANT_P (sym
);
2102 /* Placeholder for make-docfile to process. The actual symbol
2103 definition is done by lread.c's defsym. */
2104 #define DEFSYM(sym, name) /* empty */
2107 /***********************************************************************
2109 ***********************************************************************/
2111 /* The structure of a Lisp hash table. */
2113 struct hash_table_test
2115 /* Name of the function used to compare keys. */
2118 /* User-supplied hash function, or nil. */
2119 Lisp_Object user_hash_function
;
2121 /* User-supplied key comparison function, or nil. */
2122 Lisp_Object user_cmp_function
;
2124 /* C function to compare two keys. */
2125 bool (*cmpfn
) (struct hash_table_test
*t
, Lisp_Object
, Lisp_Object
);
2127 /* C function to compute hash code. */
2128 EMACS_UINT (*hashfn
) (struct hash_table_test
*t
, Lisp_Object
);
2131 struct Lisp_Hash_Table
2133 /* This is for Lisp; the hash table code does not refer to it. */
2134 union vectorlike_header header
;
2136 /* Nil if table is non-weak. Otherwise a symbol describing the
2137 weakness of the table. */
2140 /* Vector of hash codes. If hash[I] is nil, this means that the
2141 I-th entry is unused. */
2144 /* Vector used to chain entries. If entry I is free, next[I] is the
2145 entry number of the next free item. If entry I is non-free,
2146 next[I] is the index of the next entry in the collision chain,
2147 or -1 if there is such entry. */
2150 /* Bucket vector. An entry of -1 indicates no item is present,
2151 and a nonnegative entry is the index of the first item in
2152 a collision chain. This vector's size can be larger than the
2153 hash table size to reduce collisions. */
2156 /* Only the fields above are traced normally by the GC. The ones below
2157 `count' are special and are either ignored by the GC or traced in
2158 a special way (e.g. because of weakness). */
2160 /* Number of key/value entries in the table. */
2163 /* Index of first free entry in free list, or -1 if none. */
2164 ptrdiff_t next_free
;
2166 /* True if the table can be purecopied. The table cannot be
2167 changed afterwards. */
2170 /* Resize hash table when number of entries / table size is >= this
2172 float rehash_threshold
;
2174 /* Used when the table is resized. If equal to a negative integer,
2175 the user rehash-size is the integer -REHASH_SIZE, and the new
2176 size is the old size plus -REHASH_SIZE. If positive, the user
2177 rehash-size is the floating-point value REHASH_SIZE + 1, and the
2178 new size is the old size times REHASH_SIZE + 1. */
2181 /* Vector of keys and values. The key of item I is found at index
2182 2 * I, the value is found at index 2 * I + 1.
2183 This is gc_marked specially if the table is weak. */
2184 Lisp_Object key_and_value
;
2186 /* The comparison and hash functions. */
2187 struct hash_table_test test
;
2189 /* Next weak hash table if this is a weak hash table. The head
2190 of the list is in weak_hash_tables. */
2191 struct Lisp_Hash_Table
*next_weak
;
2196 HASH_TABLE_P (Lisp_Object a
)
2198 return PSEUDOVECTORP (a
, PVEC_HASH_TABLE
);
2201 INLINE
struct Lisp_Hash_Table
*
2202 XHASH_TABLE (Lisp_Object a
)
2204 eassert (HASH_TABLE_P (a
));
2205 return XUNTAG (a
, Lisp_Vectorlike
, struct Lisp_Hash_Table
);
2208 #define XSET_HASH_TABLE(VAR, PTR) \
2209 (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
2211 /* Value is the key part of entry IDX in hash table H. */
2213 HASH_KEY (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2215 return AREF (h
->key_and_value
, 2 * idx
);
2218 /* Value is the value part of entry IDX in hash table H. */
2220 HASH_VALUE (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2222 return AREF (h
->key_and_value
, 2 * idx
+ 1);
2225 /* Value is the hash code computed for entry IDX in hash table H. */
2227 HASH_HASH (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2229 return AREF (h
->hash
, idx
);
2232 /* Value is the size of hash table H. */
2234 HASH_TABLE_SIZE (struct Lisp_Hash_Table
*h
)
2236 return ASIZE (h
->next
);
2239 /* Default size for hash tables if not specified. */
2241 enum DEFAULT_HASH_SIZE
{ DEFAULT_HASH_SIZE
= 65 };
2243 /* Default threshold specifying when to resize a hash table. The
2244 value gives the ratio of current entries in the hash table and the
2245 size of the hash table. */
2247 static float const DEFAULT_REHASH_THRESHOLD
= 0.8125;
2249 /* Default factor by which to increase the size of a hash table, minus 1. */
2251 static float const DEFAULT_REHASH_SIZE
= 1.5 - 1;
2253 /* Combine two integers X and Y for hashing. The result might not fit
2254 into a Lisp integer. */
2257 sxhash_combine (EMACS_UINT x
, EMACS_UINT y
)
2259 return (x
<< 4) + (x
>> (EMACS_INT_WIDTH
- 4)) + y
;
2262 /* Hash X, returning a value that fits into a fixnum. */
2265 SXHASH_REDUCE (EMACS_UINT x
)
2267 return (x
^ x
>> (EMACS_INT_WIDTH
- FIXNUM_BITS
)) & INTMASK
;
2270 /* These structures are used for various misc types. */
2272 struct Lisp_Misc_Any
/* Supertype of all Misc types. */
2274 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_??? */
2275 bool_bf gcmarkbit
: 1;
2276 unsigned spacer
: 15;
2280 (MISCP
) (Lisp_Object x
)
2282 return lisp_h_MISCP (x
);
2285 INLINE
struct Lisp_Misc_Any
*
2286 XMISCANY (Lisp_Object a
)
2288 eassert (MISCP (a
));
2289 return XUNTAG (a
, Lisp_Misc
, struct Lisp_Misc_Any
);
2292 INLINE
enum Lisp_Misc_Type
2293 XMISCTYPE (Lisp_Object a
)
2295 return XMISCANY (a
)->type
;
2300 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Marker */
2301 bool_bf gcmarkbit
: 1;
2302 unsigned spacer
: 13;
2303 /* This flag is temporarily used in the functions
2304 decode/encode_coding_object to record that the marker position
2305 must be adjusted after the conversion. */
2306 bool_bf need_adjustment
: 1;
2307 /* True means normal insertion at the marker's position
2308 leaves the marker after the inserted text. */
2309 bool_bf insertion_type
: 1;
2310 /* This is the buffer that the marker points into, or 0 if it points nowhere.
2311 Note: a chain of markers can contain markers pointing into different
2312 buffers (the chain is per buffer_text rather than per buffer, so it's
2313 shared between indirect buffers). */
2314 /* This is used for (other than NULL-checking):
2316 - Fset_marker: check eq(oldbuf, newbuf) to avoid unchain+rechain.
2317 - unchain_marker: to find the list from which to unchain.
2318 - Fkill_buffer: to only unchain the markers of current indirect buffer.
2320 struct buffer
*buffer
;
2322 /* The remaining fields are meaningless in a marker that
2323 does not point anywhere. */
2325 /* For markers that point somewhere,
2326 this is used to chain of all the markers in a given buffer. */
2327 /* We could remove it and use an array in buffer_text instead.
2328 That would also allow us to preserve it ordered. */
2329 struct Lisp_Marker
*next
;
2330 /* This is the char position where the marker points. */
2332 /* This is the byte position.
2333 It's mostly used as a charpos<->bytepos cache (i.e. it's not directly
2334 used to implement the functionality of markers, but rather to (ab)use
2335 markers as a cache for char<->byte mappings). */
2339 /* START and END are markers in the overlay's buffer, and
2340 PLIST is the overlay's property list. */
2342 /* An overlay's real data content is:
2344 - buffer (really there are two buffer pointers, one per marker,
2345 and both points to the same buffer)
2346 - insertion type of both ends (per-marker fields)
2347 - start & start byte (of start marker)
2348 - end & end byte (of end marker)
2349 - next (singly linked list of overlays)
2350 - next fields of start and end markers (singly linked list of markers).
2351 I.e. 9words plus 2 bits, 3words of which are for external linked lists.
2354 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Overlay */
2355 bool_bf gcmarkbit
: 1;
2356 unsigned spacer
: 15;
2357 struct Lisp_Overlay
*next
;
2363 struct Lisp_Misc_Ptr
2365 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Ptr */
2366 bool_bf gcmarkbit
: 1;
2367 unsigned spacer
: 15;
2371 extern Lisp_Object
make_misc_ptr (void *);
2373 /* A mint_ptr object OBJ represents a C-language pointer P efficiently.
2374 Preferably (and typically), OBJ is a Lisp integer I such that
2375 XINTPTR (I) == P, as this represents P within a single Lisp value
2376 without requiring any auxiliary memory. However, if P would be
2377 damaged by being tagged as an integer and then untagged via
2378 XINTPTR, then OBJ is a Lisp_Misc_Ptr with pointer component P.
2380 mint_ptr objects are efficiency hacks intended for C code.
2381 Although xmint_ptr can be given any mint_ptr generated by non-buggy
2382 C code, it should not be given a mint_ptr generated from Lisp code
2383 as that would allow Lisp code to coin pointers from integers and
2384 could lead to crashes. To package a C pointer into a Lisp-visible
2385 object you can put the pointer into a Lisp_Misc object instead; see
2386 Lisp_User_Ptr for an example. */
2389 make_mint_ptr (void *a
)
2391 Lisp_Object val
= TAG_PTR (Lisp_Int0
, a
);
2392 return INTEGERP (val
) && XINTPTR (val
) == a
? val
: make_misc_ptr (a
);
2396 mint_ptrp (Lisp_Object x
)
2398 return INTEGERP (x
) || (MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Ptr
);
2402 xmint_pointer (Lisp_Object a
)
2404 eassert (mint_ptrp (a
));
2407 return XUNTAG (a
, Lisp_Misc
, struct Lisp_Misc_Ptr
)->pointer
;
2411 struct Lisp_User_Ptr
2413 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_User_Ptr */
2414 bool_bf gcmarkbit
: 1;
2415 unsigned spacer
: 15;
2417 void (*finalizer
) (void *);
2422 /* A finalizer sentinel. */
2423 struct Lisp_Finalizer
2425 struct Lisp_Misc_Any base
;
2427 /* Circular list of all active weak references. */
2428 struct Lisp_Finalizer
*prev
;
2429 struct Lisp_Finalizer
*next
;
2431 /* Call FUNCTION when the finalizer becomes unreachable, even if
2432 FUNCTION contains a reference to the finalizer; i.e., call
2433 FUNCTION when it is reachable _only_ through finalizers. */
2434 Lisp_Object function
;
2438 FINALIZERP (Lisp_Object x
)
2440 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Finalizer
;
2443 INLINE
struct Lisp_Finalizer
*
2444 XFINALIZER (Lisp_Object a
)
2446 eassert (FINALIZERP (a
));
2447 return XUNTAG (a
, Lisp_Misc
, struct Lisp_Finalizer
);
2450 /* A miscellaneous object, when it's on the free list. */
2453 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Free */
2454 bool_bf gcmarkbit
: 1;
2455 unsigned spacer
: 15;
2456 union Lisp_Misc
*chain
;
2459 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
2460 It uses one of these struct subtypes to get the type field. */
2464 struct Lisp_Misc_Any u_any
; /* Supertype of all Misc types. */
2465 struct Lisp_Free u_free
;
2466 struct Lisp_Marker u_marker
;
2467 struct Lisp_Overlay u_overlay
;
2468 struct Lisp_Finalizer u_finalizer
;
2469 struct Lisp_Misc_Ptr u_misc_ptr
;
2471 struct Lisp_User_Ptr u_user_ptr
;
2475 INLINE
union Lisp_Misc
*
2476 XMISC (Lisp_Object a
)
2478 return XUNTAG (a
, Lisp_Misc
, union Lisp_Misc
);
2482 (MARKERP
) (Lisp_Object x
)
2484 return lisp_h_MARKERP (x
);
2487 INLINE
struct Lisp_Marker
*
2488 XMARKER (Lisp_Object a
)
2490 eassert (MARKERP (a
));
2491 return XUNTAG (a
, Lisp_Misc
, struct Lisp_Marker
);
2495 OVERLAYP (Lisp_Object x
)
2497 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Overlay
;
2500 INLINE
struct Lisp_Overlay
*
2501 XOVERLAY (Lisp_Object a
)
2503 eassert (OVERLAYP (a
));
2504 return XUNTAG (a
, Lisp_Misc
, struct Lisp_Overlay
);
2509 USER_PTRP (Lisp_Object x
)
2511 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_User_Ptr
;
2514 INLINE
struct Lisp_User_Ptr
*
2515 XUSER_PTR (Lisp_Object a
)
2517 eassert (USER_PTRP (a
));
2518 return XUNTAG (a
, Lisp_Misc
, struct Lisp_User_Ptr
);
2523 /* Forwarding pointer to an int variable.
2524 This is allowed only in the value cell of a symbol,
2525 and it means that the symbol's value really lives in the
2526 specified int variable. */
2529 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Int */
2533 /* Boolean forwarding pointer to an int variable.
2534 This is like Lisp_Intfwd except that the ostensible
2535 "value" of the symbol is t if the bool variable is true,
2536 nil if it is false. */
2539 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Bool */
2543 /* Forwarding pointer to a Lisp_Object variable.
2544 This is allowed only in the value cell of a symbol,
2545 and it means that the symbol's value really lives in the
2546 specified variable. */
2549 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Obj */
2550 Lisp_Object
*objvar
;
2553 /* Like Lisp_Objfwd except that value lives in a slot in the
2554 current buffer. Value is byte index of slot within buffer. */
2555 struct Lisp_Buffer_Objfwd
2557 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Buffer_Obj */
2559 /* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp. */
2560 Lisp_Object predicate
;
2563 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
2564 the symbol has buffer-local bindings. (Exception:
2565 some buffer-local variables are built-in, with their values stored
2566 in the buffer structure itself. They are handled differently,
2567 using struct Lisp_Buffer_Objfwd.)
2569 The `valcell' slot holds the variable's current value (unless `fwd'
2570 is set). This value is the one that corresponds to the loaded binding.
2571 To read or set the variable, you must first make sure the right binding
2572 is loaded; then you can access the value in (or through) `valcell'.
2574 `where' is the buffer for which the loaded binding was found.
2575 If it has changed, to make sure the right binding is loaded it is
2576 necessary to find which binding goes with the current buffer, then
2577 load it. To load it, first unload the previous binding.
2579 `local_if_set' indicates that merely setting the variable creates a
2580 local binding for the current buffer. Otherwise the latter, setting
2581 the variable does not do that; only make-local-variable does that. */
2583 struct Lisp_Buffer_Local_Value
2585 /* True means that merely setting the variable creates a local
2586 binding for the current buffer. */
2587 bool_bf local_if_set
: 1;
2588 /* True means that the binding now loaded was found.
2589 Presumably equivalent to (defcell!=valcell). */
2591 /* If non-NULL, a forwarding to the C var where it should also be set. */
2592 union Lisp_Fwd
*fwd
; /* Should never be (Buffer|Kboard)_Objfwd. */
2593 /* The buffer for which the loaded binding was found. */
2595 /* A cons cell that holds the default value. It has the form
2596 (SYMBOL . DEFAULT-VALUE). */
2597 Lisp_Object defcell
;
2598 /* The cons cell from `where's parameter alist.
2599 It always has the form (SYMBOL . VALUE)
2600 Note that if `fwd' is non-NULL, VALUE may be out of date.
2601 Also if the currently loaded binding is the default binding, then
2602 this is `eq'ual to defcell. */
2603 Lisp_Object valcell
;
2606 /* Like Lisp_Objfwd except that value lives in a slot in the
2608 struct Lisp_Kboard_Objfwd
2610 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Kboard_Obj */
2616 struct Lisp_Intfwd u_intfwd
;
2617 struct Lisp_Boolfwd u_boolfwd
;
2618 struct Lisp_Objfwd u_objfwd
;
2619 struct Lisp_Buffer_Objfwd u_buffer_objfwd
;
2620 struct Lisp_Kboard_Objfwd u_kboard_objfwd
;
2623 INLINE
enum Lisp_Fwd_Type
2624 XFWDTYPE (union Lisp_Fwd
*a
)
2626 return a
->u_intfwd
.type
;
2630 BUFFER_OBJFWDP (union Lisp_Fwd
*a
)
2632 return XFWDTYPE (a
) == Lisp_Fwd_Buffer_Obj
;
2635 INLINE
struct Lisp_Buffer_Objfwd
*
2636 XBUFFER_OBJFWD (union Lisp_Fwd
*a
)
2638 eassert (BUFFER_OBJFWDP (a
));
2639 return &a
->u_buffer_objfwd
;
2642 /* Lisp floating point type. */
2648 struct Lisp_Float
*chain
;
2653 (FLOATP
) (Lisp_Object x
)
2655 return lisp_h_FLOATP (x
);
2658 INLINE
struct Lisp_Float
*
2659 XFLOAT (Lisp_Object a
)
2661 eassert (FLOATP (a
));
2662 return XUNTAG (a
, Lisp_Float
, struct Lisp_Float
);
2666 XFLOAT_DATA (Lisp_Object f
)
2668 return XFLOAT (f
)->u
.data
;
2671 /* Most hosts nowadays use IEEE floating point, so they use IEC 60559
2672 representations, have infinities and NaNs, and do not trap on
2673 exceptions. Define IEEE_FLOATING_POINT if this host is one of the
2674 typical ones. The C11 macro __STDC_IEC_559__ is close to what is
2675 wanted here, but is not quite right because Emacs does not require
2676 all the features of C11 Annex F (and does not require C11 at all,
2677 for that matter). */
2681 = (FLT_RADIX
== 2 && FLT_MANT_DIG
== 24
2682 && FLT_MIN_EXP
== -125 && FLT_MAX_EXP
== 128)
2685 /* A character, declared with the following typedef, is a member
2686 of some character set associated with the current buffer. */
2687 #ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
2689 typedef unsigned char UCHAR
;
2692 /* Meanings of slots in a Lisp_Compiled: */
2696 COMPILED_ARGLIST
= 0,
2697 COMPILED_BYTECODE
= 1,
2698 COMPILED_CONSTANTS
= 2,
2699 COMPILED_STACK_DEPTH
= 3,
2700 COMPILED_DOC_STRING
= 4,
2701 COMPILED_INTERACTIVE
= 5
2704 /* Flag bits in a character. These also get used in termhooks.h.
2705 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
2706 (MUlti-Lingual Emacs) might need 22 bits for the character value
2707 itself, so we probably shouldn't use any bits lower than 0x0400000. */
2710 CHAR_ALT
= 0x0400000,
2711 CHAR_SUPER
= 0x0800000,
2712 CHAR_HYPER
= 0x1000000,
2713 CHAR_SHIFT
= 0x2000000,
2714 CHAR_CTL
= 0x4000000,
2715 CHAR_META
= 0x8000000,
2717 CHAR_MODIFIER_MASK
=
2718 CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
| CHAR_SHIFT
| CHAR_CTL
| CHAR_META
,
2720 /* Actually, the current Emacs uses 22 bits for the character value
2725 /* Data type checking. */
2728 NUMBERP (Lisp_Object x
)
2730 return INTEGERP (x
) || FLOATP (x
);
2733 NATNUMP (Lisp_Object x
)
2735 return INTEGERP (x
) && 0 <= XINT (x
);
2739 RANGED_INTEGERP (intmax_t lo
, Lisp_Object x
, intmax_t hi
)
2741 return INTEGERP (x
) && lo
<= XINT (x
) && XINT (x
) <= hi
;
2744 #define TYPE_RANGED_INTEGERP(type, x) \
2746 && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \
2747 && XINT (x) <= TYPE_MAXIMUM (type))
2750 AUTOLOADP (Lisp_Object x
)
2752 return CONSP (x
) && EQ (Qautoload
, XCAR (x
));
2756 /* Test for specific pseudovector types. */
2759 WINDOW_CONFIGURATIONP (Lisp_Object a
)
2761 return PSEUDOVECTORP (a
, PVEC_WINDOW_CONFIGURATION
);
2765 COMPILEDP (Lisp_Object a
)
2767 return PSEUDOVECTORP (a
, PVEC_COMPILED
);
2771 FRAMEP (Lisp_Object a
)
2773 return PSEUDOVECTORP (a
, PVEC_FRAME
);
2777 RECORDP (Lisp_Object a
)
2779 return PSEUDOVECTORP (a
, PVEC_RECORD
);
2783 CHECK_RECORD (Lisp_Object x
)
2785 CHECK_TYPE (RECORDP (x
), Qrecordp
, x
);
2788 /* Test for image (image . spec) */
2790 IMAGEP (Lisp_Object x
)
2792 return CONSP (x
) && EQ (XCAR (x
), Qimage
);
2797 ARRAYP (Lisp_Object x
)
2799 return VECTORP (x
) || STRINGP (x
) || CHAR_TABLE_P (x
) || BOOL_VECTOR_P (x
);
2803 CHECK_LIST (Lisp_Object x
)
2805 CHECK_TYPE (CONSP (x
) || NILP (x
), Qlistp
, x
);
2809 CHECK_LIST_END (Lisp_Object x
, Lisp_Object y
)
2811 CHECK_TYPE (NILP (x
), Qlistp
, y
);
2815 (CHECK_NUMBER
) (Lisp_Object x
)
2817 lisp_h_CHECK_NUMBER (x
);
2821 CHECK_STRING_CAR (Lisp_Object x
)
2823 CHECK_TYPE (STRINGP (XCAR (x
)), Qstringp
, XCAR (x
));
2825 /* This is a bit special because we always need size afterwards. */
2827 CHECK_VECTOR_OR_STRING (Lisp_Object x
)
2833 wrong_type_argument (Qarrayp
, x
);
2836 CHECK_ARRAY (Lisp_Object x
, Lisp_Object predicate
)
2838 CHECK_TYPE (ARRAYP (x
), predicate
, x
);
2841 CHECK_NATNUM (Lisp_Object x
)
2843 CHECK_TYPE (NATNUMP (x
), Qwholenump
, x
);
2846 #define CHECK_RANGED_INTEGER(x, lo, hi) \
2849 if (! ((lo) <= XINT (x) && XINT (x) <= (hi))) \
2850 args_out_of_range_3 \
2852 make_number ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM \
2853 ? MOST_NEGATIVE_FIXNUM \
2855 make_number (min (hi, MOST_POSITIVE_FIXNUM))); \
2857 #define CHECK_TYPE_RANGED_INTEGER(type, x) \
2859 if (TYPE_SIGNED (type)) \
2860 CHECK_RANGED_INTEGER (x, TYPE_MINIMUM (type), TYPE_MAXIMUM (type)); \
2862 CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type)); \
2865 #define CHECK_NUMBER_COERCE_MARKER(x) \
2867 if (MARKERP ((x))) \
2868 XSETFASTINT (x, marker_position (x)); \
2870 CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); \
2874 XFLOATINT (Lisp_Object n
)
2876 return FLOATP (n
) ? XFLOAT_DATA (n
) : XINT (n
);
2880 CHECK_NUMBER_OR_FLOAT (Lisp_Object x
)
2882 CHECK_TYPE (NUMBERP (x
), Qnumberp
, x
);
2885 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
2888 XSETFASTINT (x, marker_position (x)); \
2890 CHECK_TYPE (NUMBERP (x), Qnumber_or_marker_p, x); \
2893 /* Since we can't assign directly to the CAR or CDR fields of a cons
2894 cell, use these when checking that those fields contain numbers. */
2896 CHECK_NUMBER_CAR (Lisp_Object x
)
2898 Lisp_Object tmp
= XCAR (x
);
2904 CHECK_NUMBER_CDR (Lisp_Object x
)
2906 Lisp_Object tmp
= XCDR (x
);
2911 /* Define a built-in function for calling from Lisp.
2912 `lname' should be the name to give the function in Lisp,
2913 as a null-terminated C string.
2914 `fnname' should be the name of the function in C.
2915 By convention, it starts with F.
2916 `sname' should be the name for the C constant structure
2917 that records information on this function for internal use.
2918 By convention, it should be the same as `fnname' but with S instead of F.
2919 It's too bad that C macros can't compute this from `fnname'.
2920 `minargs' should be a number, the minimum number of arguments allowed.
2921 `maxargs' should be a number, the maximum number of arguments allowed,
2922 or else MANY or UNEVALLED.
2923 MANY means pass a vector of evaluated arguments,
2924 in the form of an integer number-of-arguments
2925 followed by the address of a vector of Lisp_Objects
2926 which contains the argument values.
2927 UNEVALLED means pass the list of unevaluated arguments
2928 `intspec' says how interactive arguments are to be fetched.
2929 If the string starts with a `(', `intspec' is evaluated and the resulting
2930 list is the list of arguments.
2931 If it's a string that doesn't start with `(', the value should follow
2932 the one of the doc string for `interactive'.
2933 A null string means call interactively with no arguments.
2934 `doc' is documentation for the user. */
2936 /* This version of DEFUN declares a function prototype with the right
2937 arguments, so we can catch errors with maxargs at compile-time. */
2938 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
2939 static struct Lisp_Subr sname = \
2940 { { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS }, \
2941 { .a ## maxargs = fnname }, \
2942 minargs, maxargs, lname, intspec, 0}; \
2946 is how we define the symbol for function `name' at start-up time. */
2947 extern void defsubr (struct Lisp_Subr
*);
2955 /* Call a function F that accepts many args, passing it ARRAY's elements. */
2956 #define CALLMANY(f, array) (f) (ARRAYELTS (array), array)
2958 /* Call a function F that accepts many args, passing it the remaining args,
2959 E.g., 'return CALLN (Fformat, fmt, text);' is less error-prone than
2960 '{ Lisp_Object a[2]; a[0] = fmt; a[1] = text; return Fformat (2, a); }'.
2961 CALLN is overkill for simple usages like 'Finsert (1, &text);'. */
2962 #define CALLN(f, ...) CALLMANY (f, ((Lisp_Object []) {__VA_ARGS__}))
2964 extern void defvar_lisp (struct Lisp_Objfwd
*, const char *, Lisp_Object
*);
2965 extern void defvar_lisp_nopro (struct Lisp_Objfwd
*, const char *, Lisp_Object
*);
2966 extern void defvar_bool (struct Lisp_Boolfwd
*, const char *, bool *);
2967 extern void defvar_int (struct Lisp_Intfwd
*, const char *, EMACS_INT
*);
2968 extern void defvar_kboard (struct Lisp_Kboard_Objfwd
*, const char *, int);
2970 /* Macros we use to define forwarded Lisp variables.
2971 These are used in the syms_of_FILENAME functions.
2973 An ordinary (not in buffer_defaults, per-buffer, or per-keyboard)
2974 lisp variable is actually a field in `struct emacs_globals'. The
2975 field's name begins with "f_", which is a convention enforced by
2976 these macros. Each such global has a corresponding #define in
2977 globals.h; the plain name should be used in the code.
2979 E.g., the global "cons_cells_consed" is declared as "int
2980 f_cons_cells_consed" in globals.h, but there is a define:
2982 #define cons_cells_consed globals.f_cons_cells_consed
2984 All C code uses the `cons_cells_consed' name. This is all done
2985 this way to support indirection for multi-threaded Emacs. */
2987 #define DEFVAR_LISP(lname, vname, doc) \
2989 static struct Lisp_Objfwd o_fwd; \
2990 defvar_lisp (&o_fwd, lname, &globals.f_ ## vname); \
2992 #define DEFVAR_LISP_NOPRO(lname, vname, doc) \
2994 static struct Lisp_Objfwd o_fwd; \
2995 defvar_lisp_nopro (&o_fwd, lname, &globals.f_ ## vname); \
2997 #define DEFVAR_BOOL(lname, vname, doc) \
2999 static struct Lisp_Boolfwd b_fwd; \
3000 defvar_bool (&b_fwd, lname, &globals.f_ ## vname); \
3002 #define DEFVAR_INT(lname, vname, doc) \
3004 static struct Lisp_Intfwd i_fwd; \
3005 defvar_int (&i_fwd, lname, &globals.f_ ## vname); \
3008 #define DEFVAR_KBOARD(lname, vname, doc) \
3010 static struct Lisp_Kboard_Objfwd ko_fwd; \
3011 defvar_kboard (&ko_fwd, lname, offsetof (KBOARD, vname ## _)); \
3015 /* Elisp uses several stacks:
3017 - the bytecode stack: used internally by the bytecode interpreter.
3018 Allocated from the C stack.
3019 - The specpdl stack: keeps track of active unwind-protect and
3020 dynamic-let-bindings. Allocated from the `specpdl' array, a manually
3022 - The handler stack: keeps track of active catch tags and condition-case
3023 handlers. Allocated in a manually managed stack implemented by a
3024 doubly-linked list allocated via xmalloc and never freed. */
3026 /* Structure for recording Lisp call stack for backtrace purposes. */
3028 /* The special binding stack holds the outer values of variables while
3029 they are bound by a function application or a let form, stores the
3030 code to be executed for unwind-protect forms.
3032 NOTE: The specbinding union is defined here, because SPECPDL_INDEX is
3033 used all over the place, needs to be fast, and needs to know the size of
3034 union specbinding. But only eval.c should access it. */
3037 SPECPDL_UNWIND
, /* An unwind_protect function on Lisp_Object. */
3038 SPECPDL_UNWIND_ARRAY
, /* Likewise, on an array that needs freeing.
3039 Its elements are potential Lisp_Objects. */
3040 SPECPDL_UNWIND_PTR
, /* Likewise, on void *. */
3041 SPECPDL_UNWIND_INT
, /* Likewise, on int. */
3042 SPECPDL_UNWIND_EXCURSION
, /* Likewise, on an execursion. */
3043 SPECPDL_UNWIND_VOID
, /* Likewise, with no arg. */
3044 SPECPDL_BACKTRACE
, /* An element of the backtrace. */
3045 SPECPDL_LET
, /* A plain and simple dynamic let-binding. */
3046 /* Tags greater than SPECPDL_LET must be "subkinds" of LET. */
3047 SPECPDL_LET_LOCAL
, /* A buffer-local let-binding. */
3048 SPECPDL_LET_DEFAULT
/* A global binding for a localized var. */
3053 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3055 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3056 void (*func
) (Lisp_Object
);
3060 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3061 void (*func
) (Lisp_Object
);
3066 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3067 void (*func
) (void *);
3071 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3076 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3077 Lisp_Object marker
, window
;
3080 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3081 void (*func
) (void);
3084 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3085 /* `where' is not used in the case of SPECPDL_LET. */
3086 Lisp_Object symbol
, old_value
, where
;
3087 /* Normally this is unused; but it is set to the symbol's
3088 current value when a thread is swapped out. */
3089 Lisp_Object saved_value
;
3092 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3093 bool_bf debug_on_exit
: 1;
3094 Lisp_Object function
;
3100 /* These 3 are defined as macros in thread.h. */
3101 /* extern union specbinding *specpdl; */
3102 /* extern union specbinding *specpdl_ptr; */
3103 /* extern ptrdiff_t specpdl_size; */
3106 SPECPDL_INDEX (void)
3108 return specpdl_ptr
- specpdl
;
3111 /* This structure helps implement the `catch/throw' and `condition-case/signal'
3112 control structures. A struct handler contains all the information needed to
3113 restore the state of the interpreter after a non-local jump.
3115 handler structures are chained together in a doubly linked list; the `next'
3116 member points to the next outer catchtag and the `nextfree' member points in
3117 the other direction to the next inner element (which is typically the next
3118 free element since we mostly use it on the deepest handler).
3120 A call like (throw TAG VAL) searches for a catchtag whose `tag_or_ch'
3121 member is TAG, and then unbinds to it. The `val' member is used to
3122 hold VAL while the stack is unwound; `val' is returned as the value
3123 of the catch form. If there is a handler of type CATCHER_ALL, it will
3124 be treated as a handler for all invocations of `throw'; in this case
3125 `val' will be set to (TAG . VAL).
3127 All the other members are concerned with restoring the interpreter
3130 Members are volatile if their values need to survive _longjmp when
3131 a 'struct handler' is a local variable. */
3133 enum handlertype
{ CATCHER
, CONDITION_CASE
, CATCHER_ALL
};
3137 enum handlertype type
;
3138 Lisp_Object tag_or_ch
;
3140 struct handler
*next
;
3141 struct handler
*nextfree
;
3143 /* The bytecode interpreter can have several handlers active at the same
3144 time, so when we longjmp to one of them, it needs to know which handler
3145 this was and what was the corresponding internal state. This is stored
3146 here, and when we longjmp we make sure that handlerlist points to the
3148 Lisp_Object
*bytecode_top
;
3151 /* Most global vars are reset to their value via the specpdl mechanism,
3152 but a few others are handled by storing their value here. */
3154 EMACS_INT f_lisp_eval_depth
;
3156 int poll_suppress_count
;
3157 int interrupt_input_blocked
;
3160 extern Lisp_Object memory_signal_data
;
3162 extern void maybe_quit (void);
3164 /* True if ought to quit now. */
3166 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
3168 /* Process a quit rarely, based on a counter COUNT, for efficiency.
3169 "Rarely" means once per USHRT_MAX + 1 times; this is somewhat
3170 arbitrary, but efficient. */
3173 rarely_quit (unsigned short int count
)
3179 extern Lisp_Object Vascii_downcase_table
;
3180 extern Lisp_Object Vascii_canon_table
;
3182 /* Call staticpro (&var) to protect static variable `var'. */
3184 void staticpro (Lisp_Object
*);
3186 /* Forward declarations for prototypes. */
3190 /* Copy COUNT Lisp_Objects from ARGS to contents of V starting from OFFSET. */
3193 vcopy (Lisp_Object v
, ptrdiff_t offset
, Lisp_Object
*args
, ptrdiff_t count
)
3195 eassert (0 <= offset
&& 0 <= count
&& offset
+ count
<= ASIZE (v
));
3196 memcpy (XVECTOR (v
)->contents
+ offset
, args
, count
* sizeof *args
);
3199 /* Functions to modify hash tables. */
3202 set_hash_key_slot (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
, Lisp_Object val
)
3204 gc_aset (h
->key_and_value
, 2 * idx
, val
);
3208 set_hash_value_slot (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
, Lisp_Object val
)
3210 gc_aset (h
->key_and_value
, 2 * idx
+ 1, val
);
3213 /* Use these functions to set Lisp_Object
3214 or pointer slots of struct Lisp_Symbol. */
3217 set_symbol_function (Lisp_Object sym
, Lisp_Object function
)
3219 XSYMBOL (sym
)->u
.s
.function
= function
;
3223 set_symbol_plist (Lisp_Object sym
, Lisp_Object plist
)
3225 XSYMBOL (sym
)->u
.s
.plist
= plist
;
3229 set_symbol_next (Lisp_Object sym
, struct Lisp_Symbol
*next
)
3231 XSYMBOL (sym
)->u
.s
.next
= next
;
3235 make_symbol_constant (Lisp_Object sym
)
3237 XSYMBOL (sym
)->u
.s
.trapped_write
= SYMBOL_NOWRITE
;
3240 /* Buffer-local variable access functions. */
3243 blv_found (struct Lisp_Buffer_Local_Value
*blv
)
3245 eassert (blv
->found
== !EQ (blv
->defcell
, blv
->valcell
));
3249 /* Set overlay's property list. */
3252 set_overlay_plist (Lisp_Object overlay
, Lisp_Object plist
)
3254 XOVERLAY (overlay
)->plist
= plist
;
3257 /* Get text properties of S. */
3260 string_intervals (Lisp_Object s
)
3262 return XSTRING (s
)->u
.s
.intervals
;
3265 /* Set text properties of S to I. */
3268 set_string_intervals (Lisp_Object s
, INTERVAL i
)
3270 XSTRING (s
)->u
.s
.intervals
= i
;
3273 /* Set a Lisp slot in TABLE to VAL. Most code should use this instead
3274 of setting slots directly. */
3277 set_char_table_defalt (Lisp_Object table
, Lisp_Object val
)
3279 XCHAR_TABLE (table
)->defalt
= val
;
3282 set_char_table_purpose (Lisp_Object table
, Lisp_Object val
)
3284 XCHAR_TABLE (table
)->purpose
= val
;
3287 /* Set different slots in (sub)character tables. */
3290 set_char_table_extras (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3292 eassert (0 <= idx
&& idx
< CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (table
)));
3293 XCHAR_TABLE (table
)->extras
[idx
] = val
;
3297 set_char_table_contents (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3299 eassert (0 <= idx
&& idx
< (1 << CHARTAB_SIZE_BITS_0
));
3300 XCHAR_TABLE (table
)->contents
[idx
] = val
;
3304 set_sub_char_table_contents (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3306 XSUB_CHAR_TABLE (table
)->contents
[idx
] = val
;
3309 /* Defined in data.c. */
3310 extern _Noreturn
void wrong_choice (Lisp_Object
, Lisp_Object
);
3311 extern void notify_variable_watchers (Lisp_Object
, Lisp_Object
,
3312 Lisp_Object
, Lisp_Object
);
3313 extern Lisp_Object
indirect_function (Lisp_Object
);
3314 extern Lisp_Object
find_symbol_value (Lisp_Object
);
3315 enum Arith_Comparison
{
3320 ARITH_LESS_OR_EQUAL
,
3323 extern Lisp_Object
arithcompare (Lisp_Object num1
, Lisp_Object num2
,
3324 enum Arith_Comparison comparison
);
3326 /* Convert the integer I to an Emacs representation, either the integer
3327 itself, or a cons of two or three integers, or if all else fails a float.
3328 I should not have side effects. */
3329 #define INTEGER_TO_CONS(i) \
3330 (! FIXNUM_OVERFLOW_P (i) \
3332 : EXPR_SIGNED (i) ? intbig_to_lisp (i) : uintbig_to_lisp (i))
3333 extern Lisp_Object
intbig_to_lisp (intmax_t);
3334 extern Lisp_Object
uintbig_to_lisp (uintmax_t);
3336 /* Convert the Emacs representation CONS back to an integer of type
3337 TYPE, storing the result the variable VAR. Signal an error if CONS
3338 is not a valid representation or is out of range for TYPE. */
3339 #define CONS_TO_INTEGER(cons, type, var) \
3340 (TYPE_SIGNED (type) \
3341 ? ((var) = cons_to_signed (cons, TYPE_MINIMUM (type), TYPE_MAXIMUM (type))) \
3342 : ((var) = cons_to_unsigned (cons, TYPE_MAXIMUM (type))))
3343 extern intmax_t cons_to_signed (Lisp_Object
, intmax_t, intmax_t);
3344 extern uintmax_t cons_to_unsigned (Lisp_Object
, uintmax_t);
3346 extern struct Lisp_Symbol
*indirect_variable (struct Lisp_Symbol
*);
3347 extern _Noreturn
void args_out_of_range (Lisp_Object
, Lisp_Object
);
3348 extern _Noreturn
void args_out_of_range_3 (Lisp_Object
, Lisp_Object
,
3350 extern _Noreturn
void circular_list (Lisp_Object
);
3351 extern Lisp_Object
do_symval_forwarding (union Lisp_Fwd
*);
3352 enum Set_Internal_Bind
{
3355 SET_INTERNAL_UNBIND
,
3356 SET_INTERNAL_THREAD_SWITCH
3358 extern void set_internal (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3359 enum Set_Internal_Bind
);
3360 extern void set_default_internal (Lisp_Object
, Lisp_Object
,
3361 enum Set_Internal_Bind bindflag
);
3363 extern void syms_of_data (void);
3364 extern void swap_in_global_binding (struct Lisp_Symbol
*);
3366 /* Defined in cmds.c */
3367 extern void syms_of_cmds (void);
3368 extern void keys_of_cmds (void);
3370 /* Defined in coding.c. */
3371 extern Lisp_Object
detect_coding_system (const unsigned char *, ptrdiff_t,
3372 ptrdiff_t, bool, bool, Lisp_Object
);
3373 extern void init_coding (void);
3374 extern void init_coding_once (void);
3375 extern void syms_of_coding (void);
3377 /* Defined in character.c. */
3378 extern ptrdiff_t chars_in_text (const unsigned char *, ptrdiff_t);
3379 extern ptrdiff_t multibyte_chars_in_text (const unsigned char *, ptrdiff_t);
3380 extern void syms_of_character (void);
3382 /* Defined in charset.c. */
3383 extern void init_charset (void);
3384 extern void init_charset_once (void);
3385 extern void syms_of_charset (void);
3386 /* Structure forward declarations. */
3389 /* Defined in syntax.c. */
3390 extern void init_syntax_once (void);
3391 extern void syms_of_syntax (void);
3393 /* Defined in fns.c. */
3394 enum { NEXT_ALMOST_PRIME_LIMIT
= 11 };
3395 extern EMACS_INT
next_almost_prime (EMACS_INT
) ATTRIBUTE_CONST
;
3396 extern Lisp_Object
larger_vector (Lisp_Object
, ptrdiff_t, ptrdiff_t);
3397 extern void sweep_weak_hash_tables (void);
3398 extern char *extract_data_from_object (Lisp_Object
, ptrdiff_t *, ptrdiff_t *);
3399 EMACS_UINT
hash_string (char const *, ptrdiff_t);
3400 EMACS_UINT
sxhash (Lisp_Object
, int);
3401 Lisp_Object
make_hash_table (struct hash_table_test
, EMACS_INT
, float, float,
3403 ptrdiff_t hash_lookup (struct Lisp_Hash_Table
*, Lisp_Object
, EMACS_UINT
*);
3404 ptrdiff_t hash_put (struct Lisp_Hash_Table
*, Lisp_Object
, Lisp_Object
,
3406 void hash_remove_from_table (struct Lisp_Hash_Table
*, Lisp_Object
);
3407 extern struct hash_table_test
const hashtest_eq
, hashtest_eql
, hashtest_equal
;
3408 extern void validate_subarray (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3409 ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
3410 extern Lisp_Object
substring_both (Lisp_Object
, ptrdiff_t, ptrdiff_t,
3411 ptrdiff_t, ptrdiff_t);
3412 extern Lisp_Object
merge (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3413 extern Lisp_Object
do_yes_or_no_p (Lisp_Object
);
3414 extern Lisp_Object
concat2 (Lisp_Object
, Lisp_Object
);
3415 extern Lisp_Object
concat3 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3416 extern bool equal_no_quit (Lisp_Object
, Lisp_Object
);
3417 extern Lisp_Object
nconc2 (Lisp_Object
, Lisp_Object
);
3418 extern Lisp_Object
assq_no_quit (Lisp_Object
, Lisp_Object
);
3419 extern Lisp_Object
assoc_no_quit (Lisp_Object
, Lisp_Object
);
3420 extern void clear_string_char_byte_cache (void);
3421 extern ptrdiff_t string_char_to_byte (Lisp_Object
, ptrdiff_t);
3422 extern ptrdiff_t string_byte_to_char (Lisp_Object
, ptrdiff_t);
3423 extern Lisp_Object
string_to_multibyte (Lisp_Object
);
3424 extern Lisp_Object
string_make_unibyte (Lisp_Object
);
3425 extern void syms_of_fns (void);
3427 /* Defined in floatfns.c. */
3428 extern void syms_of_floatfns (void);
3429 extern Lisp_Object
fmod_float (Lisp_Object x
, Lisp_Object y
);
3431 /* Defined in fringe.c. */
3432 extern void syms_of_fringe (void);
3433 extern void init_fringe (void);
3434 #ifdef HAVE_WINDOW_SYSTEM
3435 extern void mark_fringe_data (void);
3436 extern void init_fringe_once (void);
3437 #endif /* HAVE_WINDOW_SYSTEM */
3439 /* Defined in image.c. */
3440 extern int x_bitmap_mask (struct frame
*, ptrdiff_t);
3441 extern void reset_image_types (void);
3442 extern void syms_of_image (void);
3445 /* Defined in json.c. */
3446 extern void init_json (void);
3447 extern void syms_of_json (void);
3450 /* Defined in insdel.c. */
3451 extern void move_gap_both (ptrdiff_t, ptrdiff_t);
3452 extern _Noreturn
void buffer_overflow (void);
3453 extern void make_gap (ptrdiff_t);
3454 extern void make_gap_1 (struct buffer
*, ptrdiff_t);
3455 extern ptrdiff_t copy_text (const unsigned char *, unsigned char *,
3456 ptrdiff_t, bool, bool);
3457 extern int count_combining_before (const unsigned char *,
3458 ptrdiff_t, ptrdiff_t, ptrdiff_t);
3459 extern int count_combining_after (const unsigned char *,
3460 ptrdiff_t, ptrdiff_t, ptrdiff_t);
3461 extern void insert (const char *, ptrdiff_t);
3462 extern void insert_and_inherit (const char *, ptrdiff_t);
3463 extern void insert_1_both (const char *, ptrdiff_t, ptrdiff_t,
3465 extern void insert_from_gap (ptrdiff_t, ptrdiff_t, bool text_at_gap_tail
);
3466 extern void insert_from_string (Lisp_Object
, ptrdiff_t, ptrdiff_t,
3467 ptrdiff_t, ptrdiff_t, bool);
3468 extern void insert_from_buffer (struct buffer
*, ptrdiff_t, ptrdiff_t, bool);
3469 extern void insert_char (int);
3470 extern void insert_string (const char *);
3471 extern void insert_before_markers (const char *, ptrdiff_t);
3472 extern void insert_before_markers_and_inherit (const char *, ptrdiff_t);
3473 extern void insert_from_string_before_markers (Lisp_Object
, ptrdiff_t,
3474 ptrdiff_t, ptrdiff_t,
3476 extern void del_range (ptrdiff_t, ptrdiff_t);
3477 extern Lisp_Object
del_range_1 (ptrdiff_t, ptrdiff_t, bool, bool);
3478 extern void del_range_byte (ptrdiff_t, ptrdiff_t);
3479 extern void del_range_both (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, bool);
3480 extern Lisp_Object
del_range_2 (ptrdiff_t, ptrdiff_t,
3481 ptrdiff_t, ptrdiff_t, bool);
3482 extern void modify_text (ptrdiff_t, ptrdiff_t);
3483 extern void prepare_to_modify_buffer (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
3484 extern void prepare_to_modify_buffer_1 (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
3485 extern void invalidate_buffer_caches (struct buffer
*, ptrdiff_t, ptrdiff_t);
3486 extern void signal_after_change (ptrdiff_t, ptrdiff_t, ptrdiff_t);
3487 extern void adjust_after_insert (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3488 ptrdiff_t, ptrdiff_t);
3489 extern void adjust_markers_for_delete (ptrdiff_t, ptrdiff_t,
3490 ptrdiff_t, ptrdiff_t);
3491 extern void adjust_markers_bytepos (ptrdiff_t, ptrdiff_t,
3492 ptrdiff_t, ptrdiff_t, int);
3493 extern void replace_range (ptrdiff_t, ptrdiff_t, Lisp_Object
, bool, bool, bool, bool);
3494 extern void replace_range_2 (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
3495 const char *, ptrdiff_t, ptrdiff_t, bool);
3496 extern void syms_of_insdel (void);
3498 /* Defined in dispnew.c. */
3500 _Noreturn
void __executable_start (void);
3502 extern Lisp_Object Vwindow_system
;
3503 extern Lisp_Object
sit_for (Lisp_Object
, bool, int);
3505 /* Defined in xdisp.c. */
3506 extern bool noninteractive_need_newline
;
3507 extern Lisp_Object echo_area_buffer
[2];
3508 extern void add_to_log (char const *, ...);
3509 extern void vadd_to_log (char const *, va_list);
3510 extern void check_message_stack (void);
3511 extern void setup_echo_area_for_printing (bool);
3512 extern bool push_message (void);
3513 extern void pop_message_unwind (void);
3514 extern Lisp_Object
restore_message_unwind (Lisp_Object
);
3515 extern void restore_message (void);
3516 extern Lisp_Object
current_message (void);
3517 extern void clear_message (bool, bool);
3518 extern void message (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3519 extern void message1 (const char *);
3520 extern void message1_nolog (const char *);
3521 extern void message3 (Lisp_Object
);
3522 extern void message3_nolog (Lisp_Object
);
3523 extern void message_dolog (const char *, ptrdiff_t, bool, bool);
3524 extern void message_with_string (const char *, Lisp_Object
, bool);
3525 extern void message_log_maybe_newline (void);
3526 extern void update_echo_area (void);
3527 extern void truncate_echo_area (ptrdiff_t);
3528 extern void redisplay (void);
3530 void set_frame_cursor_types (struct frame
*, Lisp_Object
);
3531 extern void syms_of_xdisp (void);
3532 extern void init_xdisp (void);
3533 extern Lisp_Object
safe_eval (Lisp_Object
);
3534 extern bool pos_visible_p (struct window
*, ptrdiff_t, int *,
3535 int *, int *, int *, int *, int *);
3537 /* Defined in xsettings.c. */
3538 extern void syms_of_xsettings (void);
3540 /* Defined in vm-limit.c. */
3541 extern void memory_warnings (void *, void (*warnfun
) (const char *));
3543 /* Defined in character.c. */
3544 extern void parse_str_as_multibyte (const unsigned char *, ptrdiff_t,
3545 ptrdiff_t *, ptrdiff_t *);
3547 /* Defined in alloc.c. */
3548 extern void *my_heap_start (void);
3549 extern void check_pure_size (void);
3550 extern void allocate_string_data (struct Lisp_String
*, EMACS_INT
, EMACS_INT
);
3551 extern void malloc_warning (const char *);
3552 extern _Noreturn
void memory_full (size_t);
3553 extern _Noreturn
void buffer_memory_full (ptrdiff_t);
3554 extern bool survives_gc_p (Lisp_Object
);
3555 extern void mark_object (Lisp_Object
);
3556 #if defined REL_ALLOC && !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
3557 extern void refill_memory_reserve (void);
3559 extern void alloc_unexec_pre (void);
3560 extern void alloc_unexec_post (void);
3561 extern void mark_maybe_objects (Lisp_Object
*, ptrdiff_t);
3562 extern void mark_stack (char *, char *);
3563 extern void flush_stack_call_func (void (*func
) (void *arg
), void *arg
);
3564 extern const char *pending_malloc_warning
;
3565 extern Lisp_Object zero_vector
;
3566 extern EMACS_INT consing_since_gc
;
3567 extern EMACS_INT gc_relative_threshold
;
3568 extern EMACS_INT memory_full_cons_threshold
;
3569 extern Lisp_Object
list1 (Lisp_Object
);
3570 extern Lisp_Object
list2 (Lisp_Object
, Lisp_Object
);
3571 extern Lisp_Object
list3 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3572 extern Lisp_Object
list4 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3573 extern Lisp_Object
list5 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
,
3575 enum constype
{CONSTYPE_HEAP
, CONSTYPE_PURE
};
3576 extern Lisp_Object
listn (enum constype
, ptrdiff_t, Lisp_Object
, ...);
3578 /* Build a frequently used 2/3/4-integer lists. */
3581 list2i (EMACS_INT x
, EMACS_INT y
)
3583 return list2 (make_number (x
), make_number (y
));
3587 list3i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
)
3589 return list3 (make_number (x
), make_number (y
), make_number (w
));
3593 list4i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
, EMACS_INT h
)
3595 return list4 (make_number (x
), make_number (y
),
3596 make_number (w
), make_number (h
));
3599 extern Lisp_Object
make_uninit_bool_vector (EMACS_INT
);
3600 extern Lisp_Object
bool_vector_fill (Lisp_Object
, Lisp_Object
);
3601 extern _Noreturn
void string_overflow (void);
3602 extern Lisp_Object
make_string (const char *, ptrdiff_t);
3603 extern Lisp_Object
make_formatted_string (char *, const char *, ...)
3604 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3605 extern Lisp_Object
make_unibyte_string (const char *, ptrdiff_t);
3607 /* Make unibyte string from C string when the length isn't known. */
3610 build_unibyte_string (const char *str
)
3612 return make_unibyte_string (str
, strlen (str
));
3615 extern Lisp_Object
make_multibyte_string (const char *, ptrdiff_t, ptrdiff_t);
3616 extern Lisp_Object
make_event_array (ptrdiff_t, Lisp_Object
*);
3617 extern Lisp_Object
make_uninit_string (EMACS_INT
);
3618 extern Lisp_Object
make_uninit_multibyte_string (EMACS_INT
, EMACS_INT
);
3619 extern Lisp_Object
make_string_from_bytes (const char *, ptrdiff_t, ptrdiff_t);
3620 extern Lisp_Object
make_specified_string (const char *,
3621 ptrdiff_t, ptrdiff_t, bool);
3622 extern Lisp_Object
make_pure_string (const char *, ptrdiff_t, ptrdiff_t, bool);
3623 extern Lisp_Object
make_pure_c_string (const char *, ptrdiff_t);
3625 /* Make a string allocated in pure space, use STR as string data. */
3628 build_pure_c_string (const char *str
)
3630 return make_pure_c_string (str
, strlen (str
));
3633 /* Make a string from the data at STR, treating it as multibyte if the
3637 build_string (const char *str
)
3639 return make_string (str
, strlen (str
));
3642 extern Lisp_Object
pure_cons (Lisp_Object
, Lisp_Object
);
3643 extern void make_byte_code (struct Lisp_Vector
*);
3644 extern struct Lisp_Vector
*allocate_vector (EMACS_INT
);
3646 /* Make an uninitialized vector for SIZE objects. NOTE: you must
3647 be sure that GC cannot happen until the vector is completely
3648 initialized. E.g. the following code is likely to crash:
3650 v = make_uninit_vector (3);
3652 ASET (v, 1, Ffunction_can_gc ());
3653 ASET (v, 2, obj1); */
3656 make_uninit_vector (ptrdiff_t size
)
3659 struct Lisp_Vector
*p
;
3661 p
= allocate_vector (size
);
3666 /* Like above, but special for sub char-tables. */
3669 make_uninit_sub_char_table (int depth
, int min_char
)
3671 int slots
= SUB_CHAR_TABLE_OFFSET
+ chartab_size
[depth
];
3672 Lisp_Object v
= make_uninit_vector (slots
);
3674 XSETPVECTYPE (XVECTOR (v
), PVEC_SUB_CHAR_TABLE
);
3675 XSUB_CHAR_TABLE (v
)->depth
= depth
;
3676 XSUB_CHAR_TABLE (v
)->min_char
= min_char
;
3680 extern struct Lisp_Vector
*allocate_pseudovector (int, int, int,
3683 /* Allocate partially initialized pseudovector where all Lisp_Object
3684 slots are set to Qnil but the rest (if any) is left uninitialized. */
3686 #define ALLOCATE_PSEUDOVECTOR(type, field, tag) \
3687 ((type *) allocate_pseudovector (VECSIZE (type), \
3688 PSEUDOVECSIZE (type, field), \
3689 PSEUDOVECSIZE (type, field), tag))
3691 /* Allocate fully initialized pseudovector where all Lisp_Object
3692 slots are set to Qnil and the rest (if any) is zeroed. */
3694 #define ALLOCATE_ZEROED_PSEUDOVECTOR(type, field, tag) \
3695 ((type *) allocate_pseudovector (VECSIZE (type), \
3696 PSEUDOVECSIZE (type, field), \
3697 VECSIZE (type), tag))
3699 extern bool gc_in_progress
;
3700 extern Lisp_Object
make_float (double);
3701 extern void display_malloc_warning (void);
3702 extern ptrdiff_t inhibit_garbage_collection (void);
3703 extern Lisp_Object
build_overlay (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3704 extern void free_cons (struct Lisp_Cons
*);
3705 extern void init_alloc_once (void);
3706 extern void init_alloc (void);
3707 extern void syms_of_alloc (void);
3708 extern struct buffer
* allocate_buffer (void);
3709 extern int valid_lisp_object_p (Lisp_Object
);
3710 #ifdef GC_CHECK_CONS_LIST
3711 extern void check_cons_list (void);
3713 INLINE
void (check_cons_list
) (void) { lisp_h_check_cons_list (); }
3716 /* Defined in gmalloc.c. */
3717 #if !defined DOUG_LEA_MALLOC && !defined HYBRID_MALLOC && !defined SYSTEM_MALLOC
3718 extern size_t __malloc_extra_blocks
;
3720 #if !HAVE_DECL_ALIGNED_ALLOC
3721 extern void *aligned_alloc (size_t, size_t) ATTRIBUTE_MALLOC_SIZE ((2));
3723 extern void malloc_enable_thread (void);
3726 /* Defined in ralloc.c. */
3727 extern void *r_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3728 extern void r_alloc_free (void **);
3729 extern void *r_re_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3730 extern void r_alloc_reset_variable (void **, void **);
3731 extern void r_alloc_inhibit_buffer_relocation (int);
3734 /* Defined in chartab.c. */
3735 extern Lisp_Object
copy_char_table (Lisp_Object
);
3736 extern Lisp_Object
char_table_ref_and_range (Lisp_Object
, int,
3738 extern void char_table_set_range (Lisp_Object
, int, int, Lisp_Object
);
3739 extern void map_char_table (void (*) (Lisp_Object
, Lisp_Object
,
3741 Lisp_Object
, Lisp_Object
, Lisp_Object
);
3742 extern void map_char_table_for_charset (void (*c_function
) (Lisp_Object
, Lisp_Object
),
3743 Lisp_Object
, Lisp_Object
,
3744 Lisp_Object
, struct charset
*,
3745 unsigned, unsigned);
3746 extern Lisp_Object
uniprop_table (Lisp_Object
);
3747 extern void syms_of_chartab (void);
3749 /* Defined in print.c. */
3750 extern Lisp_Object Vprin1_to_string_buffer
;
3751 extern void debug_print (Lisp_Object
) EXTERNALLY_VISIBLE
;
3752 extern void temp_output_buffer_setup (const char *);
3753 extern int print_level
;
3754 extern void print_error_message (Lisp_Object
, Lisp_Object
, const char *,
3756 extern Lisp_Object internal_with_output_to_temp_buffer
3757 (const char *, Lisp_Object (*) (Lisp_Object
), Lisp_Object
);
3758 #define FLOAT_TO_STRING_BUFSIZE 350
3759 extern int float_to_string (char *, double);
3760 extern void init_print_once (void);
3761 extern void syms_of_print (void);
3763 /* Defined in doprnt.c. */
3764 extern ptrdiff_t doprnt (char *, ptrdiff_t, const char *, const char *,
3766 extern ptrdiff_t esprintf (char *, char const *, ...)
3767 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3768 extern ptrdiff_t exprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3770 ATTRIBUTE_FORMAT_PRINTF (5, 6);
3771 extern ptrdiff_t evxprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3772 char const *, va_list)
3773 ATTRIBUTE_FORMAT_PRINTF (5, 0);
3775 /* Defined in lread.c. */
3776 extern Lisp_Object
check_obarray (Lisp_Object
);
3777 extern Lisp_Object
intern_1 (const char *, ptrdiff_t);
3778 extern Lisp_Object
intern_c_string_1 (const char *, ptrdiff_t);
3779 extern Lisp_Object
intern_driver (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3780 extern void init_symbol (Lisp_Object
, Lisp_Object
);
3781 extern Lisp_Object
oblookup (Lisp_Object
, const char *, ptrdiff_t, ptrdiff_t);
3783 LOADHIST_ATTACH (Lisp_Object x
)
3786 Vcurrent_load_list
= Fcons (x
, Vcurrent_load_list
);
3788 extern int openp (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3789 Lisp_Object
*, Lisp_Object
, bool);
3790 enum { S2N_IGNORE_TRAILING
= 1, S2N_OVERFLOW_TO_FLOAT
= 2 };
3791 extern Lisp_Object
string_to_number (char const *, int, int);
3792 extern void map_obarray (Lisp_Object
, void (*) (Lisp_Object
, Lisp_Object
),
3794 extern void dir_warning (const char *, Lisp_Object
);
3795 extern void init_obarray (void);
3796 extern void init_lread (void);
3797 extern void syms_of_lread (void);
3800 intern (const char *str
)
3802 return intern_1 (str
, strlen (str
));
3806 intern_c_string (const char *str
)
3808 return intern_c_string_1 (str
, strlen (str
));
3811 /* Defined in eval.c. */
3812 extern Lisp_Object Vautoload_queue
;
3813 extern Lisp_Object Vrun_hooks
;
3814 extern Lisp_Object Vsignaling_function
;
3815 extern Lisp_Object inhibit_lisp_code
;
3817 /* To run a normal hook, use the appropriate function from the list below.
3818 The calling convention:
3820 if (!NILP (Vrun_hooks))
3821 call1 (Vrun_hooks, Qmy_funny_hook);
3823 should no longer be used. */
3824 extern void run_hook (Lisp_Object
);
3825 extern void run_hook_with_args_2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3826 extern Lisp_Object
run_hook_with_args (ptrdiff_t nargs
, Lisp_Object
*args
,
3827 Lisp_Object (*funcall
)
3828 (ptrdiff_t nargs
, Lisp_Object
*args
));
3829 extern Lisp_Object
quit (void);
3830 INLINE _Noreturn
void
3831 xsignal (Lisp_Object error_symbol
, Lisp_Object data
)
3833 Fsignal (error_symbol
, data
);
3835 extern _Noreturn
void xsignal0 (Lisp_Object
);
3836 extern _Noreturn
void xsignal1 (Lisp_Object
, Lisp_Object
);
3837 extern _Noreturn
void xsignal2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3838 extern _Noreturn
void xsignal3 (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3840 extern _Noreturn
void signal_error (const char *, Lisp_Object
);
3841 extern bool FUNCTIONP (Lisp_Object
);
3842 extern Lisp_Object
funcall_subr (struct Lisp_Subr
*subr
, ptrdiff_t numargs
, Lisp_Object
*arg_vector
);
3843 extern Lisp_Object
eval_sub (Lisp_Object form
);
3844 extern Lisp_Object
apply1 (Lisp_Object
, Lisp_Object
);
3845 extern Lisp_Object
call0 (Lisp_Object
);
3846 extern Lisp_Object
call1 (Lisp_Object
, Lisp_Object
);
3847 extern Lisp_Object
call2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3848 extern Lisp_Object
call3 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3849 extern Lisp_Object
call4 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3850 extern Lisp_Object
call5 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3851 extern Lisp_Object
call6 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3852 extern Lisp_Object
call7 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3853 extern Lisp_Object
call8 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3854 extern Lisp_Object
internal_catch (Lisp_Object
, Lisp_Object (*) (Lisp_Object
), Lisp_Object
);
3855 extern Lisp_Object
internal_lisp_condition_case (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3856 extern Lisp_Object
internal_condition_case (Lisp_Object (*) (void), Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3857 extern Lisp_Object
internal_condition_case_1 (Lisp_Object (*) (Lisp_Object
), Lisp_Object
, Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3858 extern Lisp_Object
internal_condition_case_2 (Lisp_Object (*) (Lisp_Object
, Lisp_Object
), Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3859 extern Lisp_Object internal_condition_case_n
3860 (Lisp_Object (*) (ptrdiff_t, Lisp_Object
*), ptrdiff_t, Lisp_Object
*,
3861 Lisp_Object
, Lisp_Object (*) (Lisp_Object
, ptrdiff_t, Lisp_Object
*));
3862 extern Lisp_Object
internal_catch_all (Lisp_Object (*) (void *), void *, Lisp_Object (*) (Lisp_Object
));
3863 extern struct handler
*push_handler (Lisp_Object
, enum handlertype
);
3864 extern struct handler
*push_handler_nosignal (Lisp_Object
, enum handlertype
);
3865 extern void specbind (Lisp_Object
, Lisp_Object
);
3866 extern void record_unwind_protect (void (*) (Lisp_Object
), Lisp_Object
);
3867 extern void record_unwind_protect_array (Lisp_Object
*, ptrdiff_t);
3868 extern void record_unwind_protect_ptr (void (*) (void *), void *);
3869 extern void record_unwind_protect_int (void (*) (int), int);
3870 extern void record_unwind_protect_void (void (*) (void));
3871 extern void record_unwind_protect_excursion (void);
3872 extern void record_unwind_protect_nothing (void);
3873 extern void clear_unwind_protect (ptrdiff_t);
3874 extern void set_unwind_protect (ptrdiff_t, void (*) (Lisp_Object
), Lisp_Object
);
3875 extern void set_unwind_protect_ptr (ptrdiff_t, void (*) (void *), void *);
3876 extern Lisp_Object
unbind_to (ptrdiff_t, Lisp_Object
);
3877 extern void rebind_for_thread_switch (void);
3878 extern void unbind_for_thread_switch (struct thread_state
*);
3879 extern _Noreturn
void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3880 extern _Noreturn
void verror (const char *, va_list)
3881 ATTRIBUTE_FORMAT_PRINTF (1, 0);
3882 extern Lisp_Object
vformat_string (const char *, va_list)
3883 ATTRIBUTE_FORMAT_PRINTF (1, 0);
3884 extern void un_autoload (Lisp_Object
);
3885 extern Lisp_Object
call_debugger (Lisp_Object arg
);
3886 extern void init_eval_once (void);
3887 extern Lisp_Object
safe_call (ptrdiff_t, Lisp_Object
, ...);
3888 extern Lisp_Object
safe_call1 (Lisp_Object
, Lisp_Object
);
3889 extern Lisp_Object
safe_call2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3890 extern void init_eval (void);
3891 extern void syms_of_eval (void);
3892 extern void prog_ignore (Lisp_Object
);
3893 extern ptrdiff_t record_in_backtrace (Lisp_Object
, Lisp_Object
*, ptrdiff_t);
3894 extern void mark_specpdl (union specbinding
*first
, union specbinding
*ptr
);
3895 extern void get_backtrace (Lisp_Object array
);
3896 Lisp_Object
backtrace_top_function (void);
3897 extern bool let_shadows_buffer_binding_p (struct Lisp_Symbol
*symbol
);
3899 /* Defined in unexmacosx.c. */
3900 #if defined DARWIN_OS && !defined CANNOT_DUMP
3901 extern void unexec_init_emacs_zone (void);
3902 extern void *unexec_malloc (size_t);
3903 extern void *unexec_realloc (void *, size_t);
3904 extern void unexec_free (void *);
3907 #include "emacs-module.h"
3909 /* Function prototype for the module Lisp functions. */
3910 typedef emacs_value (*emacs_subr
) (emacs_env
*, ptrdiff_t,
3911 emacs_value
[], void *);
3913 /* Module function. */
3915 /* A function environment is an auxiliary structure returned by
3916 `module_make_function' to store information about a module
3917 function. It is stored in a pseudovector. Its members correspond
3918 to the arguments given to `module_make_function'. */
3920 struct Lisp_Module_Function
3922 union vectorlike_header header
;
3924 /* Fields traced by GC; these must come first. */
3925 Lisp_Object documentation
;
3927 /* Fields ignored by GC. */
3928 ptrdiff_t min_arity
, max_arity
;
3934 MODULE_FUNCTIONP (Lisp_Object o
)
3936 return PSEUDOVECTORP (o
, PVEC_MODULE_FUNCTION
);
3939 INLINE
struct Lisp_Module_Function
*
3940 XMODULE_FUNCTION (Lisp_Object o
)
3942 eassert (MODULE_FUNCTIONP (o
));
3943 return XUNTAG (o
, Lisp_Vectorlike
, struct Lisp_Module_Function
);
3947 /* Defined in alloc.c. */
3948 extern Lisp_Object
make_user_ptr (void (*finalizer
) (void *), void *p
);
3950 /* Defined in emacs-module.c. */
3951 extern Lisp_Object
funcall_module (Lisp_Object
, ptrdiff_t, Lisp_Object
*);
3952 extern Lisp_Object
module_function_arity (const struct Lisp_Module_Function
*);
3953 extern void mark_modules (void);
3954 extern void init_module_assertions (bool);
3955 extern void syms_of_module (void);
3958 /* Defined in thread.c. */
3959 extern void mark_threads (void);
3961 /* Defined in editfns.c. */
3962 extern void insert1 (Lisp_Object
);
3963 extern void save_excursion_save (union specbinding
*);
3964 extern void save_excursion_restore (Lisp_Object
, Lisp_Object
);
3965 extern Lisp_Object
save_restriction_save (void);
3966 extern void save_restriction_restore (Lisp_Object
);
3967 extern _Noreturn
void time_overflow (void);
3968 extern Lisp_Object
make_buffer_string (ptrdiff_t, ptrdiff_t, bool);
3969 extern Lisp_Object
make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3971 extern void init_editfns (bool);
3972 extern void syms_of_editfns (void);
3974 /* Defined in buffer.c. */
3975 extern bool mouse_face_overlay_overlaps (Lisp_Object
);
3976 extern Lisp_Object
disable_line_numbers_overlay_at_eob (void);
3977 extern _Noreturn
void nsberror (Lisp_Object
);
3978 extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
3979 extern void adjust_overlays_for_delete (ptrdiff_t, ptrdiff_t);
3980 extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
3981 extern void report_overlay_modification (Lisp_Object
, Lisp_Object
, bool,
3982 Lisp_Object
, Lisp_Object
, Lisp_Object
);
3983 extern bool overlay_touches_p (ptrdiff_t);
3984 extern Lisp_Object
other_buffer_safely (Lisp_Object
);
3985 extern Lisp_Object
get_truename_buffer (Lisp_Object
);
3986 extern void init_buffer_once (void);
3987 extern void init_buffer (int);
3988 extern void syms_of_buffer (void);
3989 extern void keys_of_buffer (void);
3991 /* Defined in marker.c. */
3993 extern ptrdiff_t marker_position (Lisp_Object
);
3994 extern ptrdiff_t marker_byte_position (Lisp_Object
);
3995 extern void clear_charpos_cache (struct buffer
*);
3996 extern ptrdiff_t buf_charpos_to_bytepos (struct buffer
*, ptrdiff_t);
3997 extern ptrdiff_t buf_bytepos_to_charpos (struct buffer
*, ptrdiff_t);
3998 extern void detach_marker (Lisp_Object
);
3999 extern void unchain_marker (struct Lisp_Marker
*);
4000 extern Lisp_Object
set_marker_restricted (Lisp_Object
, Lisp_Object
, Lisp_Object
);
4001 extern Lisp_Object
set_marker_both (Lisp_Object
, Lisp_Object
, ptrdiff_t, ptrdiff_t);
4002 extern Lisp_Object
set_marker_restricted_both (Lisp_Object
, Lisp_Object
,
4003 ptrdiff_t, ptrdiff_t);
4004 extern Lisp_Object
build_marker (struct buffer
*, ptrdiff_t, ptrdiff_t);
4005 extern void syms_of_marker (void);
4007 /* Defined in fileio.c. */
4009 extern Lisp_Object
expand_and_dir_to_file (Lisp_Object
);
4010 extern Lisp_Object
write_region (Lisp_Object
, Lisp_Object
, Lisp_Object
,
4011 Lisp_Object
, Lisp_Object
, Lisp_Object
,
4013 extern void close_file_unwind (int);
4014 extern void fclose_unwind (void *);
4015 extern void restore_point_unwind (Lisp_Object
);
4016 extern _Noreturn
void report_file_errno (const char *, Lisp_Object
, int);
4017 extern _Noreturn
void report_file_error (const char *, Lisp_Object
);
4018 extern _Noreturn
void report_file_notify_error (const char *, Lisp_Object
);
4019 extern bool internal_delete_file (Lisp_Object
);
4020 extern Lisp_Object
emacs_readlinkat (int, const char *);
4021 extern bool file_directory_p (Lisp_Object
);
4022 extern bool file_accessible_directory_p (Lisp_Object
);
4023 extern void init_fileio (void);
4024 extern void syms_of_fileio (void);
4026 /* Defined in search.c. */
4027 extern void shrink_regexp_cache (void);
4028 extern void restore_search_regs (void);
4029 extern void update_search_regs (ptrdiff_t oldstart
,
4030 ptrdiff_t oldend
, ptrdiff_t newend
);
4031 extern void record_unwind_save_match_data (void);
4032 extern ptrdiff_t fast_string_match_internal (Lisp_Object
, Lisp_Object
,
4036 fast_string_match (Lisp_Object regexp
, Lisp_Object string
)
4038 return fast_string_match_internal (regexp
, string
, Qnil
);
4042 fast_string_match_ignore_case (Lisp_Object regexp
, Lisp_Object string
)
4044 return fast_string_match_internal (regexp
, string
, Vascii_canon_table
);
4047 extern ptrdiff_t fast_c_string_match_ignore_case (Lisp_Object
, const char *,
4049 extern ptrdiff_t fast_looking_at (Lisp_Object
, ptrdiff_t, ptrdiff_t,
4050 ptrdiff_t, ptrdiff_t, Lisp_Object
);
4051 extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
4052 ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
4053 extern ptrdiff_t scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
4055 extern ptrdiff_t scan_newline_from_point (ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
4056 extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t,
4057 ptrdiff_t, ptrdiff_t *);
4058 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
4059 ptrdiff_t, ptrdiff_t *);
4060 extern void syms_of_search (void);
4061 extern void clear_regexp_cache (void);
4063 /* Defined in minibuf.c. */
4065 extern Lisp_Object Vminibuffer_list
;
4066 extern Lisp_Object last_minibuf_string
;
4067 extern Lisp_Object
get_minibuffer (EMACS_INT
);
4068 extern void init_minibuf_once (void);
4069 extern void syms_of_minibuf (void);
4071 /* Defined in callint.c. */
4073 extern void syms_of_callint (void);
4075 /* Defined in casefiddle.c. */
4077 extern void syms_of_casefiddle (void);
4078 extern void keys_of_casefiddle (void);
4080 /* Defined in casetab.c. */
4082 extern void init_casetab_once (void);
4083 extern void syms_of_casetab (void);
4085 /* Defined in keyboard.c. */
4087 extern Lisp_Object echo_message_buffer
;
4088 extern struct kboard
*echo_kboard
;
4089 extern void cancel_echoing (void);
4090 extern bool input_pending
;
4091 #ifdef HAVE_STACK_OVERFLOW_HANDLING
4092 extern sigjmp_buf return_to_command_loop
;
4094 extern Lisp_Object
menu_bar_items (Lisp_Object
);
4095 extern Lisp_Object
tool_bar_items (Lisp_Object
, int *);
4096 extern void discard_mouse_events (void);
4098 void handle_input_available_signal (int);
4100 extern Lisp_Object pending_funcalls
;
4101 extern bool detect_input_pending (void);
4102 extern bool detect_input_pending_ignore_squeezables (void);
4103 extern bool detect_input_pending_run_timers (bool);
4104 extern void safe_run_hooks (Lisp_Object
);
4105 extern void cmd_error_internal (Lisp_Object
, const char *);
4106 extern Lisp_Object
command_loop_1 (void);
4107 extern Lisp_Object
read_menu_command (void);
4108 extern Lisp_Object
recursive_edit_1 (void);
4109 extern void record_auto_save (void);
4110 extern void force_auto_save_soon (void);
4111 extern void init_keyboard (void);
4112 extern void syms_of_keyboard (void);
4113 extern void keys_of_keyboard (void);
4115 /* Defined in indent.c. */
4116 extern ptrdiff_t current_column (void);
4117 extern void invalidate_current_column (void);
4118 extern bool indented_beyond_p (ptrdiff_t, ptrdiff_t, EMACS_INT
);
4119 extern void syms_of_indent (void);
4121 /* Defined in frame.c. */
4122 extern void store_frame_param (struct frame
*, Lisp_Object
, Lisp_Object
);
4123 extern void store_in_alist (Lisp_Object
*, Lisp_Object
, Lisp_Object
);
4124 extern Lisp_Object
do_switch_frame (Lisp_Object
, int, int, Lisp_Object
);
4125 extern Lisp_Object
get_frame_param (struct frame
*, Lisp_Object
);
4126 extern void frames_discard_buffer (Lisp_Object
);
4127 extern void syms_of_frame (void);
4129 /* Defined in emacs.c. */
4130 extern char **initial_argv
;
4131 extern int initial_argc
;
4132 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS)
4133 extern bool display_arg
;
4135 extern Lisp_Object
decode_env_path (const char *, const char *, bool);
4136 extern Lisp_Object empty_unibyte_string
, empty_multibyte_string
;
4137 extern _Noreturn
void terminate_due_to_signal (int, int);
4139 extern Lisp_Object Vlibrary_cache
;
4142 void fixup_locale (void);
4143 void synchronize_system_messages_locale (void);
4144 void synchronize_system_time_locale (void);
4146 INLINE
void fixup_locale (void) {}
4147 INLINE
void synchronize_system_messages_locale (void) {}
4148 INLINE
void synchronize_system_time_locale (void) {}
4150 extern char *emacs_strerror (int);
4151 extern void shut_down_emacs (int, Lisp_Object
);
4153 /* True means don't do interactive redisplay and don't change tty modes. */
4154 extern bool noninteractive
;
4156 /* True means remove site-lisp directories from load-path. */
4157 extern bool no_site_lisp
;
4159 /* True means put details like time stamps into builds. */
4160 extern bool build_details
;
4163 /* 0 not a daemon, 1 foreground daemon, 2 background daemon. */
4164 extern int daemon_type
;
4165 #define IS_DAEMON (daemon_type != 0)
4166 #define DAEMON_RUNNING (daemon_type >= 0)
4167 #else /* WINDOWSNT */
4168 extern void *w32_daemon_event
;
4169 #define IS_DAEMON (w32_daemon_event != NULL)
4170 #define DAEMON_RUNNING (w32_daemon_event != INVALID_HANDLE_VALUE)
4173 /* True if handling a fatal error already. */
4174 extern bool fatal_error_in_progress
;
4176 /* True means don't do use window-system-specific display code. */
4177 extern bool inhibit_window_system
;
4178 /* True means that a filter or a sentinel is running. */
4179 extern bool running_asynch_code
;
4181 /* Defined in process.c. */
4182 struct Lisp_Process
;
4183 extern void kill_buffer_processes (Lisp_Object
);
4184 extern int wait_reading_process_output (intmax_t, int, int, bool, Lisp_Object
,
4185 struct Lisp_Process
*, int);
4186 /* Max value for the first argument of wait_reading_process_output. */
4187 #if GNUC_PREREQ (3, 0, 0) && ! GNUC_PREREQ (4, 6, 0)
4188 /* Work around a bug in GCC 3.4.2, known to be fixed in GCC 4.6.0.
4189 The bug merely causes a bogus warning, but the warning is annoying. */
4190 # define WAIT_READING_MAX min (TYPE_MAXIMUM (time_t), INTMAX_MAX)
4192 # define WAIT_READING_MAX INTMAX_MAX
4195 extern void add_timer_wait_descriptor (int);
4197 extern void add_keyboard_wait_descriptor (int);
4198 extern void delete_keyboard_wait_descriptor (int);
4200 extern void add_gpm_wait_descriptor (int);
4201 extern void delete_gpm_wait_descriptor (int);
4203 extern void init_process_emacs (int);
4204 extern void syms_of_process (void);
4205 extern void setup_process_coding_systems (Lisp_Object
);
4207 /* Defined in callproc.c. */
4209 # define CHILD_SETUP_TYPE _Noreturn void
4211 # define CHILD_SETUP_TYPE int
4213 extern CHILD_SETUP_TYPE
child_setup (int, int, int, char **, bool, Lisp_Object
);
4214 extern void init_callproc_1 (void);
4215 extern void init_callproc (void);
4216 extern void set_initial_environment (void);
4217 extern void syms_of_callproc (void);
4219 /* Defined in doc.c. */
4220 enum text_quoting_style
4222 /* Use curved single quotes ‘like this’. */
4223 CURVE_QUOTING_STYLE
,
4225 /* Use grave accent and apostrophe `like this'. */
4226 GRAVE_QUOTING_STYLE
,
4228 /* Use apostrophes 'like this'. */
4229 STRAIGHT_QUOTING_STYLE
4231 extern enum text_quoting_style
text_quoting_style (void);
4232 extern Lisp_Object
read_doc_string (Lisp_Object
);
4233 extern Lisp_Object
get_doc_string (Lisp_Object
, bool, bool);
4234 extern void syms_of_doc (void);
4235 extern int read_bytecode_char (bool);
4237 /* Defined in bytecode.c. */
4238 extern void syms_of_bytecode (void);
4239 extern Lisp_Object
exec_byte_code (Lisp_Object
, Lisp_Object
, Lisp_Object
,
4240 Lisp_Object
, ptrdiff_t, Lisp_Object
*);
4241 extern Lisp_Object
get_byte_code_arity (Lisp_Object
);
4243 /* Defined in macros.c. */
4244 extern void init_macros (void);
4245 extern void syms_of_macros (void);
4247 /* Defined in undo.c. */
4248 extern void truncate_undo_list (struct buffer
*);
4249 extern void record_insert (ptrdiff_t, ptrdiff_t);
4250 extern void record_delete (ptrdiff_t, Lisp_Object
, bool);
4251 extern void record_first_change (void);
4252 extern void record_change (ptrdiff_t, ptrdiff_t);
4253 extern void record_property_change (ptrdiff_t, ptrdiff_t,
4254 Lisp_Object
, Lisp_Object
,
4256 extern void syms_of_undo (void);
4258 /* Defined in textprop.c. */
4259 extern void report_interval_modification (Lisp_Object
, Lisp_Object
);
4261 /* Defined in menu.c. */
4262 extern void syms_of_menu (void);
4264 /* Defined in xmenu.c. */
4265 extern void syms_of_xmenu (void);
4267 /* Defined in termchar.h. */
4268 struct tty_display_info
;
4270 /* Defined in sysdep.c. */
4271 #ifdef HAVE_PERSONALITY_ADDR_NO_RANDOMIZE
4272 extern bool disable_address_randomization (void);
4274 INLINE
bool disable_address_randomization (void) { return false; }
4276 extern int emacs_exec_file (char const *, char *const *, char *const *);
4277 extern void init_standard_fds (void);
4278 extern char *emacs_get_current_dir_name (void);
4279 extern void stuff_char (char c
);
4280 extern void init_foreground_group (void);
4281 extern void sys_subshell (void);
4282 extern void sys_suspend (void);
4283 extern void discard_tty_input (void);
4284 extern void init_sys_modes (struct tty_display_info
*);
4285 extern void reset_sys_modes (struct tty_display_info
*);
4286 extern void init_all_sys_modes (void);
4287 extern void reset_all_sys_modes (void);
4288 extern void child_setup_tty (int);
4289 extern void setup_pty (int);
4290 extern int set_window_size (int, int, int);
4291 extern EMACS_INT
get_random (void);
4292 extern void seed_random (void *, ptrdiff_t);
4293 extern void init_random (void);
4294 extern void emacs_backtrace (int);
4295 extern _Noreturn
void emacs_abort (void) NO_INLINE
;
4296 extern int emacs_open (const char *, int, int);
4297 extern int emacs_pipe (int[2]);
4298 extern int emacs_close (int);
4299 extern ptrdiff_t emacs_read (int, void *, ptrdiff_t);
4300 extern ptrdiff_t emacs_read_quit (int, void *, ptrdiff_t);
4301 extern ptrdiff_t emacs_write (int, void const *, ptrdiff_t);
4302 extern ptrdiff_t emacs_write_sig (int, void const *, ptrdiff_t);
4303 extern ptrdiff_t emacs_write_quit (int, void const *, ptrdiff_t);
4304 extern void emacs_perror (char const *);
4305 extern int renameat_noreplace (int, char const *, int, char const *);
4306 extern int str_collate (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
4308 /* Defined in filelock.c. */
4309 extern void lock_file (Lisp_Object
);
4310 extern void unlock_file (Lisp_Object
);
4311 extern void unlock_all_files (void);
4312 extern void unlock_buffer (struct buffer
*);
4313 extern void syms_of_filelock (void);
4315 /* Defined in sound.c. */
4316 extern void syms_of_sound (void);
4318 /* Defined in category.c. */
4319 extern void init_category_once (void);
4320 extern Lisp_Object
char_category_set (int);
4321 extern void syms_of_category (void);
4323 /* Defined in ccl.c. */
4324 extern void syms_of_ccl (void);
4326 /* Defined in dired.c. */
4327 extern void syms_of_dired (void);
4328 extern Lisp_Object
directory_files_internal (Lisp_Object
, Lisp_Object
,
4329 Lisp_Object
, Lisp_Object
,
4332 /* Defined in term.c. */
4333 extern int *char_ins_del_vector
;
4334 extern void syms_of_term (void);
4335 extern _Noreturn
void fatal (const char *msgid
, ...)
4336 ATTRIBUTE_FORMAT_PRINTF (1, 2);
4338 /* Defined in terminal.c. */
4339 extern void syms_of_terminal (void);
4341 /* Defined in font.c. */
4342 extern void syms_of_font (void);
4343 extern void init_font (void);
4345 #ifdef HAVE_WINDOW_SYSTEM
4346 /* Defined in fontset.c. */
4347 extern void syms_of_fontset (void);
4350 /* Defined in inotify.c */
4352 extern void syms_of_inotify (void);
4355 /* Defined in kqueue.c */
4357 extern void globals_of_kqueue (void);
4358 extern void syms_of_kqueue (void);
4361 /* Defined in gfilenotify.c */
4362 #ifdef HAVE_GFILENOTIFY
4363 extern void globals_of_gfilenotify (void);
4364 extern void syms_of_gfilenotify (void);
4367 #ifdef HAVE_W32NOTIFY
4368 /* Defined on w32notify.c. */
4369 extern void syms_of_w32notify (void);
4372 #if defined HAVE_NTGUI || defined CYGWIN
4373 /* Defined in w32cygwinx.c. */
4374 extern void syms_of_w32cygwinx (void);
4377 /* Defined in xfaces.c. */
4378 extern Lisp_Object Vface_alternative_font_family_alist
;
4379 extern Lisp_Object Vface_alternative_font_registry_alist
;
4380 extern void syms_of_xfaces (void);
4382 #ifdef HAVE_X_WINDOWS
4383 /* Defined in xfns.c. */
4384 extern void syms_of_xfns (void);
4386 /* Defined in xsmfns.c. */
4387 extern void syms_of_xsmfns (void);
4389 /* Defined in xselect.c. */
4390 extern void syms_of_xselect (void);
4392 /* Defined in xterm.c. */
4393 extern void init_xterm (void);
4394 extern void syms_of_xterm (void);
4395 #endif /* HAVE_X_WINDOWS */
4397 #ifdef HAVE_WINDOW_SYSTEM
4398 /* Defined in xterm.c, nsterm.m, w32term.c. */
4399 extern char *x_get_keysym_name (int);
4400 #endif /* HAVE_WINDOW_SYSTEM */
4402 /* Defined in xml.c. */
4403 extern void syms_of_xml (void);
4405 extern void xml_cleanup_parser (void);
4409 /* Defined in lcms.c. */
4410 extern void syms_of_lcms2 (void);
4414 /* Defined in decompress.c. */
4415 extern void syms_of_decompress (void);
4419 /* Defined in dbusbind.c. */
4420 void init_dbusbind (void);
4421 void syms_of_dbusbind (void);
4425 /* Defined in profiler.c. */
4426 extern bool profiler_memory_running
;
4427 extern void malloc_probe (size_t);
4428 extern void syms_of_profiler (void);
4432 /* Defined in msdos.c, w32.c. */
4433 extern char *emacs_root_dir (void);
4436 /* Defined in lastfile.c. */
4437 extern char my_edata
[];
4438 extern char my_endbss
[];
4439 extern char *my_endbss_static
;
4441 extern void *xmalloc (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
4442 extern void *xzalloc (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
4443 extern void *xrealloc (void *, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
4444 extern void xfree (void *);
4445 extern void *xnmalloc (ptrdiff_t, ptrdiff_t) ATTRIBUTE_MALLOC_SIZE ((1,2));
4446 extern void *xnrealloc (void *, ptrdiff_t, ptrdiff_t)
4447 ATTRIBUTE_ALLOC_SIZE ((2,3));
4448 extern void *xpalloc (void *, ptrdiff_t *, ptrdiff_t, ptrdiff_t, ptrdiff_t);
4450 extern char *xstrdup (const char *) ATTRIBUTE_MALLOC
;
4451 extern char *xlispstrdup (Lisp_Object
) ATTRIBUTE_MALLOC
;
4452 extern void dupstring (char **, char const *);
4454 /* Make DEST a copy of STRING's data. Return a pointer to DEST's terminating
4455 null byte. This is like stpcpy, except the source is a Lisp string. */
4458 lispstpcpy (char *dest
, Lisp_Object string
)
4460 ptrdiff_t len
= SBYTES (string
);
4461 memcpy (dest
, SDATA (string
), len
+ 1);
4465 extern void xputenv (const char *);
4467 extern char *egetenv_internal (const char *, ptrdiff_t);
4470 egetenv (const char *var
)
4472 /* When VAR is a string literal, strlen can be optimized away. */
4473 return egetenv_internal (var
, strlen (var
));
4476 /* Set up the name of the machine we're running on. */
4477 extern void init_system_name (void);
4479 /* Return the absolute value of X. X should be a signed integer
4480 expression without side effects, and X's absolute value should not
4481 exceed the maximum for its promoted type. This is called 'eabs'
4482 because 'abs' is reserved by the C standard. */
4483 #define eabs(x) ((x) < 0 ? -(x) : (x))
4485 /* Return a fixnum or float, depending on whether the integer VAL fits
4486 in a Lisp fixnum. */
4488 #define make_fixnum_or_float(val) \
4489 (FIXNUM_OVERFLOW_P (val) ? make_float (val) : make_number (val))
4491 /* SAFE_ALLOCA normally allocates memory on the stack, but if size is
4492 larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack. */
4494 enum MAX_ALLOCA
{ MAX_ALLOCA
= 16 * 1024 };
4496 extern void *record_xmalloc (size_t) ATTRIBUTE_ALLOC_SIZE ((1));
4498 #define USE_SAFE_ALLOCA \
4499 ptrdiff_t sa_avail = MAX_ALLOCA; \
4500 ptrdiff_t sa_count = SPECPDL_INDEX (); bool sa_must_free = false
4502 #define AVAIL_ALLOCA(size) (sa_avail -= (size), alloca (size))
4504 /* SAFE_ALLOCA allocates a simple buffer. */
4506 #define SAFE_ALLOCA(size) ((size) <= sa_avail \
4507 ? AVAIL_ALLOCA (size) \
4508 : (sa_must_free = true, record_xmalloc (size)))
4510 /* SAFE_NALLOCA sets BUF to a newly allocated array of MULTIPLIER *
4511 NITEMS items, each of the same type as *BUF. MULTIPLIER must
4512 positive. The code is tuned for MULTIPLIER being a constant. */
4514 #define SAFE_NALLOCA(buf, multiplier, nitems) \
4516 if ((nitems) <= sa_avail / sizeof *(buf) / (multiplier)) \
4517 (buf) = AVAIL_ALLOCA (sizeof *(buf) * (multiplier) * (nitems)); \
4520 (buf) = xnmalloc (nitems, sizeof *(buf) * (multiplier)); \
4521 sa_must_free = true; \
4522 record_unwind_protect_ptr (xfree, buf); \
4526 /* SAFE_ALLOCA_STRING allocates a C copy of a Lisp string. */
4528 #define SAFE_ALLOCA_STRING(ptr, string) \
4530 (ptr) = SAFE_ALLOCA (SBYTES (string) + 1); \
4531 memcpy (ptr, SDATA (string), SBYTES (string) + 1); \
4534 /* SAFE_FREE frees xmalloced memory and enables GC as needed. */
4536 #define SAFE_FREE() \
4538 if (sa_must_free) { \
4539 sa_must_free = false; \
4540 unbind_to (sa_count, Qnil); \
4544 /* Set BUF to point to an allocated array of NELT Lisp_Objects,
4545 immediately followed by EXTRA spare bytes. */
4547 #define SAFE_ALLOCA_LISP_EXTRA(buf, nelt, extra) \
4549 ptrdiff_t alloca_nbytes; \
4550 if (INT_MULTIPLY_WRAPV (nelt, word_size, &alloca_nbytes) \
4551 || INT_ADD_WRAPV (alloca_nbytes, extra, &alloca_nbytes) \
4552 || SIZE_MAX < alloca_nbytes) \
4553 memory_full (SIZE_MAX); \
4554 else if (alloca_nbytes <= sa_avail) \
4555 (buf) = AVAIL_ALLOCA (alloca_nbytes); \
4558 (buf) = xmalloc (alloca_nbytes); \
4559 record_unwind_protect_array (buf, nelt); \
4560 sa_must_free = true; \
4564 /* Set BUF to point to an allocated array of NELT Lisp_Objects. */
4566 #define SAFE_ALLOCA_LISP(buf, nelt) SAFE_ALLOCA_LISP_EXTRA (buf, nelt, 0)
4569 /* If USE_STACK_LISP_OBJECTS, define macros and functions that
4570 allocate some Lisp objects on the C stack. As the storage is not
4571 managed by the garbage collector, these objects are dangerous:
4572 passing them to user code could result in undefined behavior if the
4573 objects are in use after the C function returns. Conversely, these
4574 objects have better performance because GC is not involved.
4576 While debugging you may want to disable allocation on the C stack.
4577 Build with CPPFLAGS='-DUSE_STACK_LISP_OBJECTS=0' to disable it. */
4579 #if (!defined USE_STACK_LISP_OBJECTS \
4580 && defined __GNUC__ && !defined __clang__ && ! GNUC_PREREQ (4, 3, 2))
4581 /* Work around GCC bugs 36584 and 35271, which were fixed in GCC 4.3.2. */
4582 # define USE_STACK_LISP_OBJECTS false
4584 #ifndef USE_STACK_LISP_OBJECTS
4585 # define USE_STACK_LISP_OBJECTS true
4588 #ifdef GC_CHECK_STRING_BYTES
4589 enum { defined_GC_CHECK_STRING_BYTES
= true };
4591 enum { defined_GC_CHECK_STRING_BYTES
= false };
4594 /* True for stack-based cons and string implementations, respectively.
4595 Use stack-based strings only if stack-based cons also works.
4596 Otherwise, STACK_CONS would create heap-based cons cells that
4597 could point to stack-based strings, which is a no-no. */
4601 USE_STACK_CONS
= USE_STACK_LISP_OBJECTS
,
4602 USE_STACK_STRING
= (USE_STACK_CONS
4603 && !defined_GC_CHECK_STRING_BYTES
)
4606 /* Auxiliary macros used for auto allocation of Lisp objects. Please
4607 use these only in macros like AUTO_CONS that declare a local
4608 variable whose lifetime will be clear to the programmer. */
4609 #define STACK_CONS(a, b) \
4610 make_lisp_ptr (&((struct Lisp_Cons) {{{a, {b}}}}), Lisp_Cons)
4611 #define AUTO_CONS_EXPR(a, b) \
4612 (USE_STACK_CONS ? STACK_CONS (a, b) : Fcons (a, b))
4614 /* Declare NAME as an auto Lisp cons or short list if possible, a
4615 GC-based one otherwise. This is in the sense of the C keyword
4616 'auto'; i.e., the object has the lifetime of the containing block.
4617 The resulting object should not be made visible to user Lisp code. */
4619 #define AUTO_CONS(name, a, b) Lisp_Object name = AUTO_CONS_EXPR (a, b)
4620 #define AUTO_LIST1(name, a) \
4621 Lisp_Object name = (USE_STACK_CONS ? STACK_CONS (a, Qnil) : list1 (a))
4622 #define AUTO_LIST2(name, a, b) \
4623 Lisp_Object name = (USE_STACK_CONS \
4624 ? STACK_CONS (a, STACK_CONS (b, Qnil)) \
4626 #define AUTO_LIST3(name, a, b, c) \
4627 Lisp_Object name = (USE_STACK_CONS \
4628 ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c, Qnil))) \
4630 #define AUTO_LIST4(name, a, b, c, d) \
4633 ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c, \
4634 STACK_CONS (d, Qnil)))) \
4635 : list4 (a, b, c, d))
4637 /* Declare NAME as an auto Lisp string if possible, a GC-based one if not.
4638 Take its unibyte value from the null-terminated string STR,
4639 an expression that should not have side effects.
4640 STR's value is not necessarily copied. The resulting Lisp string
4641 should not be modified or given text properties or made visible to
4644 #define AUTO_STRING(name, str) \
4645 AUTO_STRING_WITH_LEN (name, str, strlen (str))
4647 /* Declare NAME as an auto Lisp string if possible, a GC-based one if not.
4648 Take its unibyte value from the null-terminated string STR with length LEN.
4649 STR may have side effects and may contain null bytes.
4650 STR's value is not necessarily copied. The resulting Lisp string
4651 should not be modified or given text properties or made visible to
4654 #define AUTO_STRING_WITH_LEN(name, str, len) \
4655 Lisp_Object name = \
4658 ((&(struct Lisp_String) {{{len, -1, 0, (unsigned char *) (str)}}}), \
4660 : make_unibyte_string (str, len))
4662 /* Loop over conses of the list TAIL, signaling if a cycle is found,
4663 and possibly quitting after each loop iteration. In the loop body,
4664 set TAIL to the current cons. If the loop exits normally,
4665 set TAIL to the terminating non-cons, typically nil. The loop body
4666 should not modify the list’s top level structure other than by
4667 perhaps deleting the current cons. */
4669 #define FOR_EACH_TAIL(tail) \
4670 FOR_EACH_TAIL_INTERNAL (tail, circular_list (tail), true)
4672 /* Like FOR_EACH_TAIL (LIST), except do not signal or quit.
4673 If the loop exits due to a cycle, TAIL’s value is undefined. */
4675 #define FOR_EACH_TAIL_SAFE(tail) \
4676 FOR_EACH_TAIL_INTERNAL (tail, (void) ((tail) = Qnil), false)
4678 /* Iterator intended for use only within FOR_EACH_TAIL_INTERNAL. */
4679 struct for_each_tail_internal
4681 Lisp_Object tortoise
;
4683 unsigned short int q
;
4686 /* Like FOR_EACH_TAIL (LIST), except evaluate CYCLE if a cycle is
4687 found, and check for quit if CHECK_QUIT. This is an internal macro
4688 intended for use only by the above macros.
4690 Use Brent’s teleporting tortoise-hare algorithm. See:
4691 Brent RP. BIT. 1980;20(2):176-84. doi:10.1007/BF01933190
4692 http://maths-people.anu.edu.au/~brent/pd/rpb051i.pdf
4694 This macro uses maybe_quit because of an excess of caution. The
4695 call to maybe_quit should not be needed in practice, as a very long
4696 list, whether circular or not, will cause Emacs to be so slow in
4697 other uninterruptible areas (e.g., garbage collection) that there
4698 is little point to calling maybe_quit here. */
4700 #define FOR_EACH_TAIL_INTERNAL(tail, cycle, check_quit) \
4701 for (struct for_each_tail_internal li = { tail, 2, 0, 2 }; \
4703 ((tail) = XCDR (tail), \
4705 || ((check_quit) ? maybe_quit () : (void) 0, 0 < --li.n) \
4706 || (li.q = li.n = li.max <<= 1, li.n >>= USHRT_WIDTH, \
4707 li.tortoise = (tail), false)) \
4708 && EQ (tail, li.tortoise)) \
4709 ? (cycle) : (void) 0))
4711 /* Do a `for' loop over alist values. */
4713 #define FOR_EACH_ALIST_VALUE(head_var, list_var, value_var) \
4714 for ((list_var) = (head_var); \
4715 (CONSP (list_var) && ((value_var) = XCDR (XCAR (list_var)), true)); \
4716 (list_var) = XCDR (list_var))
4718 /* Check whether it's time for GC, and run it if so. */
4723 if ((consing_since_gc
> gc_cons_threshold
4724 && consing_since_gc
> gc_relative_threshold
)
4725 || (!NILP (Vmemory_full
)
4726 && consing_since_gc
> memory_full_cons_threshold
))
4727 Fgarbage_collect ();
4732 #endif /* EMACS_LISP_H */