1 /* Fundamental definitions for GNU Emacs Lisp interpreter. -*- coding: utf-8 -*-
3 Copyright (C) 1985-1987, 1993-1995, 1997-2017 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 the few static Lisp_Objects used: lispsym, all the defsubr, and
232 the two special buffers buffer_defaults and buffer_local_symbols. */
236 /* 2**GCTYPEBITS. This must be a macro that expands to a literal
237 integer constant, for MSVC. */
238 #define GCALIGNMENT 8
240 /* Number of bits in a Lisp_Object value, not counting the tag. */
241 VALBITS
= EMACS_INT_WIDTH
- GCTYPEBITS
,
243 /* Number of bits in a Lisp fixnum tag. */
244 INTTYPEBITS
= GCTYPEBITS
- 1,
246 /* Number of bits in a Lisp fixnum value, not counting the tag. */
247 FIXNUM_BITS
= VALBITS
+ 1
250 #if GCALIGNMENT != 1 << GCTYPEBITS
251 # error "GCALIGNMENT and GCTYPEBITS are inconsistent"
254 /* The maximum value that can be stored in a EMACS_INT, assuming all
255 bits other than the type bits contribute to a nonnegative signed value.
256 This can be used in #if, e.g., '#if USE_LSB_TAG' below expands to an
257 expression involving VAL_MAX. */
258 #define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1))
260 /* Whether the least-significant bits of an EMACS_INT contain the tag.
261 On hosts where pointers-as-ints do not exceed VAL_MAX / 2, USE_LSB_TAG is:
262 a. unnecessary, because the top bits of an EMACS_INT are unused, and
263 b. slower, because it typically requires extra masking.
264 So, USE_LSB_TAG is true only on hosts where it might be useful. */
265 DEFINE_GDB_SYMBOL_BEGIN (bool, USE_LSB_TAG
)
266 #define USE_LSB_TAG (VAL_MAX / 2 < INTPTR_MAX)
267 DEFINE_GDB_SYMBOL_END (USE_LSB_TAG
)
269 /* Mask for the value (as opposed to the type bits) of a Lisp object. */
270 DEFINE_GDB_SYMBOL_BEGIN (EMACS_INT
, VALMASK
)
271 # define VALMASK (USE_LSB_TAG ? - (1 << GCTYPEBITS) : VAL_MAX)
272 DEFINE_GDB_SYMBOL_END (VALMASK
)
274 #if !USE_LSB_TAG && !defined WIDE_EMACS_INT
275 # error "USE_LSB_TAG not supported on this platform; please report this." \
276 "Try 'configure --with-wide-int' to work around the problem."
280 #ifdef HAVE_STRUCT_ATTRIBUTE_ALIGNED
281 # define GCALIGNED __attribute__ ((aligned (GCALIGNMENT)))
283 # define GCALIGNED /* empty */
286 /* Some operations are so commonly executed that they are implemented
287 as macros, not functions, because otherwise runtime performance would
288 suffer too much when compiling with GCC without optimization.
289 There's no need to inline everything, just the operations that
290 would otherwise cause a serious performance problem.
292 For each such operation OP, define a macro lisp_h_OP that contains
293 the operation's implementation. That way, OP can be implemented
294 via a macro definition like this:
296 #define OP(x) lisp_h_OP (x)
298 and/or via a function definition like this:
300 Lisp_Object (OP) (Lisp_Object x) { return lisp_h_OP (x); }
302 without worrying about the implementations diverging, since
303 lisp_h_OP defines the actual implementation. The lisp_h_OP macros
304 are intended to be private to this include file, and should not be
307 FIXME: Remove the lisp_h_OP macros, and define just the inline OP
308 functions, once "gcc -Og" (new to GCC 4.8) works well enough for
309 Emacs developers. Maybe in the year 2020. See Bug#11935.
311 Commentary for these macros can be found near their corresponding
314 #if CHECK_LISP_OBJECT_TYPE
315 # define lisp_h_XLI(o) ((o).i)
316 # define lisp_h_XIL(i) ((Lisp_Object) { i })
318 # define lisp_h_XLI(o) (o)
319 # define lisp_h_XIL(i) (i)
321 #define lisp_h_CHECK_NUMBER(x) CHECK_TYPE (INTEGERP (x), Qintegerp, x)
322 #define lisp_h_CHECK_SYMBOL(x) CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
323 #define lisp_h_CHECK_TYPE(ok, predicate, x) \
324 ((ok) ? (void) 0 : wrong_type_argument (predicate, x))
325 #define lisp_h_CONSP(x) (XTYPE (x) == Lisp_Cons)
326 #define lisp_h_EQ(x, y) (XLI (x) == XLI (y))
327 #define lisp_h_FLOATP(x) (XTYPE (x) == Lisp_Float)
328 #define lisp_h_INTEGERP(x) ((XTYPE (x) & (Lisp_Int0 | ~Lisp_Int1)) == Lisp_Int0)
329 #define lisp_h_MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
330 #define lisp_h_MISCP(x) (XTYPE (x) == Lisp_Misc)
331 #define lisp_h_NILP(x) EQ (x, Qnil)
332 #define lisp_h_SET_SYMBOL_VAL(sym, v) \
333 (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v))
334 #define lisp_h_SYMBOL_CONSTANT_P(sym) (XSYMBOL (sym)->trapped_write == SYMBOL_NOWRITE)
335 #define lisp_h_SYMBOL_TRAPPED_WRITE_P(sym) (XSYMBOL (sym)->trapped_write)
336 #define lisp_h_SYMBOL_VAL(sym) \
337 (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value)
338 #define lisp_h_SYMBOLP(x) (XTYPE (x) == Lisp_Symbol)
339 #define lisp_h_VECTORLIKEP(x) (XTYPE (x) == Lisp_Vectorlike)
340 #define lisp_h_XCAR(c) XCONS (c)->car
341 #define lisp_h_XCDR(c) XCONS (c)->u.cdr
342 #define lisp_h_XCONS(a) \
343 (eassert (CONSP (a)), (struct Lisp_Cons *) XUNTAG (a, Lisp_Cons))
344 #define lisp_h_XHASH(a) XUINT (a)
345 #ifndef GC_CHECK_CONS_LIST
346 # define lisp_h_check_cons_list() ((void) 0)
349 # define lisp_h_make_number(n) \
350 XIL ((EMACS_INT) (((EMACS_UINT) (n) << INTTYPEBITS) + Lisp_Int0))
351 # define lisp_h_XFASTINT(a) XINT (a)
352 # define lisp_h_XINT(a) (XLI (a) >> INTTYPEBITS)
353 # define lisp_h_XSYMBOL(a) \
354 (eassert (SYMBOLP (a)), \
355 (struct Lisp_Symbol *) ((intptr_t) XLI (a) - Lisp_Symbol \
357 # define lisp_h_XTYPE(a) ((enum Lisp_Type) (XLI (a) & ~VALMASK))
358 # define lisp_h_XUNTAG(a, type) \
359 __builtin_assume_aligned ((void *) (intptr_t) (XLI (a) - (type)), \
363 /* When compiling via gcc -O0, define the key operations as macros, as
364 Emacs is too slow otherwise. To disable this optimization, compile
365 with -DINLINING=false. */
366 #if (defined __NO_INLINE__ \
367 && ! defined __OPTIMIZE__ && ! defined __OPTIMIZE_SIZE__ \
368 && ! (defined INLINING && ! INLINING))
369 # define DEFINE_KEY_OPS_AS_MACROS true
371 # define DEFINE_KEY_OPS_AS_MACROS false
374 #if DEFINE_KEY_OPS_AS_MACROS
375 # define XLI(o) lisp_h_XLI (o)
376 # define XIL(i) lisp_h_XIL (i)
377 # define CHECK_NUMBER(x) lisp_h_CHECK_NUMBER (x)
378 # define CHECK_SYMBOL(x) lisp_h_CHECK_SYMBOL (x)
379 # define CHECK_TYPE(ok, predicate, x) lisp_h_CHECK_TYPE (ok, predicate, x)
380 # define CONSP(x) lisp_h_CONSP (x)
381 # define EQ(x, y) lisp_h_EQ (x, y)
382 # define FLOATP(x) lisp_h_FLOATP (x)
383 # define INTEGERP(x) lisp_h_INTEGERP (x)
384 # define MARKERP(x) lisp_h_MARKERP (x)
385 # define MISCP(x) lisp_h_MISCP (x)
386 # define NILP(x) lisp_h_NILP (x)
387 # define SET_SYMBOL_VAL(sym, v) lisp_h_SET_SYMBOL_VAL (sym, v)
388 # define SYMBOL_CONSTANT_P(sym) lisp_h_SYMBOL_CONSTANT_P (sym)
389 # define SYMBOL_TRAPPED_WRITE_P(sym) lisp_h_SYMBOL_TRAPPED_WRITE_P (sym)
390 # define SYMBOL_VAL(sym) lisp_h_SYMBOL_VAL (sym)
391 # define SYMBOLP(x) lisp_h_SYMBOLP (x)
392 # define VECTORLIKEP(x) lisp_h_VECTORLIKEP (x)
393 # define XCAR(c) lisp_h_XCAR (c)
394 # define XCDR(c) lisp_h_XCDR (c)
395 # define XCONS(a) lisp_h_XCONS (a)
396 # define XHASH(a) lisp_h_XHASH (a)
397 # ifndef GC_CHECK_CONS_LIST
398 # define check_cons_list() lisp_h_check_cons_list ()
401 # define make_number(n) lisp_h_make_number (n)
402 # define XFASTINT(a) lisp_h_XFASTINT (a)
403 # define XINT(a) lisp_h_XINT (a)
404 # define XSYMBOL(a) lisp_h_XSYMBOL (a)
405 # define XTYPE(a) lisp_h_XTYPE (a)
406 # define XUNTAG(a, type) lisp_h_XUNTAG (a, type)
411 /* Define the fundamental Lisp data structures. */
413 /* This is the set of Lisp data types. If you want to define a new
414 data type, read the comments after Lisp_Fwd_Type definition
417 /* Lisp integers use 2 tags, to give them one extra bit, thus
418 extending their range from, e.g., -2^28..2^28-1 to -2^29..2^29-1. */
419 #define INTMASK (EMACS_INT_MAX >> (INTTYPEBITS - 1))
420 #define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
422 /* Idea stolen from GDB. Pedantic GCC complains about enum bitfields,
423 MSVC doesn't support them, and xlc and Oracle Studio c99 complain
424 vociferously about them. */
425 #if (defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__ \
426 || (defined __SUNPRO_C && __STDC__))
427 #define ENUM_BF(TYPE) unsigned int
429 #define ENUM_BF(TYPE) enum TYPE
435 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
438 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
439 whose first member indicates the subtype. */
442 /* Integer. XINT (obj) is the integer value. */
444 Lisp_Int1
= USE_LSB_TAG
? 6 : 3,
446 /* String. XSTRING (object) points to a struct Lisp_String.
447 The length of the string, and its contents, are stored therein. */
450 /* Vector of Lisp objects, or something resembling it.
451 XVECTOR (object) points to a struct Lisp_Vector, which contains
452 the size and contents. The size field also contains the type
453 information, if it's not a real vector object. */
456 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
457 Lisp_Cons
= USE_LSB_TAG
? 3 : 6,
462 /* This is the set of data types that share a common structure.
463 The first member of the structure is a type code from this set.
464 The enum values are arbitrary, but we'll use large numbers to make it
465 more likely that we'll spot the error if a random word in memory is
466 mistakenly interpreted as a Lisp_Misc. */
469 Lisp_Misc_Free
= 0x5eab,
472 Lisp_Misc_Save_Value
,
477 /* This is not a type code. It is for range checking. */
481 /* These are the types of forwarding objects used in the value slot
482 of symbols for special built-in variables whose value is stored in
486 Lisp_Fwd_Int
, /* Fwd to a C `int' variable. */
487 Lisp_Fwd_Bool
, /* Fwd to a C boolean var. */
488 Lisp_Fwd_Obj
, /* Fwd to a C Lisp_Object variable. */
489 Lisp_Fwd_Buffer_Obj
, /* Fwd to a Lisp_Object field of buffers. */
490 Lisp_Fwd_Kboard_Obj
/* Fwd to a Lisp_Object field of kboards. */
493 /* If you want to define a new Lisp data type, here are some
494 instructions. See the thread at
495 http://lists.gnu.org/archive/html/emacs-devel/2012-10/msg00561.html
498 First, there are already a couple of Lisp types that can be used if
499 your new type does not need to be exposed to Lisp programs nor
500 displayed to users. These are Lisp_Save_Value, a Lisp_Misc
501 subtype; and PVEC_OTHER, a kind of vectorlike object. The former
502 is suitable for temporarily stashing away pointers and integers in
503 a Lisp object. The latter is useful for vector-like Lisp objects
504 that need to be used as part of other objects, but which are never
505 shown to users or Lisp code (search for PVEC_OTHER in xterm.c for
508 These two types don't look pretty when printed, so they are
509 unsuitable for Lisp objects that can be exposed to users.
511 To define a new data type, add one more Lisp_Misc subtype or one
512 more pseudovector subtype. Pseudovectors are more suitable for
513 objects with several slots that need to support fast random access,
514 while Lisp_Misc types are for everything else. A pseudovector object
515 provides one or more slots for Lisp objects, followed by struct
516 members that are accessible only from C. A Lisp_Misc object is a
517 wrapper for a C struct that can contain anything you like.
519 Explicit freeing is discouraged for Lisp objects in general. But if
520 you really need to exploit this, use Lisp_Misc (check free_misc in
521 alloc.c to see why). There is no way to free a vectorlike object.
523 To add a new pseudovector type, extend the pvec_type enumeration;
524 to add a new Lisp_Misc, extend the Lisp_Misc_Type enumeration.
526 For a Lisp_Misc, you will also need to add your entry to union
527 Lisp_Misc, but make sure the first word has the same structure as
528 the others, starting with a 16-bit member of the Lisp_Misc_Type
529 enumeration and a 1-bit GC markbit. Also make sure the overall
530 size of the union is not increased by your addition. The latter
531 requirement is to keep Lisp_Misc objects small enough, so they
532 are handled faster: since all Lisp_Misc types use the same space,
533 enlarging any of them will affect all the rest. If you really
534 need a larger object, it is best to use Lisp_Vectorlike instead.
536 For a new pseudovector, it's highly desirable to limit the size
537 of your data type by VBLOCK_BYTES_MAX bytes (defined in alloc.c).
538 Otherwise you will need to change sweep_vectors (also in alloc.c).
540 Then you will need to add switch branches in print.c (in
541 print_object, to print your object, and possibly also in
542 print_preprocess) and to alloc.c, to mark your object (in
543 mark_object) and to free it (in gc_sweep). The latter is also the
544 right place to call any code specific to your data type that needs
545 to run when the object is recycled -- e.g., free any additional
546 resources allocated for it that are not Lisp objects. You can even
547 make a pointer to the function that frees the resources a slot in
548 your object -- this way, the same object could be used to represent
549 several disparate C structures. */
551 #ifdef CHECK_LISP_OBJECT_TYPE
553 typedef struct Lisp_Object
{ EMACS_INT i
; } Lisp_Object
;
555 #define LISP_INITIALLY(i) {i}
557 #undef CHECK_LISP_OBJECT_TYPE
558 enum CHECK_LISP_OBJECT_TYPE
{ CHECK_LISP_OBJECT_TYPE
= true };
559 #else /* CHECK_LISP_OBJECT_TYPE */
561 /* If a struct type is not wanted, define Lisp_Object as just a number. */
563 typedef EMACS_INT Lisp_Object
;
564 #define LISP_INITIALLY(i) (i)
565 enum CHECK_LISP_OBJECT_TYPE
{ CHECK_LISP_OBJECT_TYPE
= false };
566 #endif /* CHECK_LISP_OBJECT_TYPE */
568 /* Forward declarations. */
570 /* Defined in this file. */
571 INLINE
void set_sub_char_table_contents (Lisp_Object
, ptrdiff_t,
574 /* Defined in chartab.c. */
575 extern Lisp_Object
char_table_ref (Lisp_Object
, int);
576 extern void char_table_set (Lisp_Object
, int, Lisp_Object
);
578 /* Defined in data.c. */
579 extern _Noreturn
void wrong_type_argument (Lisp_Object
, Lisp_Object
);
583 enum { might_dump
= false };
584 #elif defined DOUG_LEA_MALLOC
585 /* Defined in emacs.c. */
586 extern bool might_dump
;
588 /* True means Emacs has already been initialized.
589 Used during startup to detect startup of dumped Emacs. */
590 extern bool initialized
;
592 /* Defined in floatfns.c. */
593 extern double extract_float (Lisp_Object
);
596 /* Low-level conversion and type checking. */
598 /* Convert a Lisp_Object to the corresponding EMACS_INT and vice versa.
599 At the machine level, these operations are no-ops. */
602 (XLI
) (Lisp_Object o
)
604 return lisp_h_XLI (o
);
610 return lisp_h_XIL (i
);
613 /* Extract A's type. */
615 INLINE
enum Lisp_Type
616 (XTYPE
) (Lisp_Object a
)
619 return lisp_h_XTYPE (a
);
621 EMACS_UINT i
= XLI (a
);
622 return USE_LSB_TAG
? i
& ~VALMASK
: i
>> VALBITS
;
627 (CHECK_TYPE
) (int ok
, Lisp_Object predicate
, Lisp_Object x
)
629 lisp_h_CHECK_TYPE (ok
, predicate
, x
);
632 /* Extract A's pointer value, assuming A's type is TYPE. */
635 (XUNTAG
) (Lisp_Object a
, int type
)
638 return lisp_h_XUNTAG (a
, type
);
640 intptr_t i
= USE_LSB_TAG
? XLI (a
) - type
: XLI (a
) & VALMASK
;
646 /* Interned state of a symbol. */
650 SYMBOL_UNINTERNED
= 0,
652 SYMBOL_INTERNED_IN_INITIAL_OBARRAY
= 2
659 SYMBOL_LOCALIZED
= 2,
663 enum symbol_trapped_write
665 SYMBOL_UNTRAPPED_WRITE
= 0,
667 SYMBOL_TRAPPED_WRITE
= 2
672 bool_bf gcmarkbit
: 1;
674 /* Indicates where the value can be found:
675 0 : it's a plain var, the value is in the `value' field.
676 1 : it's a varalias, the value is really in the `alias' symbol.
677 2 : it's a localized var, the value is in the `blv' object.
678 3 : it's a forwarding variable, the value is in `forward'. */
679 ENUM_BF (symbol_redirect
) redirect
: 3;
681 /* 0 : normal case, just set the value
682 1 : constant, cannot set, e.g. nil, t, :keywords.
683 2 : trap the write, call watcher functions. */
684 ENUM_BF (symbol_trapped_write
) trapped_write
: 2;
686 /* Interned state of the symbol. This is an enumerator from
687 enum symbol_interned. */
688 unsigned interned
: 2;
690 /* True means that this variable has been explicitly declared
691 special (with `defvar' etc), and shouldn't be lexically bound. */
692 bool_bf declared_special
: 1;
694 /* True if pointed to from purespace and hence can't be GC'd. */
697 /* The symbol's name, as a Lisp string. */
700 /* Value of the symbol or Qunbound if unbound. Which alternative of the
701 union is used depends on the `redirect' field above. */
704 struct Lisp_Symbol
*alias
;
705 struct Lisp_Buffer_Local_Value
*blv
;
709 /* Function value of the symbol or Qnil if not fboundp. */
710 Lisp_Object function
;
712 /* The symbol's property list. */
715 /* Next symbol in obarray bucket, if the symbol is interned. */
716 struct Lisp_Symbol
*next
;
719 /* Declare a Lisp-callable function. The MAXARGS parameter has the same
720 meaning as in the DEFUN macro, and is used to construct a prototype. */
721 /* We can use the same trick as in the DEFUN macro to generate the
722 appropriate prototype. */
723 #define EXFUN(fnname, maxargs) \
724 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
726 /* Note that the weird token-substitution semantics of ANSI C makes
727 this work for MANY and UNEVALLED. */
728 #define DEFUN_ARGS_MANY (ptrdiff_t, Lisp_Object *)
729 #define DEFUN_ARGS_UNEVALLED (Lisp_Object)
730 #define DEFUN_ARGS_0 (void)
731 #define DEFUN_ARGS_1 (Lisp_Object)
732 #define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
733 #define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
734 #define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
735 #define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
737 #define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
738 Lisp_Object, Lisp_Object)
739 #define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
740 Lisp_Object, Lisp_Object, Lisp_Object)
741 #define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
742 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
744 /* Yield a signed integer that contains TAG along with PTR.
746 Sign-extend pointers when USE_LSB_TAG (this simplifies emacs-module.c),
747 and zero-extend otherwise (that’s a bit faster here).
748 Sign extension matters only when EMACS_INT is wider than a pointer. */
749 #define TAG_PTR(tag, ptr) \
751 ? (intptr_t) (ptr) + (tag) \
752 : (EMACS_INT) (((EMACS_UINT) (tag) << VALBITS) + (uintptr_t) (ptr)))
754 /* Yield an integer that contains a symbol tag along with OFFSET.
755 OFFSET should be the offset in bytes from 'lispsym' to the symbol. */
756 #define TAG_SYMOFFSET(offset) TAG_PTR (Lisp_Symbol, offset)
758 /* XLI_BUILTIN_LISPSYM (iQwhatever) is equivalent to
759 XLI (builtin_lisp_symbol (Qwhatever)),
760 except the former expands to an integer constant expression. */
761 #define XLI_BUILTIN_LISPSYM(iname) TAG_SYMOFFSET ((iname) * sizeof *lispsym)
763 /* LISPSYM_INITIALLY (Qfoo) is equivalent to Qfoo except it is
764 designed for use as an initializer, even for a constant initializer. */
765 #define LISPSYM_INITIALLY(name) LISP_INITIALLY (XLI_BUILTIN_LISPSYM (i##name))
767 /* Declare extern constants for Lisp symbols. These can be helpful
768 when using a debugger like GDB, on older platforms where the debug
769 format does not represent C macros. */
770 #define DEFINE_LISP_SYMBOL(name) \
771 DEFINE_GDB_SYMBOL_BEGIN (Lisp_Object, name) \
772 DEFINE_GDB_SYMBOL_END (LISPSYM_INITIALLY (name))
774 /* The index of the C-defined Lisp symbol SYM.
775 This can be used in a static initializer. */
776 #define SYMBOL_INDEX(sym) i##sym
778 /* By default, define macros for Qt, etc., as this leads to a bit
779 better performance in the core Emacs interpreter. A plugin can
780 define DEFINE_NON_NIL_Q_SYMBOL_MACROS to be false, to be portable to
781 other Emacs instances that assign different values to Qt, etc. */
782 #ifndef DEFINE_NON_NIL_Q_SYMBOL_MACROS
783 # define DEFINE_NON_NIL_Q_SYMBOL_MACROS true
788 /* Header of vector-like objects. This documents the layout constraints on
789 vectors and pseudovectors (objects of PVEC_xxx subtype). It also prevents
790 compilers from being fooled by Emacs's type punning: XSETPSEUDOVECTOR
791 and PSEUDOVECTORP cast their pointers to struct vectorlike_header *,
792 because when two such pointers potentially alias, a compiler won't
793 incorrectly reorder loads and stores to their size fields. See
795 struct vectorlike_header
797 /* The only field contains various pieces of information:
798 - The MSB (ARRAY_MARK_FLAG) holds the gcmarkbit.
799 - The next bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
800 vector (0) or a pseudovector (1).
801 - If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
802 of slots) of the vector.
803 - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
804 - a) pseudovector subtype held in PVEC_TYPE_MASK field;
805 - b) number of Lisp_Objects slots at the beginning of the object
806 held in PSEUDOVECTOR_SIZE_MASK field. These objects are always
808 - c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
809 measured in word_size units. Rest fields may also include
810 Lisp_Objects, but these objects usually needs some special treatment
812 There are some exceptions. For PVEC_FREE, b) is always zero. For
813 PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
814 Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
815 4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots. */
820 (SYMBOLP
) (Lisp_Object x
)
822 return lisp_h_SYMBOLP (x
);
825 INLINE
struct Lisp_Symbol
*
826 (XSYMBOL
) (Lisp_Object a
)
829 return lisp_h_XSYMBOL (a
);
831 eassert (SYMBOLP (a
));
832 intptr_t i
= (intptr_t) XUNTAG (a
, Lisp_Symbol
);
833 void *p
= (char *) lispsym
+ i
;
839 make_lisp_symbol (struct Lisp_Symbol
*sym
)
841 Lisp_Object a
= XIL (TAG_SYMOFFSET ((char *) sym
- (char *) lispsym
));
842 eassert (XSYMBOL (a
) == sym
);
847 builtin_lisp_symbol (int index
)
849 return make_lisp_symbol (&lispsym
[index
].s
);
853 (CHECK_SYMBOL
) (Lisp_Object x
)
855 lisp_h_CHECK_SYMBOL (x
);
858 /* In the size word of a vector, this bit means the vector has been marked. */
860 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, ARRAY_MARK_FLAG
)
861 # define ARRAY_MARK_FLAG PTRDIFF_MIN
862 DEFINE_GDB_SYMBOL_END (ARRAY_MARK_FLAG
)
864 /* In the size word of a struct Lisp_Vector, this bit means it's really
865 some other vector-like object. */
866 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, PSEUDOVECTOR_FLAG
)
867 # define PSEUDOVECTOR_FLAG (PTRDIFF_MAX - PTRDIFF_MAX / 2)
868 DEFINE_GDB_SYMBOL_END (PSEUDOVECTOR_FLAG
)
870 /* In a pseudovector, the size field actually contains a word with one
871 PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
872 with PVEC_TYPE_MASK to indicate the actual type. */
884 PVEC_WINDOW_CONFIGURATION
,
886 PVEC_OTHER
, /* Should never be visible to Elisp code. */
892 PVEC_MODULE_FUNCTION
,
894 /* These should be last, check internal_equal to see why. */
899 PVEC_FONT
/* Should be last because it's used for range checking. */
904 /* For convenience, we also store the number of elements in these bits.
905 Note that this size is not necessarily the memory-footprint size, but
906 only the number of Lisp_Object fields (that need to be traced by GC).
907 The distinction is used, e.g., by Lisp_Process, which places extra
908 non-Lisp_Object fields at the end of the structure. */
909 PSEUDOVECTOR_SIZE_BITS
= 12,
910 PSEUDOVECTOR_SIZE_MASK
= (1 << PSEUDOVECTOR_SIZE_BITS
) - 1,
912 /* To calculate the memory footprint of the pseudovector, it's useful
913 to store the size of non-Lisp area in word_size units here. */
914 PSEUDOVECTOR_REST_BITS
= 12,
915 PSEUDOVECTOR_REST_MASK
= (((1 << PSEUDOVECTOR_REST_BITS
) - 1)
916 << PSEUDOVECTOR_SIZE_BITS
),
918 /* Used to extract pseudovector subtype information. */
919 PSEUDOVECTOR_AREA_BITS
= PSEUDOVECTOR_SIZE_BITS
+ PSEUDOVECTOR_REST_BITS
,
920 PVEC_TYPE_MASK
= 0x3f << PSEUDOVECTOR_AREA_BITS
923 /* These functions extract various sorts of values from a Lisp_Object.
924 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
925 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for
928 /* Largest and smallest representable fixnum values. These are the C
929 values. They are macros for use in static initializers. */
930 #define MOST_POSITIVE_FIXNUM (EMACS_INT_MAX >> INTTYPEBITS)
931 #define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_FIXNUM)
936 (make_number
) (EMACS_INT n
)
938 return lisp_h_make_number (n
);
942 (XINT
) (Lisp_Object a
)
944 return lisp_h_XINT (a
);
948 (XFASTINT
) (Lisp_Object a
)
950 EMACS_INT n
= lisp_h_XFASTINT (a
);
955 #else /* ! USE_LSB_TAG */
957 /* Although compiled only if ! USE_LSB_TAG, the following functions
958 also work when USE_LSB_TAG; this is to aid future maintenance when
959 the lisp_h_* macros are eventually removed. */
961 /* Make a Lisp integer representing the value of the low order
964 make_number (EMACS_INT n
)
966 EMACS_INT int0
= Lisp_Int0
;
970 n
= u
<< INTTYPEBITS
;
976 n
+= (int0
<< VALBITS
);
981 /* Extract A's value as a signed integer. */
985 EMACS_INT i
= XLI (a
);
989 i
= u
<< INTTYPEBITS
;
991 return i
>> INTTYPEBITS
;
994 /* Like XINT (A), but may be faster. A must be nonnegative.
995 If ! USE_LSB_TAG, this takes advantage of the fact that Lisp
996 integers have zero-bits in their tags. */
998 XFASTINT (Lisp_Object a
)
1000 EMACS_INT int0
= Lisp_Int0
;
1001 EMACS_INT n
= USE_LSB_TAG
? XINT (a
) : XLI (a
) - (int0
<< VALBITS
);
1006 #endif /* ! USE_LSB_TAG */
1008 /* Extract A's value as an unsigned integer. */
1010 XUINT (Lisp_Object a
)
1012 EMACS_UINT i
= XLI (a
);
1013 return USE_LSB_TAG
? i
>> INTTYPEBITS
: i
& INTMASK
;
1016 /* Return A's (Lisp-integer sized) hash. Happens to be like XUINT
1017 right now, but XUINT should only be applied to objects we know are
1021 (XHASH
) (Lisp_Object a
)
1023 return lisp_h_XHASH (a
);
1026 /* Like make_number (N), but may be faster. N must be in nonnegative range. */
1028 make_natnum (EMACS_INT n
)
1030 eassert (0 <= n
&& n
<= MOST_POSITIVE_FIXNUM
);
1031 EMACS_INT int0
= Lisp_Int0
;
1032 return USE_LSB_TAG
? make_number (n
) : XIL (n
+ (int0
<< VALBITS
));
1035 /* Return true if X and Y are the same object. */
1038 (EQ
) (Lisp_Object x
, Lisp_Object y
)
1040 return lisp_h_EQ (x
, y
);
1043 /* True if the possibly-unsigned integer I doesn't fit in a Lisp fixnum. */
1045 #define FIXNUM_OVERFLOW_P(i) \
1046 (! ((0 <= (i) || MOST_NEGATIVE_FIXNUM <= (i)) && (i) <= MOST_POSITIVE_FIXNUM))
1049 clip_to_bounds (ptrdiff_t lower
, EMACS_INT num
, ptrdiff_t upper
)
1051 return num
< lower
? lower
: num
<= upper
? num
: upper
;
1054 /* Construct a Lisp_Object from a value or address. */
1057 make_lisp_ptr (void *ptr
, enum Lisp_Type type
)
1059 Lisp_Object a
= XIL (TAG_PTR (type
, ptr
));
1060 eassert (XTYPE (a
) == type
&& XUNTAG (a
, type
) == ptr
);
1065 (INTEGERP
) (Lisp_Object x
)
1067 return lisp_h_INTEGERP (x
);
1070 #define XSETINT(a, b) ((a) = make_number (b))
1071 #define XSETFASTINT(a, b) ((a) = make_natnum (b))
1072 #define XSETCONS(a, b) ((a) = make_lisp_ptr (b, Lisp_Cons))
1073 #define XSETVECTOR(a, b) ((a) = make_lisp_ptr (b, Lisp_Vectorlike))
1074 #define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
1075 #define XSETSYMBOL(a, b) ((a) = make_lisp_symbol (b))
1076 #define XSETFLOAT(a, b) ((a) = make_lisp_ptr (b, Lisp_Float))
1077 #define XSETMISC(a, b) ((a) = make_lisp_ptr (b, Lisp_Misc))
1079 /* Pseudovector types. */
1081 #define XSETPVECTYPE(v, code) \
1082 ((v)->header.size |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS))
1083 #define XSETPVECTYPESIZE(v, code, lispsize, restsize) \
1084 ((v)->header.size = (PSEUDOVECTOR_FLAG \
1085 | ((code) << PSEUDOVECTOR_AREA_BITS) \
1086 | ((restsize) << PSEUDOVECTOR_SIZE_BITS) \
1089 /* The cast to struct vectorlike_header * avoids aliasing issues. */
1090 #define XSETPSEUDOVECTOR(a, b, code) \
1091 XSETTYPED_PSEUDOVECTOR (a, b, \
1092 (((struct vectorlike_header *) \
1093 XUNTAG (a, Lisp_Vectorlike)) \
1096 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code) \
1097 (XSETVECTOR (a, b), \
1098 eassert ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) \
1099 == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS))))
1101 #define XSETWINDOW_CONFIGURATION(a, b) \
1102 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
1103 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
1104 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
1105 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
1106 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
1107 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
1108 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
1109 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
1110 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
1111 #define XSETSUB_CHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUB_CHAR_TABLE))
1112 #define XSETTHREAD(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_THREAD))
1113 #define XSETMUTEX(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_MUTEX))
1114 #define XSETCONDVAR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CONDVAR))
1116 /* Efficiently convert a pointer to a Lisp object and back. The
1117 pointer is represented as a Lisp integer, so the garbage collector
1118 does not know about it. The pointer should not have both Lisp_Int1
1119 bits set, which makes this conversion inherently unportable. */
1122 XINTPTR (Lisp_Object a
)
1124 return XUNTAG (a
, Lisp_Int0
);
1128 make_pointer_integer (void *p
)
1130 Lisp_Object a
= XIL (TAG_PTR (Lisp_Int0
, p
));
1131 eassert (INTEGERP (a
) && XINTPTR (a
) == p
);
1135 /* See the macros in intervals.h. */
1137 typedef struct interval
*INTERVAL
;
1139 struct GCALIGNED Lisp_Cons
1141 /* Car of this cons cell. */
1146 /* Cdr of this cons cell. */
1149 /* Used to chain conses on a free list. */
1150 struct Lisp_Cons
*chain
;
1155 (NILP
) (Lisp_Object x
)
1157 return lisp_h_NILP (x
);
1161 (CONSP
) (Lisp_Object x
)
1163 return lisp_h_CONSP (x
);
1167 CHECK_CONS (Lisp_Object x
)
1169 CHECK_TYPE (CONSP (x
), Qconsp
, x
);
1172 INLINE
struct Lisp_Cons
*
1173 (XCONS
) (Lisp_Object a
)
1175 return lisp_h_XCONS (a
);
1178 /* Take the car or cdr of something known to be a cons cell. */
1179 /* The _addr functions shouldn't be used outside of the minimal set
1180 of code that has to know what a cons cell looks like. Other code not
1181 part of the basic lisp implementation should assume that the car and cdr
1182 fields are not accessible. (What if we want to switch to
1183 a copying collector someday? Cached cons cell field addresses may be
1184 invalidated at arbitrary points.) */
1185 INLINE Lisp_Object
*
1186 xcar_addr (Lisp_Object c
)
1188 return &XCONS (c
)->car
;
1190 INLINE Lisp_Object
*
1191 xcdr_addr (Lisp_Object c
)
1193 return &XCONS (c
)->u
.cdr
;
1196 /* Use these from normal code. */
1199 (XCAR
) (Lisp_Object c
)
1201 return lisp_h_XCAR (c
);
1205 (XCDR
) (Lisp_Object c
)
1207 return lisp_h_XCDR (c
);
1210 /* Use these to set the fields of a cons cell.
1212 Note that both arguments may refer to the same object, so 'n'
1213 should not be read after 'c' is first modified. */
1215 XSETCAR (Lisp_Object c
, Lisp_Object n
)
1220 XSETCDR (Lisp_Object c
, Lisp_Object n
)
1225 /* Take the car or cdr of something whose type is not known. */
1232 wrong_type_argument (Qlistp
, c
);
1241 wrong_type_argument (Qlistp
, c
);
1245 /* Take the car or cdr of something whose type is not known. */
1247 CAR_SAFE (Lisp_Object c
)
1249 return CONSP (c
) ? XCAR (c
) : Qnil
;
1252 CDR_SAFE (Lisp_Object c
)
1254 return CONSP (c
) ? XCDR (c
) : Qnil
;
1257 /* In a string or vector, the sign bit of the `size' is the gc mark bit. */
1259 struct GCALIGNED Lisp_String
1262 ptrdiff_t size_byte
;
1263 INTERVAL intervals
; /* Text properties in this string. */
1264 unsigned char *data
;
1268 STRINGP (Lisp_Object x
)
1270 return XTYPE (x
) == Lisp_String
;
1274 CHECK_STRING (Lisp_Object x
)
1276 CHECK_TYPE (STRINGP (x
), Qstringp
, x
);
1279 INLINE
struct Lisp_String
*
1280 XSTRING (Lisp_Object a
)
1282 eassert (STRINGP (a
));
1283 return XUNTAG (a
, Lisp_String
);
1286 /* True if STR is a multibyte string. */
1288 STRING_MULTIBYTE (Lisp_Object str
)
1290 return 0 <= XSTRING (str
)->size_byte
;
1293 /* An upper bound on the number of bytes in a Lisp string, not
1294 counting the terminating null. This a tight enough bound to
1295 prevent integer overflow errors that would otherwise occur during
1296 string size calculations. A string cannot contain more bytes than
1297 a fixnum can represent, nor can it be so long that C pointer
1298 arithmetic stops working on the string plus its terminating null.
1299 Although the actual size limit (see STRING_BYTES_MAX in alloc.c)
1300 may be a bit smaller than STRING_BYTES_BOUND, calculating it here
1301 would expose alloc.c internal details that we'd rather keep
1304 This is a macro for use in static initializers. The cast to
1305 ptrdiff_t ensures that the macro is signed. */
1306 #define STRING_BYTES_BOUND \
1307 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1))
1309 /* Mark STR as a unibyte string. */
1310 #define STRING_SET_UNIBYTE(STR) \
1312 if (XSTRING (STR)->size == 0) \
1313 (STR) = empty_unibyte_string; \
1315 XSTRING (STR)->size_byte = -1; \
1318 /* Mark STR as a multibyte string. Assure that STR contains only
1319 ASCII characters in advance. */
1320 #define STRING_SET_MULTIBYTE(STR) \
1322 if (XSTRING (STR)->size == 0) \
1323 (STR) = empty_multibyte_string; \
1325 XSTRING (STR)->size_byte = XSTRING (STR)->size; \
1328 /* Convenience functions for dealing with Lisp strings. */
1330 INLINE
unsigned char *
1331 SDATA (Lisp_Object string
)
1333 return XSTRING (string
)->data
;
1336 SSDATA (Lisp_Object string
)
1338 /* Avoid "differ in sign" warnings. */
1339 return (char *) SDATA (string
);
1341 INLINE
unsigned char
1342 SREF (Lisp_Object string
, ptrdiff_t index
)
1344 return SDATA (string
)[index
];
1347 SSET (Lisp_Object string
, ptrdiff_t index
, unsigned char new)
1349 SDATA (string
)[index
] = new;
1352 SCHARS (Lisp_Object string
)
1354 ptrdiff_t nchars
= XSTRING (string
)->size
;
1355 eassume (0 <= nchars
);
1359 #ifdef GC_CHECK_STRING_BYTES
1360 extern ptrdiff_t string_bytes (struct Lisp_String
*);
1363 STRING_BYTES (struct Lisp_String
*s
)
1365 #ifdef GC_CHECK_STRING_BYTES
1366 ptrdiff_t nbytes
= string_bytes (s
);
1368 ptrdiff_t nbytes
= s
->size_byte
< 0 ? s
->size
: s
->size_byte
;
1370 eassume (0 <= nbytes
);
1375 SBYTES (Lisp_Object string
)
1377 return STRING_BYTES (XSTRING (string
));
1380 STRING_SET_CHARS (Lisp_Object string
, ptrdiff_t newsize
)
1382 /* This function cannot change the size of data allocated for the
1383 string when it was created. */
1384 eassert (STRING_MULTIBYTE (string
)
1385 ? 0 <= newsize
&& newsize
<= SBYTES (string
)
1386 : newsize
== SCHARS (string
));
1387 XSTRING (string
)->size
= newsize
;
1390 /* A regular vector is just a header plus an array of Lisp_Objects. */
1394 struct vectorlike_header header
;
1395 Lisp_Object contents
[FLEXIBLE_ARRAY_MEMBER
];
1399 (VECTORLIKEP
) (Lisp_Object x
)
1401 return lisp_h_VECTORLIKEP (x
);
1404 INLINE
struct Lisp_Vector
*
1405 XVECTOR (Lisp_Object a
)
1407 eassert (VECTORLIKEP (a
));
1408 return XUNTAG (a
, Lisp_Vectorlike
);
1412 ASIZE (Lisp_Object array
)
1414 ptrdiff_t size
= XVECTOR (array
)->header
.size
;
1415 eassume (0 <= size
);
1420 PVSIZE (Lisp_Object pv
)
1422 return ASIZE (pv
) & PSEUDOVECTOR_SIZE_MASK
;
1426 VECTORP (Lisp_Object x
)
1428 return VECTORLIKEP (x
) && ! (ASIZE (x
) & PSEUDOVECTOR_FLAG
);
1432 CHECK_VECTOR (Lisp_Object x
)
1434 CHECK_TYPE (VECTORP (x
), Qvectorp
, x
);
1438 /* A pseudovector is like a vector, but has other non-Lisp components. */
1440 INLINE
enum pvec_type
1441 PSEUDOVECTOR_TYPE (struct Lisp_Vector
*v
)
1443 ptrdiff_t size
= v
->header
.size
;
1444 return (size
& PSEUDOVECTOR_FLAG
1445 ? (size
& PVEC_TYPE_MASK
) >> PSEUDOVECTOR_AREA_BITS
1446 : PVEC_NORMAL_VECTOR
);
1449 /* Can't be used with PVEC_NORMAL_VECTOR. */
1451 PSEUDOVECTOR_TYPEP (struct vectorlike_header
*a
, enum pvec_type code
)
1453 /* We don't use PSEUDOVECTOR_TYPE here so as to avoid a shift
1454 * operation when `code' is known. */
1455 return ((a
->size
& (PSEUDOVECTOR_FLAG
| PVEC_TYPE_MASK
))
1456 == (PSEUDOVECTOR_FLAG
| (code
<< PSEUDOVECTOR_AREA_BITS
)));
1459 /* True if A is a pseudovector whose code is CODE. */
1461 PSEUDOVECTORP (Lisp_Object a
, int code
)
1463 if (! VECTORLIKEP (a
))
1467 /* Converting to struct vectorlike_header * avoids aliasing issues. */
1468 struct vectorlike_header
*h
= XUNTAG (a
, Lisp_Vectorlike
);
1469 return PSEUDOVECTOR_TYPEP (h
, code
);
1473 /* A boolvector is a kind of vectorlike, with contents like a string. */
1475 struct Lisp_Bool_Vector
1477 /* HEADER.SIZE is the vector's size field. It doesn't have the real size,
1478 just the subtype information. */
1479 struct vectorlike_header header
;
1480 /* This is the size in bits. */
1482 /* The actual bits, packed into bytes.
1483 Zeros fill out the last word if needed.
1484 The bits are in little-endian order in the bytes, and
1485 the bytes are in little-endian order in the words. */
1486 bits_word data
[FLEXIBLE_ARRAY_MEMBER
];
1489 /* Some handy constants for calculating sizes
1490 and offsets, mostly of vectorlike objects. */
1494 header_size
= offsetof (struct Lisp_Vector
, contents
),
1495 bool_header_size
= offsetof (struct Lisp_Bool_Vector
, data
),
1496 word_size
= sizeof (Lisp_Object
)
1499 /* The number of data words and bytes in a bool vector with SIZE bits. */
1502 bool_vector_words (EMACS_INT size
)
1504 eassume (0 <= size
&& size
<= EMACS_INT_MAX
- (BITS_PER_BITS_WORD
- 1));
1505 return (size
+ BITS_PER_BITS_WORD
- 1) / BITS_PER_BITS_WORD
;
1509 bool_vector_bytes (EMACS_INT size
)
1511 eassume (0 <= size
&& size
<= EMACS_INT_MAX
- (BITS_PER_BITS_WORD
- 1));
1512 return (size
+ BOOL_VECTOR_BITS_PER_CHAR
- 1) / BOOL_VECTOR_BITS_PER_CHAR
;
1516 BOOL_VECTOR_P (Lisp_Object a
)
1518 return PSEUDOVECTORP (a
, PVEC_BOOL_VECTOR
);
1522 CHECK_BOOL_VECTOR (Lisp_Object x
)
1524 CHECK_TYPE (BOOL_VECTOR_P (x
), Qbool_vector_p
, x
);
1527 INLINE
struct Lisp_Bool_Vector
*
1528 XBOOL_VECTOR (Lisp_Object a
)
1530 eassert (BOOL_VECTOR_P (a
));
1531 return XUNTAG (a
, Lisp_Vectorlike
);
1535 bool_vector_size (Lisp_Object a
)
1537 EMACS_INT size
= XBOOL_VECTOR (a
)->size
;
1538 eassume (0 <= size
);
1543 bool_vector_data (Lisp_Object a
)
1545 return XBOOL_VECTOR (a
)->data
;
1548 INLINE
unsigned char *
1549 bool_vector_uchar_data (Lisp_Object a
)
1551 return (unsigned char *) bool_vector_data (a
);
1554 /* True if A's Ith bit is set. */
1557 bool_vector_bitref (Lisp_Object a
, EMACS_INT i
)
1559 eassume (0 <= i
&& i
< bool_vector_size (a
));
1560 return !! (bool_vector_uchar_data (a
)[i
/ BOOL_VECTOR_BITS_PER_CHAR
]
1561 & (1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
)));
1565 bool_vector_ref (Lisp_Object a
, EMACS_INT i
)
1567 return bool_vector_bitref (a
, i
) ? Qt
: Qnil
;
1570 /* Set A's Ith bit to B. */
1573 bool_vector_set (Lisp_Object a
, EMACS_INT i
, bool b
)
1575 unsigned char *addr
;
1577 eassume (0 <= i
&& i
< bool_vector_size (a
));
1578 addr
= &bool_vector_uchar_data (a
)[i
/ BOOL_VECTOR_BITS_PER_CHAR
];
1581 *addr
|= 1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
);
1583 *addr
&= ~ (1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
));
1586 /* Conveniences for dealing with Lisp arrays. */
1589 AREF (Lisp_Object array
, ptrdiff_t idx
)
1591 return XVECTOR (array
)->contents
[idx
];
1594 INLINE Lisp_Object
*
1595 aref_addr (Lisp_Object array
, ptrdiff_t idx
)
1597 return & XVECTOR (array
)->contents
[idx
];
1601 gc_asize (Lisp_Object array
)
1603 /* Like ASIZE, but also can be used in the garbage collector. */
1604 return XVECTOR (array
)->header
.size
& ~ARRAY_MARK_FLAG
;
1608 ASET (Lisp_Object array
, ptrdiff_t idx
, Lisp_Object val
)
1610 eassert (0 <= idx
&& idx
< ASIZE (array
));
1611 XVECTOR (array
)->contents
[idx
] = val
;
1615 gc_aset (Lisp_Object array
, ptrdiff_t idx
, Lisp_Object val
)
1617 /* Like ASET, but also can be used in the garbage collector:
1618 sweep_weak_table calls set_hash_key etc. while the table is marked. */
1619 eassert (0 <= idx
&& idx
< gc_asize (array
));
1620 XVECTOR (array
)->contents
[idx
] = val
;
1623 /* True, since Qnil's representation is zero. Every place in the code
1624 that assumes Qnil is zero should verify (NIL_IS_ZERO), to make it easy
1625 to find such assumptions later if we change Qnil to be nonzero. */
1626 enum { NIL_IS_ZERO
= XLI_BUILTIN_LISPSYM (iQnil
) == 0 };
1628 /* Clear the object addressed by P, with size NBYTES, so that all its
1629 bytes are zero and all its Lisp values are nil. */
1631 memclear (void *p
, ptrdiff_t nbytes
)
1633 eassert (0 <= nbytes
);
1634 verify (NIL_IS_ZERO
);
1635 /* Since Qnil is zero, memset suffices. */
1636 memset (p
, 0, nbytes
);
1639 /* If a struct is made to look like a vector, this macro returns the length
1640 of the shortest vector that would hold that struct. */
1642 #define VECSIZE(type) \
1643 ((sizeof (type) - header_size + word_size - 1) / word_size)
1645 /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields
1646 at the end and we need to compute the number of Lisp_Object fields (the
1647 ones that the GC needs to trace). */
1649 #define PSEUDOVECSIZE(type, nonlispfield) \
1650 ((offsetof (type, nonlispfield) - header_size) / word_size)
1652 /* Compute A OP B, using the unsigned comparison operator OP. A and B
1653 should be integer expressions. This is not the same as
1654 mathematical comparison; for example, UNSIGNED_CMP (0, <, -1)
1655 returns true. For efficiency, prefer plain unsigned comparison if A
1656 and B's sizes both fit (after integer promotion). */
1657 #define UNSIGNED_CMP(a, op, b) \
1658 (max (sizeof ((a) + 0), sizeof ((b) + 0)) <= sizeof (unsigned) \
1659 ? ((a) + (unsigned) 0) op ((b) + (unsigned) 0) \
1660 : ((a) + (uintmax_t) 0) op ((b) + (uintmax_t) 0))
1662 /* True iff C is an ASCII character. */
1663 #define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80)
1665 /* A char-table is a kind of vectorlike, with contents are like a
1666 vector but with a few other slots. For some purposes, it makes
1667 sense to handle a char-table with type struct Lisp_Vector. An
1668 element of a char table can be any Lisp objects, but if it is a sub
1669 char-table, we treat it a table that contains information of a
1670 specific range of characters. A sub char-table is like a vector but
1671 with two integer fields between the header and Lisp data, which means
1672 that it has to be marked with some precautions (see mark_char_table
1673 in alloc.c). A sub char-table appears only in an element of a char-table,
1674 and there's no way to access it directly from Emacs Lisp program. */
1676 enum CHARTAB_SIZE_BITS
1678 CHARTAB_SIZE_BITS_0
= 6,
1679 CHARTAB_SIZE_BITS_1
= 4,
1680 CHARTAB_SIZE_BITS_2
= 5,
1681 CHARTAB_SIZE_BITS_3
= 7
1684 extern const int chartab_size
[4];
1686 struct Lisp_Char_Table
1688 /* HEADER.SIZE is the vector's size field, which also holds the
1689 pseudovector type information. It holds the size, too.
1690 The size counts the defalt, parent, purpose, ascii,
1691 contents, and extras slots. */
1692 struct vectorlike_header header
;
1694 /* This holds a default value,
1695 which is used whenever the value for a specific character is nil. */
1698 /* This points to another char table, which we inherit from when the
1699 value for a specific character is nil. The `defalt' slot takes
1700 precedence over this. */
1703 /* This is a symbol which says what kind of use this char-table is
1705 Lisp_Object purpose
;
1707 /* The bottom sub char-table for characters of the range 0..127. It
1708 is nil if none of ASCII character has a specific value. */
1711 Lisp_Object contents
[(1 << CHARTAB_SIZE_BITS_0
)];
1713 /* These hold additional data. It is a vector. */
1714 Lisp_Object extras
[FLEXIBLE_ARRAY_MEMBER
];
1718 CHAR_TABLE_P (Lisp_Object a
)
1720 return PSEUDOVECTORP (a
, PVEC_CHAR_TABLE
);
1723 INLINE
struct Lisp_Char_Table
*
1724 XCHAR_TABLE (Lisp_Object a
)
1726 eassert (CHAR_TABLE_P (a
));
1727 return XUNTAG (a
, Lisp_Vectorlike
);
1730 struct Lisp_Sub_Char_Table
1732 /* HEADER.SIZE is the vector's size field, which also holds the
1733 pseudovector type information. It holds the size, too. */
1734 struct vectorlike_header header
;
1736 /* Depth of this sub char-table. It should be 1, 2, or 3. A sub
1737 char-table of depth 1 contains 16 elements, and each element
1738 covers 4096 (128*32) characters. A sub char-table of depth 2
1739 contains 32 elements, and each element covers 128 characters. A
1740 sub char-table of depth 3 contains 128 elements, and each element
1741 is for one character. */
1744 /* Minimum character covered by the sub char-table. */
1747 /* Use set_sub_char_table_contents to set this. */
1748 Lisp_Object contents
[FLEXIBLE_ARRAY_MEMBER
];
1752 SUB_CHAR_TABLE_P (Lisp_Object a
)
1754 return PSEUDOVECTORP (a
, PVEC_SUB_CHAR_TABLE
);
1757 INLINE
struct Lisp_Sub_Char_Table
*
1758 XSUB_CHAR_TABLE (Lisp_Object a
)
1760 eassert (SUB_CHAR_TABLE_P (a
));
1761 return XUNTAG (a
, Lisp_Vectorlike
);
1765 CHAR_TABLE_REF_ASCII (Lisp_Object ct
, ptrdiff_t idx
)
1767 struct Lisp_Char_Table
*tbl
= NULL
;
1771 tbl
= tbl
? XCHAR_TABLE (tbl
->parent
) : XCHAR_TABLE (ct
);
1772 val
= (! SUB_CHAR_TABLE_P (tbl
->ascii
) ? tbl
->ascii
1773 : XSUB_CHAR_TABLE (tbl
->ascii
)->contents
[idx
]);
1777 while (NILP (val
) && ! NILP (tbl
->parent
));
1782 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
1783 characters. Do not check validity of CT. */
1785 CHAR_TABLE_REF (Lisp_Object ct
, int idx
)
1787 return (ASCII_CHAR_P (idx
)
1788 ? CHAR_TABLE_REF_ASCII (ct
, idx
)
1789 : char_table_ref (ct
, idx
));
1792 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
1793 8-bit European characters. Do not check validity of CT. */
1795 CHAR_TABLE_SET (Lisp_Object ct
, int idx
, Lisp_Object val
)
1797 if (ASCII_CHAR_P (idx
) && SUB_CHAR_TABLE_P (XCHAR_TABLE (ct
)->ascii
))
1798 set_sub_char_table_contents (XCHAR_TABLE (ct
)->ascii
, idx
, val
);
1800 char_table_set (ct
, idx
, val
);
1803 /* This structure describes a built-in function.
1804 It is generated by the DEFUN macro only.
1805 defsubr makes it into a Lisp object. */
1809 struct vectorlike_header header
;
1811 Lisp_Object (*a0
) (void);
1812 Lisp_Object (*a1
) (Lisp_Object
);
1813 Lisp_Object (*a2
) (Lisp_Object
, Lisp_Object
);
1814 Lisp_Object (*a3
) (Lisp_Object
, Lisp_Object
, Lisp_Object
);
1815 Lisp_Object (*a4
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1816 Lisp_Object (*a5
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1817 Lisp_Object (*a6
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1818 Lisp_Object (*a7
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1819 Lisp_Object (*a8
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1820 Lisp_Object (*aUNEVALLED
) (Lisp_Object args
);
1821 Lisp_Object (*aMANY
) (ptrdiff_t, Lisp_Object
*);
1823 short min_args
, max_args
;
1824 const char *symbol_name
;
1825 const char *intspec
;
1830 SUBRP (Lisp_Object a
)
1832 return PSEUDOVECTORP (a
, PVEC_SUBR
);
1835 INLINE
struct Lisp_Subr
*
1836 XSUBR (Lisp_Object a
)
1838 eassert (SUBRP (a
));
1839 return XUNTAG (a
, Lisp_Vectorlike
);
1842 enum char_table_specials
1844 /* This is the number of slots that every char table must have. This
1845 counts the ordinary slots and the top, defalt, parent, and purpose
1847 CHAR_TABLE_STANDARD_SLOTS
= PSEUDOVECSIZE (struct Lisp_Char_Table
, extras
),
1849 /* This is an index of first Lisp_Object field in Lisp_Sub_Char_Table
1850 when the latter is treated as an ordinary Lisp_Vector. */
1851 SUB_CHAR_TABLE_OFFSET
= PSEUDOVECSIZE (struct Lisp_Sub_Char_Table
, contents
)
1854 /* Return the number of "extra" slots in the char table CT. */
1857 CHAR_TABLE_EXTRA_SLOTS (struct Lisp_Char_Table
*ct
)
1859 return ((ct
->header
.size
& PSEUDOVECTOR_SIZE_MASK
)
1860 - CHAR_TABLE_STANDARD_SLOTS
);
1863 /* Make sure that sub char-table contents slot is where we think it is. */
1864 verify (offsetof (struct Lisp_Sub_Char_Table
, contents
)
1865 == (offsetof (struct Lisp_Vector
, contents
)
1866 + SUB_CHAR_TABLE_OFFSET
* sizeof (Lisp_Object
)));
1870 /***********************************************************************
1872 ***********************************************************************/
1874 /* Value is name of symbol. */
1877 (SYMBOL_VAL
) (struct Lisp_Symbol
*sym
)
1879 return lisp_h_SYMBOL_VAL (sym
);
1882 INLINE
struct Lisp_Symbol
*
1883 SYMBOL_ALIAS (struct Lisp_Symbol
*sym
)
1885 eassume (sym
->redirect
== SYMBOL_VARALIAS
&& sym
->val
.alias
);
1886 return sym
->val
.alias
;
1888 INLINE
struct Lisp_Buffer_Local_Value
*
1889 SYMBOL_BLV (struct Lisp_Symbol
*sym
)
1891 eassume (sym
->redirect
== SYMBOL_LOCALIZED
&& sym
->val
.blv
);
1892 return sym
->val
.blv
;
1894 INLINE
union Lisp_Fwd
*
1895 SYMBOL_FWD (struct Lisp_Symbol
*sym
)
1897 eassume (sym
->redirect
== SYMBOL_FORWARDED
&& sym
->val
.fwd
);
1898 return sym
->val
.fwd
;
1902 (SET_SYMBOL_VAL
) (struct Lisp_Symbol
*sym
, Lisp_Object v
)
1904 lisp_h_SET_SYMBOL_VAL (sym
, v
);
1908 SET_SYMBOL_ALIAS (struct Lisp_Symbol
*sym
, struct Lisp_Symbol
*v
)
1910 eassume (sym
->redirect
== SYMBOL_VARALIAS
&& v
);
1914 SET_SYMBOL_BLV (struct Lisp_Symbol
*sym
, struct Lisp_Buffer_Local_Value
*v
)
1916 eassume (sym
->redirect
== SYMBOL_LOCALIZED
&& v
);
1920 SET_SYMBOL_FWD (struct Lisp_Symbol
*sym
, union Lisp_Fwd
*v
)
1922 eassume (sym
->redirect
== SYMBOL_FORWARDED
&& v
);
1927 SYMBOL_NAME (Lisp_Object sym
)
1929 return XSYMBOL (sym
)->name
;
1932 /* Value is true if SYM is an interned symbol. */
1935 SYMBOL_INTERNED_P (Lisp_Object sym
)
1937 return XSYMBOL (sym
)->interned
!= SYMBOL_UNINTERNED
;
1940 /* Value is true if SYM is interned in initial_obarray. */
1943 SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P (Lisp_Object sym
)
1945 return XSYMBOL (sym
)->interned
== SYMBOL_INTERNED_IN_INITIAL_OBARRAY
;
1948 /* Value is non-zero if symbol cannot be changed through a simple set,
1949 i.e. it's a constant (e.g. nil, t, :keywords), or it has some
1950 watching functions. */
1953 (SYMBOL_TRAPPED_WRITE_P
) (Lisp_Object sym
)
1955 return lisp_h_SYMBOL_TRAPPED_WRITE_P (sym
);
1958 /* Value is non-zero if symbol cannot be changed at all, i.e. it's a
1959 constant (e.g. nil, t, :keywords). Code that actually wants to
1960 write to SYM, should also check whether there are any watching
1964 (SYMBOL_CONSTANT_P
) (Lisp_Object sym
)
1966 return lisp_h_SYMBOL_CONSTANT_P (sym
);
1969 /* Placeholder for make-docfile to process. The actual symbol
1970 definition is done by lread.c's defsym. */
1971 #define DEFSYM(sym, name) /* empty */
1974 /***********************************************************************
1976 ***********************************************************************/
1978 /* The structure of a Lisp hash table. */
1980 struct hash_table_test
1982 /* Name of the function used to compare keys. */
1985 /* User-supplied hash function, or nil. */
1986 Lisp_Object user_hash_function
;
1988 /* User-supplied key comparison function, or nil. */
1989 Lisp_Object user_cmp_function
;
1991 /* C function to compare two keys. */
1992 bool (*cmpfn
) (struct hash_table_test
*t
, Lisp_Object
, Lisp_Object
);
1994 /* C function to compute hash code. */
1995 EMACS_UINT (*hashfn
) (struct hash_table_test
*t
, Lisp_Object
);
1998 struct Lisp_Hash_Table
2000 /* This is for Lisp; the hash table code does not refer to it. */
2001 struct vectorlike_header header
;
2003 /* Nil if table is non-weak. Otherwise a symbol describing the
2004 weakness of the table. */
2007 /* Vector of hash codes. If hash[I] is nil, this means that the
2008 I-th entry is unused. */
2011 /* Vector used to chain entries. If entry I is free, next[I] is the
2012 entry number of the next free item. If entry I is non-free,
2013 next[I] is the index of the next entry in the collision chain,
2014 or -1 if there is such entry. */
2017 /* Bucket vector. An entry of -1 indicates no item is present,
2018 and a nonnegative entry is the index of the first item in
2019 a collision chain. This vector's size can be larger than the
2020 hash table size to reduce collisions. */
2023 /* Only the fields above are traced normally by the GC. The ones below
2024 `count' are special and are either ignored by the GC or traced in
2025 a special way (e.g. because of weakness). */
2027 /* Number of key/value entries in the table. */
2030 /* Index of first free entry in free list, or -1 if none. */
2031 ptrdiff_t next_free
;
2033 /* True if the table can be purecopied. The table cannot be
2034 changed afterwards. */
2037 /* Resize hash table when number of entries / table size is >= this
2039 float rehash_threshold
;
2041 /* Used when the table is resized. If equal to a negative integer,
2042 the user rehash-size is the integer -REHASH_SIZE, and the new
2043 size is the old size plus -REHASH_SIZE. If positive, the user
2044 rehash-size is the floating-point value REHASH_SIZE + 1, and the
2045 new size is the old size times REHASH_SIZE + 1. */
2048 /* Vector of keys and values. The key of item I is found at index
2049 2 * I, the value is found at index 2 * I + 1.
2050 This is gc_marked specially if the table is weak. */
2051 Lisp_Object key_and_value
;
2053 /* The comparison and hash functions. */
2054 struct hash_table_test test
;
2056 /* Next weak hash table if this is a weak hash table. The head
2057 of the list is in weak_hash_tables. */
2058 struct Lisp_Hash_Table
*next_weak
;
2063 HASH_TABLE_P (Lisp_Object a
)
2065 return PSEUDOVECTORP (a
, PVEC_HASH_TABLE
);
2068 INLINE
struct Lisp_Hash_Table
*
2069 XHASH_TABLE (Lisp_Object a
)
2071 eassert (HASH_TABLE_P (a
));
2072 return XUNTAG (a
, Lisp_Vectorlike
);
2075 #define XSET_HASH_TABLE(VAR, PTR) \
2076 (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
2078 /* Value is the key part of entry IDX in hash table H. */
2080 HASH_KEY (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2082 return AREF (h
->key_and_value
, 2 * idx
);
2085 /* Value is the value part of entry IDX in hash table H. */
2087 HASH_VALUE (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2089 return AREF (h
->key_and_value
, 2 * idx
+ 1);
2092 /* Value is the hash code computed for entry IDX in hash table H. */
2094 HASH_HASH (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2096 return AREF (h
->hash
, idx
);
2099 /* Value is the size of hash table H. */
2101 HASH_TABLE_SIZE (struct Lisp_Hash_Table
*h
)
2103 return ASIZE (h
->next
);
2106 /* Default size for hash tables if not specified. */
2108 enum DEFAULT_HASH_SIZE
{ DEFAULT_HASH_SIZE
= 65 };
2110 /* Default threshold specifying when to resize a hash table. The
2111 value gives the ratio of current entries in the hash table and the
2112 size of the hash table. */
2114 static float const DEFAULT_REHASH_THRESHOLD
= 0.8125;
2116 /* Default factor by which to increase the size of a hash table, minus 1. */
2118 static float const DEFAULT_REHASH_SIZE
= 1.5 - 1;
2120 /* Combine two integers X and Y for hashing. The result might not fit
2121 into a Lisp integer. */
2124 sxhash_combine (EMACS_UINT x
, EMACS_UINT y
)
2126 return (x
<< 4) + (x
>> (EMACS_INT_WIDTH
- 4)) + y
;
2129 /* Hash X, returning a value that fits into a fixnum. */
2132 SXHASH_REDUCE (EMACS_UINT x
)
2134 return (x
^ x
>> (EMACS_INT_WIDTH
- FIXNUM_BITS
)) & INTMASK
;
2137 /* These structures are used for various misc types. */
2139 struct Lisp_Misc_Any
/* Supertype of all Misc types. */
2141 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_??? */
2142 bool_bf gcmarkbit
: 1;
2143 unsigned spacer
: 15;
2147 (MISCP
) (Lisp_Object x
)
2149 return lisp_h_MISCP (x
);
2152 INLINE
struct Lisp_Misc_Any
*
2153 XMISCANY (Lisp_Object a
)
2155 eassert (MISCP (a
));
2156 return XUNTAG (a
, Lisp_Misc
);
2159 INLINE
enum Lisp_Misc_Type
2160 XMISCTYPE (Lisp_Object a
)
2162 return XMISCANY (a
)->type
;
2167 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Marker */
2168 bool_bf gcmarkbit
: 1;
2169 unsigned spacer
: 13;
2170 /* This flag is temporarily used in the functions
2171 decode/encode_coding_object to record that the marker position
2172 must be adjusted after the conversion. */
2173 bool_bf need_adjustment
: 1;
2174 /* True means normal insertion at the marker's position
2175 leaves the marker after the inserted text. */
2176 bool_bf insertion_type
: 1;
2177 /* This is the buffer that the marker points into, or 0 if it points nowhere.
2178 Note: a chain of markers can contain markers pointing into different
2179 buffers (the chain is per buffer_text rather than per buffer, so it's
2180 shared between indirect buffers). */
2181 /* This is used for (other than NULL-checking):
2183 - Fset_marker: check eq(oldbuf, newbuf) to avoid unchain+rechain.
2184 - unchain_marker: to find the list from which to unchain.
2185 - Fkill_buffer: to only unchain the markers of current indirect buffer.
2187 struct buffer
*buffer
;
2189 /* The remaining fields are meaningless in a marker that
2190 does not point anywhere. */
2192 /* For markers that point somewhere,
2193 this is used to chain of all the markers in a given buffer. */
2194 /* We could remove it and use an array in buffer_text instead.
2195 That would also allow us to preserve it ordered. */
2196 struct Lisp_Marker
*next
;
2197 /* This is the char position where the marker points. */
2199 /* This is the byte position.
2200 It's mostly used as a charpos<->bytepos cache (i.e. it's not directly
2201 used to implement the functionality of markers, but rather to (ab)use
2202 markers as a cache for char<->byte mappings). */
2206 /* START and END are markers in the overlay's buffer, and
2207 PLIST is the overlay's property list. */
2209 /* An overlay's real data content is:
2211 - buffer (really there are two buffer pointers, one per marker,
2212 and both points to the same buffer)
2213 - insertion type of both ends (per-marker fields)
2214 - start & start byte (of start marker)
2215 - end & end byte (of end marker)
2216 - next (singly linked list of overlays)
2217 - next fields of start and end markers (singly linked list of markers).
2218 I.e. 9words plus 2 bits, 3words of which are for external linked lists.
2221 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Overlay */
2222 bool_bf gcmarkbit
: 1;
2223 unsigned spacer
: 15;
2224 struct Lisp_Overlay
*next
;
2230 /* Number of bits needed to store one of the values
2231 SAVE_UNUSED..SAVE_OBJECT. */
2232 enum { SAVE_SLOT_BITS
= 3 };
2234 /* Number of slots in a save value where save_type is nonzero. */
2235 enum { SAVE_VALUE_SLOTS
= 4 };
2237 /* Bit-width and values for struct Lisp_Save_Value's save_type member. */
2239 enum { SAVE_TYPE_BITS
= SAVE_VALUE_SLOTS
* SAVE_SLOT_BITS
+ 1 };
2241 /* Types of data which may be saved in a Lisp_Save_Value. */
2250 SAVE_TYPE_INT_INT
= SAVE_INTEGER
+ (SAVE_INTEGER
<< SAVE_SLOT_BITS
),
2251 SAVE_TYPE_INT_INT_INT
2252 = (SAVE_INTEGER
+ (SAVE_TYPE_INT_INT
<< SAVE_SLOT_BITS
)),
2253 SAVE_TYPE_OBJ_OBJ
= SAVE_OBJECT
+ (SAVE_OBJECT
<< SAVE_SLOT_BITS
),
2254 SAVE_TYPE_OBJ_OBJ_OBJ
= SAVE_OBJECT
+ (SAVE_TYPE_OBJ_OBJ
<< SAVE_SLOT_BITS
),
2255 SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
2256 = SAVE_OBJECT
+ (SAVE_TYPE_OBJ_OBJ_OBJ
<< SAVE_SLOT_BITS
),
2257 SAVE_TYPE_PTR_INT
= SAVE_POINTER
+ (SAVE_INTEGER
<< SAVE_SLOT_BITS
),
2258 SAVE_TYPE_PTR_OBJ
= SAVE_POINTER
+ (SAVE_OBJECT
<< SAVE_SLOT_BITS
),
2259 SAVE_TYPE_PTR_PTR
= SAVE_POINTER
+ (SAVE_POINTER
<< SAVE_SLOT_BITS
),
2260 SAVE_TYPE_FUNCPTR_PTR_OBJ
2261 = SAVE_FUNCPOINTER
+ (SAVE_TYPE_PTR_OBJ
<< SAVE_SLOT_BITS
),
2263 /* This has an extra bit indicating it's raw memory. */
2264 SAVE_TYPE_MEMORY
= SAVE_TYPE_PTR_INT
+ (1 << (SAVE_TYPE_BITS
- 1))
2267 /* SAVE_SLOT_BITS must be large enough to represent these values. */
2268 verify (((SAVE_UNUSED
| SAVE_INTEGER
| SAVE_FUNCPOINTER
2269 | SAVE_POINTER
| SAVE_OBJECT
)
2273 /* Special object used to hold a different values for later use.
2275 This is mostly used to package C integers and pointers to call
2276 record_unwind_protect when two or more values need to be saved.
2280 struct my_data *md = get_my_data ();
2281 ptrdiff_t mi = get_my_integer ();
2282 record_unwind_protect (my_unwind, make_save_ptr_int (md, mi));
2285 Lisp_Object my_unwind (Lisp_Object arg)
2287 struct my_data *md = XSAVE_POINTER (arg, 0);
2288 ptrdiff_t mi = XSAVE_INTEGER (arg, 1);
2292 If ENABLE_CHECKING is in effect, XSAVE_xxx macros do type checking of the
2293 saved objects and raise eassert if type of the saved object doesn't match
2294 the type which is extracted. In the example above, XSAVE_INTEGER (arg, 2)
2295 and XSAVE_OBJECT (arg, 0) are wrong because nothing was saved in slot 2 and
2296 slot 0 is a pointer. */
2298 typedef void (*voidfuncptr
) (void);
2300 struct Lisp_Save_Value
2302 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Save_Value */
2303 bool_bf gcmarkbit
: 1;
2304 unsigned spacer
: 32 - (16 + 1 + SAVE_TYPE_BITS
);
2306 /* V->data may hold up to SAVE_VALUE_SLOTS entries. The type of
2307 V's data entries are determined by V->save_type. E.g., if
2308 V->save_type == SAVE_TYPE_PTR_OBJ, V->data[0] is a pointer,
2309 V->data[1] is an integer, and V's other data entries are unused.
2311 If V->save_type == SAVE_TYPE_MEMORY, V->data[0].pointer is the address of
2312 a memory area containing V->data[1].integer potential Lisp_Objects. */
2313 ENUM_BF (Lisp_Save_Type
) save_type
: SAVE_TYPE_BITS
;
2316 voidfuncptr funcpointer
;
2319 } data
[SAVE_VALUE_SLOTS
];
2323 SAVE_VALUEP (Lisp_Object x
)
2325 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Save_Value
;
2328 INLINE
struct Lisp_Save_Value
*
2329 XSAVE_VALUE (Lisp_Object a
)
2331 eassert (SAVE_VALUEP (a
));
2332 return XUNTAG (a
, Lisp_Misc
);
2335 /* Return the type of V's Nth saved value. */
2337 save_type (struct Lisp_Save_Value
*v
, int n
)
2339 eassert (0 <= n
&& n
< SAVE_VALUE_SLOTS
);
2340 return (v
->save_type
>> (SAVE_SLOT_BITS
* n
) & ((1 << SAVE_SLOT_BITS
) - 1));
2343 /* Get and set the Nth saved pointer. */
2346 XSAVE_POINTER (Lisp_Object obj
, int n
)
2348 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_POINTER
);
2349 return XSAVE_VALUE (obj
)->data
[n
].pointer
;
2352 set_save_pointer (Lisp_Object obj
, int n
, void *val
)
2354 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_POINTER
);
2355 XSAVE_VALUE (obj
)->data
[n
].pointer
= val
;
2358 XSAVE_FUNCPOINTER (Lisp_Object obj
, int n
)
2360 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_FUNCPOINTER
);
2361 return XSAVE_VALUE (obj
)->data
[n
].funcpointer
;
2364 /* Likewise for the saved integer. */
2367 XSAVE_INTEGER (Lisp_Object obj
, int n
)
2369 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_INTEGER
);
2370 return XSAVE_VALUE (obj
)->data
[n
].integer
;
2373 set_save_integer (Lisp_Object obj
, int n
, ptrdiff_t val
)
2375 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_INTEGER
);
2376 XSAVE_VALUE (obj
)->data
[n
].integer
= val
;
2379 /* Extract Nth saved object. */
2382 XSAVE_OBJECT (Lisp_Object obj
, int n
)
2384 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_OBJECT
);
2385 return XSAVE_VALUE (obj
)->data
[n
].object
;
2389 struct Lisp_User_Ptr
2391 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_User_Ptr */
2392 bool_bf gcmarkbit
: 1;
2393 unsigned spacer
: 15;
2395 void (*finalizer
) (void *);
2400 /* A finalizer sentinel. */
2401 struct Lisp_Finalizer
2403 struct Lisp_Misc_Any base
;
2405 /* Circular list of all active weak references. */
2406 struct Lisp_Finalizer
*prev
;
2407 struct Lisp_Finalizer
*next
;
2409 /* Call FUNCTION when the finalizer becomes unreachable, even if
2410 FUNCTION contains a reference to the finalizer; i.e., call
2411 FUNCTION when it is reachable _only_ through finalizers. */
2412 Lisp_Object function
;
2416 FINALIZERP (Lisp_Object x
)
2418 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Finalizer
;
2421 INLINE
struct Lisp_Finalizer
*
2422 XFINALIZER (Lisp_Object a
)
2424 eassert (FINALIZERP (a
));
2425 return XUNTAG (a
, Lisp_Misc
);
2428 /* A miscellaneous object, when it's on the free list. */
2431 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Free */
2432 bool_bf gcmarkbit
: 1;
2433 unsigned spacer
: 15;
2434 union Lisp_Misc
*chain
;
2437 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
2438 It uses one of these struct subtypes to get the type field. */
2442 struct Lisp_Misc_Any u_any
; /* Supertype of all Misc types. */
2443 struct Lisp_Free u_free
;
2444 struct Lisp_Marker u_marker
;
2445 struct Lisp_Overlay u_overlay
;
2446 struct Lisp_Save_Value u_save_value
;
2447 struct Lisp_Finalizer u_finalizer
;
2449 struct Lisp_User_Ptr u_user_ptr
;
2453 INLINE
union Lisp_Misc
*
2454 XMISC (Lisp_Object a
)
2456 return XUNTAG (a
, Lisp_Misc
);
2460 (MARKERP
) (Lisp_Object x
)
2462 return lisp_h_MARKERP (x
);
2465 INLINE
struct Lisp_Marker
*
2466 XMARKER (Lisp_Object a
)
2468 eassert (MARKERP (a
));
2469 return XUNTAG (a
, Lisp_Misc
);
2473 OVERLAYP (Lisp_Object x
)
2475 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Overlay
;
2478 INLINE
struct Lisp_Overlay
*
2479 XOVERLAY (Lisp_Object a
)
2481 eassert (OVERLAYP (a
));
2482 return XUNTAG (a
, Lisp_Misc
);
2487 USER_PTRP (Lisp_Object x
)
2489 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_User_Ptr
;
2492 INLINE
struct Lisp_User_Ptr
*
2493 XUSER_PTR (Lisp_Object a
)
2495 eassert (USER_PTRP (a
));
2496 return XUNTAG (a
, Lisp_Misc
);
2501 /* Forwarding pointer to an int variable.
2502 This is allowed only in the value cell of a symbol,
2503 and it means that the symbol's value really lives in the
2504 specified int variable. */
2507 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Int */
2511 /* Boolean forwarding pointer to an int variable.
2512 This is like Lisp_Intfwd except that the ostensible
2513 "value" of the symbol is t if the bool variable is true,
2514 nil if it is false. */
2517 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Bool */
2521 /* Forwarding pointer to a Lisp_Object variable.
2522 This is allowed only in the value cell of a symbol,
2523 and it means that the symbol's value really lives in the
2524 specified variable. */
2527 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Obj */
2528 Lisp_Object
*objvar
;
2531 /* Like Lisp_Objfwd except that value lives in a slot in the
2532 current buffer. Value is byte index of slot within buffer. */
2533 struct Lisp_Buffer_Objfwd
2535 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Buffer_Obj */
2537 /* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp. */
2538 Lisp_Object predicate
;
2541 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
2542 the symbol has buffer-local bindings. (Exception:
2543 some buffer-local variables are built-in, with their values stored
2544 in the buffer structure itself. They are handled differently,
2545 using struct Lisp_Buffer_Objfwd.)
2547 The `realvalue' slot holds the variable's current value, or a
2548 forwarding pointer to where that value is kept. This value is the
2549 one that corresponds to the loaded binding. To read or set the
2550 variable, you must first make sure the right binding is loaded;
2551 then you can access the value in (or through) `realvalue'.
2553 `buffer' and `frame' are the buffer and frame for which the loaded
2554 binding was found. If those have changed, to make sure the right
2555 binding is loaded it is necessary to find which binding goes with
2556 the current buffer and selected frame, then load it. To load it,
2557 first unload the previous binding, then copy the value of the new
2558 binding into `realvalue' (or through it). Also update
2559 LOADED-BINDING to point to the newly loaded binding.
2561 `local_if_set' indicates that merely setting the variable creates a
2562 local binding for the current buffer. Otherwise the latter, setting
2563 the variable does not do that; only make-local-variable does that. */
2565 struct Lisp_Buffer_Local_Value
2567 /* True means that merely setting the variable creates a local
2568 binding for the current buffer. */
2569 bool_bf local_if_set
: 1;
2570 /* True means that the binding now loaded was found.
2571 Presumably equivalent to (defcell!=valcell). */
2573 /* If non-NULL, a forwarding to the C var where it should also be set. */
2574 union Lisp_Fwd
*fwd
; /* Should never be (Buffer|Kboard)_Objfwd. */
2575 /* The buffer or frame for which the loaded binding was found. */
2577 /* A cons cell that holds the default value. It has the form
2578 (SYMBOL . DEFAULT-VALUE). */
2579 Lisp_Object defcell
;
2580 /* The cons cell from `where's parameter alist.
2581 It always has the form (SYMBOL . VALUE)
2582 Note that if `forward' is non-nil, VALUE may be out of date.
2583 Also if the currently loaded binding is the default binding, then
2584 this is `eq'ual to defcell. */
2585 Lisp_Object valcell
;
2588 /* Like Lisp_Objfwd except that value lives in a slot in the
2590 struct Lisp_Kboard_Objfwd
2592 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Kboard_Obj */
2598 struct Lisp_Intfwd u_intfwd
;
2599 struct Lisp_Boolfwd u_boolfwd
;
2600 struct Lisp_Objfwd u_objfwd
;
2601 struct Lisp_Buffer_Objfwd u_buffer_objfwd
;
2602 struct Lisp_Kboard_Objfwd u_kboard_objfwd
;
2605 INLINE
enum Lisp_Fwd_Type
2606 XFWDTYPE (union Lisp_Fwd
*a
)
2608 return a
->u_intfwd
.type
;
2612 BUFFER_OBJFWDP (union Lisp_Fwd
*a
)
2614 return XFWDTYPE (a
) == Lisp_Fwd_Buffer_Obj
;
2617 INLINE
struct Lisp_Buffer_Objfwd
*
2618 XBUFFER_OBJFWD (union Lisp_Fwd
*a
)
2620 eassert (BUFFER_OBJFWDP (a
));
2621 return &a
->u_buffer_objfwd
;
2624 /* Lisp floating point type. */
2630 struct Lisp_Float
*chain
;
2635 (FLOATP
) (Lisp_Object x
)
2637 return lisp_h_FLOATP (x
);
2640 INLINE
struct Lisp_Float
*
2641 XFLOAT (Lisp_Object a
)
2643 eassert (FLOATP (a
));
2644 return XUNTAG (a
, Lisp_Float
);
2648 XFLOAT_DATA (Lisp_Object f
)
2650 return XFLOAT (f
)->u
.data
;
2653 /* Most hosts nowadays use IEEE floating point, so they use IEC 60559
2654 representations, have infinities and NaNs, and do not trap on
2655 exceptions. Define IEEE_FLOATING_POINT if this host is one of the
2656 typical ones. The C11 macro __STDC_IEC_559__ is close to what is
2657 wanted here, but is not quite right because Emacs does not require
2658 all the features of C11 Annex F (and does not require C11 at all,
2659 for that matter). */
2663 = (FLT_RADIX
== 2 && FLT_MANT_DIG
== 24
2664 && FLT_MIN_EXP
== -125 && FLT_MAX_EXP
== 128)
2667 /* A character, declared with the following typedef, is a member
2668 of some character set associated with the current buffer. */
2669 #ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
2671 typedef unsigned char UCHAR
;
2674 /* Meanings of slots in a Lisp_Compiled: */
2678 COMPILED_ARGLIST
= 0,
2679 COMPILED_BYTECODE
= 1,
2680 COMPILED_CONSTANTS
= 2,
2681 COMPILED_STACK_DEPTH
= 3,
2682 COMPILED_DOC_STRING
= 4,
2683 COMPILED_INTERACTIVE
= 5
2686 /* Flag bits in a character. These also get used in termhooks.h.
2687 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
2688 (MUlti-Lingual Emacs) might need 22 bits for the character value
2689 itself, so we probably shouldn't use any bits lower than 0x0400000. */
2692 CHAR_ALT
= 0x0400000,
2693 CHAR_SUPER
= 0x0800000,
2694 CHAR_HYPER
= 0x1000000,
2695 CHAR_SHIFT
= 0x2000000,
2696 CHAR_CTL
= 0x4000000,
2697 CHAR_META
= 0x8000000,
2699 CHAR_MODIFIER_MASK
=
2700 CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
| CHAR_SHIFT
| CHAR_CTL
| CHAR_META
,
2702 /* Actually, the current Emacs uses 22 bits for the character value
2707 /* Data type checking. */
2710 NUMBERP (Lisp_Object x
)
2712 return INTEGERP (x
) || FLOATP (x
);
2715 NATNUMP (Lisp_Object x
)
2717 return INTEGERP (x
) && 0 <= XINT (x
);
2721 RANGED_INTEGERP (intmax_t lo
, Lisp_Object x
, intmax_t hi
)
2723 return INTEGERP (x
) && lo
<= XINT (x
) && XINT (x
) <= hi
;
2726 #define TYPE_RANGED_INTEGERP(type, x) \
2728 && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \
2729 && XINT (x) <= TYPE_MAXIMUM (type))
2732 AUTOLOADP (Lisp_Object x
)
2734 return CONSP (x
) && EQ (Qautoload
, XCAR (x
));
2738 /* Test for specific pseudovector types. */
2741 WINDOW_CONFIGURATIONP (Lisp_Object a
)
2743 return PSEUDOVECTORP (a
, PVEC_WINDOW_CONFIGURATION
);
2747 COMPILEDP (Lisp_Object a
)
2749 return PSEUDOVECTORP (a
, PVEC_COMPILED
);
2753 FRAMEP (Lisp_Object a
)
2755 return PSEUDOVECTORP (a
, PVEC_FRAME
);
2759 RECORDP (Lisp_Object a
)
2761 return PSEUDOVECTORP (a
, PVEC_RECORD
);
2765 CHECK_RECORD (Lisp_Object x
)
2767 CHECK_TYPE (RECORDP (x
), Qrecordp
, x
);
2770 /* Test for image (image . spec) */
2772 IMAGEP (Lisp_Object x
)
2774 return CONSP (x
) && EQ (XCAR (x
), Qimage
);
2779 ARRAYP (Lisp_Object x
)
2781 return VECTORP (x
) || STRINGP (x
) || CHAR_TABLE_P (x
) || BOOL_VECTOR_P (x
);
2785 CHECK_LIST (Lisp_Object x
)
2787 CHECK_TYPE (CONSP (x
) || NILP (x
), Qlistp
, x
);
2791 CHECK_LIST_END (Lisp_Object x
, Lisp_Object y
)
2793 CHECK_TYPE (NILP (x
), Qlistp
, y
);
2797 (CHECK_NUMBER
) (Lisp_Object x
)
2799 lisp_h_CHECK_NUMBER (x
);
2803 CHECK_STRING_CAR (Lisp_Object x
)
2805 CHECK_TYPE (STRINGP (XCAR (x
)), Qstringp
, XCAR (x
));
2807 /* This is a bit special because we always need size afterwards. */
2809 CHECK_VECTOR_OR_STRING (Lisp_Object x
)
2815 wrong_type_argument (Qarrayp
, x
);
2818 CHECK_ARRAY (Lisp_Object x
, Lisp_Object predicate
)
2820 CHECK_TYPE (ARRAYP (x
), predicate
, x
);
2823 CHECK_NATNUM (Lisp_Object x
)
2825 CHECK_TYPE (NATNUMP (x
), Qwholenump
, x
);
2828 #define CHECK_RANGED_INTEGER(x, lo, hi) \
2831 if (! ((lo) <= XINT (x) && XINT (x) <= (hi))) \
2832 args_out_of_range_3 \
2834 make_number ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM \
2835 ? MOST_NEGATIVE_FIXNUM \
2837 make_number (min (hi, MOST_POSITIVE_FIXNUM))); \
2839 #define CHECK_TYPE_RANGED_INTEGER(type, x) \
2841 if (TYPE_SIGNED (type)) \
2842 CHECK_RANGED_INTEGER (x, TYPE_MINIMUM (type), TYPE_MAXIMUM (type)); \
2844 CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type)); \
2847 #define CHECK_NUMBER_COERCE_MARKER(x) \
2849 if (MARKERP ((x))) \
2850 XSETFASTINT (x, marker_position (x)); \
2852 CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); \
2856 XFLOATINT (Lisp_Object n
)
2858 return FLOATP (n
) ? XFLOAT_DATA (n
) : XINT (n
);
2862 CHECK_NUMBER_OR_FLOAT (Lisp_Object x
)
2864 CHECK_TYPE (NUMBERP (x
), Qnumberp
, x
);
2867 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
2870 XSETFASTINT (x, marker_position (x)); \
2872 CHECK_TYPE (NUMBERP (x), Qnumber_or_marker_p, x); \
2875 /* Since we can't assign directly to the CAR or CDR fields of a cons
2876 cell, use these when checking that those fields contain numbers. */
2878 CHECK_NUMBER_CAR (Lisp_Object x
)
2880 Lisp_Object tmp
= XCAR (x
);
2886 CHECK_NUMBER_CDR (Lisp_Object x
)
2888 Lisp_Object tmp
= XCDR (x
);
2893 /* Define a built-in function for calling from Lisp.
2894 `lname' should be the name to give the function in Lisp,
2895 as a null-terminated C string.
2896 `fnname' should be the name of the function in C.
2897 By convention, it starts with F.
2898 `sname' should be the name for the C constant structure
2899 that records information on this function for internal use.
2900 By convention, it should be the same as `fnname' but with S instead of F.
2901 It's too bad that C macros can't compute this from `fnname'.
2902 `minargs' should be a number, the minimum number of arguments allowed.
2903 `maxargs' should be a number, the maximum number of arguments allowed,
2904 or else MANY or UNEVALLED.
2905 MANY means pass a vector of evaluated arguments,
2906 in the form of an integer number-of-arguments
2907 followed by the address of a vector of Lisp_Objects
2908 which contains the argument values.
2909 UNEVALLED means pass the list of unevaluated arguments
2910 `intspec' says how interactive arguments are to be fetched.
2911 If the string starts with a `(', `intspec' is evaluated and the resulting
2912 list is the list of arguments.
2913 If it's a string that doesn't start with `(', the value should follow
2914 the one of the doc string for `interactive'.
2915 A null string means call interactively with no arguments.
2916 `doc' is documentation for the user. */
2918 /* This version of DEFUN declares a function prototype with the right
2919 arguments, so we can catch errors with maxargs at compile-time. */
2921 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
2922 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
2923 static struct Lisp_Subr alignas (GCALIGNMENT) sname = \
2924 { { (PVEC_SUBR << PSEUDOVECTOR_AREA_BITS) \
2925 | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)) }, \
2926 { (Lisp_Object (__cdecl *)(void))fnname }, \
2927 minargs, maxargs, lname, intspec, 0}; \
2929 #else /* not _MSC_VER */
2930 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
2931 static struct Lisp_Subr alignas (GCALIGNMENT) sname = \
2932 { { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS }, \
2933 { .a ## maxargs = fnname }, \
2934 minargs, maxargs, lname, intspec, 0}; \
2939 is how we define the symbol for function `name' at start-up time. */
2940 extern void defsubr (struct Lisp_Subr
*);
2948 /* Call a function F that accepts many args, passing it ARRAY's elements. */
2949 #define CALLMANY(f, array) (f) (ARRAYELTS (array), array)
2951 /* Call a function F that accepts many args, passing it the remaining args,
2952 E.g., 'return CALLN (Fformat, fmt, text);' is less error-prone than
2953 '{ Lisp_Object a[2]; a[0] = fmt; a[1] = text; return Fformat (2, a); }'.
2954 CALLN is overkill for simple usages like 'Finsert (1, &text);'. */
2955 #define CALLN(f, ...) CALLMANY (f, ((Lisp_Object []) {__VA_ARGS__}))
2957 extern void defvar_lisp (struct Lisp_Objfwd
*, const char *, Lisp_Object
*);
2958 extern void defvar_lisp_nopro (struct Lisp_Objfwd
*, const char *, Lisp_Object
*);
2959 extern void defvar_bool (struct Lisp_Boolfwd
*, const char *, bool *);
2960 extern void defvar_int (struct Lisp_Intfwd
*, const char *, EMACS_INT
*);
2961 extern void defvar_kboard (struct Lisp_Kboard_Objfwd
*, const char *, int);
2963 /* Macros we use to define forwarded Lisp variables.
2964 These are used in the syms_of_FILENAME functions.
2966 An ordinary (not in buffer_defaults, per-buffer, or per-keyboard)
2967 lisp variable is actually a field in `struct emacs_globals'. The
2968 field's name begins with "f_", which is a convention enforced by
2969 these macros. Each such global has a corresponding #define in
2970 globals.h; the plain name should be used in the code.
2972 E.g., the global "cons_cells_consed" is declared as "int
2973 f_cons_cells_consed" in globals.h, but there is a define:
2975 #define cons_cells_consed globals.f_cons_cells_consed
2977 All C code uses the `cons_cells_consed' name. This is all done
2978 this way to support indirection for multi-threaded Emacs. */
2980 #define DEFVAR_LISP(lname, vname, doc) \
2982 static struct Lisp_Objfwd o_fwd; \
2983 defvar_lisp (&o_fwd, lname, &globals.f_ ## vname); \
2985 #define DEFVAR_LISP_NOPRO(lname, vname, doc) \
2987 static struct Lisp_Objfwd o_fwd; \
2988 defvar_lisp_nopro (&o_fwd, lname, &globals.f_ ## vname); \
2990 #define DEFVAR_BOOL(lname, vname, doc) \
2992 static struct Lisp_Boolfwd b_fwd; \
2993 defvar_bool (&b_fwd, lname, &globals.f_ ## vname); \
2995 #define DEFVAR_INT(lname, vname, doc) \
2997 static struct Lisp_Intfwd i_fwd; \
2998 defvar_int (&i_fwd, lname, &globals.f_ ## vname); \
3001 #define DEFVAR_KBOARD(lname, vname, doc) \
3003 static struct Lisp_Kboard_Objfwd ko_fwd; \
3004 defvar_kboard (&ko_fwd, lname, offsetof (KBOARD, vname ## _)); \
3007 /* Save and restore the instruction and environment pointers,
3008 without affecting the signal mask. */
3011 typedef jmp_buf sys_jmp_buf
;
3012 # define sys_setjmp(j) _setjmp (j)
3013 # define sys_longjmp(j, v) _longjmp (j, v)
3014 #elif defined HAVE_SIGSETJMP
3015 typedef sigjmp_buf sys_jmp_buf
;
3016 # define sys_setjmp(j) sigsetjmp (j, 0)
3017 # define sys_longjmp(j, v) siglongjmp (j, v)
3019 /* A platform that uses neither _longjmp nor siglongjmp; assume
3020 longjmp does not affect the sigmask. */
3021 typedef jmp_buf sys_jmp_buf
;
3022 # define sys_setjmp(j) setjmp (j)
3023 # define sys_longjmp(j, v) longjmp (j, v)
3027 /* Elisp uses several stacks:
3029 - the bytecode stack: used internally by the bytecode interpreter.
3030 Allocated from the C stack.
3031 - The specpdl stack: keeps track of active unwind-protect and
3032 dynamic-let-bindings. Allocated from the `specpdl' array, a manually
3034 - The handler stack: keeps track of active catch tags and condition-case
3035 handlers. Allocated in a manually managed stack implemented by a
3036 doubly-linked list allocated via xmalloc and never freed. */
3038 /* Structure for recording Lisp call stack for backtrace purposes. */
3040 /* The special binding stack holds the outer values of variables while
3041 they are bound by a function application or a let form, stores the
3042 code to be executed for unwind-protect forms.
3044 NOTE: The specbinding union is defined here, because SPECPDL_INDEX is
3045 used all over the place, needs to be fast, and needs to know the size of
3046 union specbinding. But only eval.c should access it. */
3049 SPECPDL_UNWIND
, /* An unwind_protect function on Lisp_Object. */
3050 SPECPDL_UNWIND_PTR
, /* Likewise, on void *. */
3051 SPECPDL_UNWIND_INT
, /* Likewise, on int. */
3052 SPECPDL_UNWIND_VOID
, /* Likewise, with no arg. */
3053 SPECPDL_BACKTRACE
, /* An element of the backtrace. */
3054 SPECPDL_LET
, /* A plain and simple dynamic let-binding. */
3055 /* Tags greater than SPECPDL_LET must be "subkinds" of LET. */
3056 SPECPDL_LET_LOCAL
, /* A buffer-local let-binding. */
3057 SPECPDL_LET_DEFAULT
/* A global binding for a localized var. */
3062 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3064 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3065 void (*func
) (Lisp_Object
);
3069 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3070 void (*func
) (void *);
3074 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3079 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3080 void (*func
) (void);
3083 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3084 /* `where' is not used in the case of SPECPDL_LET. */
3085 Lisp_Object symbol
, old_value
, where
;
3086 /* Normally this is unused; but it is set to the symbol's
3087 current value when a thread is swapped out. */
3088 Lisp_Object saved_value
;
3091 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3092 bool_bf debug_on_exit
: 1;
3093 Lisp_Object function
;
3099 /* These 3 are defined as macros in thread.h. */
3100 /* extern union specbinding *specpdl; */
3101 /* extern union specbinding *specpdl_ptr; */
3102 /* extern ptrdiff_t specpdl_size; */
3105 SPECPDL_INDEX (void)
3107 return specpdl_ptr
- specpdl
;
3110 /* This structure helps implement the `catch/throw' and `condition-case/signal'
3111 control structures. A struct handler contains all the information needed to
3112 restore the state of the interpreter after a non-local jump.
3114 handler structures are chained together in a doubly linked list; the `next'
3115 member points to the next outer catchtag and the `nextfree' member points in
3116 the other direction to the next inner element (which is typically the next
3117 free element since we mostly use it on the deepest handler).
3119 A call like (throw TAG VAL) searches for a catchtag whose `tag_or_ch'
3120 member is TAG, and then unbinds to it. The `val' member is used to
3121 hold VAL while the stack is unwound; `val' is returned as the value
3122 of the catch form. If there is a handler of type CATCHER_ALL, it will
3123 be treated as a handler for all invocations of `throw'; in this case
3124 `val' will be set to (TAG . VAL).
3126 All the other members are concerned with restoring the interpreter
3129 Members are volatile if their values need to survive _longjmp when
3130 a 'struct handler' is a local variable. */
3132 enum handlertype
{ CATCHER
, CONDITION_CASE
, CATCHER_ALL
};
3136 enum handlertype type
;
3137 Lisp_Object tag_or_ch
;
3139 struct handler
*next
;
3140 struct handler
*nextfree
;
3142 /* The bytecode interpreter can have several handlers active at the same
3143 time, so when we longjmp to one of them, it needs to know which handler
3144 this was and what was the corresponding internal state. This is stored
3145 here, and when we longjmp we make sure that handlerlist points to the
3147 Lisp_Object
*bytecode_top
;
3150 /* Most global vars are reset to their value via the specpdl mechanism,
3151 but a few others are handled by storing their value here. */
3153 EMACS_INT f_lisp_eval_depth
;
3155 int poll_suppress_count
;
3156 int interrupt_input_blocked
;
3159 extern Lisp_Object memory_signal_data
;
3161 extern void maybe_quit (void);
3163 /* True if ought to quit now. */
3165 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
3167 /* Process a quit rarely, based on a counter COUNT, for efficiency.
3168 "Rarely" means once per USHRT_MAX + 1 times; this is somewhat
3169 arbitrary, but efficient. */
3172 rarely_quit (unsigned short int count
)
3178 extern Lisp_Object Vascii_downcase_table
;
3179 extern Lisp_Object Vascii_canon_table
;
3181 /* Call staticpro (&var) to protect static variable `var'. */
3183 void staticpro (Lisp_Object
*);
3185 /* Forward declarations for prototypes. */
3189 /* Copy COUNT Lisp_Objects from ARGS to contents of V starting from OFFSET. */
3192 vcopy (Lisp_Object v
, ptrdiff_t offset
, Lisp_Object
*args
, ptrdiff_t count
)
3194 eassert (0 <= offset
&& 0 <= count
&& offset
+ count
<= ASIZE (v
));
3195 memcpy (XVECTOR (v
)->contents
+ offset
, args
, count
* sizeof *args
);
3198 /* Functions to modify hash tables. */
3201 set_hash_key_slot (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
, Lisp_Object val
)
3203 gc_aset (h
->key_and_value
, 2 * idx
, val
);
3207 set_hash_value_slot (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
, Lisp_Object val
)
3209 gc_aset (h
->key_and_value
, 2 * idx
+ 1, val
);
3212 /* Use these functions to set Lisp_Object
3213 or pointer slots of struct Lisp_Symbol. */
3216 set_symbol_function (Lisp_Object sym
, Lisp_Object function
)
3218 XSYMBOL (sym
)->function
= function
;
3222 set_symbol_plist (Lisp_Object sym
, Lisp_Object plist
)
3224 XSYMBOL (sym
)->plist
= plist
;
3228 set_symbol_next (Lisp_Object sym
, struct Lisp_Symbol
*next
)
3230 XSYMBOL (sym
)->next
= next
;
3234 make_symbol_constant (Lisp_Object sym
)
3236 XSYMBOL (sym
)->trapped_write
= SYMBOL_NOWRITE
;
3239 /* Buffer-local variable access functions. */
3242 blv_found (struct Lisp_Buffer_Local_Value
*blv
)
3244 eassert (blv
->found
== !EQ (blv
->defcell
, blv
->valcell
));
3248 /* Set overlay's property list. */
3251 set_overlay_plist (Lisp_Object overlay
, Lisp_Object plist
)
3253 XOVERLAY (overlay
)->plist
= plist
;
3256 /* Get text properties of S. */
3259 string_intervals (Lisp_Object s
)
3261 return XSTRING (s
)->intervals
;
3264 /* Set text properties of S to I. */
3267 set_string_intervals (Lisp_Object s
, INTERVAL i
)
3269 XSTRING (s
)->intervals
= i
;
3272 /* Set a Lisp slot in TABLE to VAL. Most code should use this instead
3273 of setting slots directly. */
3276 set_char_table_defalt (Lisp_Object table
, Lisp_Object val
)
3278 XCHAR_TABLE (table
)->defalt
= val
;
3281 set_char_table_purpose (Lisp_Object table
, Lisp_Object val
)
3283 XCHAR_TABLE (table
)->purpose
= val
;
3286 /* Set different slots in (sub)character tables. */
3289 set_char_table_extras (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3291 eassert (0 <= idx
&& idx
< CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (table
)));
3292 XCHAR_TABLE (table
)->extras
[idx
] = val
;
3296 set_char_table_contents (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3298 eassert (0 <= idx
&& idx
< (1 << CHARTAB_SIZE_BITS_0
));
3299 XCHAR_TABLE (table
)->contents
[idx
] = val
;
3303 set_sub_char_table_contents (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3305 XSUB_CHAR_TABLE (table
)->contents
[idx
] = val
;
3308 /* Defined in data.c. */
3309 extern _Noreturn
void wrong_choice (Lisp_Object
, Lisp_Object
);
3310 extern void notify_variable_watchers (Lisp_Object
, Lisp_Object
,
3311 Lisp_Object
, Lisp_Object
);
3312 extern Lisp_Object
indirect_function (Lisp_Object
);
3313 extern Lisp_Object
find_symbol_value (Lisp_Object
);
3314 enum Arith_Comparison
{
3319 ARITH_LESS_OR_EQUAL
,
3322 extern Lisp_Object
arithcompare (Lisp_Object num1
, Lisp_Object num2
,
3323 enum Arith_Comparison comparison
);
3325 /* Convert the integer I to an Emacs representation, either the integer
3326 itself, or a cons of two or three integers, or if all else fails a float.
3327 I should not have side effects. */
3328 #define INTEGER_TO_CONS(i) \
3329 (! FIXNUM_OVERFLOW_P (i) \
3331 : EXPR_SIGNED (i) ? intbig_to_lisp (i) : uintbig_to_lisp (i))
3332 extern Lisp_Object
intbig_to_lisp (intmax_t);
3333 extern Lisp_Object
uintbig_to_lisp (uintmax_t);
3335 /* Convert the Emacs representation CONS back to an integer of type
3336 TYPE, storing the result the variable VAR. Signal an error if CONS
3337 is not a valid representation or is out of range for TYPE. */
3338 #define CONS_TO_INTEGER(cons, type, var) \
3339 (TYPE_SIGNED (type) \
3340 ? ((var) = cons_to_signed (cons, TYPE_MINIMUM (type), TYPE_MAXIMUM (type))) \
3341 : ((var) = cons_to_unsigned (cons, TYPE_MAXIMUM (type))))
3342 extern intmax_t cons_to_signed (Lisp_Object
, intmax_t, intmax_t);
3343 extern uintmax_t cons_to_unsigned (Lisp_Object
, uintmax_t);
3345 extern struct Lisp_Symbol
*indirect_variable (struct Lisp_Symbol
*);
3346 extern _Noreturn
void args_out_of_range (Lisp_Object
, Lisp_Object
);
3347 extern _Noreturn
void args_out_of_range_3 (Lisp_Object
, Lisp_Object
,
3349 extern _Noreturn
void circular_list (Lisp_Object
);
3350 extern Lisp_Object
do_symval_forwarding (union Lisp_Fwd
*);
3351 enum Set_Internal_Bind
{
3354 SET_INTERNAL_UNBIND
,
3355 SET_INTERNAL_THREAD_SWITCH
3357 extern void set_internal (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3358 enum Set_Internal_Bind
);
3359 extern void set_default_internal (Lisp_Object
, Lisp_Object
,
3360 enum Set_Internal_Bind bindflag
);
3362 extern void syms_of_data (void);
3363 extern void swap_in_global_binding (struct Lisp_Symbol
*);
3365 /* Defined in cmds.c */
3366 extern void syms_of_cmds (void);
3367 extern void keys_of_cmds (void);
3369 /* Defined in coding.c. */
3370 extern Lisp_Object
detect_coding_system (const unsigned char *, ptrdiff_t,
3371 ptrdiff_t, bool, bool, Lisp_Object
);
3372 extern void init_coding (void);
3373 extern void init_coding_once (void);
3374 extern void syms_of_coding (void);
3376 /* Defined in character.c. */
3377 extern ptrdiff_t chars_in_text (const unsigned char *, ptrdiff_t);
3378 extern ptrdiff_t multibyte_chars_in_text (const unsigned char *, ptrdiff_t);
3379 extern void syms_of_character (void);
3381 /* Defined in charset.c. */
3382 extern void init_charset (void);
3383 extern void init_charset_once (void);
3384 extern void syms_of_charset (void);
3385 /* Structure forward declarations. */
3388 /* Defined in syntax.c. */
3389 extern void init_syntax_once (void);
3390 extern void syms_of_syntax (void);
3392 /* Defined in fns.c. */
3393 enum { NEXT_ALMOST_PRIME_LIMIT
= 11 };
3394 extern EMACS_INT
next_almost_prime (EMACS_INT
) ATTRIBUTE_CONST
;
3395 extern Lisp_Object
larger_vector (Lisp_Object
, ptrdiff_t, ptrdiff_t);
3396 extern void sweep_weak_hash_tables (void);
3397 extern char *extract_data_from_object (Lisp_Object
, ptrdiff_t *, ptrdiff_t *);
3398 EMACS_UINT
hash_string (char const *, ptrdiff_t);
3399 EMACS_UINT
sxhash (Lisp_Object
, int);
3400 Lisp_Object
make_hash_table (struct hash_table_test
, EMACS_INT
, float, float,
3402 ptrdiff_t hash_lookup (struct Lisp_Hash_Table
*, Lisp_Object
, EMACS_UINT
*);
3403 ptrdiff_t hash_put (struct Lisp_Hash_Table
*, Lisp_Object
, Lisp_Object
,
3405 void hash_remove_from_table (struct Lisp_Hash_Table
*, Lisp_Object
);
3406 extern struct hash_table_test
const hashtest_eq
, hashtest_eql
, hashtest_equal
;
3407 extern void validate_subarray (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3408 ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
3409 extern Lisp_Object
substring_both (Lisp_Object
, ptrdiff_t, ptrdiff_t,
3410 ptrdiff_t, ptrdiff_t);
3411 extern Lisp_Object
merge (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3412 extern Lisp_Object
do_yes_or_no_p (Lisp_Object
);
3413 extern Lisp_Object
concat2 (Lisp_Object
, Lisp_Object
);
3414 extern Lisp_Object
concat3 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3415 extern bool equal_no_quit (Lisp_Object
, Lisp_Object
);
3416 extern Lisp_Object
nconc2 (Lisp_Object
, Lisp_Object
);
3417 extern Lisp_Object
assq_no_quit (Lisp_Object
, Lisp_Object
);
3418 extern Lisp_Object
assoc_no_quit (Lisp_Object
, Lisp_Object
);
3419 extern void clear_string_char_byte_cache (void);
3420 extern ptrdiff_t string_char_to_byte (Lisp_Object
, ptrdiff_t);
3421 extern ptrdiff_t string_byte_to_char (Lisp_Object
, ptrdiff_t);
3422 extern Lisp_Object
string_to_multibyte (Lisp_Object
);
3423 extern Lisp_Object
string_make_unibyte (Lisp_Object
);
3424 extern void syms_of_fns (void);
3426 /* Defined in floatfns.c. */
3427 extern void syms_of_floatfns (void);
3428 extern Lisp_Object
fmod_float (Lisp_Object x
, Lisp_Object y
);
3430 /* Defined in fringe.c. */
3431 extern void syms_of_fringe (void);
3432 extern void init_fringe (void);
3433 #ifdef HAVE_WINDOW_SYSTEM
3434 extern void mark_fringe_data (void);
3435 extern void init_fringe_once (void);
3436 #endif /* HAVE_WINDOW_SYSTEM */
3438 /* Defined in image.c. */
3439 extern int x_bitmap_mask (struct frame
*, ptrdiff_t);
3440 extern void reset_image_types (void);
3441 extern void syms_of_image (void);
3443 /* Defined in insdel.c. */
3444 extern void move_gap_both (ptrdiff_t, ptrdiff_t);
3445 extern _Noreturn
void buffer_overflow (void);
3446 extern void make_gap (ptrdiff_t);
3447 extern void make_gap_1 (struct buffer
*, ptrdiff_t);
3448 extern ptrdiff_t copy_text (const unsigned char *, unsigned char *,
3449 ptrdiff_t, bool, bool);
3450 extern int count_combining_before (const unsigned char *,
3451 ptrdiff_t, ptrdiff_t, ptrdiff_t);
3452 extern int count_combining_after (const unsigned char *,
3453 ptrdiff_t, ptrdiff_t, ptrdiff_t);
3454 extern void insert (const char *, ptrdiff_t);
3455 extern void insert_and_inherit (const char *, ptrdiff_t);
3456 extern void insert_1_both (const char *, ptrdiff_t, ptrdiff_t,
3458 extern void insert_from_gap (ptrdiff_t, ptrdiff_t, bool text_at_gap_tail
);
3459 extern void insert_from_string (Lisp_Object
, ptrdiff_t, ptrdiff_t,
3460 ptrdiff_t, ptrdiff_t, bool);
3461 extern void insert_from_buffer (struct buffer
*, ptrdiff_t, ptrdiff_t, bool);
3462 extern void insert_char (int);
3463 extern void insert_string (const char *);
3464 extern void insert_before_markers (const char *, ptrdiff_t);
3465 extern void insert_before_markers_and_inherit (const char *, ptrdiff_t);
3466 extern void insert_from_string_before_markers (Lisp_Object
, ptrdiff_t,
3467 ptrdiff_t, ptrdiff_t,
3469 extern void del_range (ptrdiff_t, ptrdiff_t);
3470 extern Lisp_Object
del_range_1 (ptrdiff_t, ptrdiff_t, bool, bool);
3471 extern void del_range_byte (ptrdiff_t, ptrdiff_t);
3472 extern void del_range_both (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, bool);
3473 extern Lisp_Object
del_range_2 (ptrdiff_t, ptrdiff_t,
3474 ptrdiff_t, ptrdiff_t, bool);
3475 extern void modify_text (ptrdiff_t, ptrdiff_t);
3476 extern void prepare_to_modify_buffer (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
3477 extern void prepare_to_modify_buffer_1 (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
3478 extern void invalidate_buffer_caches (struct buffer
*, ptrdiff_t, ptrdiff_t);
3479 extern void signal_after_change (ptrdiff_t, ptrdiff_t, ptrdiff_t);
3480 extern void adjust_after_insert (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3481 ptrdiff_t, ptrdiff_t);
3482 extern void adjust_markers_for_delete (ptrdiff_t, ptrdiff_t,
3483 ptrdiff_t, ptrdiff_t);
3484 extern void adjust_markers_bytepos (ptrdiff_t, ptrdiff_t,
3485 ptrdiff_t, ptrdiff_t, int);
3486 extern void replace_range (ptrdiff_t, ptrdiff_t, Lisp_Object
, bool, bool, bool, bool);
3487 extern void replace_range_2 (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
3488 const char *, ptrdiff_t, ptrdiff_t, bool);
3489 extern void syms_of_insdel (void);
3491 /* Defined in dispnew.c. */
3492 #if (defined PROFILING \
3493 && (defined __FreeBSD__ || defined GNU_LINUX || defined __MINGW32__))
3494 _Noreturn
void __executable_start (void);
3496 extern Lisp_Object Vwindow_system
;
3497 extern Lisp_Object
sit_for (Lisp_Object
, bool, int);
3499 /* Defined in xdisp.c. */
3500 extern bool noninteractive_need_newline
;
3501 extern Lisp_Object echo_area_buffer
[2];
3502 extern void add_to_log (char const *, ...);
3503 extern void vadd_to_log (char const *, va_list);
3504 extern void check_message_stack (void);
3505 extern void setup_echo_area_for_printing (bool);
3506 extern bool push_message (void);
3507 extern void pop_message_unwind (void);
3508 extern Lisp_Object
restore_message_unwind (Lisp_Object
);
3509 extern void restore_message (void);
3510 extern Lisp_Object
current_message (void);
3511 extern void clear_message (bool, bool);
3512 extern void message (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3513 extern void message1 (const char *);
3514 extern void message1_nolog (const char *);
3515 extern void message3 (Lisp_Object
);
3516 extern void message3_nolog (Lisp_Object
);
3517 extern void message_dolog (const char *, ptrdiff_t, bool, bool);
3518 extern void message_with_string (const char *, Lisp_Object
, bool);
3519 extern void message_log_maybe_newline (void);
3520 extern void update_echo_area (void);
3521 extern void truncate_echo_area (ptrdiff_t);
3522 extern void redisplay (void);
3524 void set_frame_cursor_types (struct frame
*, Lisp_Object
);
3525 extern void syms_of_xdisp (void);
3526 extern void init_xdisp (void);
3527 extern Lisp_Object
safe_eval (Lisp_Object
);
3528 extern bool pos_visible_p (struct window
*, ptrdiff_t, int *,
3529 int *, int *, int *, int *, int *);
3531 /* Defined in xsettings.c. */
3532 extern void syms_of_xsettings (void);
3534 /* Defined in vm-limit.c. */
3535 extern void memory_warnings (void *, void (*warnfun
) (const char *));
3537 /* Defined in character.c. */
3538 extern void parse_str_as_multibyte (const unsigned char *, ptrdiff_t,
3539 ptrdiff_t *, ptrdiff_t *);
3541 /* Defined in alloc.c. */
3542 extern void *my_heap_start (void);
3543 extern void check_pure_size (void);
3544 extern void free_misc (Lisp_Object
);
3545 extern void allocate_string_data (struct Lisp_String
*, EMACS_INT
, EMACS_INT
);
3546 extern void malloc_warning (const char *);
3547 extern _Noreturn
void memory_full (size_t);
3548 extern _Noreturn
void buffer_memory_full (ptrdiff_t);
3549 extern bool survives_gc_p (Lisp_Object
);
3550 extern void mark_object (Lisp_Object
);
3551 #if defined REL_ALLOC && !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
3552 extern void refill_memory_reserve (void);
3554 extern void alloc_unexec_pre (void);
3555 extern void alloc_unexec_post (void);
3556 extern void mark_stack (char *, char *);
3557 extern void flush_stack_call_func (void (*func
) (void *arg
), void *arg
);
3558 extern const char *pending_malloc_warning
;
3559 extern Lisp_Object zero_vector
;
3560 extern EMACS_INT consing_since_gc
;
3561 extern EMACS_INT gc_relative_threshold
;
3562 extern EMACS_INT memory_full_cons_threshold
;
3563 extern Lisp_Object
list1 (Lisp_Object
);
3564 extern Lisp_Object
list2 (Lisp_Object
, Lisp_Object
);
3565 extern Lisp_Object
list3 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3566 extern Lisp_Object
list4 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3567 extern Lisp_Object
list5 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
,
3569 enum constype
{CONSTYPE_HEAP
, CONSTYPE_PURE
};
3570 extern Lisp_Object
listn (enum constype
, ptrdiff_t, Lisp_Object
, ...);
3572 /* Build a frequently used 2/3/4-integer lists. */
3575 list2i (EMACS_INT x
, EMACS_INT y
)
3577 return list2 (make_number (x
), make_number (y
));
3581 list3i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
)
3583 return list3 (make_number (x
), make_number (y
), make_number (w
));
3587 list4i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
, EMACS_INT h
)
3589 return list4 (make_number (x
), make_number (y
),
3590 make_number (w
), make_number (h
));
3593 extern Lisp_Object
make_uninit_bool_vector (EMACS_INT
);
3594 extern Lisp_Object
bool_vector_fill (Lisp_Object
, Lisp_Object
);
3595 extern _Noreturn
void string_overflow (void);
3596 extern Lisp_Object
make_string (const char *, ptrdiff_t);
3597 extern Lisp_Object
make_formatted_string (char *, const char *, ...)
3598 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3599 extern Lisp_Object
make_unibyte_string (const char *, ptrdiff_t);
3601 /* Make unibyte string from C string when the length isn't known. */
3604 build_unibyte_string (const char *str
)
3606 return make_unibyte_string (str
, strlen (str
));
3609 extern Lisp_Object
make_multibyte_string (const char *, ptrdiff_t, ptrdiff_t);
3610 extern Lisp_Object
make_event_array (ptrdiff_t, Lisp_Object
*);
3611 extern Lisp_Object
make_uninit_string (EMACS_INT
);
3612 extern Lisp_Object
make_uninit_multibyte_string (EMACS_INT
, EMACS_INT
);
3613 extern Lisp_Object
make_string_from_bytes (const char *, ptrdiff_t, ptrdiff_t);
3614 extern Lisp_Object
make_specified_string (const char *,
3615 ptrdiff_t, ptrdiff_t, bool);
3616 extern Lisp_Object
make_pure_string (const char *, ptrdiff_t, ptrdiff_t, bool);
3617 extern Lisp_Object
make_pure_c_string (const char *, ptrdiff_t);
3619 /* Make a string allocated in pure space, use STR as string data. */
3622 build_pure_c_string (const char *str
)
3624 return make_pure_c_string (str
, strlen (str
));
3627 /* Make a string from the data at STR, treating it as multibyte if the
3631 build_string (const char *str
)
3633 return make_string (str
, strlen (str
));
3636 extern Lisp_Object
pure_cons (Lisp_Object
, Lisp_Object
);
3637 extern void make_byte_code (struct Lisp_Vector
*);
3638 extern struct Lisp_Vector
*allocate_vector (EMACS_INT
);
3640 /* Make an uninitialized vector for SIZE objects. NOTE: you must
3641 be sure that GC cannot happen until the vector is completely
3642 initialized. E.g. the following code is likely to crash:
3644 v = make_uninit_vector (3);
3646 ASET (v, 1, Ffunction_can_gc ());
3647 ASET (v, 2, obj1); */
3650 make_uninit_vector (ptrdiff_t size
)
3653 struct Lisp_Vector
*p
;
3655 p
= allocate_vector (size
);
3660 /* Like above, but special for sub char-tables. */
3663 make_uninit_sub_char_table (int depth
, int min_char
)
3665 int slots
= SUB_CHAR_TABLE_OFFSET
+ chartab_size
[depth
];
3666 Lisp_Object v
= make_uninit_vector (slots
);
3668 XSETPVECTYPE (XVECTOR (v
), PVEC_SUB_CHAR_TABLE
);
3669 XSUB_CHAR_TABLE (v
)->depth
= depth
;
3670 XSUB_CHAR_TABLE (v
)->min_char
= min_char
;
3674 extern struct Lisp_Vector
*allocate_pseudovector (int, int, int,
3677 /* Allocate partially initialized pseudovector where all Lisp_Object
3678 slots are set to Qnil but the rest (if any) is left uninitialized. */
3680 #define ALLOCATE_PSEUDOVECTOR(type, field, tag) \
3681 ((type *) allocate_pseudovector (VECSIZE (type), \
3682 PSEUDOVECSIZE (type, field), \
3683 PSEUDOVECSIZE (type, field), tag))
3685 /* Allocate fully initialized pseudovector where all Lisp_Object
3686 slots are set to Qnil and the rest (if any) is zeroed. */
3688 #define ALLOCATE_ZEROED_PSEUDOVECTOR(type, field, tag) \
3689 ((type *) allocate_pseudovector (VECSIZE (type), \
3690 PSEUDOVECSIZE (type, field), \
3691 VECSIZE (type), tag))
3693 extern bool gc_in_progress
;
3694 extern Lisp_Object
make_float (double);
3695 extern void display_malloc_warning (void);
3696 extern ptrdiff_t inhibit_garbage_collection (void);
3697 extern Lisp_Object
make_save_int_int_int (ptrdiff_t, ptrdiff_t, ptrdiff_t);
3698 extern Lisp_Object
make_save_obj_obj_obj_obj (Lisp_Object
, Lisp_Object
,
3699 Lisp_Object
, Lisp_Object
);
3700 extern Lisp_Object
make_save_ptr (void *);
3701 extern Lisp_Object
make_save_ptr_int (void *, ptrdiff_t);
3702 extern Lisp_Object
make_save_ptr_ptr (void *, void *);
3703 extern Lisp_Object
make_save_funcptr_ptr_obj (void (*) (void), void *,
3705 extern Lisp_Object
make_save_memory (Lisp_Object
*, ptrdiff_t);
3706 extern void free_save_value (Lisp_Object
);
3707 extern Lisp_Object
build_overlay (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3708 extern void free_marker (Lisp_Object
);
3709 extern void free_cons (struct Lisp_Cons
*);
3710 extern void init_alloc_once (void);
3711 extern void init_alloc (void);
3712 extern void syms_of_alloc (void);
3713 extern struct buffer
* allocate_buffer (void);
3714 extern int valid_lisp_object_p (Lisp_Object
);
3715 #ifdef GC_CHECK_CONS_LIST
3716 extern void check_cons_list (void);
3718 INLINE
void (check_cons_list
) (void) { lisp_h_check_cons_list (); }
3721 /* Defined in gmalloc.c. */
3722 #if !defined DOUG_LEA_MALLOC && !defined HYBRID_MALLOC && !defined SYSTEM_MALLOC
3723 extern size_t __malloc_extra_blocks
;
3725 #if !HAVE_DECL_ALIGNED_ALLOC
3726 extern void *aligned_alloc (size_t, size_t) ATTRIBUTE_MALLOC_SIZE ((2));
3728 extern void malloc_enable_thread (void);
3731 /* Defined in ralloc.c. */
3732 extern void *r_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3733 extern void r_alloc_free (void **);
3734 extern void *r_re_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3735 extern void r_alloc_reset_variable (void **, void **);
3736 extern void r_alloc_inhibit_buffer_relocation (int);
3739 /* Defined in chartab.c. */
3740 extern Lisp_Object
copy_char_table (Lisp_Object
);
3741 extern Lisp_Object
char_table_ref_and_range (Lisp_Object
, int,
3743 extern void char_table_set_range (Lisp_Object
, int, int, Lisp_Object
);
3744 extern void map_char_table (void (*) (Lisp_Object
, Lisp_Object
,
3746 Lisp_Object
, Lisp_Object
, Lisp_Object
);
3747 extern void map_char_table_for_charset (void (*c_function
) (Lisp_Object
, Lisp_Object
),
3748 Lisp_Object
, Lisp_Object
,
3749 Lisp_Object
, struct charset
*,
3750 unsigned, unsigned);
3751 extern Lisp_Object
uniprop_table (Lisp_Object
);
3752 extern void syms_of_chartab (void);
3754 /* Defined in print.c. */
3755 extern Lisp_Object Vprin1_to_string_buffer
;
3756 extern void debug_print (Lisp_Object
) EXTERNALLY_VISIBLE
;
3757 extern void temp_output_buffer_setup (const char *);
3758 extern int print_level
;
3759 extern void print_error_message (Lisp_Object
, Lisp_Object
, const char *,
3761 extern Lisp_Object internal_with_output_to_temp_buffer
3762 (const char *, Lisp_Object (*) (Lisp_Object
), Lisp_Object
);
3763 #define FLOAT_TO_STRING_BUFSIZE 350
3764 extern int float_to_string (char *, double);
3765 extern void init_print_once (void);
3766 extern void syms_of_print (void);
3768 /* Defined in doprnt.c. */
3769 extern ptrdiff_t doprnt (char *, ptrdiff_t, const char *, const char *,
3771 extern ptrdiff_t esprintf (char *, char const *, ...)
3772 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3773 extern ptrdiff_t exprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3775 ATTRIBUTE_FORMAT_PRINTF (5, 6);
3776 extern ptrdiff_t evxprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3777 char const *, va_list)
3778 ATTRIBUTE_FORMAT_PRINTF (5, 0);
3780 /* Defined in lread.c. */
3781 extern Lisp_Object
check_obarray (Lisp_Object
);
3782 extern Lisp_Object
intern_1 (const char *, ptrdiff_t);
3783 extern Lisp_Object
intern_c_string_1 (const char *, ptrdiff_t);
3784 extern Lisp_Object
intern_driver (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3785 extern void init_symbol (Lisp_Object
, Lisp_Object
);
3786 extern Lisp_Object
oblookup (Lisp_Object
, const char *, ptrdiff_t, ptrdiff_t);
3788 LOADHIST_ATTACH (Lisp_Object x
)
3791 Vcurrent_load_list
= Fcons (x
, Vcurrent_load_list
);
3793 extern int openp (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3794 Lisp_Object
*, Lisp_Object
, bool);
3795 extern Lisp_Object
string_to_number (char const *, int, bool);
3796 extern void map_obarray (Lisp_Object
, void (*) (Lisp_Object
, Lisp_Object
),
3798 extern void dir_warning (const char *, Lisp_Object
);
3799 extern void init_obarray (void);
3800 extern void init_lread (void);
3801 extern void syms_of_lread (void);
3804 intern (const char *str
)
3806 return intern_1 (str
, strlen (str
));
3810 intern_c_string (const char *str
)
3812 return intern_c_string_1 (str
, strlen (str
));
3815 /* Defined in eval.c. */
3816 extern Lisp_Object Vautoload_queue
;
3817 extern Lisp_Object Vrun_hooks
;
3818 extern Lisp_Object Vsignaling_function
;
3819 extern Lisp_Object inhibit_lisp_code
;
3821 /* To run a normal hook, use the appropriate function from the list below.
3822 The calling convention:
3824 if (!NILP (Vrun_hooks))
3825 call1 (Vrun_hooks, Qmy_funny_hook);
3827 should no longer be used. */
3828 extern void run_hook (Lisp_Object
);
3829 extern void run_hook_with_args_2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3830 extern Lisp_Object
run_hook_with_args (ptrdiff_t nargs
, Lisp_Object
*args
,
3831 Lisp_Object (*funcall
)
3832 (ptrdiff_t nargs
, Lisp_Object
*args
));
3833 extern Lisp_Object
quit (void);
3834 INLINE _Noreturn
void
3835 xsignal (Lisp_Object error_symbol
, Lisp_Object data
)
3837 Fsignal (error_symbol
, data
);
3839 extern _Noreturn
void xsignal0 (Lisp_Object
);
3840 extern _Noreturn
void xsignal1 (Lisp_Object
, Lisp_Object
);
3841 extern _Noreturn
void xsignal2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3842 extern _Noreturn
void xsignal3 (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3844 extern _Noreturn
void signal_error (const char *, Lisp_Object
);
3845 extern bool FUNCTIONP (Lisp_Object
);
3846 extern Lisp_Object
funcall_subr (struct Lisp_Subr
*subr
, ptrdiff_t numargs
, Lisp_Object
*arg_vector
);
3847 extern Lisp_Object
eval_sub (Lisp_Object form
);
3848 extern Lisp_Object
apply1 (Lisp_Object
, Lisp_Object
);
3849 extern Lisp_Object
call0 (Lisp_Object
);
3850 extern Lisp_Object
call1 (Lisp_Object
, Lisp_Object
);
3851 extern Lisp_Object
call2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3852 extern Lisp_Object
call3 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3853 extern Lisp_Object
call4 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3854 extern Lisp_Object
call5 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3855 extern Lisp_Object
call6 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3856 extern Lisp_Object
call7 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3857 extern Lisp_Object
call8 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3858 extern Lisp_Object
internal_catch (Lisp_Object
, Lisp_Object (*) (Lisp_Object
), Lisp_Object
);
3859 extern Lisp_Object
internal_lisp_condition_case (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3860 extern Lisp_Object
internal_condition_case (Lisp_Object (*) (void), Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3861 extern Lisp_Object
internal_condition_case_1 (Lisp_Object (*) (Lisp_Object
), Lisp_Object
, Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3862 extern Lisp_Object
internal_condition_case_2 (Lisp_Object (*) (Lisp_Object
, Lisp_Object
), Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3863 extern Lisp_Object internal_condition_case_n
3864 (Lisp_Object (*) (ptrdiff_t, Lisp_Object
*), ptrdiff_t, Lisp_Object
*,
3865 Lisp_Object
, Lisp_Object (*) (Lisp_Object
, ptrdiff_t, Lisp_Object
*));
3866 extern struct handler
*push_handler (Lisp_Object
, enum handlertype
);
3867 extern struct handler
*push_handler_nosignal (Lisp_Object
, enum handlertype
);
3868 extern void specbind (Lisp_Object
, Lisp_Object
);
3869 extern void record_unwind_protect (void (*) (Lisp_Object
), Lisp_Object
);
3870 extern void record_unwind_protect_ptr (void (*) (void *), void *);
3871 extern void record_unwind_protect_int (void (*) (int), int);
3872 extern void record_unwind_protect_void (void (*) (void));
3873 extern void record_unwind_protect_nothing (void);
3874 extern void clear_unwind_protect (ptrdiff_t);
3875 extern void set_unwind_protect (ptrdiff_t, void (*) (Lisp_Object
), Lisp_Object
);
3876 extern void set_unwind_protect_ptr (ptrdiff_t, void (*) (void *), void *);
3877 extern Lisp_Object
unbind_to (ptrdiff_t, Lisp_Object
);
3878 extern void rebind_for_thread_switch (void);
3879 extern void unbind_for_thread_switch (struct thread_state
*);
3880 extern _Noreturn
void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3881 extern _Noreturn
void verror (const char *, va_list)
3882 ATTRIBUTE_FORMAT_PRINTF (1, 0);
3883 extern Lisp_Object
vformat_string (const char *, va_list)
3884 ATTRIBUTE_FORMAT_PRINTF (1, 0);
3885 extern void un_autoload (Lisp_Object
);
3886 extern Lisp_Object
call_debugger (Lisp_Object arg
);
3887 extern void init_eval_once (void);
3888 extern Lisp_Object
safe_call (ptrdiff_t, Lisp_Object
, ...);
3889 extern Lisp_Object
safe_call1 (Lisp_Object
, Lisp_Object
);
3890 extern Lisp_Object
safe_call2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3891 extern void init_eval (void);
3892 extern void syms_of_eval (void);
3893 extern void prog_ignore (Lisp_Object
);
3894 extern ptrdiff_t record_in_backtrace (Lisp_Object
, Lisp_Object
*, ptrdiff_t);
3895 extern void mark_specpdl (union specbinding
*first
, union specbinding
*ptr
);
3896 extern void get_backtrace (Lisp_Object array
);
3897 Lisp_Object
backtrace_top_function (void);
3898 extern bool let_shadows_buffer_binding_p (struct Lisp_Symbol
*symbol
);
3900 /* Defined in unexmacosx.c. */
3901 #if defined DARWIN_OS && !defined CANNOT_DUMP
3902 extern void unexec_init_emacs_zone (void);
3903 extern void *unexec_malloc (size_t);
3904 extern void *unexec_realloc (void *, size_t);
3905 extern void unexec_free (void *);
3908 #include "emacs-module.h"
3910 /* Function prototype for the module Lisp functions. */
3911 typedef emacs_value (*emacs_subr
) (emacs_env
*, ptrdiff_t,
3912 emacs_value
[], void *);
3914 /* Module function. */
3916 /* A function environment is an auxiliary structure returned by
3917 `module_make_function' to store information about a module
3918 function. It is stored in a pseudovector. Its members correspond
3919 to the arguments given to `module_make_function'. */
3921 struct Lisp_Module_Function
3923 struct vectorlike_header header
;
3925 /* Fields traced by GC; these must come first. */
3926 Lisp_Object documentation
;
3928 /* Fields ignored by GC. */
3929 ptrdiff_t min_arity
, max_arity
;
3935 MODULE_FUNCTIONP (Lisp_Object o
)
3937 return PSEUDOVECTORP (o
, PVEC_MODULE_FUNCTION
);
3940 INLINE
struct Lisp_Module_Function
*
3941 XMODULE_FUNCTION (Lisp_Object o
)
3943 eassert (MODULE_FUNCTIONP (o
));
3944 return XUNTAG (o
, Lisp_Vectorlike
);
3948 /* Defined in alloc.c. */
3949 extern Lisp_Object
make_user_ptr (void (*finalizer
) (void *), void *p
);
3951 /* Defined in emacs-module.c. */
3952 extern Lisp_Object
funcall_module (Lisp_Object
, ptrdiff_t, Lisp_Object
*);
3953 extern Lisp_Object
module_function_arity (const struct Lisp_Module_Function
*);
3954 extern void mark_modules (void);
3955 extern void init_module_assertions (bool);
3956 extern void syms_of_module (void);
3959 /* Defined in thread.c. */
3960 extern void mark_threads (void);
3962 /* Defined in editfns.c. */
3963 extern void insert1 (Lisp_Object
);
3964 extern Lisp_Object
save_excursion_save (void);
3965 extern Lisp_Object
save_restriction_save (void);
3966 extern void save_excursion_restore (Lisp_Object
);
3967 extern void save_restriction_restore (Lisp_Object
);
3968 extern _Noreturn
void time_overflow (void);
3969 extern Lisp_Object
make_buffer_string (ptrdiff_t, ptrdiff_t, bool);
3970 extern Lisp_Object
make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3972 extern Lisp_Object
styled_format (ptrdiff_t, Lisp_Object
*, bool, bool);
3973 extern void init_editfns (bool);
3974 extern void syms_of_editfns (void);
3976 /* Defined in buffer.c. */
3977 extern bool mouse_face_overlay_overlaps (Lisp_Object
);
3978 extern Lisp_Object
disable_line_numbers_overlay_at_eob (void);
3979 extern _Noreturn
void nsberror (Lisp_Object
);
3980 extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
3981 extern void adjust_overlays_for_delete (ptrdiff_t, ptrdiff_t);
3982 extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
3983 extern void report_overlay_modification (Lisp_Object
, Lisp_Object
, bool,
3984 Lisp_Object
, Lisp_Object
, Lisp_Object
);
3985 extern bool overlay_touches_p (ptrdiff_t);
3986 extern Lisp_Object
other_buffer_safely (Lisp_Object
);
3987 extern Lisp_Object
get_truename_buffer (Lisp_Object
);
3988 extern void init_buffer_once (void);
3989 extern void init_buffer (int);
3990 extern void syms_of_buffer (void);
3991 extern void keys_of_buffer (void);
3993 /* Defined in marker.c. */
3995 extern ptrdiff_t marker_position (Lisp_Object
);
3996 extern ptrdiff_t marker_byte_position (Lisp_Object
);
3997 extern void clear_charpos_cache (struct buffer
*);
3998 extern ptrdiff_t buf_charpos_to_bytepos (struct buffer
*, ptrdiff_t);
3999 extern ptrdiff_t buf_bytepos_to_charpos (struct buffer
*, ptrdiff_t);
4000 extern void unchain_marker (struct Lisp_Marker
*marker
);
4001 extern Lisp_Object
set_marker_restricted (Lisp_Object
, Lisp_Object
, Lisp_Object
);
4002 extern Lisp_Object
set_marker_both (Lisp_Object
, Lisp_Object
, ptrdiff_t, ptrdiff_t);
4003 extern Lisp_Object
set_marker_restricted_both (Lisp_Object
, Lisp_Object
,
4004 ptrdiff_t, ptrdiff_t);
4005 extern Lisp_Object
build_marker (struct buffer
*, ptrdiff_t, ptrdiff_t);
4006 extern void syms_of_marker (void);
4008 /* Defined in fileio.c. */
4010 extern Lisp_Object
expand_and_dir_to_file (Lisp_Object
);
4011 extern Lisp_Object
write_region (Lisp_Object
, Lisp_Object
, Lisp_Object
,
4012 Lisp_Object
, Lisp_Object
, Lisp_Object
,
4014 extern void close_file_unwind (int);
4015 extern void fclose_unwind (void *);
4016 extern void restore_point_unwind (Lisp_Object
);
4017 extern _Noreturn
void report_file_errno (const char *, Lisp_Object
, int);
4018 extern _Noreturn
void report_file_error (const char *, Lisp_Object
);
4019 extern _Noreturn
void report_file_notify_error (const char *, Lisp_Object
);
4020 extern bool internal_delete_file (Lisp_Object
);
4021 extern Lisp_Object
emacs_readlinkat (int, const char *);
4022 extern bool file_directory_p (const char *);
4023 extern bool file_accessible_directory_p (Lisp_Object
);
4024 extern void init_fileio (void);
4025 extern void syms_of_fileio (void);
4027 /* Defined in search.c. */
4028 extern void shrink_regexp_cache (void);
4029 extern void restore_search_regs (void);
4030 extern void update_search_regs (ptrdiff_t oldstart
,
4031 ptrdiff_t oldend
, ptrdiff_t newend
);
4032 extern void record_unwind_save_match_data (void);
4033 struct re_registers
;
4034 extern struct re_pattern_buffer
*compile_pattern (Lisp_Object
,
4035 struct re_registers
*,
4036 Lisp_Object
, bool, bool);
4037 extern ptrdiff_t fast_string_match_internal (Lisp_Object
, Lisp_Object
,
4041 fast_string_match (Lisp_Object regexp
, Lisp_Object string
)
4043 return fast_string_match_internal (regexp
, string
, Qnil
);
4047 fast_string_match_ignore_case (Lisp_Object regexp
, Lisp_Object string
)
4049 return fast_string_match_internal (regexp
, string
, Vascii_canon_table
);
4052 extern ptrdiff_t fast_c_string_match_ignore_case (Lisp_Object
, const char *,
4054 extern ptrdiff_t fast_looking_at (Lisp_Object
, ptrdiff_t, ptrdiff_t,
4055 ptrdiff_t, ptrdiff_t, Lisp_Object
);
4056 extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
4057 ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
4058 extern ptrdiff_t scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
4060 extern ptrdiff_t scan_newline_from_point (ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
4061 extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t,
4062 ptrdiff_t, ptrdiff_t *);
4063 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
4064 ptrdiff_t, ptrdiff_t *);
4065 extern void syms_of_search (void);
4066 extern void clear_regexp_cache (void);
4068 /* Defined in minibuf.c. */
4070 extern Lisp_Object Vminibuffer_list
;
4071 extern Lisp_Object last_minibuf_string
;
4072 extern Lisp_Object
get_minibuffer (EMACS_INT
);
4073 extern void init_minibuf_once (void);
4074 extern void syms_of_minibuf (void);
4076 /* Defined in callint.c. */
4078 extern void syms_of_callint (void);
4080 /* Defined in casefiddle.c. */
4082 extern void syms_of_casefiddle (void);
4083 extern void keys_of_casefiddle (void);
4085 /* Defined in casetab.c. */
4087 extern void init_casetab_once (void);
4088 extern void syms_of_casetab (void);
4090 /* Defined in keyboard.c. */
4092 extern Lisp_Object echo_message_buffer
;
4093 extern struct kboard
*echo_kboard
;
4094 extern void cancel_echoing (void);
4095 extern bool input_pending
;
4096 #ifdef HAVE_STACK_OVERFLOW_HANDLING
4097 extern sigjmp_buf return_to_command_loop
;
4099 extern Lisp_Object
menu_bar_items (Lisp_Object
);
4100 extern Lisp_Object
tool_bar_items (Lisp_Object
, int *);
4101 extern void discard_mouse_events (void);
4103 void handle_input_available_signal (int);
4105 extern Lisp_Object pending_funcalls
;
4106 extern bool detect_input_pending (void);
4107 extern bool detect_input_pending_ignore_squeezables (void);
4108 extern bool detect_input_pending_run_timers (bool);
4109 extern void safe_run_hooks (Lisp_Object
);
4110 extern void cmd_error_internal (Lisp_Object
, const char *);
4111 extern Lisp_Object
command_loop_1 (void);
4112 extern Lisp_Object
read_menu_command (void);
4113 extern Lisp_Object
recursive_edit_1 (void);
4114 extern void record_auto_save (void);
4115 extern void force_auto_save_soon (void);
4116 extern void init_keyboard (void);
4117 extern void syms_of_keyboard (void);
4118 extern void keys_of_keyboard (void);
4120 /* Defined in indent.c. */
4121 extern ptrdiff_t current_column (void);
4122 extern void invalidate_current_column (void);
4123 extern bool indented_beyond_p (ptrdiff_t, ptrdiff_t, EMACS_INT
);
4124 extern void syms_of_indent (void);
4126 /* Defined in frame.c. */
4127 extern void store_frame_param (struct frame
*, Lisp_Object
, Lisp_Object
);
4128 extern void store_in_alist (Lisp_Object
*, Lisp_Object
, Lisp_Object
);
4129 extern Lisp_Object
do_switch_frame (Lisp_Object
, int, int, Lisp_Object
);
4130 extern Lisp_Object
get_frame_param (struct frame
*, Lisp_Object
);
4131 extern void frames_discard_buffer (Lisp_Object
);
4132 extern void syms_of_frame (void);
4134 /* Defined in emacs.c. */
4135 extern char **initial_argv
;
4136 extern int initial_argc
;
4137 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS)
4138 extern bool display_arg
;
4140 extern Lisp_Object
decode_env_path (const char *, const char *, bool);
4141 extern Lisp_Object empty_unibyte_string
, empty_multibyte_string
;
4142 extern _Noreturn
void terminate_due_to_signal (int, int);
4144 extern Lisp_Object Vlibrary_cache
;
4147 void fixup_locale (void);
4148 void synchronize_system_messages_locale (void);
4149 void synchronize_system_time_locale (void);
4151 INLINE
void fixup_locale (void) {}
4152 INLINE
void synchronize_system_messages_locale (void) {}
4153 INLINE
void synchronize_system_time_locale (void) {}
4155 extern char *emacs_strerror (int);
4156 extern void shut_down_emacs (int, Lisp_Object
);
4158 /* True means don't do interactive redisplay and don't change tty modes. */
4159 extern bool noninteractive
;
4161 /* True means remove site-lisp directories from load-path. */
4162 extern bool no_site_lisp
;
4164 /* True means put details like time stamps into builds. */
4165 extern bool build_details
;
4168 /* 0 not a daemon, 1 foreground daemon, 2 background daemon. */
4169 extern int daemon_type
;
4170 #define IS_DAEMON (daemon_type != 0)
4171 #define DAEMON_RUNNING (daemon_type >= 0)
4172 #else /* WINDOWSNT */
4173 extern void *w32_daemon_event
;
4174 #define IS_DAEMON (w32_daemon_event != NULL)
4175 #define DAEMON_RUNNING (w32_daemon_event != INVALID_HANDLE_VALUE)
4178 /* True if handling a fatal error already. */
4179 extern bool fatal_error_in_progress
;
4181 /* True means don't do use window-system-specific display code. */
4182 extern bool inhibit_window_system
;
4183 /* True means that a filter or a sentinel is running. */
4184 extern bool running_asynch_code
;
4186 /* Defined in process.c. */
4187 struct Lisp_Process
;
4188 extern void kill_buffer_processes (Lisp_Object
);
4189 extern int wait_reading_process_output (intmax_t, int, int, bool, Lisp_Object
,
4190 struct Lisp_Process
*, int);
4191 /* Max value for the first argument of wait_reading_process_output. */
4192 #if GNUC_PREREQ (3, 0, 0) && ! GNUC_PREREQ (4, 6, 0)
4193 /* Work around a bug in GCC 3.4.2, known to be fixed in GCC 4.6.0.
4194 The bug merely causes a bogus warning, but the warning is annoying. */
4195 # define WAIT_READING_MAX min (TYPE_MAXIMUM (time_t), INTMAX_MAX)
4197 # define WAIT_READING_MAX INTMAX_MAX
4200 extern void add_timer_wait_descriptor (int);
4202 extern void add_keyboard_wait_descriptor (int);
4203 extern void delete_keyboard_wait_descriptor (int);
4205 extern void add_gpm_wait_descriptor (int);
4206 extern void delete_gpm_wait_descriptor (int);
4208 extern void init_process_emacs (int);
4209 extern void syms_of_process (void);
4210 extern void setup_process_coding_systems (Lisp_Object
);
4212 /* Defined in callproc.c. */
4214 # define CHILD_SETUP_TYPE _Noreturn void
4216 # define CHILD_SETUP_TYPE int
4218 extern CHILD_SETUP_TYPE
child_setup (int, int, int, char **, bool, Lisp_Object
);
4219 extern void init_callproc_1 (void);
4220 extern void init_callproc (void);
4221 extern void set_initial_environment (void);
4222 extern void syms_of_callproc (void);
4224 /* Defined in doc.c. */
4225 enum text_quoting_style
4227 /* Use curved single quotes ‘like this’. */
4228 CURVE_QUOTING_STYLE
,
4230 /* Use grave accent and apostrophe `like this'. */
4231 GRAVE_QUOTING_STYLE
,
4233 /* Use apostrophes 'like this'. */
4234 STRAIGHT_QUOTING_STYLE
4236 extern enum text_quoting_style
text_quoting_style (void);
4237 extern Lisp_Object
read_doc_string (Lisp_Object
);
4238 extern Lisp_Object
get_doc_string (Lisp_Object
, bool, bool);
4239 extern void syms_of_doc (void);
4240 extern int read_bytecode_char (bool);
4242 /* Defined in bytecode.c. */
4243 extern void syms_of_bytecode (void);
4244 extern Lisp_Object
exec_byte_code (Lisp_Object
, Lisp_Object
, Lisp_Object
,
4245 Lisp_Object
, ptrdiff_t, Lisp_Object
*);
4246 extern Lisp_Object
get_byte_code_arity (Lisp_Object
);
4248 /* Defined in macros.c. */
4249 extern void init_macros (void);
4250 extern void syms_of_macros (void);
4252 /* Defined in undo.c. */
4253 extern void truncate_undo_list (struct buffer
*);
4254 extern void record_insert (ptrdiff_t, ptrdiff_t);
4255 extern void record_delete (ptrdiff_t, Lisp_Object
, bool);
4256 extern void record_first_change (void);
4257 extern void record_change (ptrdiff_t, ptrdiff_t);
4258 extern void record_property_change (ptrdiff_t, ptrdiff_t,
4259 Lisp_Object
, Lisp_Object
,
4261 extern void syms_of_undo (void);
4263 /* Defined in textprop.c. */
4264 extern void report_interval_modification (Lisp_Object
, Lisp_Object
);
4266 /* Defined in menu.c. */
4267 extern void syms_of_menu (void);
4269 /* Defined in xmenu.c. */
4270 extern void syms_of_xmenu (void);
4272 /* Defined in termchar.h. */
4273 struct tty_display_info
;
4275 /* Defined in sysdep.c. */
4276 #ifdef HAVE_PERSONALITY_ADDR_NO_RANDOMIZE
4277 extern bool disable_address_randomization (void);
4279 INLINE
bool disable_address_randomization (void) { return false; }
4281 extern int emacs_exec_file (char const *, char *const *, char *const *);
4282 extern void init_standard_fds (void);
4283 extern char *emacs_get_current_dir_name (void);
4284 extern void stuff_char (char c
);
4285 extern void init_foreground_group (void);
4286 extern void sys_subshell (void);
4287 extern void sys_suspend (void);
4288 extern void discard_tty_input (void);
4289 extern void init_sys_modes (struct tty_display_info
*);
4290 extern void reset_sys_modes (struct tty_display_info
*);
4291 extern void init_all_sys_modes (void);
4292 extern void reset_all_sys_modes (void);
4293 extern void child_setup_tty (int);
4294 extern void setup_pty (int);
4295 extern int set_window_size (int, int, int);
4296 extern EMACS_INT
get_random (void);
4297 extern void seed_random (void *, ptrdiff_t);
4298 extern void init_random (void);
4299 extern void emacs_backtrace (int);
4300 extern _Noreturn
void emacs_abort (void) NO_INLINE
;
4301 extern int emacs_open (const char *, int, int);
4302 extern int emacs_pipe (int[2]);
4303 extern int emacs_close (int);
4304 extern ptrdiff_t emacs_read (int, void *, ptrdiff_t);
4305 extern ptrdiff_t emacs_read_quit (int, void *, ptrdiff_t);
4306 extern ptrdiff_t emacs_write (int, void const *, ptrdiff_t);
4307 extern ptrdiff_t emacs_write_sig (int, void const *, ptrdiff_t);
4308 extern ptrdiff_t emacs_write_quit (int, void const *, ptrdiff_t);
4309 extern void emacs_perror (char const *);
4310 extern int renameat_noreplace (int, char const *, int, char const *);
4311 extern int str_collate (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
4313 /* Defined in filelock.c. */
4314 extern void lock_file (Lisp_Object
);
4315 extern void unlock_file (Lisp_Object
);
4316 extern void unlock_all_files (void);
4317 extern void unlock_buffer (struct buffer
*);
4318 extern void syms_of_filelock (void);
4320 /* Defined in sound.c. */
4321 extern void syms_of_sound (void);
4323 /* Defined in category.c. */
4324 extern void init_category_once (void);
4325 extern Lisp_Object
char_category_set (int);
4326 extern void syms_of_category (void);
4328 /* Defined in ccl.c. */
4329 extern void syms_of_ccl (void);
4331 /* Defined in dired.c. */
4332 extern void syms_of_dired (void);
4333 extern Lisp_Object
directory_files_internal (Lisp_Object
, Lisp_Object
,
4334 Lisp_Object
, Lisp_Object
,
4337 /* Defined in term.c. */
4338 extern int *char_ins_del_vector
;
4339 extern void syms_of_term (void);
4340 extern _Noreturn
void fatal (const char *msgid
, ...)
4341 ATTRIBUTE_FORMAT_PRINTF (1, 2);
4343 /* Defined in terminal.c. */
4344 extern void syms_of_terminal (void);
4346 /* Defined in font.c. */
4347 extern void syms_of_font (void);
4348 extern void init_font (void);
4350 #ifdef HAVE_WINDOW_SYSTEM
4351 /* Defined in fontset.c. */
4352 extern void syms_of_fontset (void);
4355 /* Defined in inotify.c */
4357 extern void syms_of_inotify (void);
4360 /* Defined in kqueue.c */
4362 extern void globals_of_kqueue (void);
4363 extern void syms_of_kqueue (void);
4366 /* Defined in gfilenotify.c */
4367 #ifdef HAVE_GFILENOTIFY
4368 extern void globals_of_gfilenotify (void);
4369 extern void syms_of_gfilenotify (void);
4372 #ifdef HAVE_W32NOTIFY
4373 /* Defined on w32notify.c. */
4374 extern void syms_of_w32notify (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 */
4403 /* Defined in xml.c. */
4404 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); \
4559 (buf) = xmalloc (alloca_nbytes); \
4560 arg_ = make_save_memory (buf, nelt); \
4561 sa_must_free = true; \
4562 record_unwind_protect (free_save_value, arg_); \
4566 /* Set BUF to point to an allocated array of NELT Lisp_Objects. */
4568 #define SAFE_ALLOCA_LISP(buf, nelt) SAFE_ALLOCA_LISP_EXTRA (buf, nelt, 0)
4571 /* If USE_STACK_LISP_OBJECTS, define macros that and functions that allocate
4572 block-scoped conses and strings. These objects are not
4573 managed by the garbage collector, so they are dangerous: passing them
4574 out of their scope (e.g., to user code) results in undefined behavior.
4575 Conversely, they have better performance because GC is not involved.
4577 This feature is experimental and requires careful debugging.
4578 Build with CPPFLAGS='-DUSE_STACK_LISP_OBJECTS=0' to disable it. */
4580 #if (!defined USE_STACK_LISP_OBJECTS \
4581 && defined __GNUC__ && !defined __clang__ && ! GNUC_PREREQ (4, 3, 2))
4582 /* Work around GCC bugs 36584 and 35271, which were fixed in GCC 4.3.2. */
4583 # define USE_STACK_LISP_OBJECTS false
4585 #ifndef USE_STACK_LISP_OBJECTS
4586 # define USE_STACK_LISP_OBJECTS true
4589 #ifdef GC_CHECK_STRING_BYTES
4590 enum { defined_GC_CHECK_STRING_BYTES
= true };
4592 enum { defined_GC_CHECK_STRING_BYTES
= false };
4595 /* Struct inside unions that are typically no larger and aligned enough. */
4600 double d
; intmax_t i
; void *p
;
4603 union Aligned_String
4605 struct Lisp_String s
;
4606 double d
; intmax_t i
; void *p
;
4609 /* True for stack-based cons and string implementations, respectively.
4610 Use stack-based strings only if stack-based cons also works.
4611 Otherwise, STACK_CONS would create heap-based cons cells that
4612 could point to stack-based strings, which is a no-no. */
4616 USE_STACK_CONS
= (USE_STACK_LISP_OBJECTS
4617 && alignof (union Aligned_Cons
) % GCALIGNMENT
== 0),
4618 USE_STACK_STRING
= (USE_STACK_CONS
4619 && !defined_GC_CHECK_STRING_BYTES
4620 && alignof (union Aligned_String
) % GCALIGNMENT
== 0)
4623 /* Auxiliary macros used for auto allocation of Lisp objects. Please
4624 use these only in macros like AUTO_CONS that declare a local
4625 variable whose lifetime will be clear to the programmer. */
4626 #define STACK_CONS(a, b) \
4627 make_lisp_ptr (&((union Aligned_Cons) { { a, { b } } }).s, Lisp_Cons)
4628 #define AUTO_CONS_EXPR(a, b) \
4629 (USE_STACK_CONS ? STACK_CONS (a, b) : Fcons (a, b))
4631 /* Declare NAME as an auto Lisp cons or short list if possible, a
4632 GC-based one otherwise. This is in the sense of the C keyword
4633 'auto'; i.e., the object has the lifetime of the containing block.
4634 The resulting object should not be made visible to user Lisp code. */
4636 #define AUTO_CONS(name, a, b) Lisp_Object name = AUTO_CONS_EXPR (a, b)
4637 #define AUTO_LIST1(name, a) \
4638 Lisp_Object name = (USE_STACK_CONS ? STACK_CONS (a, Qnil) : list1 (a))
4639 #define AUTO_LIST2(name, a, b) \
4640 Lisp_Object name = (USE_STACK_CONS \
4641 ? STACK_CONS (a, STACK_CONS (b, Qnil)) \
4643 #define AUTO_LIST3(name, a, b, c) \
4644 Lisp_Object name = (USE_STACK_CONS \
4645 ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c, Qnil))) \
4647 #define AUTO_LIST4(name, a, b, c, d) \
4650 ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c, \
4651 STACK_CONS (d, Qnil)))) \
4652 : list4 (a, b, c, d))
4654 /* Declare NAME as an auto Lisp string if possible, a GC-based one if not.
4655 Take its unibyte value from the null-terminated string STR,
4656 an expression that should not have side effects.
4657 STR's value is not necessarily copied. The resulting Lisp string
4658 should not be modified or made visible to user code. */
4660 #define AUTO_STRING(name, str) \
4661 AUTO_STRING_WITH_LEN (name, str, strlen (str))
4663 /* Declare NAME as an auto Lisp string if possible, a GC-based one if not.
4664 Take its unibyte value from the null-terminated string STR with length LEN.
4665 STR may have side effects and may contain null bytes.
4666 STR's value is not necessarily copied. The resulting Lisp string
4667 should not be modified or made visible to user code. */
4669 #define AUTO_STRING_WITH_LEN(name, str, len) \
4670 Lisp_Object name = \
4673 ((&((union Aligned_String) {{len, -1, 0, (unsigned char *) (str)}}).s), \
4675 : make_unibyte_string (str, len))
4677 /* Loop over conses of the list TAIL, signaling if a cycle is found,
4678 and possibly quitting after each loop iteration. In the loop body,
4679 set TAIL to the current cons. If the loop exits normally,
4680 set TAIL to the terminating non-cons, typically nil. The loop body
4681 should not modify the list’s top level structure other than by
4682 perhaps deleting the current cons. */
4684 #define FOR_EACH_TAIL(tail) \
4685 FOR_EACH_TAIL_INTERNAL (tail, circular_list (tail), true)
4687 /* Like FOR_EACH_TAIL (LIST), except do not signal or quit.
4688 If the loop exits due to a cycle, TAIL’s value is undefined. */
4690 #define FOR_EACH_TAIL_SAFE(tail) \
4691 FOR_EACH_TAIL_INTERNAL (tail, (void) ((tail) = Qnil), false)
4693 /* Iterator intended for use only within FOR_EACH_TAIL_INTERNAL. */
4694 struct for_each_tail_internal
4696 Lisp_Object tortoise
;
4698 unsigned short int q
;
4701 /* Like FOR_EACH_TAIL (LIST), except evaluate CYCLE if a cycle is
4702 found, and check for quit if CHECK_QUIT. This is an internal macro
4703 intended for use only by the above macros.
4705 Use Brent’s teleporting tortoise-hare algorithm. See:
4706 Brent RP. BIT. 1980;20(2):176-84. doi:10.1007/BF01933190
4707 http://maths-people.anu.edu.au/~brent/pd/rpb051i.pdf
4709 This macro uses maybe_quit because of an excess of caution. The
4710 call to maybe_quit should not be needed in practice, as a very long
4711 list, whether circular or not, will cause Emacs to be so slow in
4712 other uninterruptible areas (e.g., garbage collection) that there
4713 is little point to calling maybe_quit here. */
4715 #define FOR_EACH_TAIL_INTERNAL(tail, cycle, check_quit) \
4716 for (struct for_each_tail_internal li = { tail, 2, 0, 2 }; \
4718 ((tail) = XCDR (tail), \
4720 || ((check_quit) ? maybe_quit () : (void) 0, 0 < --li.n) \
4721 || (li.q = li.n = li.max <<= 1, li.n >>= USHRT_WIDTH, \
4722 li.tortoise = (tail), false)) \
4723 && EQ (tail, li.tortoise)) \
4724 ? (cycle) : (void) 0))
4726 /* Do a `for' loop over alist values. */
4728 #define FOR_EACH_ALIST_VALUE(head_var, list_var, value_var) \
4729 for ((list_var) = (head_var); \
4730 (CONSP (list_var) && ((value_var) = XCDR (XCAR (list_var)), true)); \
4731 (list_var) = XCDR (list_var))
4733 /* Check whether it's time for GC, and run it if so. */
4738 if ((consing_since_gc
> gc_cons_threshold
4739 && consing_since_gc
> gc_relative_threshold
)
4740 || (!NILP (Vmemory_full
)
4741 && consing_since_gc
> memory_full_cons_threshold
))
4742 Fgarbage_collect ();
4747 #endif /* EMACS_LISP_H */