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 <http://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
103 # error "INTPTR_MAX too large"
107 /* Number of bits to put in each character in the internal representation
108 of bool vectors. This should not vary across implementations. */
109 enum { BOOL_VECTOR_BITS_PER_CHAR
=
110 #define BOOL_VECTOR_BITS_PER_CHAR 8
111 BOOL_VECTOR_BITS_PER_CHAR
114 /* An unsigned integer type representing a fixed-length bit sequence,
115 suitable for bool vector words, GC mark bits, etc. Normally it is size_t
116 for speed, but on weird platforms it is unsigned char and not all
117 its bits are used. */
118 #if BOOL_VECTOR_BITS_PER_CHAR == CHAR_BIT
119 typedef size_t bits_word
;
120 # define BITS_WORD_MAX SIZE_MAX
121 enum { BITS_PER_BITS_WORD
= SIZE_WIDTH
};
123 typedef unsigned char bits_word
;
124 # define BITS_WORD_MAX ((1u << BOOL_VECTOR_BITS_PER_CHAR) - 1)
125 enum { BITS_PER_BITS_WORD
= BOOL_VECTOR_BITS_PER_CHAR
};
127 verify (BITS_WORD_MAX
>> (BITS_PER_BITS_WORD
- 1) == 1);
129 /* printmax_t and uprintmax_t are types for printing large integers.
130 These are the widest integers that are supported for printing.
131 pMd etc. are conversions for printing them.
132 On C99 hosts, there's no problem, as even the widest integers work.
133 Fall back on EMACS_INT on pre-C99 hosts. */
135 typedef intmax_t printmax_t
;
136 typedef uintmax_t uprintmax_t
;
140 typedef EMACS_INT printmax_t
;
141 typedef EMACS_UINT uprintmax_t
;
146 /* Use pD to format ptrdiff_t values, which suffice for indexes into
147 buffers and strings. Emacs never allocates objects larger than
148 PTRDIFF_MAX bytes, as they cause problems with pointer subtraction.
149 In C99, pD can always be "t"; configure it here for the sake of
150 pre-C99 libraries such as glibc 2.0 and Solaris 8. */
151 #if PTRDIFF_MAX == INT_MAX
153 #elif PTRDIFF_MAX == LONG_MAX
155 #elif PTRDIFF_MAX == LLONG_MAX
161 /* Extra internal type checking? */
163 /* Define Emacs versions of <assert.h>'s 'assert (COND)' and <verify.h>'s
164 'assume (COND)'. COND should be free of side effects, as it may or
165 may not be evaluated.
167 'eassert (COND)' checks COND at runtime if ENABLE_CHECKING is
168 defined and suppress_checking is false, and does nothing otherwise.
169 Emacs dies if COND is checked and is false. The suppress_checking
170 variable is initialized to 0 in alloc.c. Set it to 1 using a
171 debugger to temporarily disable aborting on detected internal
172 inconsistencies or error conditions.
174 In some cases, a good compiler may be able to optimize away the
175 eassert macro even if ENABLE_CHECKING is true, e.g., if XSTRING (x)
176 uses eassert to test STRINGP (x), but a particular use of XSTRING
177 is invoked only after testing that STRINGP (x) is true, making the
180 eassume is like eassert except that it also causes the compiler to
181 assume that COND is true afterwards, regardless of whether runtime
182 checking is enabled. This can improve performance in some cases,
183 though it can degrade performance in others. It's often suboptimal
184 for COND to call external functions or access volatile storage. */
186 #ifndef ENABLE_CHECKING
187 # define eassert(cond) ((void) (false && (cond))) /* Check COND compiles. */
188 # define eassume(cond) assume (cond)
189 #else /* ENABLE_CHECKING */
191 extern _Noreturn
void die (const char *, const char *, int);
193 extern bool suppress_checking EXTERNALLY_VISIBLE
;
195 # define eassert(cond) \
196 (suppress_checking || (cond) \
198 : die (# cond, __FILE__, __LINE__))
199 # define eassume(cond) \
204 : die (# cond, __FILE__, __LINE__))
205 #endif /* ENABLE_CHECKING */
208 /* Use the configure flag --enable-check-lisp-object-type to make
209 Lisp_Object use a struct type instead of the default int. The flag
210 causes CHECK_LISP_OBJECT_TYPE to be defined. */
212 /***** Select the tagging scheme. *****/
213 /* The following option controls the tagging scheme:
214 - USE_LSB_TAG means that we can assume the least 3 bits of pointers are
215 always 0, and we can thus use them to hold tag bits, without
216 restricting our addressing space.
218 If ! USE_LSB_TAG, then use the top 3 bits for tagging, thus
219 restricting our possible address range.
221 USE_LSB_TAG not only requires the least 3 bits of pointers returned by
222 malloc to be 0 but also needs to be able to impose a mult-of-8 alignment
223 on the few static Lisp_Objects used: lispsym, all the defsubr, and
224 the two special buffers buffer_defaults and buffer_local_symbols. */
228 /* 2**GCTYPEBITS. This must be a macro that expands to a literal
229 integer constant, for MSVC. */
230 #define GCALIGNMENT 8
232 /* Number of bits in a Lisp_Object value, not counting the tag. */
233 VALBITS
= EMACS_INT_WIDTH
- GCTYPEBITS
,
235 /* Number of bits in a Lisp fixnum tag. */
236 INTTYPEBITS
= GCTYPEBITS
- 1,
238 /* Number of bits in a Lisp fixnum value, not counting the tag. */
239 FIXNUM_BITS
= VALBITS
+ 1
242 #if GCALIGNMENT != 1 << GCTYPEBITS
243 # error "GCALIGNMENT and GCTYPEBITS are inconsistent"
246 /* The maximum value that can be stored in a EMACS_INT, assuming all
247 bits other than the type bits contribute to a nonnegative signed value.
248 This can be used in #if, e.g., '#if USE_LSB_TAG' below expands to an
249 expression involving VAL_MAX. */
250 #define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1))
252 /* Whether the least-significant bits of an EMACS_INT contain the tag.
253 On hosts where pointers-as-ints do not exceed VAL_MAX / 2, USE_LSB_TAG is:
254 a. unnecessary, because the top bits of an EMACS_INT are unused, and
255 b. slower, because it typically requires extra masking.
256 So, USE_LSB_TAG is true only on hosts where it might be useful. */
257 DEFINE_GDB_SYMBOL_BEGIN (bool, USE_LSB_TAG
)
258 #define USE_LSB_TAG (VAL_MAX / 2 < INTPTR_MAX)
259 DEFINE_GDB_SYMBOL_END (USE_LSB_TAG
)
261 /* Mask for the value (as opposed to the type bits) of a Lisp object. */
262 DEFINE_GDB_SYMBOL_BEGIN (EMACS_INT
, VALMASK
)
263 # define VALMASK (USE_LSB_TAG ? - (1 << GCTYPEBITS) : VAL_MAX)
264 DEFINE_GDB_SYMBOL_END (VALMASK
)
266 #if !USE_LSB_TAG && !defined WIDE_EMACS_INT
267 # error "USE_LSB_TAG not supported on this platform; please report this." \
268 "Try 'configure --with-wide-int' to work around the problem."
272 #ifdef HAVE_STRUCT_ATTRIBUTE_ALIGNED
273 # define GCALIGNED __attribute__ ((aligned (GCALIGNMENT)))
275 # define GCALIGNED /* empty */
278 /* Some operations are so commonly executed that they are implemented
279 as macros, not functions, because otherwise runtime performance would
280 suffer too much when compiling with GCC without optimization.
281 There's no need to inline everything, just the operations that
282 would otherwise cause a serious performance problem.
284 For each such operation OP, define a macro lisp_h_OP that contains
285 the operation's implementation. That way, OP can be implemented
286 via a macro definition like this:
288 #define OP(x) lisp_h_OP (x)
290 and/or via a function definition like this:
292 Lisp_Object (OP) (Lisp_Object x) { return lisp_h_OP (x); }
294 without worrying about the implementations diverging, since
295 lisp_h_OP defines the actual implementation. The lisp_h_OP macros
296 are intended to be private to this include file, and should not be
299 FIXME: Remove the lisp_h_OP macros, and define just the inline OP
300 functions, once "gcc -Og" (new to GCC 4.8) works well enough for
301 Emacs developers. Maybe in the year 2020. See Bug#11935.
303 Commentary for these macros can be found near their corresponding
306 #if CHECK_LISP_OBJECT_TYPE
307 # define lisp_h_XLI(o) ((o).i)
308 # define lisp_h_XIL(i) ((Lisp_Object) { i })
310 # define lisp_h_XLI(o) (o)
311 # define lisp_h_XIL(i) (i)
313 #define lisp_h_CHECK_NUMBER(x) CHECK_TYPE (INTEGERP (x), Qintegerp, x)
314 #define lisp_h_CHECK_SYMBOL(x) CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
315 #define lisp_h_CHECK_TYPE(ok, predicate, x) \
316 ((ok) ? (void) 0 : wrong_type_argument (predicate, x))
317 #define lisp_h_CONSP(x) (XTYPE (x) == Lisp_Cons)
318 #define lisp_h_EQ(x, y) (XLI (x) == XLI (y))
319 #define lisp_h_FLOATP(x) (XTYPE (x) == Lisp_Float)
320 #define lisp_h_INTEGERP(x) ((XTYPE (x) & (Lisp_Int0 | ~Lisp_Int1)) == Lisp_Int0)
321 #define lisp_h_MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
322 #define lisp_h_MISCP(x) (XTYPE (x) == Lisp_Misc)
323 #define lisp_h_NILP(x) EQ (x, Qnil)
324 #define lisp_h_SET_SYMBOL_VAL(sym, v) \
325 (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v))
326 #define lisp_h_SYMBOL_CONSTANT_P(sym) (XSYMBOL (sym)->trapped_write == SYMBOL_NOWRITE)
327 #define lisp_h_SYMBOL_TRAPPED_WRITE_P(sym) (XSYMBOL (sym)->trapped_write)
328 #define lisp_h_SYMBOL_VAL(sym) \
329 (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value)
330 #define lisp_h_SYMBOLP(x) (XTYPE (x) == Lisp_Symbol)
331 #define lisp_h_VECTORLIKEP(x) (XTYPE (x) == Lisp_Vectorlike)
332 #define lisp_h_XCAR(c) XCONS (c)->car
333 #define lisp_h_XCDR(c) XCONS (c)->u.cdr
334 #define lisp_h_XCONS(a) \
335 (eassert (CONSP (a)), (struct Lisp_Cons *) XUNTAG (a, Lisp_Cons))
336 #define lisp_h_XHASH(a) XUINT (a)
337 #ifndef GC_CHECK_CONS_LIST
338 # define lisp_h_check_cons_list() ((void) 0)
341 # define lisp_h_make_number(n) \
342 XIL ((EMACS_INT) (((EMACS_UINT) (n) << INTTYPEBITS) + Lisp_Int0))
343 # define lisp_h_XFASTINT(a) XINT (a)
344 # define lisp_h_XINT(a) (XLI (a) >> INTTYPEBITS)
345 # define lisp_h_XSYMBOL(a) \
346 (eassert (SYMBOLP (a)), \
347 (struct Lisp_Symbol *) ((intptr_t) XLI (a) - Lisp_Symbol \
349 # define lisp_h_XTYPE(a) ((enum Lisp_Type) (XLI (a) & ~VALMASK))
350 # define lisp_h_XUNTAG(a, type) \
351 __builtin_assume_aligned ((void *) (intptr_t) (XLI (a) - (type)), \
355 /* When compiling via gcc -O0, define the key operations as macros, as
356 Emacs is too slow otherwise. To disable this optimization, compile
357 with -DINLINING=false. */
358 #if (defined __NO_INLINE__ \
359 && ! defined __OPTIMIZE__ && ! defined __OPTIMIZE_SIZE__ \
360 && ! (defined INLINING && ! INLINING))
361 # define DEFINE_KEY_OPS_AS_MACROS true
363 # define DEFINE_KEY_OPS_AS_MACROS false
366 #if DEFINE_KEY_OPS_AS_MACROS
367 # define XLI(o) lisp_h_XLI (o)
368 # define XIL(i) lisp_h_XIL (i)
369 # define CHECK_NUMBER(x) lisp_h_CHECK_NUMBER (x)
370 # define CHECK_SYMBOL(x) lisp_h_CHECK_SYMBOL (x)
371 # define CHECK_TYPE(ok, predicate, x) lisp_h_CHECK_TYPE (ok, predicate, x)
372 # define CONSP(x) lisp_h_CONSP (x)
373 # define EQ(x, y) lisp_h_EQ (x, y)
374 # define FLOATP(x) lisp_h_FLOATP (x)
375 # define INTEGERP(x) lisp_h_INTEGERP (x)
376 # define MARKERP(x) lisp_h_MARKERP (x)
377 # define MISCP(x) lisp_h_MISCP (x)
378 # define NILP(x) lisp_h_NILP (x)
379 # define SET_SYMBOL_VAL(sym, v) lisp_h_SET_SYMBOL_VAL (sym, v)
380 # define SYMBOL_CONSTANT_P(sym) lisp_h_SYMBOL_CONSTANT_P (sym)
381 # define SYMBOL_TRAPPED_WRITE_P(sym) lisp_h_SYMBOL_TRAPPED_WRITE_P (sym)
382 # define SYMBOL_VAL(sym) lisp_h_SYMBOL_VAL (sym)
383 # define SYMBOLP(x) lisp_h_SYMBOLP (x)
384 # define VECTORLIKEP(x) lisp_h_VECTORLIKEP (x)
385 # define XCAR(c) lisp_h_XCAR (c)
386 # define XCDR(c) lisp_h_XCDR (c)
387 # define XCONS(a) lisp_h_XCONS (a)
388 # define XHASH(a) lisp_h_XHASH (a)
389 # ifndef GC_CHECK_CONS_LIST
390 # define check_cons_list() lisp_h_check_cons_list ()
393 # define make_number(n) lisp_h_make_number (n)
394 # define XFASTINT(a) lisp_h_XFASTINT (a)
395 # define XINT(a) lisp_h_XINT (a)
396 # define XSYMBOL(a) lisp_h_XSYMBOL (a)
397 # define XTYPE(a) lisp_h_XTYPE (a)
398 # define XUNTAG(a, type) lisp_h_XUNTAG (a, type)
403 /* Define the fundamental Lisp data structures. */
405 /* This is the set of Lisp data types. If you want to define a new
406 data type, read the comments after Lisp_Fwd_Type definition
409 /* Lisp integers use 2 tags, to give them one extra bit, thus
410 extending their range from, e.g., -2^28..2^28-1 to -2^29..2^29-1. */
411 #define INTMASK (EMACS_INT_MAX >> (INTTYPEBITS - 1))
412 #define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
414 /* Idea stolen from GDB. Pedantic GCC complains about enum bitfields,
415 MSVC doesn't support them, and xlc and Oracle Studio c99 complain
416 vociferously about them. */
417 #if (defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__ \
418 || (defined __SUNPRO_C && __STDC__))
419 #define ENUM_BF(TYPE) unsigned int
421 #define ENUM_BF(TYPE) enum TYPE
427 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
430 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
431 whose first member indicates the subtype. */
434 /* Integer. XINT (obj) is the integer value. */
436 Lisp_Int1
= USE_LSB_TAG
? 6 : 3,
438 /* String. XSTRING (object) points to a struct Lisp_String.
439 The length of the string, and its contents, are stored therein. */
442 /* Vector of Lisp objects, or something resembling it.
443 XVECTOR (object) points to a struct Lisp_Vector, which contains
444 the size and contents. The size field also contains the type
445 information, if it's not a real vector object. */
448 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
449 Lisp_Cons
= USE_LSB_TAG
? 3 : 6,
454 /* This is the set of data types that share a common structure.
455 The first member of the structure is a type code from this set.
456 The enum values are arbitrary, but we'll use large numbers to make it
457 more likely that we'll spot the error if a random word in memory is
458 mistakenly interpreted as a Lisp_Misc. */
461 Lisp_Misc_Free
= 0x5eab,
464 Lisp_Misc_Save_Value
,
469 /* Currently floats are not a misc type,
470 but let's define this in case we want to change that. */
472 /* This is not a type code. It is for range checking. */
476 /* These are the types of forwarding objects used in the value slot
477 of symbols for special built-in variables whose value is stored in
481 Lisp_Fwd_Int
, /* Fwd to a C `int' variable. */
482 Lisp_Fwd_Bool
, /* Fwd to a C boolean var. */
483 Lisp_Fwd_Obj
, /* Fwd to a C Lisp_Object variable. */
484 Lisp_Fwd_Buffer_Obj
, /* Fwd to a Lisp_Object field of buffers. */
485 Lisp_Fwd_Kboard_Obj
/* Fwd to a Lisp_Object field of kboards. */
488 /* If you want to define a new Lisp data type, here are some
489 instructions. See the thread at
490 http://lists.gnu.org/archive/html/emacs-devel/2012-10/msg00561.html
493 First, there are already a couple of Lisp types that can be used if
494 your new type does not need to be exposed to Lisp programs nor
495 displayed to users. These are Lisp_Save_Value, a Lisp_Misc
496 subtype; and PVEC_OTHER, a kind of vectorlike object. The former
497 is suitable for temporarily stashing away pointers and integers in
498 a Lisp object. The latter is useful for vector-like Lisp objects
499 that need to be used as part of other objects, but which are never
500 shown to users or Lisp code (search for PVEC_OTHER in xterm.c for
503 These two types don't look pretty when printed, so they are
504 unsuitable for Lisp objects that can be exposed to users.
506 To define a new data type, add one more Lisp_Misc subtype or one
507 more pseudovector subtype. Pseudovectors are more suitable for
508 objects with several slots that need to support fast random access,
509 while Lisp_Misc types are for everything else. A pseudovector object
510 provides one or more slots for Lisp objects, followed by struct
511 members that are accessible only from C. A Lisp_Misc object is a
512 wrapper for a C struct that can contain anything you like.
514 Explicit freeing is discouraged for Lisp objects in general. But if
515 you really need to exploit this, use Lisp_Misc (check free_misc in
516 alloc.c to see why). There is no way to free a vectorlike object.
518 To add a new pseudovector type, extend the pvec_type enumeration;
519 to add a new Lisp_Misc, extend the Lisp_Misc_Type enumeration.
521 For a Lisp_Misc, you will also need to add your entry to union
522 Lisp_Misc, but make sure the first word has the same structure as
523 the others, starting with a 16-bit member of the Lisp_Misc_Type
524 enumeration and a 1-bit GC markbit. Also make sure the overall
525 size of the union is not increased by your addition. The latter
526 requirement is to keep Lisp_Misc objects small enough, so they
527 are handled faster: since all Lisp_Misc types use the same space,
528 enlarging any of them will affect all the rest. If you really
529 need a larger object, it is best to use Lisp_Vectorlike instead.
531 For a new pseudovector, it's highly desirable to limit the size
532 of your data type by VBLOCK_BYTES_MAX bytes (defined in alloc.c).
533 Otherwise you will need to change sweep_vectors (also in alloc.c).
535 Then you will need to add switch branches in print.c (in
536 print_object, to print your object, and possibly also in
537 print_preprocess) and to alloc.c, to mark your object (in
538 mark_object) and to free it (in gc_sweep). The latter is also the
539 right place to call any code specific to your data type that needs
540 to run when the object is recycled -- e.g., free any additional
541 resources allocated for it that are not Lisp objects. You can even
542 make a pointer to the function that frees the resources a slot in
543 your object -- this way, the same object could be used to represent
544 several disparate C structures. */
546 #ifdef CHECK_LISP_OBJECT_TYPE
548 typedef struct Lisp_Object
{ EMACS_INT i
; } Lisp_Object
;
550 #define LISP_INITIALLY(i) {i}
552 #undef CHECK_LISP_OBJECT_TYPE
553 enum CHECK_LISP_OBJECT_TYPE
{ CHECK_LISP_OBJECT_TYPE
= true };
554 #else /* CHECK_LISP_OBJECT_TYPE */
556 /* If a struct type is not wanted, define Lisp_Object as just a number. */
558 typedef EMACS_INT Lisp_Object
;
559 #define LISP_INITIALLY(i) (i)
560 enum CHECK_LISP_OBJECT_TYPE
{ CHECK_LISP_OBJECT_TYPE
= false };
561 #endif /* CHECK_LISP_OBJECT_TYPE */
563 /* Forward declarations. */
565 /* Defined in this file. */
566 INLINE
void set_sub_char_table_contents (Lisp_Object
, ptrdiff_t,
569 /* Defined in chartab.c. */
570 extern Lisp_Object
char_table_ref (Lisp_Object
, int);
571 extern void char_table_set (Lisp_Object
, int, Lisp_Object
);
573 /* Defined in data.c. */
574 extern _Noreturn
void wrong_type_argument (Lisp_Object
, Lisp_Object
);
578 enum { might_dump
= false };
579 #elif defined DOUG_LEA_MALLOC
580 /* Defined in emacs.c. */
581 extern bool might_dump
;
583 /* True means Emacs has already been initialized.
584 Used during startup to detect startup of dumped Emacs. */
585 extern bool initialized
;
587 /* Defined in floatfns.c. */
588 extern double extract_float (Lisp_Object
);
591 /* Low-level conversion and type checking. */
593 /* Convert a Lisp_Object to the corresponding EMACS_INT and vice versa.
594 At the machine level, these operations are no-ops. */
597 (XLI
) (Lisp_Object o
)
599 return lisp_h_XLI (o
);
605 return lisp_h_XIL (i
);
608 /* Extract A's type. */
610 INLINE
enum Lisp_Type
611 (XTYPE
) (Lisp_Object a
)
614 return lisp_h_XTYPE (a
);
616 EMACS_UINT i
= XLI (a
);
617 return USE_LSB_TAG
? i
& ~VALMASK
: i
>> VALBITS
;
622 (CHECK_TYPE
) (int ok
, Lisp_Object predicate
, Lisp_Object x
)
624 lisp_h_CHECK_TYPE (ok
, predicate
, x
);
627 /* Extract A's pointer value, assuming A's type is TYPE. */
630 (XUNTAG
) (Lisp_Object a
, int type
)
633 return lisp_h_XUNTAG (a
, type
);
635 intptr_t i
= USE_LSB_TAG
? XLI (a
) - type
: XLI (a
) & VALMASK
;
641 /* Interned state of a symbol. */
645 SYMBOL_UNINTERNED
= 0,
647 SYMBOL_INTERNED_IN_INITIAL_OBARRAY
= 2
654 SYMBOL_LOCALIZED
= 2,
658 enum symbol_trapped_write
660 SYMBOL_UNTRAPPED_WRITE
= 0,
662 SYMBOL_TRAPPED_WRITE
= 2
667 bool_bf gcmarkbit
: 1;
669 /* Indicates where the value can be found:
670 0 : it's a plain var, the value is in the `value' field.
671 1 : it's a varalias, the value is really in the `alias' symbol.
672 2 : it's a localized var, the value is in the `blv' object.
673 3 : it's a forwarding variable, the value is in `forward'. */
674 ENUM_BF (symbol_redirect
) redirect
: 3;
676 /* 0 : normal case, just set the value
677 1 : constant, cannot set, e.g. nil, t, :keywords.
678 2 : trap the write, call watcher functions. */
679 ENUM_BF (symbol_trapped_write
) trapped_write
: 2;
681 /* Interned state of the symbol. This is an enumerator from
682 enum symbol_interned. */
683 unsigned interned
: 2;
685 /* True means that this variable has been explicitly declared
686 special (with `defvar' etc), and shouldn't be lexically bound. */
687 bool_bf declared_special
: 1;
689 /* True if pointed to from purespace and hence can't be GC'd. */
692 /* The symbol's name, as a Lisp string. */
695 /* Value of the symbol or Qunbound if unbound. Which alternative of the
696 union is used depends on the `redirect' field above. */
699 struct Lisp_Symbol
*alias
;
700 struct Lisp_Buffer_Local_Value
*blv
;
704 /* Function value of the symbol or Qnil if not fboundp. */
705 Lisp_Object function
;
707 /* The symbol's property list. */
710 /* Next symbol in obarray bucket, if the symbol is interned. */
711 struct Lisp_Symbol
*next
;
714 /* Declare a Lisp-callable function. The MAXARGS parameter has the same
715 meaning as in the DEFUN macro, and is used to construct a prototype. */
716 /* We can use the same trick as in the DEFUN macro to generate the
717 appropriate prototype. */
718 #define EXFUN(fnname, maxargs) \
719 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
721 /* Note that the weird token-substitution semantics of ANSI C makes
722 this work for MANY and UNEVALLED. */
723 #define DEFUN_ARGS_MANY (ptrdiff_t, Lisp_Object *)
724 #define DEFUN_ARGS_UNEVALLED (Lisp_Object)
725 #define DEFUN_ARGS_0 (void)
726 #define DEFUN_ARGS_1 (Lisp_Object)
727 #define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
728 #define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
729 #define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
730 #define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
732 #define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
733 Lisp_Object, Lisp_Object)
734 #define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
735 Lisp_Object, Lisp_Object, Lisp_Object)
736 #define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
737 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
739 /* Yield a signed integer that contains TAG along with PTR.
741 Sign-extend pointers when USE_LSB_TAG (this simplifies emacs-module.c),
742 and zero-extend otherwise (that’s a bit faster here).
743 Sign extension matters only when EMACS_INT is wider than a pointer. */
744 #define TAG_PTR(tag, ptr) \
746 ? (intptr_t) (ptr) + (tag) \
747 : (EMACS_INT) (((EMACS_UINT) (tag) << VALBITS) + (uintptr_t) (ptr)))
749 /* Yield an integer that contains a symbol tag along with OFFSET.
750 OFFSET should be the offset in bytes from 'lispsym' to the symbol. */
751 #define TAG_SYMOFFSET(offset) TAG_PTR (Lisp_Symbol, offset)
753 /* XLI_BUILTIN_LISPSYM (iQwhatever) is equivalent to
754 XLI (builtin_lisp_symbol (Qwhatever)),
755 except the former expands to an integer constant expression. */
756 #define XLI_BUILTIN_LISPSYM(iname) TAG_SYMOFFSET ((iname) * sizeof *lispsym)
758 /* LISPSYM_INITIALLY (Qfoo) is equivalent to Qfoo except it is
759 designed for use as an initializer, even for a constant initializer. */
760 #define LISPSYM_INITIALLY(name) LISP_INITIALLY (XLI_BUILTIN_LISPSYM (i##name))
762 /* Declare extern constants for Lisp symbols. These can be helpful
763 when using a debugger like GDB, on older platforms where the debug
764 format does not represent C macros. */
765 #define DEFINE_LISP_SYMBOL(name) \
766 DEFINE_GDB_SYMBOL_BEGIN (Lisp_Object, name) \
767 DEFINE_GDB_SYMBOL_END (LISPSYM_INITIALLY (name))
769 /* The index of the C-defined Lisp symbol SYM.
770 This can be used in a static initializer. */
771 #define SYMBOL_INDEX(sym) i##sym
773 /* By default, define macros for Qt, etc., as this leads to a bit
774 better performance in the core Emacs interpreter. A plugin can
775 define DEFINE_NON_NIL_Q_SYMBOL_MACROS to be false, to be portable to
776 other Emacs instances that assign different values to Qt, etc. */
777 #ifndef DEFINE_NON_NIL_Q_SYMBOL_MACROS
778 # define DEFINE_NON_NIL_Q_SYMBOL_MACROS true
783 /* Header of vector-like objects. This documents the layout constraints on
784 vectors and pseudovectors (objects of PVEC_xxx subtype). It also prevents
785 compilers from being fooled by Emacs's type punning: XSETPSEUDOVECTOR
786 and PSEUDOVECTORP cast their pointers to struct vectorlike_header *,
787 because when two such pointers potentially alias, a compiler won't
788 incorrectly reorder loads and stores to their size fields. See
790 struct vectorlike_header
792 /* The only field contains various pieces of information:
793 - The MSB (ARRAY_MARK_FLAG) holds the gcmarkbit.
794 - The next bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
795 vector (0) or a pseudovector (1).
796 - If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
797 of slots) of the vector.
798 - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
799 - a) pseudovector subtype held in PVEC_TYPE_MASK field;
800 - b) number of Lisp_Objects slots at the beginning of the object
801 held in PSEUDOVECTOR_SIZE_MASK field. These objects are always
803 - c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
804 measured in word_size units. Rest fields may also include
805 Lisp_Objects, but these objects usually needs some special treatment
807 There are some exceptions. For PVEC_FREE, b) is always zero. For
808 PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
809 Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
810 4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots. */
815 (SYMBOLP
) (Lisp_Object x
)
817 return lisp_h_SYMBOLP (x
);
820 INLINE
struct Lisp_Symbol
*
821 (XSYMBOL
) (Lisp_Object a
)
824 return lisp_h_XSYMBOL (a
);
826 eassert (SYMBOLP (a
));
827 intptr_t i
= (intptr_t) XUNTAG (a
, Lisp_Symbol
);
828 void *p
= (char *) lispsym
+ i
;
834 make_lisp_symbol (struct Lisp_Symbol
*sym
)
836 Lisp_Object a
= XIL (TAG_SYMOFFSET ((char *) sym
- (char *) lispsym
));
837 eassert (XSYMBOL (a
) == sym
);
842 builtin_lisp_symbol (int index
)
844 return make_lisp_symbol (lispsym
+ index
);
848 (CHECK_SYMBOL
) (Lisp_Object x
)
850 lisp_h_CHECK_SYMBOL (x
);
853 /* In the size word of a vector, this bit means the vector has been marked. */
855 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, ARRAY_MARK_FLAG
)
856 # define ARRAY_MARK_FLAG PTRDIFF_MIN
857 DEFINE_GDB_SYMBOL_END (ARRAY_MARK_FLAG
)
859 /* In the size word of a struct Lisp_Vector, this bit means it's really
860 some other vector-like object. */
861 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, PSEUDOVECTOR_FLAG
)
862 # define PSEUDOVECTOR_FLAG (PTRDIFF_MAX - PTRDIFF_MAX / 2)
863 DEFINE_GDB_SYMBOL_END (PSEUDOVECTOR_FLAG
)
865 /* In a pseudovector, the size field actually contains a word with one
866 PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
867 with PVEC_TYPE_MASK to indicate the actual type. */
879 PVEC_WINDOW_CONFIGURATION
,
881 PVEC_OTHER
, /* Should never be visible to Elisp code. */
887 PVEC_MODULE_FUNCTION
,
889 /* These should be last, check internal_equal to see why. */
894 PVEC_FONT
/* Should be last because it's used for range checking. */
899 /* For convenience, we also store the number of elements in these bits.
900 Note that this size is not necessarily the memory-footprint size, but
901 only the number of Lisp_Object fields (that need to be traced by GC).
902 The distinction is used, e.g., by Lisp_Process, which places extra
903 non-Lisp_Object fields at the end of the structure. */
904 PSEUDOVECTOR_SIZE_BITS
= 12,
905 PSEUDOVECTOR_SIZE_MASK
= (1 << PSEUDOVECTOR_SIZE_BITS
) - 1,
907 /* To calculate the memory footprint of the pseudovector, it's useful
908 to store the size of non-Lisp area in word_size units here. */
909 PSEUDOVECTOR_REST_BITS
= 12,
910 PSEUDOVECTOR_REST_MASK
= (((1 << PSEUDOVECTOR_REST_BITS
) - 1)
911 << PSEUDOVECTOR_SIZE_BITS
),
913 /* Used to extract pseudovector subtype information. */
914 PSEUDOVECTOR_AREA_BITS
= PSEUDOVECTOR_SIZE_BITS
+ PSEUDOVECTOR_REST_BITS
,
915 PVEC_TYPE_MASK
= 0x3f << PSEUDOVECTOR_AREA_BITS
918 /* These functions extract various sorts of values from a Lisp_Object.
919 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
920 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for
923 /* Largest and smallest representable fixnum values. These are the C
924 values. They are macros for use in static initializers. */
925 #define MOST_POSITIVE_FIXNUM (EMACS_INT_MAX >> INTTYPEBITS)
926 #define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_FIXNUM)
931 (make_number
) (EMACS_INT n
)
933 return lisp_h_make_number (n
);
937 (XINT
) (Lisp_Object a
)
939 return lisp_h_XINT (a
);
943 (XFASTINT
) (Lisp_Object a
)
945 EMACS_INT n
= lisp_h_XFASTINT (a
);
950 #else /* ! USE_LSB_TAG */
952 /* Although compiled only if ! USE_LSB_TAG, the following functions
953 also work when USE_LSB_TAG; this is to aid future maintenance when
954 the lisp_h_* macros are eventually removed. */
956 /* Make a Lisp integer representing the value of the low order
959 make_number (EMACS_INT n
)
961 EMACS_INT int0
= Lisp_Int0
;
965 n
= u
<< INTTYPEBITS
;
971 n
+= (int0
<< VALBITS
);
976 /* Extract A's value as a signed integer. */
980 EMACS_INT i
= XLI (a
);
984 i
= u
<< INTTYPEBITS
;
986 return i
>> INTTYPEBITS
;
989 /* Like XINT (A), but may be faster. A must be nonnegative.
990 If ! USE_LSB_TAG, this takes advantage of the fact that Lisp
991 integers have zero-bits in their tags. */
993 XFASTINT (Lisp_Object a
)
995 EMACS_INT int0
= Lisp_Int0
;
996 EMACS_INT n
= USE_LSB_TAG
? XINT (a
) : XLI (a
) - (int0
<< VALBITS
);
1001 #endif /* ! USE_LSB_TAG */
1003 /* Extract A's value as an unsigned integer. */
1005 XUINT (Lisp_Object a
)
1007 EMACS_UINT i
= XLI (a
);
1008 return USE_LSB_TAG
? i
>> INTTYPEBITS
: i
& INTMASK
;
1011 /* Return A's (Lisp-integer sized) hash. Happens to be like XUINT
1012 right now, but XUINT should only be applied to objects we know are
1016 (XHASH
) (Lisp_Object a
)
1018 return lisp_h_XHASH (a
);
1021 /* Like make_number (N), but may be faster. N must be in nonnegative range. */
1023 make_natnum (EMACS_INT n
)
1025 eassert (0 <= n
&& n
<= MOST_POSITIVE_FIXNUM
);
1026 EMACS_INT int0
= Lisp_Int0
;
1027 return USE_LSB_TAG
? make_number (n
) : XIL (n
+ (int0
<< VALBITS
));
1030 /* Return true if X and Y are the same object. */
1033 (EQ
) (Lisp_Object x
, Lisp_Object y
)
1035 return lisp_h_EQ (x
, y
);
1038 /* True if the possibly-unsigned integer I doesn't fit in a Lisp fixnum. */
1040 #define FIXNUM_OVERFLOW_P(i) \
1041 (! ((0 <= (i) || MOST_NEGATIVE_FIXNUM <= (i)) && (i) <= MOST_POSITIVE_FIXNUM))
1044 clip_to_bounds (ptrdiff_t lower
, EMACS_INT num
, ptrdiff_t upper
)
1046 return num
< lower
? lower
: num
<= upper
? num
: upper
;
1049 /* Construct a Lisp_Object from a value or address. */
1052 make_lisp_ptr (void *ptr
, enum Lisp_Type type
)
1054 Lisp_Object a
= XIL (TAG_PTR (type
, ptr
));
1055 eassert (XTYPE (a
) == type
&& XUNTAG (a
, type
) == ptr
);
1060 (INTEGERP
) (Lisp_Object x
)
1062 return lisp_h_INTEGERP (x
);
1065 #define XSETINT(a, b) ((a) = make_number (b))
1066 #define XSETFASTINT(a, b) ((a) = make_natnum (b))
1067 #define XSETCONS(a, b) ((a) = make_lisp_ptr (b, Lisp_Cons))
1068 #define XSETVECTOR(a, b) ((a) = make_lisp_ptr (b, Lisp_Vectorlike))
1069 #define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
1070 #define XSETSYMBOL(a, b) ((a) = make_lisp_symbol (b))
1071 #define XSETFLOAT(a, b) ((a) = make_lisp_ptr (b, Lisp_Float))
1072 #define XSETMISC(a, b) ((a) = make_lisp_ptr (b, Lisp_Misc))
1074 /* Pseudovector types. */
1076 #define XSETPVECTYPE(v, code) \
1077 ((v)->header.size |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS))
1078 #define XSETPVECTYPESIZE(v, code, lispsize, restsize) \
1079 ((v)->header.size = (PSEUDOVECTOR_FLAG \
1080 | ((code) << PSEUDOVECTOR_AREA_BITS) \
1081 | ((restsize) << PSEUDOVECTOR_SIZE_BITS) \
1084 /* The cast to struct vectorlike_header * avoids aliasing issues. */
1085 #define XSETPSEUDOVECTOR(a, b, code) \
1086 XSETTYPED_PSEUDOVECTOR (a, b, \
1087 (((struct vectorlike_header *) \
1088 XUNTAG (a, Lisp_Vectorlike)) \
1091 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code) \
1092 (XSETVECTOR (a, b), \
1093 eassert ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) \
1094 == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS))))
1096 #define XSETWINDOW_CONFIGURATION(a, b) \
1097 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
1098 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
1099 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
1100 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
1101 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
1102 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
1103 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
1104 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
1105 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
1106 #define XSETSUB_CHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUB_CHAR_TABLE))
1107 #define XSETTHREAD(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_THREAD))
1108 #define XSETMUTEX(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_MUTEX))
1109 #define XSETCONDVAR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CONDVAR))
1111 /* Efficiently convert a pointer to a Lisp object and back. The
1112 pointer is represented as a Lisp integer, so the garbage collector
1113 does not know about it. The pointer should not have both Lisp_Int1
1114 bits set, which makes this conversion inherently unportable. */
1117 XINTPTR (Lisp_Object a
)
1119 return XUNTAG (a
, Lisp_Int0
);
1123 make_pointer_integer (void *p
)
1125 Lisp_Object a
= XIL (TAG_PTR (Lisp_Int0
, p
));
1126 eassert (INTEGERP (a
) && XINTPTR (a
) == p
);
1130 /* See the macros in intervals.h. */
1132 typedef struct interval
*INTERVAL
;
1134 struct GCALIGNED Lisp_Cons
1136 /* Car of this cons cell. */
1141 /* Cdr of this cons cell. */
1144 /* Used to chain conses on a free list. */
1145 struct Lisp_Cons
*chain
;
1150 (NILP
) (Lisp_Object x
)
1152 return lisp_h_NILP (x
);
1156 (CONSP
) (Lisp_Object x
)
1158 return lisp_h_CONSP (x
);
1162 CHECK_CONS (Lisp_Object x
)
1164 CHECK_TYPE (CONSP (x
), Qconsp
, x
);
1167 INLINE
struct Lisp_Cons
*
1168 (XCONS
) (Lisp_Object a
)
1170 return lisp_h_XCONS (a
);
1173 /* Take the car or cdr of something known to be a cons cell. */
1174 /* The _addr functions shouldn't be used outside of the minimal set
1175 of code that has to know what a cons cell looks like. Other code not
1176 part of the basic lisp implementation should assume that the car and cdr
1177 fields are not accessible. (What if we want to switch to
1178 a copying collector someday? Cached cons cell field addresses may be
1179 invalidated at arbitrary points.) */
1180 INLINE Lisp_Object
*
1181 xcar_addr (Lisp_Object c
)
1183 return &XCONS (c
)->car
;
1185 INLINE Lisp_Object
*
1186 xcdr_addr (Lisp_Object c
)
1188 return &XCONS (c
)->u
.cdr
;
1191 /* Use these from normal code. */
1194 (XCAR
) (Lisp_Object c
)
1196 return lisp_h_XCAR (c
);
1200 (XCDR
) (Lisp_Object c
)
1202 return lisp_h_XCDR (c
);
1205 /* Use these to set the fields of a cons cell.
1207 Note that both arguments may refer to the same object, so 'n'
1208 should not be read after 'c' is first modified. */
1210 XSETCAR (Lisp_Object c
, Lisp_Object n
)
1215 XSETCDR (Lisp_Object c
, Lisp_Object n
)
1220 /* Take the car or cdr of something whose type is not known. */
1227 wrong_type_argument (Qlistp
, c
);
1236 wrong_type_argument (Qlistp
, c
);
1240 /* Take the car or cdr of something whose type is not known. */
1242 CAR_SAFE (Lisp_Object c
)
1244 return CONSP (c
) ? XCAR (c
) : Qnil
;
1247 CDR_SAFE (Lisp_Object c
)
1249 return CONSP (c
) ? XCDR (c
) : Qnil
;
1252 /* In a string or vector, the sign bit of the `size' is the gc mark bit. */
1254 struct GCALIGNED Lisp_String
1257 ptrdiff_t size_byte
;
1258 INTERVAL intervals
; /* Text properties in this string. */
1259 unsigned char *data
;
1263 STRINGP (Lisp_Object x
)
1265 return XTYPE (x
) == Lisp_String
;
1269 CHECK_STRING (Lisp_Object x
)
1271 CHECK_TYPE (STRINGP (x
), Qstringp
, x
);
1274 INLINE
struct Lisp_String
*
1275 XSTRING (Lisp_Object a
)
1277 eassert (STRINGP (a
));
1278 return XUNTAG (a
, Lisp_String
);
1281 /* True if STR is a multibyte string. */
1283 STRING_MULTIBYTE (Lisp_Object str
)
1285 return 0 <= XSTRING (str
)->size_byte
;
1288 /* An upper bound on the number of bytes in a Lisp string, not
1289 counting the terminating null. This a tight enough bound to
1290 prevent integer overflow errors that would otherwise occur during
1291 string size calculations. A string cannot contain more bytes than
1292 a fixnum can represent, nor can it be so long that C pointer
1293 arithmetic stops working on the string plus its terminating null.
1294 Although the actual size limit (see STRING_BYTES_MAX in alloc.c)
1295 may be a bit smaller than STRING_BYTES_BOUND, calculating it here
1296 would expose alloc.c internal details that we'd rather keep
1299 This is a macro for use in static initializers. The cast to
1300 ptrdiff_t ensures that the macro is signed. */
1301 #define STRING_BYTES_BOUND \
1302 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1))
1304 /* Mark STR as a unibyte string. */
1305 #define STRING_SET_UNIBYTE(STR) \
1307 if (XSTRING (STR)->size == 0) \
1308 (STR) = empty_unibyte_string; \
1310 XSTRING (STR)->size_byte = -1; \
1313 /* Mark STR as a multibyte string. Assure that STR contains only
1314 ASCII characters in advance. */
1315 #define STRING_SET_MULTIBYTE(STR) \
1317 if (XSTRING (STR)->size == 0) \
1318 (STR) = empty_multibyte_string; \
1320 XSTRING (STR)->size_byte = XSTRING (STR)->size; \
1323 /* Convenience functions for dealing with Lisp strings. */
1325 INLINE
unsigned char *
1326 SDATA (Lisp_Object string
)
1328 return XSTRING (string
)->data
;
1331 SSDATA (Lisp_Object string
)
1333 /* Avoid "differ in sign" warnings. */
1334 return (char *) SDATA (string
);
1336 INLINE
unsigned char
1337 SREF (Lisp_Object string
, ptrdiff_t index
)
1339 return SDATA (string
)[index
];
1342 SSET (Lisp_Object string
, ptrdiff_t index
, unsigned char new)
1344 SDATA (string
)[index
] = new;
1347 SCHARS (Lisp_Object string
)
1349 return XSTRING (string
)->size
;
1352 #ifdef GC_CHECK_STRING_BYTES
1353 extern ptrdiff_t string_bytes (struct Lisp_String
*);
1356 STRING_BYTES (struct Lisp_String
*s
)
1358 #ifdef GC_CHECK_STRING_BYTES
1359 return string_bytes (s
);
1361 return s
->size_byte
< 0 ? s
->size
: s
->size_byte
;
1366 SBYTES (Lisp_Object string
)
1368 return STRING_BYTES (XSTRING (string
));
1371 STRING_SET_CHARS (Lisp_Object string
, ptrdiff_t newsize
)
1373 /* This function cannot change the size of data allocated for the
1374 string when it was created. */
1375 eassert (STRING_MULTIBYTE (string
)
1376 ? newsize
<= SBYTES (string
)
1377 : newsize
== SCHARS (string
));
1378 XSTRING (string
)->size
= newsize
;
1381 /* A regular vector is just a header plus an array of Lisp_Objects. */
1385 struct vectorlike_header header
;
1386 Lisp_Object contents
[FLEXIBLE_ARRAY_MEMBER
];
1390 (VECTORLIKEP
) (Lisp_Object x
)
1392 return lisp_h_VECTORLIKEP (x
);
1395 INLINE
struct Lisp_Vector
*
1396 XVECTOR (Lisp_Object a
)
1398 eassert (VECTORLIKEP (a
));
1399 return XUNTAG (a
, Lisp_Vectorlike
);
1403 ASIZE (Lisp_Object array
)
1405 ptrdiff_t size
= XVECTOR (array
)->header
.size
;
1406 eassume (0 <= size
);
1411 PVSIZE (Lisp_Object pv
)
1413 return ASIZE (pv
) & PSEUDOVECTOR_SIZE_MASK
;
1417 VECTORP (Lisp_Object x
)
1419 return VECTORLIKEP (x
) && ! (ASIZE (x
) & PSEUDOVECTOR_FLAG
);
1423 CHECK_VECTOR (Lisp_Object x
)
1425 CHECK_TYPE (VECTORP (x
), Qvectorp
, x
);
1429 /* A pseudovector is like a vector, but has other non-Lisp components. */
1431 INLINE
enum pvec_type
1432 PSEUDOVECTOR_TYPE (struct Lisp_Vector
*v
)
1434 ptrdiff_t size
= v
->header
.size
;
1435 return (size
& PSEUDOVECTOR_FLAG
1436 ? (size
& PVEC_TYPE_MASK
) >> PSEUDOVECTOR_AREA_BITS
1437 : PVEC_NORMAL_VECTOR
);
1440 /* Can't be used with PVEC_NORMAL_VECTOR. */
1442 PSEUDOVECTOR_TYPEP (struct vectorlike_header
*a
, enum pvec_type code
)
1444 /* We don't use PSEUDOVECTOR_TYPE here so as to avoid a shift
1445 * operation when `code' is known. */
1446 return ((a
->size
& (PSEUDOVECTOR_FLAG
| PVEC_TYPE_MASK
))
1447 == (PSEUDOVECTOR_FLAG
| (code
<< PSEUDOVECTOR_AREA_BITS
)));
1450 /* True if A is a pseudovector whose code is CODE. */
1452 PSEUDOVECTORP (Lisp_Object a
, int code
)
1454 if (! VECTORLIKEP (a
))
1458 /* Converting to struct vectorlike_header * avoids aliasing issues. */
1459 struct vectorlike_header
*h
= XUNTAG (a
, Lisp_Vectorlike
);
1460 return PSEUDOVECTOR_TYPEP (h
, code
);
1464 /* A boolvector is a kind of vectorlike, with contents like a string. */
1466 struct Lisp_Bool_Vector
1468 /* HEADER.SIZE is the vector's size field. It doesn't have the real size,
1469 just the subtype information. */
1470 struct vectorlike_header header
;
1471 /* This is the size in bits. */
1473 /* The actual bits, packed into bytes.
1474 Zeros fill out the last word if needed.
1475 The bits are in little-endian order in the bytes, and
1476 the bytes are in little-endian order in the words. */
1477 bits_word data
[FLEXIBLE_ARRAY_MEMBER
];
1480 /* Some handy constants for calculating sizes
1481 and offsets, mostly of vectorlike objects. */
1485 header_size
= offsetof (struct Lisp_Vector
, contents
),
1486 bool_header_size
= offsetof (struct Lisp_Bool_Vector
, data
),
1487 word_size
= sizeof (Lisp_Object
)
1490 /* The number of data words and bytes in a bool vector with SIZE bits. */
1493 bool_vector_words (EMACS_INT size
)
1495 eassume (0 <= size
&& size
<= EMACS_INT_MAX
- (BITS_PER_BITS_WORD
- 1));
1496 return (size
+ BITS_PER_BITS_WORD
- 1) / BITS_PER_BITS_WORD
;
1500 bool_vector_bytes (EMACS_INT size
)
1502 eassume (0 <= size
&& size
<= EMACS_INT_MAX
- (BITS_PER_BITS_WORD
- 1));
1503 return (size
+ BOOL_VECTOR_BITS_PER_CHAR
- 1) / BOOL_VECTOR_BITS_PER_CHAR
;
1507 BOOL_VECTOR_P (Lisp_Object a
)
1509 return PSEUDOVECTORP (a
, PVEC_BOOL_VECTOR
);
1513 CHECK_BOOL_VECTOR (Lisp_Object x
)
1515 CHECK_TYPE (BOOL_VECTOR_P (x
), Qbool_vector_p
, x
);
1518 INLINE
struct Lisp_Bool_Vector
*
1519 XBOOL_VECTOR (Lisp_Object a
)
1521 eassert (BOOL_VECTOR_P (a
));
1522 return XUNTAG (a
, Lisp_Vectorlike
);
1526 bool_vector_size (Lisp_Object a
)
1528 EMACS_INT size
= XBOOL_VECTOR (a
)->size
;
1529 eassume (0 <= size
);
1534 bool_vector_data (Lisp_Object a
)
1536 return XBOOL_VECTOR (a
)->data
;
1539 INLINE
unsigned char *
1540 bool_vector_uchar_data (Lisp_Object a
)
1542 return (unsigned char *) bool_vector_data (a
);
1545 /* True if A's Ith bit is set. */
1548 bool_vector_bitref (Lisp_Object a
, EMACS_INT i
)
1550 eassume (0 <= i
&& i
< bool_vector_size (a
));
1551 return !! (bool_vector_uchar_data (a
)[i
/ BOOL_VECTOR_BITS_PER_CHAR
]
1552 & (1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
)));
1556 bool_vector_ref (Lisp_Object a
, EMACS_INT i
)
1558 return bool_vector_bitref (a
, i
) ? Qt
: Qnil
;
1561 /* Set A's Ith bit to B. */
1564 bool_vector_set (Lisp_Object a
, EMACS_INT i
, bool b
)
1566 unsigned char *addr
;
1568 eassume (0 <= i
&& i
< bool_vector_size (a
));
1569 addr
= &bool_vector_uchar_data (a
)[i
/ BOOL_VECTOR_BITS_PER_CHAR
];
1572 *addr
|= 1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
);
1574 *addr
&= ~ (1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
));
1577 /* Conveniences for dealing with Lisp arrays. */
1580 AREF (Lisp_Object array
, ptrdiff_t idx
)
1582 return XVECTOR (array
)->contents
[idx
];
1585 INLINE Lisp_Object
*
1586 aref_addr (Lisp_Object array
, ptrdiff_t idx
)
1588 return & XVECTOR (array
)->contents
[idx
];
1592 gc_asize (Lisp_Object array
)
1594 /* Like ASIZE, but also can be used in the garbage collector. */
1595 return XVECTOR (array
)->header
.size
& ~ARRAY_MARK_FLAG
;
1599 ASET (Lisp_Object array
, ptrdiff_t idx
, Lisp_Object val
)
1601 eassert (0 <= idx
&& idx
< ASIZE (array
));
1602 XVECTOR (array
)->contents
[idx
] = val
;
1606 gc_aset (Lisp_Object array
, ptrdiff_t idx
, Lisp_Object val
)
1608 /* Like ASET, but also can be used in the garbage collector:
1609 sweep_weak_table calls set_hash_key etc. while the table is marked. */
1610 eassert (0 <= idx
&& idx
< gc_asize (array
));
1611 XVECTOR (array
)->contents
[idx
] = val
;
1614 /* True, since Qnil's representation is zero. Every place in the code
1615 that assumes Qnil is zero should verify (NIL_IS_ZERO), to make it easy
1616 to find such assumptions later if we change Qnil to be nonzero. */
1617 enum { NIL_IS_ZERO
= XLI_BUILTIN_LISPSYM (iQnil
) == 0 };
1619 /* Clear the object addressed by P, with size NBYTES, so that all its
1620 bytes are zero and all its Lisp values are nil. */
1622 memclear (void *p
, ptrdiff_t nbytes
)
1624 eassert (0 <= nbytes
);
1625 verify (NIL_IS_ZERO
);
1626 /* Since Qnil is zero, memset suffices. */
1627 memset (p
, 0, nbytes
);
1630 /* If a struct is made to look like a vector, this macro returns the length
1631 of the shortest vector that would hold that struct. */
1633 #define VECSIZE(type) \
1634 ((sizeof (type) - header_size + word_size - 1) / word_size)
1636 /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields
1637 at the end and we need to compute the number of Lisp_Object fields (the
1638 ones that the GC needs to trace). */
1640 #define PSEUDOVECSIZE(type, nonlispfield) \
1641 ((offsetof (type, nonlispfield) - header_size) / word_size)
1643 /* Compute A OP B, using the unsigned comparison operator OP. A and B
1644 should be integer expressions. This is not the same as
1645 mathematical comparison; for example, UNSIGNED_CMP (0, <, -1)
1646 returns true. For efficiency, prefer plain unsigned comparison if A
1647 and B's sizes both fit (after integer promotion). */
1648 #define UNSIGNED_CMP(a, op, b) \
1649 (max (sizeof ((a) + 0), sizeof ((b) + 0)) <= sizeof (unsigned) \
1650 ? ((a) + (unsigned) 0) op ((b) + (unsigned) 0) \
1651 : ((a) + (uintmax_t) 0) op ((b) + (uintmax_t) 0))
1653 /* True iff C is an ASCII character. */
1654 #define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80)
1656 /* A char-table is a kind of vectorlike, with contents are like a
1657 vector but with a few other slots. For some purposes, it makes
1658 sense to handle a char-table with type struct Lisp_Vector. An
1659 element of a char table can be any Lisp objects, but if it is a sub
1660 char-table, we treat it a table that contains information of a
1661 specific range of characters. A sub char-table is like a vector but
1662 with two integer fields between the header and Lisp data, which means
1663 that it has to be marked with some precautions (see mark_char_table
1664 in alloc.c). A sub char-table appears only in an element of a char-table,
1665 and there's no way to access it directly from Emacs Lisp program. */
1667 enum CHARTAB_SIZE_BITS
1669 CHARTAB_SIZE_BITS_0
= 6,
1670 CHARTAB_SIZE_BITS_1
= 4,
1671 CHARTAB_SIZE_BITS_2
= 5,
1672 CHARTAB_SIZE_BITS_3
= 7
1675 extern const int chartab_size
[4];
1677 struct Lisp_Char_Table
1679 /* HEADER.SIZE is the vector's size field, which also holds the
1680 pseudovector type information. It holds the size, too.
1681 The size counts the defalt, parent, purpose, ascii,
1682 contents, and extras slots. */
1683 struct vectorlike_header header
;
1685 /* This holds a default value,
1686 which is used whenever the value for a specific character is nil. */
1689 /* This points to another char table, which we inherit from when the
1690 value for a specific character is nil. The `defalt' slot takes
1691 precedence over this. */
1694 /* This is a symbol which says what kind of use this char-table is
1696 Lisp_Object purpose
;
1698 /* The bottom sub char-table for characters of the range 0..127. It
1699 is nil if none of ASCII character has a specific value. */
1702 Lisp_Object contents
[(1 << CHARTAB_SIZE_BITS_0
)];
1704 /* These hold additional data. It is a vector. */
1705 Lisp_Object extras
[FLEXIBLE_ARRAY_MEMBER
];
1709 CHAR_TABLE_P (Lisp_Object a
)
1711 return PSEUDOVECTORP (a
, PVEC_CHAR_TABLE
);
1714 INLINE
struct Lisp_Char_Table
*
1715 XCHAR_TABLE (Lisp_Object a
)
1717 eassert (CHAR_TABLE_P (a
));
1718 return XUNTAG (a
, Lisp_Vectorlike
);
1721 struct Lisp_Sub_Char_Table
1723 /* HEADER.SIZE is the vector's size field, which also holds the
1724 pseudovector type information. It holds the size, too. */
1725 struct vectorlike_header header
;
1727 /* Depth of this sub char-table. It should be 1, 2, or 3. A sub
1728 char-table of depth 1 contains 16 elements, and each element
1729 covers 4096 (128*32) characters. A sub char-table of depth 2
1730 contains 32 elements, and each element covers 128 characters. A
1731 sub char-table of depth 3 contains 128 elements, and each element
1732 is for one character. */
1735 /* Minimum character covered by the sub char-table. */
1738 /* Use set_sub_char_table_contents to set this. */
1739 Lisp_Object contents
[FLEXIBLE_ARRAY_MEMBER
];
1743 SUB_CHAR_TABLE_P (Lisp_Object a
)
1745 return PSEUDOVECTORP (a
, PVEC_SUB_CHAR_TABLE
);
1748 INLINE
struct Lisp_Sub_Char_Table
*
1749 XSUB_CHAR_TABLE (Lisp_Object a
)
1751 eassert (SUB_CHAR_TABLE_P (a
));
1752 return XUNTAG (a
, Lisp_Vectorlike
);
1756 CHAR_TABLE_REF_ASCII (Lisp_Object ct
, ptrdiff_t idx
)
1758 struct Lisp_Char_Table
*tbl
= NULL
;
1762 tbl
= tbl
? XCHAR_TABLE (tbl
->parent
) : XCHAR_TABLE (ct
);
1763 val
= (! SUB_CHAR_TABLE_P (tbl
->ascii
) ? tbl
->ascii
1764 : XSUB_CHAR_TABLE (tbl
->ascii
)->contents
[idx
]);
1768 while (NILP (val
) && ! NILP (tbl
->parent
));
1773 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
1774 characters. Do not check validity of CT. */
1776 CHAR_TABLE_REF (Lisp_Object ct
, int idx
)
1778 return (ASCII_CHAR_P (idx
)
1779 ? CHAR_TABLE_REF_ASCII (ct
, idx
)
1780 : char_table_ref (ct
, idx
));
1783 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
1784 8-bit European characters. Do not check validity of CT. */
1786 CHAR_TABLE_SET (Lisp_Object ct
, int idx
, Lisp_Object val
)
1788 if (ASCII_CHAR_P (idx
) && SUB_CHAR_TABLE_P (XCHAR_TABLE (ct
)->ascii
))
1789 set_sub_char_table_contents (XCHAR_TABLE (ct
)->ascii
, idx
, val
);
1791 char_table_set (ct
, idx
, val
);
1794 /* This structure describes a built-in function.
1795 It is generated by the DEFUN macro only.
1796 defsubr makes it into a Lisp object. */
1800 struct vectorlike_header header
;
1802 Lisp_Object (*a0
) (void);
1803 Lisp_Object (*a1
) (Lisp_Object
);
1804 Lisp_Object (*a2
) (Lisp_Object
, Lisp_Object
);
1805 Lisp_Object (*a3
) (Lisp_Object
, Lisp_Object
, Lisp_Object
);
1806 Lisp_Object (*a4
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1807 Lisp_Object (*a5
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1808 Lisp_Object (*a6
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1809 Lisp_Object (*a7
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1810 Lisp_Object (*a8
) (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
1811 Lisp_Object (*aUNEVALLED
) (Lisp_Object args
);
1812 Lisp_Object (*aMANY
) (ptrdiff_t, Lisp_Object
*);
1814 short min_args
, max_args
;
1815 const char *symbol_name
;
1816 const char *intspec
;
1821 SUBRP (Lisp_Object a
)
1823 return PSEUDOVECTORP (a
, PVEC_SUBR
);
1826 INLINE
struct Lisp_Subr
*
1827 XSUBR (Lisp_Object a
)
1829 eassert (SUBRP (a
));
1830 return XUNTAG (a
, Lisp_Vectorlike
);
1833 enum char_table_specials
1835 /* This is the number of slots that every char table must have. This
1836 counts the ordinary slots and the top, defalt, parent, and purpose
1838 CHAR_TABLE_STANDARD_SLOTS
= PSEUDOVECSIZE (struct Lisp_Char_Table
, extras
),
1840 /* This is an index of first Lisp_Object field in Lisp_Sub_Char_Table
1841 when the latter is treated as an ordinary Lisp_Vector. */
1842 SUB_CHAR_TABLE_OFFSET
= PSEUDOVECSIZE (struct Lisp_Sub_Char_Table
, contents
)
1845 /* Return the number of "extra" slots in the char table CT. */
1848 CHAR_TABLE_EXTRA_SLOTS (struct Lisp_Char_Table
*ct
)
1850 return ((ct
->header
.size
& PSEUDOVECTOR_SIZE_MASK
)
1851 - CHAR_TABLE_STANDARD_SLOTS
);
1854 /* Make sure that sub char-table contents slot is where we think it is. */
1855 verify (offsetof (struct Lisp_Sub_Char_Table
, contents
)
1856 == (offsetof (struct Lisp_Vector
, contents
)
1857 + SUB_CHAR_TABLE_OFFSET
* sizeof (Lisp_Object
)));
1861 /***********************************************************************
1863 ***********************************************************************/
1865 /* Value is name of symbol. */
1868 (SYMBOL_VAL
) (struct Lisp_Symbol
*sym
)
1870 return lisp_h_SYMBOL_VAL (sym
);
1873 INLINE
struct Lisp_Symbol
*
1874 SYMBOL_ALIAS (struct Lisp_Symbol
*sym
)
1876 eassume (sym
->redirect
== SYMBOL_VARALIAS
&& sym
->val
.alias
);
1877 return sym
->val
.alias
;
1879 INLINE
struct Lisp_Buffer_Local_Value
*
1880 SYMBOL_BLV (struct Lisp_Symbol
*sym
)
1882 eassume (sym
->redirect
== SYMBOL_LOCALIZED
&& sym
->val
.blv
);
1883 return sym
->val
.blv
;
1885 INLINE
union Lisp_Fwd
*
1886 SYMBOL_FWD (struct Lisp_Symbol
*sym
)
1888 eassume (sym
->redirect
== SYMBOL_FORWARDED
&& sym
->val
.fwd
);
1889 return sym
->val
.fwd
;
1893 (SET_SYMBOL_VAL
) (struct Lisp_Symbol
*sym
, Lisp_Object v
)
1895 lisp_h_SET_SYMBOL_VAL (sym
, v
);
1899 SET_SYMBOL_ALIAS (struct Lisp_Symbol
*sym
, struct Lisp_Symbol
*v
)
1901 eassume (sym
->redirect
== SYMBOL_VARALIAS
&& v
);
1905 SET_SYMBOL_BLV (struct Lisp_Symbol
*sym
, struct Lisp_Buffer_Local_Value
*v
)
1907 eassume (sym
->redirect
== SYMBOL_LOCALIZED
&& v
);
1911 SET_SYMBOL_FWD (struct Lisp_Symbol
*sym
, union Lisp_Fwd
*v
)
1913 eassume (sym
->redirect
== SYMBOL_FORWARDED
&& v
);
1918 SYMBOL_NAME (Lisp_Object sym
)
1920 return XSYMBOL (sym
)->name
;
1923 /* Value is true if SYM is an interned symbol. */
1926 SYMBOL_INTERNED_P (Lisp_Object sym
)
1928 return XSYMBOL (sym
)->interned
!= SYMBOL_UNINTERNED
;
1931 /* Value is true if SYM is interned in initial_obarray. */
1934 SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P (Lisp_Object sym
)
1936 return XSYMBOL (sym
)->interned
== SYMBOL_INTERNED_IN_INITIAL_OBARRAY
;
1939 /* Value is non-zero if symbol cannot be changed through a simple set,
1940 i.e. it's a constant (e.g. nil, t, :keywords), or it has some
1941 watching functions. */
1944 (SYMBOL_TRAPPED_WRITE_P
) (Lisp_Object sym
)
1946 return lisp_h_SYMBOL_TRAPPED_WRITE_P (sym
);
1949 /* Value is non-zero if symbol cannot be changed at all, i.e. it's a
1950 constant (e.g. nil, t, :keywords). Code that actually wants to
1951 write to SYM, should also check whether there are any watching
1955 (SYMBOL_CONSTANT_P
) (Lisp_Object sym
)
1957 return lisp_h_SYMBOL_CONSTANT_P (sym
);
1960 /* Placeholder for make-docfile to process. The actual symbol
1961 definition is done by lread.c's defsym. */
1962 #define DEFSYM(sym, name) /* empty */
1965 /***********************************************************************
1967 ***********************************************************************/
1969 /* The structure of a Lisp hash table. */
1971 struct hash_table_test
1973 /* Name of the function used to compare keys. */
1976 /* User-supplied hash function, or nil. */
1977 Lisp_Object user_hash_function
;
1979 /* User-supplied key comparison function, or nil. */
1980 Lisp_Object user_cmp_function
;
1982 /* C function to compare two keys. */
1983 bool (*cmpfn
) (struct hash_table_test
*t
, Lisp_Object
, Lisp_Object
);
1985 /* C function to compute hash code. */
1986 EMACS_UINT (*hashfn
) (struct hash_table_test
*t
, Lisp_Object
);
1989 struct Lisp_Hash_Table
1991 /* This is for Lisp; the hash table code does not refer to it. */
1992 struct vectorlike_header header
;
1994 /* Nil if table is non-weak. Otherwise a symbol describing the
1995 weakness of the table. */
1998 /* Vector of hash codes. If hash[I] is nil, this means that the
1999 I-th entry is unused. */
2002 /* Vector used to chain entries. If entry I is free, next[I] is the
2003 entry number of the next free item. If entry I is non-free,
2004 next[I] is the index of the next entry in the collision chain,
2005 or -1 if there is such entry. */
2008 /* Bucket vector. An entry of -1 indicates no item is present,
2009 and a nonnegative entry is the index of the first item in
2010 a collision chain. This vector's size can be larger than the
2011 hash table size to reduce collisions. */
2014 /* Only the fields above are traced normally by the GC. The ones below
2015 `count' are special and are either ignored by the GC or traced in
2016 a special way (e.g. because of weakness). */
2018 /* Number of key/value entries in the table. */
2021 /* Index of first free entry in free list, or -1 if none. */
2022 ptrdiff_t next_free
;
2024 /* True if the table can be purecopied. The table cannot be
2025 changed afterwards. */
2028 /* Resize hash table when number of entries / table size is >= this
2030 float rehash_threshold
;
2032 /* Used when the table is resized. If equal to a negative integer,
2033 the user rehash-size is the integer -REHASH_SIZE, and the new
2034 size is the old size plus -REHASH_SIZE. If positive, the user
2035 rehash-size is the floating-point value REHASH_SIZE + 1, and the
2036 new size is the old size times REHASH_SIZE + 1. */
2039 /* Vector of keys and values. The key of item I is found at index
2040 2 * I, the value is found at index 2 * I + 1.
2041 This is gc_marked specially if the table is weak. */
2042 Lisp_Object key_and_value
;
2044 /* The comparison and hash functions. */
2045 struct hash_table_test test
;
2047 /* Next weak hash table if this is a weak hash table. The head
2048 of the list is in weak_hash_tables. */
2049 struct Lisp_Hash_Table
*next_weak
;
2054 HASH_TABLE_P (Lisp_Object a
)
2056 return PSEUDOVECTORP (a
, PVEC_HASH_TABLE
);
2059 INLINE
struct Lisp_Hash_Table
*
2060 XHASH_TABLE (Lisp_Object a
)
2062 eassert (HASH_TABLE_P (a
));
2063 return XUNTAG (a
, Lisp_Vectorlike
);
2066 #define XSET_HASH_TABLE(VAR, PTR) \
2067 (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
2069 /* Value is the key part of entry IDX in hash table H. */
2071 HASH_KEY (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2073 return AREF (h
->key_and_value
, 2 * idx
);
2076 /* Value is the value part of entry IDX in hash table H. */
2078 HASH_VALUE (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2080 return AREF (h
->key_and_value
, 2 * idx
+ 1);
2083 /* Value is the hash code computed for entry IDX in hash table H. */
2085 HASH_HASH (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
2087 return AREF (h
->hash
, idx
);
2090 /* Value is the size of hash table H. */
2092 HASH_TABLE_SIZE (struct Lisp_Hash_Table
*h
)
2094 return ASIZE (h
->next
);
2097 /* Default size for hash tables if not specified. */
2099 enum DEFAULT_HASH_SIZE
{ DEFAULT_HASH_SIZE
= 65 };
2101 /* Default threshold specifying when to resize a hash table. The
2102 value gives the ratio of current entries in the hash table and the
2103 size of the hash table. */
2105 static float const DEFAULT_REHASH_THRESHOLD
= 0.8125;
2107 /* Default factor by which to increase the size of a hash table, minus 1. */
2109 static float const DEFAULT_REHASH_SIZE
= 1.5 - 1;
2111 /* Combine two integers X and Y for hashing. The result might not fit
2112 into a Lisp integer. */
2115 sxhash_combine (EMACS_UINT x
, EMACS_UINT y
)
2117 return (x
<< 4) + (x
>> (EMACS_INT_WIDTH
- 4)) + y
;
2120 /* Hash X, returning a value that fits into a fixnum. */
2123 SXHASH_REDUCE (EMACS_UINT x
)
2125 return (x
^ x
>> (EMACS_INT_WIDTH
- FIXNUM_BITS
)) & INTMASK
;
2128 /* These structures are used for various misc types. */
2130 struct Lisp_Misc_Any
/* Supertype of all Misc types. */
2132 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_??? */
2133 bool_bf gcmarkbit
: 1;
2134 unsigned spacer
: 15;
2138 (MISCP
) (Lisp_Object x
)
2140 return lisp_h_MISCP (x
);
2143 INLINE
struct Lisp_Misc_Any
*
2144 XMISCANY (Lisp_Object a
)
2146 eassert (MISCP (a
));
2147 return XUNTAG (a
, Lisp_Misc
);
2150 INLINE
enum Lisp_Misc_Type
2151 XMISCTYPE (Lisp_Object a
)
2153 return XMISCANY (a
)->type
;
2158 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Marker */
2159 bool_bf gcmarkbit
: 1;
2160 unsigned spacer
: 13;
2161 /* This flag is temporarily used in the functions
2162 decode/encode_coding_object to record that the marker position
2163 must be adjusted after the conversion. */
2164 bool_bf need_adjustment
: 1;
2165 /* True means normal insertion at the marker's position
2166 leaves the marker after the inserted text. */
2167 bool_bf insertion_type
: 1;
2168 /* This is the buffer that the marker points into, or 0 if it points nowhere.
2169 Note: a chain of markers can contain markers pointing into different
2170 buffers (the chain is per buffer_text rather than per buffer, so it's
2171 shared between indirect buffers). */
2172 /* This is used for (other than NULL-checking):
2174 - Fset_marker: check eq(oldbuf, newbuf) to avoid unchain+rechain.
2175 - unchain_marker: to find the list from which to unchain.
2176 - Fkill_buffer: to only unchain the markers of current indirect buffer.
2178 struct buffer
*buffer
;
2180 /* The remaining fields are meaningless in a marker that
2181 does not point anywhere. */
2183 /* For markers that point somewhere,
2184 this is used to chain of all the markers in a given buffer. */
2185 /* We could remove it and use an array in buffer_text instead.
2186 That would also allow us to preserve it ordered. */
2187 struct Lisp_Marker
*next
;
2188 /* This is the char position where the marker points. */
2190 /* This is the byte position.
2191 It's mostly used as a charpos<->bytepos cache (i.e. it's not directly
2192 used to implement the functionality of markers, but rather to (ab)use
2193 markers as a cache for char<->byte mappings). */
2197 /* START and END are markers in the overlay's buffer, and
2198 PLIST is the overlay's property list. */
2200 /* An overlay's real data content is:
2202 - buffer (really there are two buffer pointers, one per marker,
2203 and both points to the same buffer)
2204 - insertion type of both ends (per-marker fields)
2205 - start & start byte (of start marker)
2206 - end & end byte (of end marker)
2207 - next (singly linked list of overlays)
2208 - next fields of start and end markers (singly linked list of markers).
2209 I.e. 9words plus 2 bits, 3words of which are for external linked lists.
2212 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Overlay */
2213 bool_bf gcmarkbit
: 1;
2214 unsigned spacer
: 15;
2215 struct Lisp_Overlay
*next
;
2221 /* Number of bits needed to store one of the values
2222 SAVE_UNUSED..SAVE_OBJECT. */
2223 enum { SAVE_SLOT_BITS
= 3 };
2225 /* Number of slots in a save value where save_type is nonzero. */
2226 enum { SAVE_VALUE_SLOTS
= 4 };
2228 /* Bit-width and values for struct Lisp_Save_Value's save_type member. */
2230 enum { SAVE_TYPE_BITS
= SAVE_VALUE_SLOTS
* SAVE_SLOT_BITS
+ 1 };
2232 /* Types of data which may be saved in a Lisp_Save_Value. */
2241 SAVE_TYPE_INT_INT
= SAVE_INTEGER
+ (SAVE_INTEGER
<< SAVE_SLOT_BITS
),
2242 SAVE_TYPE_INT_INT_INT
2243 = (SAVE_INTEGER
+ (SAVE_TYPE_INT_INT
<< SAVE_SLOT_BITS
)),
2244 SAVE_TYPE_OBJ_OBJ
= SAVE_OBJECT
+ (SAVE_OBJECT
<< SAVE_SLOT_BITS
),
2245 SAVE_TYPE_OBJ_OBJ_OBJ
= SAVE_OBJECT
+ (SAVE_TYPE_OBJ_OBJ
<< SAVE_SLOT_BITS
),
2246 SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
2247 = SAVE_OBJECT
+ (SAVE_TYPE_OBJ_OBJ_OBJ
<< SAVE_SLOT_BITS
),
2248 SAVE_TYPE_PTR_INT
= SAVE_POINTER
+ (SAVE_INTEGER
<< SAVE_SLOT_BITS
),
2249 SAVE_TYPE_PTR_OBJ
= SAVE_POINTER
+ (SAVE_OBJECT
<< SAVE_SLOT_BITS
),
2250 SAVE_TYPE_PTR_PTR
= SAVE_POINTER
+ (SAVE_POINTER
<< SAVE_SLOT_BITS
),
2251 SAVE_TYPE_FUNCPTR_PTR_OBJ
2252 = SAVE_FUNCPOINTER
+ (SAVE_TYPE_PTR_OBJ
<< SAVE_SLOT_BITS
),
2254 /* This has an extra bit indicating it's raw memory. */
2255 SAVE_TYPE_MEMORY
= SAVE_TYPE_PTR_INT
+ (1 << (SAVE_TYPE_BITS
- 1))
2258 /* SAVE_SLOT_BITS must be large enough to represent these values. */
2259 verify (((SAVE_UNUSED
| SAVE_INTEGER
| SAVE_FUNCPOINTER
2260 | SAVE_POINTER
| SAVE_OBJECT
)
2264 /* Special object used to hold a different values for later use.
2266 This is mostly used to package C integers and pointers to call
2267 record_unwind_protect when two or more values need to be saved.
2271 struct my_data *md = get_my_data ();
2272 ptrdiff_t mi = get_my_integer ();
2273 record_unwind_protect (my_unwind, make_save_ptr_int (md, mi));
2276 Lisp_Object my_unwind (Lisp_Object arg)
2278 struct my_data *md = XSAVE_POINTER (arg, 0);
2279 ptrdiff_t mi = XSAVE_INTEGER (arg, 1);
2283 If ENABLE_CHECKING is in effect, XSAVE_xxx macros do type checking of the
2284 saved objects and raise eassert if type of the saved object doesn't match
2285 the type which is extracted. In the example above, XSAVE_INTEGER (arg, 2)
2286 and XSAVE_OBJECT (arg, 0) are wrong because nothing was saved in slot 2 and
2287 slot 0 is a pointer. */
2289 typedef void (*voidfuncptr
) (void);
2291 struct Lisp_Save_Value
2293 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Save_Value */
2294 bool_bf gcmarkbit
: 1;
2295 unsigned spacer
: 32 - (16 + 1 + SAVE_TYPE_BITS
);
2297 /* V->data may hold up to SAVE_VALUE_SLOTS entries. The type of
2298 V's data entries are determined by V->save_type. E.g., if
2299 V->save_type == SAVE_TYPE_PTR_OBJ, V->data[0] is a pointer,
2300 V->data[1] is an integer, and V's other data entries are unused.
2302 If V->save_type == SAVE_TYPE_MEMORY, V->data[0].pointer is the address of
2303 a memory area containing V->data[1].integer potential Lisp_Objects. */
2304 ENUM_BF (Lisp_Save_Type
) save_type
: SAVE_TYPE_BITS
;
2307 voidfuncptr funcpointer
;
2310 } data
[SAVE_VALUE_SLOTS
];
2314 SAVE_VALUEP (Lisp_Object x
)
2316 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Save_Value
;
2319 INLINE
struct Lisp_Save_Value
*
2320 XSAVE_VALUE (Lisp_Object a
)
2322 eassert (SAVE_VALUEP (a
));
2323 return XUNTAG (a
, Lisp_Misc
);
2326 /* Return the type of V's Nth saved value. */
2328 save_type (struct Lisp_Save_Value
*v
, int n
)
2330 eassert (0 <= n
&& n
< SAVE_VALUE_SLOTS
);
2331 return (v
->save_type
>> (SAVE_SLOT_BITS
* n
) & ((1 << SAVE_SLOT_BITS
) - 1));
2334 /* Get and set the Nth saved pointer. */
2337 XSAVE_POINTER (Lisp_Object obj
, int n
)
2339 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_POINTER
);
2340 return XSAVE_VALUE (obj
)->data
[n
].pointer
;
2343 set_save_pointer (Lisp_Object obj
, int n
, void *val
)
2345 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_POINTER
);
2346 XSAVE_VALUE (obj
)->data
[n
].pointer
= val
;
2349 XSAVE_FUNCPOINTER (Lisp_Object obj
, int n
)
2351 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_FUNCPOINTER
);
2352 return XSAVE_VALUE (obj
)->data
[n
].funcpointer
;
2355 /* Likewise for the saved integer. */
2358 XSAVE_INTEGER (Lisp_Object obj
, int n
)
2360 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_INTEGER
);
2361 return XSAVE_VALUE (obj
)->data
[n
].integer
;
2364 set_save_integer (Lisp_Object obj
, int n
, ptrdiff_t val
)
2366 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_INTEGER
);
2367 XSAVE_VALUE (obj
)->data
[n
].integer
= val
;
2370 /* Extract Nth saved object. */
2373 XSAVE_OBJECT (Lisp_Object obj
, int n
)
2375 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_OBJECT
);
2376 return XSAVE_VALUE (obj
)->data
[n
].object
;
2380 struct Lisp_User_Ptr
2382 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_User_Ptr */
2383 bool_bf gcmarkbit
: 1;
2384 unsigned spacer
: 15;
2386 void (*finalizer
) (void *);
2391 /* A finalizer sentinel. */
2392 struct Lisp_Finalizer
2394 struct Lisp_Misc_Any base
;
2396 /* Circular list of all active weak references. */
2397 struct Lisp_Finalizer
*prev
;
2398 struct Lisp_Finalizer
*next
;
2400 /* Call FUNCTION when the finalizer becomes unreachable, even if
2401 FUNCTION contains a reference to the finalizer; i.e., call
2402 FUNCTION when it is reachable _only_ through finalizers. */
2403 Lisp_Object function
;
2407 FINALIZERP (Lisp_Object x
)
2409 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Finalizer
;
2412 INLINE
struct Lisp_Finalizer
*
2413 XFINALIZER (Lisp_Object a
)
2415 eassert (FINALIZERP (a
));
2416 return XUNTAG (a
, Lisp_Misc
);
2419 /* A miscellaneous object, when it's on the free list. */
2422 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Free */
2423 bool_bf gcmarkbit
: 1;
2424 unsigned spacer
: 15;
2425 union Lisp_Misc
*chain
;
2428 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
2429 It uses one of these struct subtypes to get the type field. */
2433 struct Lisp_Misc_Any u_any
; /* Supertype of all Misc types. */
2434 struct Lisp_Free u_free
;
2435 struct Lisp_Marker u_marker
;
2436 struct Lisp_Overlay u_overlay
;
2437 struct Lisp_Save_Value u_save_value
;
2438 struct Lisp_Finalizer u_finalizer
;
2440 struct Lisp_User_Ptr u_user_ptr
;
2444 INLINE
union Lisp_Misc
*
2445 XMISC (Lisp_Object a
)
2447 return XUNTAG (a
, Lisp_Misc
);
2451 (MARKERP
) (Lisp_Object x
)
2453 return lisp_h_MARKERP (x
);
2456 INLINE
struct Lisp_Marker
*
2457 XMARKER (Lisp_Object a
)
2459 eassert (MARKERP (a
));
2460 return XUNTAG (a
, Lisp_Misc
);
2464 OVERLAYP (Lisp_Object x
)
2466 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Overlay
;
2469 INLINE
struct Lisp_Overlay
*
2470 XOVERLAY (Lisp_Object a
)
2472 eassert (OVERLAYP (a
));
2473 return XUNTAG (a
, Lisp_Misc
);
2478 USER_PTRP (Lisp_Object x
)
2480 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_User_Ptr
;
2483 INLINE
struct Lisp_User_Ptr
*
2484 XUSER_PTR (Lisp_Object a
)
2486 eassert (USER_PTRP (a
));
2487 return XUNTAG (a
, Lisp_Misc
);
2492 /* Forwarding pointer to an int variable.
2493 This is allowed only in the value cell of a symbol,
2494 and it means that the symbol's value really lives in the
2495 specified int variable. */
2498 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Int */
2502 /* Boolean forwarding pointer to an int variable.
2503 This is like Lisp_Intfwd except that the ostensible
2504 "value" of the symbol is t if the bool variable is true,
2505 nil if it is false. */
2508 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Bool */
2512 /* Forwarding pointer to a Lisp_Object variable.
2513 This is allowed only in the value cell of a symbol,
2514 and it means that the symbol's value really lives in the
2515 specified variable. */
2518 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Obj */
2519 Lisp_Object
*objvar
;
2522 /* Like Lisp_Objfwd except that value lives in a slot in the
2523 current buffer. Value is byte index of slot within buffer. */
2524 struct Lisp_Buffer_Objfwd
2526 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Buffer_Obj */
2528 /* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp. */
2529 Lisp_Object predicate
;
2532 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
2533 the symbol has buffer-local bindings. (Exception:
2534 some buffer-local variables are built-in, with their values stored
2535 in the buffer structure itself. They are handled differently,
2536 using struct Lisp_Buffer_Objfwd.)
2538 The `realvalue' slot holds the variable's current value, or a
2539 forwarding pointer to where that value is kept. This value is the
2540 one that corresponds to the loaded binding. To read or set the
2541 variable, you must first make sure the right binding is loaded;
2542 then you can access the value in (or through) `realvalue'.
2544 `buffer' and `frame' are the buffer and frame for which the loaded
2545 binding was found. If those have changed, to make sure the right
2546 binding is loaded it is necessary to find which binding goes with
2547 the current buffer and selected frame, then load it. To load it,
2548 first unload the previous binding, then copy the value of the new
2549 binding into `realvalue' (or through it). Also update
2550 LOADED-BINDING to point to the newly loaded binding.
2552 `local_if_set' indicates that merely setting the variable creates a
2553 local binding for the current buffer. Otherwise the latter, setting
2554 the variable does not do that; only make-local-variable does that. */
2556 struct Lisp_Buffer_Local_Value
2558 /* True means that merely setting the variable creates a local
2559 binding for the current buffer. */
2560 bool_bf local_if_set
: 1;
2561 /* True means that the binding now loaded was found.
2562 Presumably equivalent to (defcell!=valcell). */
2564 /* If non-NULL, a forwarding to the C var where it should also be set. */
2565 union Lisp_Fwd
*fwd
; /* Should never be (Buffer|Kboard)_Objfwd. */
2566 /* The buffer or frame for which the loaded binding was found. */
2568 /* A cons cell that holds the default value. It has the form
2569 (SYMBOL . DEFAULT-VALUE). */
2570 Lisp_Object defcell
;
2571 /* The cons cell from `where's parameter alist.
2572 It always has the form (SYMBOL . VALUE)
2573 Note that if `forward' is non-nil, VALUE may be out of date.
2574 Also if the currently loaded binding is the default binding, then
2575 this is `eq'ual to defcell. */
2576 Lisp_Object valcell
;
2579 /* Like Lisp_Objfwd except that value lives in a slot in the
2581 struct Lisp_Kboard_Objfwd
2583 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Kboard_Obj */
2589 struct Lisp_Intfwd u_intfwd
;
2590 struct Lisp_Boolfwd u_boolfwd
;
2591 struct Lisp_Objfwd u_objfwd
;
2592 struct Lisp_Buffer_Objfwd u_buffer_objfwd
;
2593 struct Lisp_Kboard_Objfwd u_kboard_objfwd
;
2596 INLINE
enum Lisp_Fwd_Type
2597 XFWDTYPE (union Lisp_Fwd
*a
)
2599 return a
->u_intfwd
.type
;
2603 BUFFER_OBJFWDP (union Lisp_Fwd
*a
)
2605 return XFWDTYPE (a
) == Lisp_Fwd_Buffer_Obj
;
2608 INLINE
struct Lisp_Buffer_Objfwd
*
2609 XBUFFER_OBJFWD (union Lisp_Fwd
*a
)
2611 eassert (BUFFER_OBJFWDP (a
));
2612 return &a
->u_buffer_objfwd
;
2615 /* Lisp floating point type. */
2621 struct Lisp_Float
*chain
;
2626 (FLOATP
) (Lisp_Object x
)
2628 return lisp_h_FLOATP (x
);
2631 INLINE
struct Lisp_Float
*
2632 XFLOAT (Lisp_Object a
)
2634 eassert (FLOATP (a
));
2635 return XUNTAG (a
, Lisp_Float
);
2639 XFLOAT_DATA (Lisp_Object f
)
2641 return XFLOAT (f
)->u
.data
;
2644 /* Most hosts nowadays use IEEE floating point, so they use IEC 60559
2645 representations, have infinities and NaNs, and do not trap on
2646 exceptions. Define IEEE_FLOATING_POINT if this host is one of the
2647 typical ones. The C11 macro __STDC_IEC_559__ is close to what is
2648 wanted here, but is not quite right because Emacs does not require
2649 all the features of C11 Annex F (and does not require C11 at all,
2650 for that matter). */
2654 = (FLT_RADIX
== 2 && FLT_MANT_DIG
== 24
2655 && FLT_MIN_EXP
== -125 && FLT_MAX_EXP
== 128)
2658 /* A character, declared with the following typedef, is a member
2659 of some character set associated with the current buffer. */
2660 #ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
2662 typedef unsigned char UCHAR
;
2665 /* Meanings of slots in a Lisp_Compiled: */
2669 COMPILED_ARGLIST
= 0,
2670 COMPILED_BYTECODE
= 1,
2671 COMPILED_CONSTANTS
= 2,
2672 COMPILED_STACK_DEPTH
= 3,
2673 COMPILED_DOC_STRING
= 4,
2674 COMPILED_INTERACTIVE
= 5
2677 /* Flag bits in a character. These also get used in termhooks.h.
2678 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
2679 (MUlti-Lingual Emacs) might need 22 bits for the character value
2680 itself, so we probably shouldn't use any bits lower than 0x0400000. */
2683 CHAR_ALT
= 0x0400000,
2684 CHAR_SUPER
= 0x0800000,
2685 CHAR_HYPER
= 0x1000000,
2686 CHAR_SHIFT
= 0x2000000,
2687 CHAR_CTL
= 0x4000000,
2688 CHAR_META
= 0x8000000,
2690 CHAR_MODIFIER_MASK
=
2691 CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
| CHAR_SHIFT
| CHAR_CTL
| CHAR_META
,
2693 /* Actually, the current Emacs uses 22 bits for the character value
2698 /* Data type checking. */
2701 NUMBERP (Lisp_Object x
)
2703 return INTEGERP (x
) || FLOATP (x
);
2706 NATNUMP (Lisp_Object x
)
2708 return INTEGERP (x
) && 0 <= XINT (x
);
2712 RANGED_INTEGERP (intmax_t lo
, Lisp_Object x
, intmax_t hi
)
2714 return INTEGERP (x
) && lo
<= XINT (x
) && XINT (x
) <= hi
;
2717 #define TYPE_RANGED_INTEGERP(type, x) \
2719 && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \
2720 && XINT (x) <= TYPE_MAXIMUM (type))
2723 AUTOLOADP (Lisp_Object x
)
2725 return CONSP (x
) && EQ (Qautoload
, XCAR (x
));
2729 /* Test for specific pseudovector types. */
2732 WINDOW_CONFIGURATIONP (Lisp_Object a
)
2734 return PSEUDOVECTORP (a
, PVEC_WINDOW_CONFIGURATION
);
2738 COMPILEDP (Lisp_Object a
)
2740 return PSEUDOVECTORP (a
, PVEC_COMPILED
);
2744 FRAMEP (Lisp_Object a
)
2746 return PSEUDOVECTORP (a
, PVEC_FRAME
);
2750 RECORDP (Lisp_Object a
)
2752 return PSEUDOVECTORP (a
, PVEC_RECORD
);
2756 CHECK_RECORD (Lisp_Object x
)
2758 CHECK_TYPE (RECORDP (x
), Qrecordp
, x
);
2761 /* Test for image (image . spec) */
2763 IMAGEP (Lisp_Object x
)
2765 return CONSP (x
) && EQ (XCAR (x
), Qimage
);
2770 ARRAYP (Lisp_Object x
)
2772 return VECTORP (x
) || STRINGP (x
) || CHAR_TABLE_P (x
) || BOOL_VECTOR_P (x
);
2776 CHECK_LIST (Lisp_Object x
)
2778 CHECK_TYPE (CONSP (x
) || NILP (x
), Qlistp
, x
);
2782 CHECK_LIST_END (Lisp_Object x
, Lisp_Object y
)
2784 CHECK_TYPE (NILP (x
), Qlistp
, y
);
2788 (CHECK_NUMBER
) (Lisp_Object x
)
2790 lisp_h_CHECK_NUMBER (x
);
2794 CHECK_STRING_CAR (Lisp_Object x
)
2796 CHECK_TYPE (STRINGP (XCAR (x
)), Qstringp
, XCAR (x
));
2798 /* This is a bit special because we always need size afterwards. */
2800 CHECK_VECTOR_OR_STRING (Lisp_Object x
)
2806 wrong_type_argument (Qarrayp
, x
);
2809 CHECK_ARRAY (Lisp_Object x
, Lisp_Object predicate
)
2811 CHECK_TYPE (ARRAYP (x
), predicate
, x
);
2814 CHECK_NATNUM (Lisp_Object x
)
2816 CHECK_TYPE (NATNUMP (x
), Qwholenump
, x
);
2819 #define CHECK_RANGED_INTEGER(x, lo, hi) \
2822 if (! ((lo) <= XINT (x) && XINT (x) <= (hi))) \
2823 args_out_of_range_3 \
2825 make_number ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM \
2826 ? MOST_NEGATIVE_FIXNUM \
2828 make_number (min (hi, MOST_POSITIVE_FIXNUM))); \
2830 #define CHECK_TYPE_RANGED_INTEGER(type, x) \
2832 if (TYPE_SIGNED (type)) \
2833 CHECK_RANGED_INTEGER (x, TYPE_MINIMUM (type), TYPE_MAXIMUM (type)); \
2835 CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type)); \
2838 #define CHECK_NUMBER_COERCE_MARKER(x) \
2840 if (MARKERP ((x))) \
2841 XSETFASTINT (x, marker_position (x)); \
2843 CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); \
2847 XFLOATINT (Lisp_Object n
)
2849 return FLOATP (n
) ? XFLOAT_DATA (n
) : XINT (n
);
2853 CHECK_NUMBER_OR_FLOAT (Lisp_Object x
)
2855 CHECK_TYPE (NUMBERP (x
), Qnumberp
, x
);
2858 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
2861 XSETFASTINT (x, marker_position (x)); \
2863 CHECK_TYPE (NUMBERP (x), Qnumber_or_marker_p, x); \
2866 /* Since we can't assign directly to the CAR or CDR fields of a cons
2867 cell, use these when checking that those fields contain numbers. */
2869 CHECK_NUMBER_CAR (Lisp_Object x
)
2871 Lisp_Object tmp
= XCAR (x
);
2877 CHECK_NUMBER_CDR (Lisp_Object x
)
2879 Lisp_Object tmp
= XCDR (x
);
2884 /* Define a built-in function for calling from Lisp.
2885 `lname' should be the name to give the function in Lisp,
2886 as a null-terminated C string.
2887 `fnname' should be the name of the function in C.
2888 By convention, it starts with F.
2889 `sname' should be the name for the C constant structure
2890 that records information on this function for internal use.
2891 By convention, it should be the same as `fnname' but with S instead of F.
2892 It's too bad that C macros can't compute this from `fnname'.
2893 `minargs' should be a number, the minimum number of arguments allowed.
2894 `maxargs' should be a number, the maximum number of arguments allowed,
2895 or else MANY or UNEVALLED.
2896 MANY means pass a vector of evaluated arguments,
2897 in the form of an integer number-of-arguments
2898 followed by the address of a vector of Lisp_Objects
2899 which contains the argument values.
2900 UNEVALLED means pass the list of unevaluated arguments
2901 `intspec' says how interactive arguments are to be fetched.
2902 If the string starts with a `(', `intspec' is evaluated and the resulting
2903 list is the list of arguments.
2904 If it's a string that doesn't start with `(', the value should follow
2905 the one of the doc string for `interactive'.
2906 A null string means call interactively with no arguments.
2907 `doc' is documentation for the user. */
2909 /* This version of DEFUN declares a function prototype with the right
2910 arguments, so we can catch errors with maxargs at compile-time. */
2912 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
2913 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
2914 static struct Lisp_Subr alignas (GCALIGNMENT) sname = \
2915 { { (PVEC_SUBR << PSEUDOVECTOR_AREA_BITS) \
2916 | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)) }, \
2917 { (Lisp_Object (__cdecl *)(void))fnname }, \
2918 minargs, maxargs, lname, intspec, 0}; \
2920 #else /* not _MSC_VER */
2921 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
2922 static struct Lisp_Subr alignas (GCALIGNMENT) sname = \
2923 { { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS }, \
2924 { .a ## maxargs = fnname }, \
2925 minargs, maxargs, lname, intspec, 0}; \
2930 is how we define the symbol for function `name' at start-up time. */
2931 extern void defsubr (struct Lisp_Subr
*);
2939 /* Call a function F that accepts many args, passing it ARRAY's elements. */
2940 #define CALLMANY(f, array) (f) (ARRAYELTS (array), array)
2942 /* Call a function F that accepts many args, passing it the remaining args,
2943 E.g., 'return CALLN (Fformat, fmt, text);' is less error-prone than
2944 '{ Lisp_Object a[2]; a[0] = fmt; a[1] = text; return Fformat (2, a); }'.
2945 CALLN is overkill for simple usages like 'Finsert (1, &text);'. */
2946 #define CALLN(f, ...) CALLMANY (f, ((Lisp_Object []) {__VA_ARGS__}))
2948 extern void defvar_lisp (struct Lisp_Objfwd
*, const char *, Lisp_Object
*);
2949 extern void defvar_lisp_nopro (struct Lisp_Objfwd
*, const char *, Lisp_Object
*);
2950 extern void defvar_bool (struct Lisp_Boolfwd
*, const char *, bool *);
2951 extern void defvar_int (struct Lisp_Intfwd
*, const char *, EMACS_INT
*);
2952 extern void defvar_kboard (struct Lisp_Kboard_Objfwd
*, const char *, int);
2954 /* Macros we use to define forwarded Lisp variables.
2955 These are used in the syms_of_FILENAME functions.
2957 An ordinary (not in buffer_defaults, per-buffer, or per-keyboard)
2958 lisp variable is actually a field in `struct emacs_globals'. The
2959 field's name begins with "f_", which is a convention enforced by
2960 these macros. Each such global has a corresponding #define in
2961 globals.h; the plain name should be used in the code.
2963 E.g., the global "cons_cells_consed" is declared as "int
2964 f_cons_cells_consed" in globals.h, but there is a define:
2966 #define cons_cells_consed globals.f_cons_cells_consed
2968 All C code uses the `cons_cells_consed' name. This is all done
2969 this way to support indirection for multi-threaded Emacs. */
2971 #define DEFVAR_LISP(lname, vname, doc) \
2973 static struct Lisp_Objfwd o_fwd; \
2974 defvar_lisp (&o_fwd, lname, &globals.f_ ## vname); \
2976 #define DEFVAR_LISP_NOPRO(lname, vname, doc) \
2978 static struct Lisp_Objfwd o_fwd; \
2979 defvar_lisp_nopro (&o_fwd, lname, &globals.f_ ## vname); \
2981 #define DEFVAR_BOOL(lname, vname, doc) \
2983 static struct Lisp_Boolfwd b_fwd; \
2984 defvar_bool (&b_fwd, lname, &globals.f_ ## vname); \
2986 #define DEFVAR_INT(lname, vname, doc) \
2988 static struct Lisp_Intfwd i_fwd; \
2989 defvar_int (&i_fwd, lname, &globals.f_ ## vname); \
2992 #define DEFVAR_KBOARD(lname, vname, doc) \
2994 static struct Lisp_Kboard_Objfwd ko_fwd; \
2995 defvar_kboard (&ko_fwd, lname, offsetof (KBOARD, vname ## _)); \
2998 /* Save and restore the instruction and environment pointers,
2999 without affecting the signal mask. */
3002 typedef jmp_buf sys_jmp_buf
;
3003 # define sys_setjmp(j) _setjmp (j)
3004 # define sys_longjmp(j, v) _longjmp (j, v)
3005 #elif defined HAVE_SIGSETJMP
3006 typedef sigjmp_buf sys_jmp_buf
;
3007 # define sys_setjmp(j) sigsetjmp (j, 0)
3008 # define sys_longjmp(j, v) siglongjmp (j, v)
3010 /* A platform that uses neither _longjmp nor siglongjmp; assume
3011 longjmp does not affect the sigmask. */
3012 typedef jmp_buf sys_jmp_buf
;
3013 # define sys_setjmp(j) setjmp (j)
3014 # define sys_longjmp(j, v) longjmp (j, v)
3018 /* Elisp uses several stacks:
3020 - the bytecode stack: used internally by the bytecode interpreter.
3021 Allocated from the C stack.
3022 - The specpdl stack: keeps track of active unwind-protect and
3023 dynamic-let-bindings. Allocated from the `specpdl' array, a manually
3025 - The handler stack: keeps track of active catch tags and condition-case
3026 handlers. Allocated in a manually managed stack implemented by a
3027 doubly-linked list allocated via xmalloc and never freed. */
3029 /* Structure for recording Lisp call stack for backtrace purposes. */
3031 /* The special binding stack holds the outer values of variables while
3032 they are bound by a function application or a let form, stores the
3033 code to be executed for unwind-protect forms.
3035 NOTE: The specbinding union is defined here, because SPECPDL_INDEX is
3036 used all over the place, needs to be fast, and needs to know the size of
3037 union specbinding. But only eval.c should access it. */
3040 SPECPDL_UNWIND
, /* An unwind_protect function on Lisp_Object. */
3041 SPECPDL_UNWIND_PTR
, /* Likewise, on void *. */
3042 SPECPDL_UNWIND_INT
, /* Likewise, on int. */
3043 SPECPDL_UNWIND_VOID
, /* Likewise, with no arg. */
3044 SPECPDL_BACKTRACE
, /* An element of the backtrace. */
3045 SPECPDL_LET
, /* A plain and simple dynamic let-binding. */
3046 /* Tags greater than SPECPDL_LET must be "subkinds" of LET. */
3047 SPECPDL_LET_LOCAL
, /* A buffer-local let-binding. */
3048 SPECPDL_LET_DEFAULT
/* A global binding for a localized var. */
3053 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3055 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3056 void (*func
) (Lisp_Object
);
3060 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3061 void (*func
) (void *);
3065 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3070 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3071 void (*func
) (void);
3074 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3075 /* `where' is not used in the case of SPECPDL_LET. */
3076 Lisp_Object symbol
, old_value
, where
;
3077 /* Normally this is unused; but it is set to the symbol's
3078 current value when a thread is swapped out. */
3079 Lisp_Object saved_value
;
3082 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
3083 bool_bf debug_on_exit
: 1;
3084 Lisp_Object function
;
3090 /* These 3 are defined as macros in thread.h. */
3091 /* extern union specbinding *specpdl; */
3092 /* extern union specbinding *specpdl_ptr; */
3093 /* extern ptrdiff_t specpdl_size; */
3096 SPECPDL_INDEX (void)
3098 return specpdl_ptr
- specpdl
;
3101 /* This structure helps implement the `catch/throw' and `condition-case/signal'
3102 control structures. A struct handler contains all the information needed to
3103 restore the state of the interpreter after a non-local jump.
3105 handler structures are chained together in a doubly linked list; the `next'
3106 member points to the next outer catchtag and the `nextfree' member points in
3107 the other direction to the next inner element (which is typically the next
3108 free element since we mostly use it on the deepest handler).
3110 A call like (throw TAG VAL) searches for a catchtag whose `tag_or_ch'
3111 member is TAG, and then unbinds to it. The `val' member is used to
3112 hold VAL while the stack is unwound; `val' is returned as the value
3113 of the catch form. If there is a handler of type CATCHER_ALL, it will
3114 be treated as a handler for all invocations of `throw'; in this case
3115 `val' will be set to (TAG . VAL).
3117 All the other members are concerned with restoring the interpreter
3120 Members are volatile if their values need to survive _longjmp when
3121 a 'struct handler' is a local variable. */
3123 enum handlertype
{ CATCHER
, CONDITION_CASE
, CATCHER_ALL
};
3127 enum handlertype type
;
3128 Lisp_Object tag_or_ch
;
3130 struct handler
*next
;
3131 struct handler
*nextfree
;
3133 /* The bytecode interpreter can have several handlers active at the same
3134 time, so when we longjmp to one of them, it needs to know which handler
3135 this was and what was the corresponding internal state. This is stored
3136 here, and when we longjmp we make sure that handlerlist points to the
3138 Lisp_Object
*bytecode_top
;
3141 /* Most global vars are reset to their value via the specpdl mechanism,
3142 but a few others are handled by storing their value here. */
3144 EMACS_INT f_lisp_eval_depth
;
3146 int poll_suppress_count
;
3147 int interrupt_input_blocked
;
3150 extern Lisp_Object memory_signal_data
;
3152 extern void maybe_quit (void);
3154 /* True if ought to quit now. */
3156 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
3158 /* Process a quit rarely, based on a counter COUNT, for efficiency.
3159 "Rarely" means once per USHRT_MAX + 1 times; this is somewhat
3160 arbitrary, but efficient. */
3163 rarely_quit (unsigned short int count
)
3169 extern Lisp_Object Vascii_downcase_table
;
3170 extern Lisp_Object Vascii_canon_table
;
3172 /* Call staticpro (&var) to protect static variable `var'. */
3174 void staticpro (Lisp_Object
*);
3176 /* Forward declarations for prototypes. */
3180 /* Copy COUNT Lisp_Objects from ARGS to contents of V starting from OFFSET. */
3183 vcopy (Lisp_Object v
, ptrdiff_t offset
, Lisp_Object
*args
, ptrdiff_t count
)
3185 eassert (0 <= offset
&& 0 <= count
&& offset
+ count
<= ASIZE (v
));
3186 memcpy (XVECTOR (v
)->contents
+ offset
, args
, count
* sizeof *args
);
3189 /* Functions to modify hash tables. */
3192 set_hash_key_slot (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
, Lisp_Object val
)
3194 gc_aset (h
->key_and_value
, 2 * idx
, val
);
3198 set_hash_value_slot (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
, Lisp_Object val
)
3200 gc_aset (h
->key_and_value
, 2 * idx
+ 1, val
);
3203 /* Use these functions to set Lisp_Object
3204 or pointer slots of struct Lisp_Symbol. */
3207 set_symbol_function (Lisp_Object sym
, Lisp_Object function
)
3209 XSYMBOL (sym
)->function
= function
;
3213 set_symbol_plist (Lisp_Object sym
, Lisp_Object plist
)
3215 XSYMBOL (sym
)->plist
= plist
;
3219 set_symbol_next (Lisp_Object sym
, struct Lisp_Symbol
*next
)
3221 XSYMBOL (sym
)->next
= next
;
3225 make_symbol_constant (Lisp_Object sym
)
3227 XSYMBOL (sym
)->trapped_write
= SYMBOL_NOWRITE
;
3230 /* Buffer-local variable access functions. */
3233 blv_found (struct Lisp_Buffer_Local_Value
*blv
)
3235 eassert (blv
->found
== !EQ (blv
->defcell
, blv
->valcell
));
3239 /* Set overlay's property list. */
3242 set_overlay_plist (Lisp_Object overlay
, Lisp_Object plist
)
3244 XOVERLAY (overlay
)->plist
= plist
;
3247 /* Get text properties of S. */
3250 string_intervals (Lisp_Object s
)
3252 return XSTRING (s
)->intervals
;
3255 /* Set text properties of S to I. */
3258 set_string_intervals (Lisp_Object s
, INTERVAL i
)
3260 XSTRING (s
)->intervals
= i
;
3263 /* Set a Lisp slot in TABLE to VAL. Most code should use this instead
3264 of setting slots directly. */
3267 set_char_table_defalt (Lisp_Object table
, Lisp_Object val
)
3269 XCHAR_TABLE (table
)->defalt
= val
;
3272 set_char_table_purpose (Lisp_Object table
, Lisp_Object val
)
3274 XCHAR_TABLE (table
)->purpose
= val
;
3277 /* Set different slots in (sub)character tables. */
3280 set_char_table_extras (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3282 eassert (0 <= idx
&& idx
< CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (table
)));
3283 XCHAR_TABLE (table
)->extras
[idx
] = val
;
3287 set_char_table_contents (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3289 eassert (0 <= idx
&& idx
< (1 << CHARTAB_SIZE_BITS_0
));
3290 XCHAR_TABLE (table
)->contents
[idx
] = val
;
3294 set_sub_char_table_contents (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
3296 XSUB_CHAR_TABLE (table
)->contents
[idx
] = val
;
3299 /* Defined in data.c. */
3300 extern _Noreturn
void wrong_choice (Lisp_Object
, Lisp_Object
);
3301 extern void notify_variable_watchers (Lisp_Object
, Lisp_Object
,
3302 Lisp_Object
, Lisp_Object
);
3303 extern Lisp_Object
indirect_function (Lisp_Object
);
3304 extern Lisp_Object
find_symbol_value (Lisp_Object
);
3305 enum Arith_Comparison
{
3310 ARITH_LESS_OR_EQUAL
,
3313 extern Lisp_Object
arithcompare (Lisp_Object num1
, Lisp_Object num2
,
3314 enum Arith_Comparison comparison
);
3316 /* Convert the integer I to an Emacs representation, either the integer
3317 itself, or a cons of two or three integers, or if all else fails a float.
3318 I should not have side effects. */
3319 #define INTEGER_TO_CONS(i) \
3320 (! FIXNUM_OVERFLOW_P (i) \
3322 : EXPR_SIGNED (i) ? intbig_to_lisp (i) : uintbig_to_lisp (i))
3323 extern Lisp_Object
intbig_to_lisp (intmax_t);
3324 extern Lisp_Object
uintbig_to_lisp (uintmax_t);
3326 /* Convert the Emacs representation CONS back to an integer of type
3327 TYPE, storing the result the variable VAR. Signal an error if CONS
3328 is not a valid representation or is out of range for TYPE. */
3329 #define CONS_TO_INTEGER(cons, type, var) \
3330 (TYPE_SIGNED (type) \
3331 ? ((var) = cons_to_signed (cons, TYPE_MINIMUM (type), TYPE_MAXIMUM (type))) \
3332 : ((var) = cons_to_unsigned (cons, TYPE_MAXIMUM (type))))
3333 extern intmax_t cons_to_signed (Lisp_Object
, intmax_t, intmax_t);
3334 extern uintmax_t cons_to_unsigned (Lisp_Object
, uintmax_t);
3336 extern struct Lisp_Symbol
*indirect_variable (struct Lisp_Symbol
*);
3337 extern _Noreturn
void args_out_of_range (Lisp_Object
, Lisp_Object
);
3338 extern _Noreturn
void args_out_of_range_3 (Lisp_Object
, Lisp_Object
,
3340 extern _Noreturn
void circular_list (Lisp_Object
);
3341 extern Lisp_Object
do_symval_forwarding (union Lisp_Fwd
*);
3342 enum Set_Internal_Bind
{
3345 SET_INTERNAL_UNBIND
,
3346 SET_INTERNAL_THREAD_SWITCH
3348 extern void set_internal (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3349 enum Set_Internal_Bind
);
3350 extern void set_default_internal (Lisp_Object
, Lisp_Object
,
3351 enum Set_Internal_Bind bindflag
);
3353 extern void syms_of_data (void);
3354 extern void swap_in_global_binding (struct Lisp_Symbol
*);
3356 /* Defined in cmds.c */
3357 extern void syms_of_cmds (void);
3358 extern void keys_of_cmds (void);
3360 /* Defined in coding.c. */
3361 extern Lisp_Object
detect_coding_system (const unsigned char *, ptrdiff_t,
3362 ptrdiff_t, bool, bool, Lisp_Object
);
3363 extern void init_coding (void);
3364 extern void init_coding_once (void);
3365 extern void syms_of_coding (void);
3367 /* Defined in character.c. */
3368 extern ptrdiff_t chars_in_text (const unsigned char *, ptrdiff_t);
3369 extern ptrdiff_t multibyte_chars_in_text (const unsigned char *, ptrdiff_t);
3370 extern void syms_of_character (void);
3372 /* Defined in charset.c. */
3373 extern void init_charset (void);
3374 extern void init_charset_once (void);
3375 extern void syms_of_charset (void);
3376 /* Structure forward declarations. */
3379 /* Defined in syntax.c. */
3380 extern void init_syntax_once (void);
3381 extern void syms_of_syntax (void);
3383 /* Defined in fns.c. */
3384 enum { NEXT_ALMOST_PRIME_LIMIT
= 11 };
3385 extern EMACS_INT
next_almost_prime (EMACS_INT
) ATTRIBUTE_CONST
;
3386 extern Lisp_Object
larger_vector (Lisp_Object
, ptrdiff_t, ptrdiff_t);
3387 extern void sweep_weak_hash_tables (void);
3388 EMACS_UINT
hash_string (char const *, ptrdiff_t);
3389 EMACS_UINT
sxhash (Lisp_Object
, int);
3390 Lisp_Object
make_hash_table (struct hash_table_test
, EMACS_INT
, float, float,
3392 ptrdiff_t hash_lookup (struct Lisp_Hash_Table
*, Lisp_Object
, EMACS_UINT
*);
3393 ptrdiff_t hash_put (struct Lisp_Hash_Table
*, Lisp_Object
, Lisp_Object
,
3395 void hash_remove_from_table (struct Lisp_Hash_Table
*, Lisp_Object
);
3396 extern struct hash_table_test
const hashtest_eq
, hashtest_eql
, hashtest_equal
;
3397 extern void validate_subarray (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3398 ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
3399 extern Lisp_Object
substring_both (Lisp_Object
, ptrdiff_t, ptrdiff_t,
3400 ptrdiff_t, ptrdiff_t);
3401 extern Lisp_Object
merge (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3402 extern Lisp_Object
do_yes_or_no_p (Lisp_Object
);
3403 extern Lisp_Object
concat2 (Lisp_Object
, Lisp_Object
);
3404 extern Lisp_Object
concat3 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3405 extern bool equal_no_quit (Lisp_Object
, Lisp_Object
);
3406 extern Lisp_Object
nconc2 (Lisp_Object
, Lisp_Object
);
3407 extern Lisp_Object
assq_no_quit (Lisp_Object
, Lisp_Object
);
3408 extern Lisp_Object
assoc_no_quit (Lisp_Object
, Lisp_Object
);
3409 extern void clear_string_char_byte_cache (void);
3410 extern ptrdiff_t string_char_to_byte (Lisp_Object
, ptrdiff_t);
3411 extern ptrdiff_t string_byte_to_char (Lisp_Object
, ptrdiff_t);
3412 extern Lisp_Object
string_to_multibyte (Lisp_Object
);
3413 extern Lisp_Object
string_make_unibyte (Lisp_Object
);
3414 extern void syms_of_fns (void);
3416 /* Defined in floatfns.c. */
3417 extern void syms_of_floatfns (void);
3418 extern Lisp_Object
fmod_float (Lisp_Object x
, Lisp_Object y
);
3420 /* Defined in fringe.c. */
3421 extern void syms_of_fringe (void);
3422 extern void init_fringe (void);
3423 #ifdef HAVE_WINDOW_SYSTEM
3424 extern void mark_fringe_data (void);
3425 extern void init_fringe_once (void);
3426 #endif /* HAVE_WINDOW_SYSTEM */
3428 /* Defined in image.c. */
3429 extern int x_bitmap_mask (struct frame
*, ptrdiff_t);
3430 extern void reset_image_types (void);
3431 extern void syms_of_image (void);
3433 /* Defined in insdel.c. */
3434 extern void move_gap_both (ptrdiff_t, ptrdiff_t);
3435 extern _Noreturn
void buffer_overflow (void);
3436 extern void make_gap (ptrdiff_t);
3437 extern void make_gap_1 (struct buffer
*, ptrdiff_t);
3438 extern ptrdiff_t copy_text (const unsigned char *, unsigned char *,
3439 ptrdiff_t, bool, bool);
3440 extern int count_combining_before (const unsigned char *,
3441 ptrdiff_t, ptrdiff_t, ptrdiff_t);
3442 extern int count_combining_after (const unsigned char *,
3443 ptrdiff_t, ptrdiff_t, ptrdiff_t);
3444 extern void insert (const char *, ptrdiff_t);
3445 extern void insert_and_inherit (const char *, ptrdiff_t);
3446 extern void insert_1_both (const char *, ptrdiff_t, ptrdiff_t,
3448 extern void insert_from_gap (ptrdiff_t, ptrdiff_t, bool text_at_gap_tail
);
3449 extern void insert_from_string (Lisp_Object
, ptrdiff_t, ptrdiff_t,
3450 ptrdiff_t, ptrdiff_t, bool);
3451 extern void insert_from_buffer (struct buffer
*, ptrdiff_t, ptrdiff_t, bool);
3452 extern void insert_char (int);
3453 extern void insert_string (const char *);
3454 extern void insert_before_markers (const char *, ptrdiff_t);
3455 extern void insert_before_markers_and_inherit (const char *, ptrdiff_t);
3456 extern void insert_from_string_before_markers (Lisp_Object
, ptrdiff_t,
3457 ptrdiff_t, ptrdiff_t,
3459 extern void del_range (ptrdiff_t, ptrdiff_t);
3460 extern Lisp_Object
del_range_1 (ptrdiff_t, ptrdiff_t, bool, bool);
3461 extern void del_range_byte (ptrdiff_t, ptrdiff_t);
3462 extern void del_range_both (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, bool);
3463 extern Lisp_Object
del_range_2 (ptrdiff_t, ptrdiff_t,
3464 ptrdiff_t, ptrdiff_t, bool);
3465 extern void modify_text (ptrdiff_t, ptrdiff_t);
3466 extern void prepare_to_modify_buffer (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
3467 extern void prepare_to_modify_buffer_1 (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
3468 extern void invalidate_buffer_caches (struct buffer
*, ptrdiff_t, ptrdiff_t);
3469 extern void signal_after_change (ptrdiff_t, ptrdiff_t, ptrdiff_t);
3470 extern void adjust_after_insert (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3471 ptrdiff_t, ptrdiff_t);
3472 extern void adjust_markers_for_delete (ptrdiff_t, ptrdiff_t,
3473 ptrdiff_t, ptrdiff_t);
3474 extern void adjust_markers_bytepos (ptrdiff_t, ptrdiff_t,
3475 ptrdiff_t, ptrdiff_t, int);
3476 extern void replace_range (ptrdiff_t, ptrdiff_t, Lisp_Object
, bool, bool, bool, bool);
3477 extern void replace_range_2 (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
3478 const char *, ptrdiff_t, ptrdiff_t, bool);
3479 extern void syms_of_insdel (void);
3481 /* Defined in dispnew.c. */
3482 #if (defined PROFILING \
3483 && (defined __FreeBSD__ || defined GNU_LINUX || defined __MINGW32__))
3484 _Noreturn
void __executable_start (void);
3486 extern Lisp_Object Vwindow_system
;
3487 extern Lisp_Object
sit_for (Lisp_Object
, bool, int);
3489 /* Defined in xdisp.c. */
3490 extern bool noninteractive_need_newline
;
3491 extern Lisp_Object echo_area_buffer
[2];
3492 extern void add_to_log (char const *, ...);
3493 extern void vadd_to_log (char const *, va_list);
3494 extern void check_message_stack (void);
3495 extern void setup_echo_area_for_printing (bool);
3496 extern bool push_message (void);
3497 extern void pop_message_unwind (void);
3498 extern Lisp_Object
restore_message_unwind (Lisp_Object
);
3499 extern void restore_message (void);
3500 extern Lisp_Object
current_message (void);
3501 extern void clear_message (bool, bool);
3502 extern void message (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3503 extern void message1 (const char *);
3504 extern void message1_nolog (const char *);
3505 extern void message3 (Lisp_Object
);
3506 extern void message3_nolog (Lisp_Object
);
3507 extern void message_dolog (const char *, ptrdiff_t, bool, bool);
3508 extern void message_with_string (const char *, Lisp_Object
, bool);
3509 extern void message_log_maybe_newline (void);
3510 extern void update_echo_area (void);
3511 extern void truncate_echo_area (ptrdiff_t);
3512 extern void redisplay (void);
3514 void set_frame_cursor_types (struct frame
*, Lisp_Object
);
3515 extern void syms_of_xdisp (void);
3516 extern void init_xdisp (void);
3517 extern Lisp_Object
safe_eval (Lisp_Object
);
3518 extern bool pos_visible_p (struct window
*, ptrdiff_t, int *,
3519 int *, int *, int *, int *, int *);
3521 /* Defined in xsettings.c. */
3522 extern void syms_of_xsettings (void);
3524 /* Defined in vm-limit.c. */
3525 extern void memory_warnings (void *, void (*warnfun
) (const char *));
3527 /* Defined in character.c. */
3528 extern void parse_str_as_multibyte (const unsigned char *, ptrdiff_t,
3529 ptrdiff_t *, ptrdiff_t *);
3531 /* Defined in alloc.c. */
3532 extern void *my_heap_start (void);
3533 extern void check_pure_size (void);
3534 extern void free_misc (Lisp_Object
);
3535 extern void allocate_string_data (struct Lisp_String
*, EMACS_INT
, EMACS_INT
);
3536 extern void malloc_warning (const char *);
3537 extern _Noreturn
void memory_full (size_t);
3538 extern _Noreturn
void buffer_memory_full (ptrdiff_t);
3539 extern bool survives_gc_p (Lisp_Object
);
3540 extern void mark_object (Lisp_Object
);
3541 #if defined REL_ALLOC && !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
3542 extern void refill_memory_reserve (void);
3544 extern void alloc_unexec_pre (void);
3545 extern void alloc_unexec_post (void);
3546 extern void mark_stack (char *, char *);
3547 extern void flush_stack_call_func (void (*func
) (void *arg
), void *arg
);
3548 extern const char *pending_malloc_warning
;
3549 extern Lisp_Object zero_vector
;
3550 extern EMACS_INT consing_since_gc
;
3551 extern EMACS_INT gc_relative_threshold
;
3552 extern EMACS_INT memory_full_cons_threshold
;
3553 extern Lisp_Object
list1 (Lisp_Object
);
3554 extern Lisp_Object
list2 (Lisp_Object
, Lisp_Object
);
3555 extern Lisp_Object
list3 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3556 extern Lisp_Object
list4 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3557 extern Lisp_Object
list5 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
,
3559 enum constype
{CONSTYPE_HEAP
, CONSTYPE_PURE
};
3560 extern Lisp_Object
listn (enum constype
, ptrdiff_t, Lisp_Object
, ...);
3562 /* Build a frequently used 2/3/4-integer lists. */
3565 list2i (EMACS_INT x
, EMACS_INT y
)
3567 return list2 (make_number (x
), make_number (y
));
3571 list3i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
)
3573 return list3 (make_number (x
), make_number (y
), make_number (w
));
3577 list4i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
, EMACS_INT h
)
3579 return list4 (make_number (x
), make_number (y
),
3580 make_number (w
), make_number (h
));
3583 extern Lisp_Object
make_uninit_bool_vector (EMACS_INT
);
3584 extern Lisp_Object
bool_vector_fill (Lisp_Object
, Lisp_Object
);
3585 extern _Noreturn
void string_overflow (void);
3586 extern Lisp_Object
make_string (const char *, ptrdiff_t);
3587 extern Lisp_Object
make_formatted_string (char *, const char *, ...)
3588 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3589 extern Lisp_Object
make_unibyte_string (const char *, ptrdiff_t);
3591 /* Make unibyte string from C string when the length isn't known. */
3594 build_unibyte_string (const char *str
)
3596 return make_unibyte_string (str
, strlen (str
));
3599 extern Lisp_Object
make_multibyte_string (const char *, ptrdiff_t, ptrdiff_t);
3600 extern Lisp_Object
make_event_array (ptrdiff_t, Lisp_Object
*);
3601 extern Lisp_Object
make_uninit_string (EMACS_INT
);
3602 extern Lisp_Object
make_uninit_multibyte_string (EMACS_INT
, EMACS_INT
);
3603 extern Lisp_Object
make_string_from_bytes (const char *, ptrdiff_t, ptrdiff_t);
3604 extern Lisp_Object
make_specified_string (const char *,
3605 ptrdiff_t, ptrdiff_t, bool);
3606 extern Lisp_Object
make_pure_string (const char *, ptrdiff_t, ptrdiff_t, bool);
3607 extern Lisp_Object
make_pure_c_string (const char *, ptrdiff_t);
3609 /* Make a string allocated in pure space, use STR as string data. */
3612 build_pure_c_string (const char *str
)
3614 return make_pure_c_string (str
, strlen (str
));
3617 /* Make a string from the data at STR, treating it as multibyte if the
3621 build_string (const char *str
)
3623 return make_string (str
, strlen (str
));
3626 extern Lisp_Object
pure_cons (Lisp_Object
, Lisp_Object
);
3627 extern void make_byte_code (struct Lisp_Vector
*);
3628 extern struct Lisp_Vector
*allocate_vector (EMACS_INT
);
3630 /* Make an uninitialized vector for SIZE objects. NOTE: you must
3631 be sure that GC cannot happen until the vector is completely
3632 initialized. E.g. the following code is likely to crash:
3634 v = make_uninit_vector (3);
3636 ASET (v, 1, Ffunction_can_gc ());
3637 ASET (v, 2, obj1); */
3640 make_uninit_vector (ptrdiff_t size
)
3643 struct Lisp_Vector
*p
;
3645 p
= allocate_vector (size
);
3650 /* Like above, but special for sub char-tables. */
3653 make_uninit_sub_char_table (int depth
, int min_char
)
3655 int slots
= SUB_CHAR_TABLE_OFFSET
+ chartab_size
[depth
];
3656 Lisp_Object v
= make_uninit_vector (slots
);
3658 XSETPVECTYPE (XVECTOR (v
), PVEC_SUB_CHAR_TABLE
);
3659 XSUB_CHAR_TABLE (v
)->depth
= depth
;
3660 XSUB_CHAR_TABLE (v
)->min_char
= min_char
;
3664 extern struct Lisp_Vector
*allocate_pseudovector (int, int, int,
3667 /* Allocate partially initialized pseudovector where all Lisp_Object
3668 slots are set to Qnil but the rest (if any) is left uninitialized. */
3670 #define ALLOCATE_PSEUDOVECTOR(type, field, tag) \
3671 ((type *) allocate_pseudovector (VECSIZE (type), \
3672 PSEUDOVECSIZE (type, field), \
3673 PSEUDOVECSIZE (type, field), tag))
3675 /* Allocate fully initialized pseudovector where all Lisp_Object
3676 slots are set to Qnil and the rest (if any) is zeroed. */
3678 #define ALLOCATE_ZEROED_PSEUDOVECTOR(type, field, tag) \
3679 ((type *) allocate_pseudovector (VECSIZE (type), \
3680 PSEUDOVECSIZE (type, field), \
3681 VECSIZE (type), tag))
3683 extern bool gc_in_progress
;
3684 extern Lisp_Object
make_float (double);
3685 extern void display_malloc_warning (void);
3686 extern ptrdiff_t inhibit_garbage_collection (void);
3687 extern Lisp_Object
make_save_int_int_int (ptrdiff_t, ptrdiff_t, ptrdiff_t);
3688 extern Lisp_Object
make_save_obj_obj_obj_obj (Lisp_Object
, Lisp_Object
,
3689 Lisp_Object
, Lisp_Object
);
3690 extern Lisp_Object
make_save_ptr (void *);
3691 extern Lisp_Object
make_save_ptr_int (void *, ptrdiff_t);
3692 extern Lisp_Object
make_save_ptr_ptr (void *, void *);
3693 extern Lisp_Object
make_save_funcptr_ptr_obj (void (*) (void), void *,
3695 extern Lisp_Object
make_save_memory (Lisp_Object
*, ptrdiff_t);
3696 extern void free_save_value (Lisp_Object
);
3697 extern Lisp_Object
build_overlay (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3698 extern void free_marker (Lisp_Object
);
3699 extern void free_cons (struct Lisp_Cons
*);
3700 extern void init_alloc_once (void);
3701 extern void init_alloc (void);
3702 extern void syms_of_alloc (void);
3703 extern struct buffer
* allocate_buffer (void);
3704 extern int valid_lisp_object_p (Lisp_Object
);
3705 #ifdef GC_CHECK_CONS_LIST
3706 extern void check_cons_list (void);
3708 INLINE
void (check_cons_list
) (void) { lisp_h_check_cons_list (); }
3711 /* Defined in gmalloc.c. */
3712 #if !defined DOUG_LEA_MALLOC && !defined HYBRID_MALLOC && !defined SYSTEM_MALLOC
3713 extern size_t __malloc_extra_blocks
;
3715 #if !HAVE_DECL_ALIGNED_ALLOC
3716 extern void *aligned_alloc (size_t, size_t) ATTRIBUTE_MALLOC_SIZE ((2));
3718 extern void malloc_enable_thread (void);
3721 /* Defined in ralloc.c. */
3722 extern void *r_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3723 extern void r_alloc_free (void **);
3724 extern void *r_re_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3725 extern void r_alloc_reset_variable (void **, void **);
3726 extern void r_alloc_inhibit_buffer_relocation (int);
3729 /* Defined in chartab.c. */
3730 extern Lisp_Object
copy_char_table (Lisp_Object
);
3731 extern Lisp_Object
char_table_ref_and_range (Lisp_Object
, int,
3733 extern void char_table_set_range (Lisp_Object
, int, int, Lisp_Object
);
3734 extern void map_char_table (void (*) (Lisp_Object
, Lisp_Object
,
3736 Lisp_Object
, Lisp_Object
, Lisp_Object
);
3737 extern void map_char_table_for_charset (void (*c_function
) (Lisp_Object
, Lisp_Object
),
3738 Lisp_Object
, Lisp_Object
,
3739 Lisp_Object
, struct charset
*,
3740 unsigned, unsigned);
3741 extern Lisp_Object
uniprop_table (Lisp_Object
);
3742 extern void syms_of_chartab (void);
3744 /* Defined in print.c. */
3745 extern Lisp_Object Vprin1_to_string_buffer
;
3746 extern void debug_print (Lisp_Object
) EXTERNALLY_VISIBLE
;
3747 extern void temp_output_buffer_setup (const char *);
3748 extern int print_level
;
3749 extern void print_error_message (Lisp_Object
, Lisp_Object
, const char *,
3751 extern Lisp_Object internal_with_output_to_temp_buffer
3752 (const char *, Lisp_Object (*) (Lisp_Object
), Lisp_Object
);
3753 #define FLOAT_TO_STRING_BUFSIZE 350
3754 extern int float_to_string (char *, double);
3755 extern void init_print_once (void);
3756 extern void syms_of_print (void);
3758 /* Defined in doprnt.c. */
3759 extern ptrdiff_t doprnt (char *, ptrdiff_t, const char *, const char *,
3761 extern ptrdiff_t esprintf (char *, char const *, ...)
3762 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3763 extern ptrdiff_t exprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3765 ATTRIBUTE_FORMAT_PRINTF (5, 6);
3766 extern ptrdiff_t evxprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3767 char const *, va_list)
3768 ATTRIBUTE_FORMAT_PRINTF (5, 0);
3770 /* Defined in lread.c. */
3771 extern Lisp_Object
check_obarray (Lisp_Object
);
3772 extern Lisp_Object
intern_1 (const char *, ptrdiff_t);
3773 extern Lisp_Object
intern_c_string_1 (const char *, ptrdiff_t);
3774 extern Lisp_Object
intern_driver (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3775 extern void init_symbol (Lisp_Object
, Lisp_Object
);
3776 extern Lisp_Object
oblookup (Lisp_Object
, const char *, ptrdiff_t, ptrdiff_t);
3778 LOADHIST_ATTACH (Lisp_Object x
)
3781 Vcurrent_load_list
= Fcons (x
, Vcurrent_load_list
);
3783 extern int openp (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3784 Lisp_Object
*, Lisp_Object
, bool);
3785 extern Lisp_Object
string_to_number (char const *, int, bool);
3786 extern void map_obarray (Lisp_Object
, void (*) (Lisp_Object
, Lisp_Object
),
3788 extern void dir_warning (const char *, Lisp_Object
);
3789 extern void init_obarray (void);
3790 extern void init_lread (void);
3791 extern void syms_of_lread (void);
3794 intern (const char *str
)
3796 return intern_1 (str
, strlen (str
));
3800 intern_c_string (const char *str
)
3802 return intern_c_string_1 (str
, strlen (str
));
3805 /* Defined in eval.c. */
3806 extern Lisp_Object Vautoload_queue
;
3807 extern Lisp_Object Vrun_hooks
;
3808 extern Lisp_Object Vsignaling_function
;
3809 extern Lisp_Object inhibit_lisp_code
;
3811 /* To run a normal hook, use the appropriate function from the list below.
3812 The calling convention:
3814 if (!NILP (Vrun_hooks))
3815 call1 (Vrun_hooks, Qmy_funny_hook);
3817 should no longer be used. */
3818 extern void run_hook (Lisp_Object
);
3819 extern void run_hook_with_args_2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3820 extern Lisp_Object
run_hook_with_args (ptrdiff_t nargs
, Lisp_Object
*args
,
3821 Lisp_Object (*funcall
)
3822 (ptrdiff_t nargs
, Lisp_Object
*args
));
3823 extern Lisp_Object
quit (void);
3824 INLINE _Noreturn
void
3825 xsignal (Lisp_Object error_symbol
, Lisp_Object data
)
3827 Fsignal (error_symbol
, data
);
3829 extern _Noreturn
void xsignal0 (Lisp_Object
);
3830 extern _Noreturn
void xsignal1 (Lisp_Object
, Lisp_Object
);
3831 extern _Noreturn
void xsignal2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3832 extern _Noreturn
void xsignal3 (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3834 extern _Noreturn
void signal_error (const char *, Lisp_Object
);
3835 extern bool FUNCTIONP (Lisp_Object
);
3836 extern Lisp_Object
funcall_subr (struct Lisp_Subr
*subr
, ptrdiff_t numargs
, Lisp_Object
*arg_vector
);
3837 extern Lisp_Object
eval_sub (Lisp_Object form
);
3838 extern Lisp_Object
apply1 (Lisp_Object
, Lisp_Object
);
3839 extern Lisp_Object
call0 (Lisp_Object
);
3840 extern Lisp_Object
call1 (Lisp_Object
, Lisp_Object
);
3841 extern Lisp_Object
call2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3842 extern Lisp_Object
call3 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3843 extern Lisp_Object
call4 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3844 extern Lisp_Object
call5 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3845 extern Lisp_Object
call6 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3846 extern Lisp_Object
call7 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3847 extern Lisp_Object
internal_catch (Lisp_Object
, Lisp_Object (*) (Lisp_Object
), Lisp_Object
);
3848 extern Lisp_Object
internal_lisp_condition_case (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3849 extern Lisp_Object
internal_condition_case (Lisp_Object (*) (void), Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3850 extern Lisp_Object
internal_condition_case_1 (Lisp_Object (*) (Lisp_Object
), Lisp_Object
, Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3851 extern Lisp_Object
internal_condition_case_2 (Lisp_Object (*) (Lisp_Object
, Lisp_Object
), Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3852 extern Lisp_Object internal_condition_case_n
3853 (Lisp_Object (*) (ptrdiff_t, Lisp_Object
*), ptrdiff_t, Lisp_Object
*,
3854 Lisp_Object
, Lisp_Object (*) (Lisp_Object
, ptrdiff_t, Lisp_Object
*));
3855 extern struct handler
*push_handler (Lisp_Object
, enum handlertype
);
3856 extern struct handler
*push_handler_nosignal (Lisp_Object
, enum handlertype
);
3857 extern void specbind (Lisp_Object
, Lisp_Object
);
3858 extern void record_unwind_protect (void (*) (Lisp_Object
), Lisp_Object
);
3859 extern void record_unwind_protect_ptr (void (*) (void *), void *);
3860 extern void record_unwind_protect_int (void (*) (int), int);
3861 extern void record_unwind_protect_void (void (*) (void));
3862 extern void record_unwind_protect_nothing (void);
3863 extern void clear_unwind_protect (ptrdiff_t);
3864 extern void set_unwind_protect (ptrdiff_t, void (*) (Lisp_Object
), Lisp_Object
);
3865 extern void set_unwind_protect_ptr (ptrdiff_t, void (*) (void *), void *);
3866 extern Lisp_Object
unbind_to (ptrdiff_t, Lisp_Object
);
3867 extern void rebind_for_thread_switch (void);
3868 extern void unbind_for_thread_switch (struct thread_state
*);
3869 extern _Noreturn
void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3870 extern _Noreturn
void verror (const char *, va_list)
3871 ATTRIBUTE_FORMAT_PRINTF (1, 0);
3872 extern Lisp_Object
vformat_string (const char *, va_list)
3873 ATTRIBUTE_FORMAT_PRINTF (1, 0);
3874 extern void un_autoload (Lisp_Object
);
3875 extern Lisp_Object
call_debugger (Lisp_Object arg
);
3876 extern void *near_C_stack_top (void);
3877 extern void init_eval_once (void);
3878 extern Lisp_Object
safe_call (ptrdiff_t, Lisp_Object
, ...);
3879 extern Lisp_Object
safe_call1 (Lisp_Object
, Lisp_Object
);
3880 extern Lisp_Object
safe_call2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3881 extern void init_eval (void);
3882 extern void syms_of_eval (void);
3883 extern void prog_ignore (Lisp_Object
);
3884 extern ptrdiff_t record_in_backtrace (Lisp_Object
, Lisp_Object
*, ptrdiff_t);
3885 extern void mark_specpdl (union specbinding
*first
, union specbinding
*ptr
);
3886 extern void get_backtrace (Lisp_Object array
);
3887 Lisp_Object
backtrace_top_function (void);
3888 extern bool let_shadows_buffer_binding_p (struct Lisp_Symbol
*symbol
);
3890 /* Defined in unexmacosx.c. */
3891 #if defined DARWIN_OS && !defined CANNOT_DUMP
3892 extern void unexec_init_emacs_zone (void);
3893 extern void *unexec_malloc (size_t);
3894 extern void *unexec_realloc (void *, size_t);
3895 extern void unexec_free (void *);
3898 #include "emacs-module.h"
3900 /* Function prototype for the module Lisp functions. */
3901 typedef emacs_value (*emacs_subr
) (emacs_env
*, ptrdiff_t,
3902 emacs_value
[], void *);
3904 /* Module function. */
3906 /* A function environment is an auxiliary structure returned by
3907 `module_make_function' to store information about a module
3908 function. It is stored in a pseudovector. Its members correspond
3909 to the arguments given to `module_make_function'. */
3911 struct Lisp_Module_Function
3913 struct vectorlike_header header
;
3915 /* Fields traced by GC; these must come first. */
3916 Lisp_Object documentation
;
3918 /* Fields ignored by GC. */
3919 ptrdiff_t min_arity
, max_arity
;
3924 INLINE
struct Lisp_Module_Function
*
3925 allocate_module_function (void)
3927 return ALLOCATE_PSEUDOVECTOR (struct Lisp_Module_Function
,
3928 /* Name of the first field to be
3931 PVEC_MODULE_FUNCTION
);
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
);
3947 #define XSET_MODULE_FUNCTION(var, ptr) \
3948 (XSETPSEUDOVECTOR (var, ptr, PVEC_MODULE_FUNCTION))
3951 /* Defined in alloc.c. */
3952 extern Lisp_Object
make_user_ptr (void (*finalizer
) (void *), void *p
);
3954 /* Defined in emacs-module.c. */
3955 extern Lisp_Object
funcall_module (const struct Lisp_Module_Function
*,
3956 ptrdiff_t, Lisp_Object
*);
3957 extern Lisp_Object
module_function_arity (const struct Lisp_Module_Function
*);
3958 extern Lisp_Object
module_format_fun_env (const struct Lisp_Module_Function
*);
3959 extern void syms_of_module (void);
3962 /* Defined in thread.c. */
3963 extern void mark_threads (void);
3965 /* Defined in editfns.c. */
3966 extern void insert1 (Lisp_Object
);
3967 extern Lisp_Object
save_excursion_save (void);
3968 extern Lisp_Object
save_restriction_save (void);
3969 extern void save_excursion_restore (Lisp_Object
);
3970 extern void save_restriction_restore (Lisp_Object
);
3971 extern _Noreturn
void time_overflow (void);
3972 extern Lisp_Object
make_buffer_string (ptrdiff_t, ptrdiff_t, bool);
3973 extern Lisp_Object
make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3975 extern void init_editfns (bool);
3976 extern void syms_of_editfns (void);
3978 /* Defined in buffer.c. */
3979 extern bool mouse_face_overlay_overlaps (Lisp_Object
);
3980 extern _Noreturn
void nsberror (Lisp_Object
);
3981 extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
3982 extern void adjust_overlays_for_delete (ptrdiff_t, ptrdiff_t);
3983 extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
3984 extern void report_overlay_modification (Lisp_Object
, Lisp_Object
, bool,
3985 Lisp_Object
, Lisp_Object
, Lisp_Object
);
3986 extern bool overlay_touches_p (ptrdiff_t);
3987 extern Lisp_Object
other_buffer_safely (Lisp_Object
);
3988 extern Lisp_Object
get_truename_buffer (Lisp_Object
);
3989 extern void init_buffer_once (void);
3990 extern void init_buffer (int);
3991 extern void syms_of_buffer (void);
3992 extern void keys_of_buffer (void);
3994 /* Defined in marker.c. */
3996 extern ptrdiff_t marker_position (Lisp_Object
);
3997 extern ptrdiff_t marker_byte_position (Lisp_Object
);
3998 extern void clear_charpos_cache (struct buffer
*);
3999 extern ptrdiff_t buf_charpos_to_bytepos (struct buffer
*, ptrdiff_t);
4000 extern ptrdiff_t buf_bytepos_to_charpos (struct buffer
*, ptrdiff_t);
4001 extern void unchain_marker (struct Lisp_Marker
*marker
);
4002 extern Lisp_Object
set_marker_restricted (Lisp_Object
, Lisp_Object
, Lisp_Object
);
4003 extern Lisp_Object
set_marker_both (Lisp_Object
, Lisp_Object
, ptrdiff_t, ptrdiff_t);
4004 extern Lisp_Object
set_marker_restricted_both (Lisp_Object
, Lisp_Object
,
4005 ptrdiff_t, ptrdiff_t);
4006 extern Lisp_Object
build_marker (struct buffer
*, ptrdiff_t, ptrdiff_t);
4007 extern void syms_of_marker (void);
4009 /* Defined in fileio.c. */
4011 extern Lisp_Object
expand_and_dir_to_file (Lisp_Object
, Lisp_Object
);
4012 extern Lisp_Object
write_region (Lisp_Object
, Lisp_Object
, Lisp_Object
,
4013 Lisp_Object
, Lisp_Object
, Lisp_Object
,
4015 extern void close_file_unwind (int);
4016 extern void fclose_unwind (void *);
4017 extern void restore_point_unwind (Lisp_Object
);
4018 extern _Noreturn
void report_file_errno (const char *, Lisp_Object
, int);
4019 extern _Noreturn
void report_file_error (const char *, Lisp_Object
);
4020 extern _Noreturn
void report_file_notify_error (const char *, Lisp_Object
);
4021 extern bool internal_delete_file (Lisp_Object
);
4022 extern Lisp_Object
emacs_readlinkat (int, const char *);
4023 extern bool file_directory_p (const char *);
4024 extern bool file_accessible_directory_p (Lisp_Object
);
4025 extern void init_fileio (void);
4026 extern void syms_of_fileio (void);
4027 extern Lisp_Object
make_temp_name (Lisp_Object
, bool);
4029 /* Defined in search.c. */
4030 extern void shrink_regexp_cache (void);
4031 extern void restore_search_regs (void);
4032 extern void update_search_regs (ptrdiff_t oldstart
,
4033 ptrdiff_t oldend
, ptrdiff_t newend
);
4034 extern void record_unwind_save_match_data (void);
4035 struct re_registers
;
4036 extern struct re_pattern_buffer
*compile_pattern (Lisp_Object
,
4037 struct re_registers
*,
4038 Lisp_Object
, bool, bool);
4039 extern ptrdiff_t fast_string_match_internal (Lisp_Object
, Lisp_Object
,
4043 fast_string_match (Lisp_Object regexp
, Lisp_Object string
)
4045 return fast_string_match_internal (regexp
, string
, Qnil
);
4049 fast_string_match_ignore_case (Lisp_Object regexp
, Lisp_Object string
)
4051 return fast_string_match_internal (regexp
, string
, Vascii_canon_table
);
4054 extern ptrdiff_t fast_c_string_match_ignore_case (Lisp_Object
, const char *,
4056 extern ptrdiff_t fast_looking_at (Lisp_Object
, ptrdiff_t, ptrdiff_t,
4057 ptrdiff_t, ptrdiff_t, Lisp_Object
);
4058 extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
4059 ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
4060 extern ptrdiff_t scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
4062 extern ptrdiff_t scan_newline_from_point (ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
4063 extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t,
4064 ptrdiff_t, ptrdiff_t *);
4065 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
4066 ptrdiff_t, ptrdiff_t *);
4067 extern void syms_of_search (void);
4068 extern void clear_regexp_cache (void);
4070 /* Defined in minibuf.c. */
4072 extern Lisp_Object Vminibuffer_list
;
4073 extern Lisp_Object last_minibuf_string
;
4074 extern Lisp_Object
get_minibuffer (EMACS_INT
);
4075 extern void init_minibuf_once (void);
4076 extern void syms_of_minibuf (void);
4078 /* Defined in callint.c. */
4080 extern void syms_of_callint (void);
4082 /* Defined in casefiddle.c. */
4084 extern void syms_of_casefiddle (void);
4085 extern void keys_of_casefiddle (void);
4087 /* Defined in casetab.c. */
4089 extern void init_casetab_once (void);
4090 extern void syms_of_casetab (void);
4092 /* Defined in keyboard.c. */
4094 extern Lisp_Object echo_message_buffer
;
4095 extern struct kboard
*echo_kboard
;
4096 extern void cancel_echoing (void);
4097 extern bool input_pending
;
4098 #ifdef HAVE_STACK_OVERFLOW_HANDLING
4099 extern sigjmp_buf return_to_command_loop
;
4101 extern Lisp_Object
menu_bar_items (Lisp_Object
);
4102 extern Lisp_Object
tool_bar_items (Lisp_Object
, int *);
4103 extern void discard_mouse_events (void);
4105 void handle_input_available_signal (int);
4107 extern Lisp_Object pending_funcalls
;
4108 extern bool detect_input_pending (void);
4109 extern bool detect_input_pending_ignore_squeezables (void);
4110 extern bool detect_input_pending_run_timers (bool);
4111 extern void safe_run_hooks (Lisp_Object
);
4112 extern void cmd_error_internal (Lisp_Object
, const char *);
4113 extern Lisp_Object
command_loop_1 (void);
4114 extern Lisp_Object
read_menu_command (void);
4115 extern Lisp_Object
recursive_edit_1 (void);
4116 extern void record_auto_save (void);
4117 extern void force_auto_save_soon (void);
4118 extern void init_keyboard (void);
4119 extern void syms_of_keyboard (void);
4120 extern void keys_of_keyboard (void);
4122 /* Defined in indent.c. */
4123 extern ptrdiff_t current_column (void);
4124 extern void invalidate_current_column (void);
4125 extern bool indented_beyond_p (ptrdiff_t, ptrdiff_t, EMACS_INT
);
4126 extern void syms_of_indent (void);
4128 /* Defined in frame.c. */
4129 extern void store_frame_param (struct frame
*, Lisp_Object
, Lisp_Object
);
4130 extern void store_in_alist (Lisp_Object
*, Lisp_Object
, Lisp_Object
);
4131 extern Lisp_Object
do_switch_frame (Lisp_Object
, int, int, Lisp_Object
);
4132 extern Lisp_Object
get_frame_param (struct frame
*, Lisp_Object
);
4133 extern void frames_discard_buffer (Lisp_Object
);
4134 extern void syms_of_frame (void);
4136 /* Defined in emacs.c. */
4137 extern char **initial_argv
;
4138 extern int initial_argc
;
4139 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS)
4140 extern bool display_arg
;
4142 extern Lisp_Object
decode_env_path (const char *, const char *, bool);
4143 extern Lisp_Object empty_unibyte_string
, empty_multibyte_string
;
4144 extern _Noreturn
void terminate_due_to_signal (int, int);
4146 extern Lisp_Object Vlibrary_cache
;
4149 void fixup_locale (void);
4150 void synchronize_system_messages_locale (void);
4151 void synchronize_system_time_locale (void);
4153 INLINE
void fixup_locale (void) {}
4154 INLINE
void synchronize_system_messages_locale (void) {}
4155 INLINE
void synchronize_system_time_locale (void) {}
4157 extern char *emacs_strerror (int);
4158 extern void shut_down_emacs (int, Lisp_Object
);
4160 /* True means don't do interactive redisplay and don't change tty modes. */
4161 extern bool noninteractive
;
4163 /* True means remove site-lisp directories from load-path. */
4164 extern bool no_site_lisp
;
4166 /* True means put details like time stamps into builds. */
4167 extern bool build_details
;
4170 /* 0 not a daemon, 1 new-style (foreground), 2 old-style (background). */
4171 extern int daemon_type
;
4172 #define IS_DAEMON (daemon_type != 0)
4173 #define DAEMON_RUNNING (daemon_type >= 0)
4174 #else /* WINDOWSNT */
4175 extern void *w32_daemon_event
;
4176 #define IS_DAEMON (w32_daemon_event != NULL)
4177 #define DAEMON_RUNNING (w32_daemon_event != INVALID_HANDLE_VALUE)
4180 /* True if handling a fatal error already. */
4181 extern bool fatal_error_in_progress
;
4183 /* True means don't do use window-system-specific display code. */
4184 extern bool inhibit_window_system
;
4185 /* True means that a filter or a sentinel is running. */
4186 extern bool running_asynch_code
;
4188 /* Defined in process.c. */
4189 struct Lisp_Process
;
4190 extern void kill_buffer_processes (Lisp_Object
);
4191 extern int wait_reading_process_output (intmax_t, int, int, bool, Lisp_Object
,
4192 struct Lisp_Process
*, int);
4193 /* Max value for the first argument of wait_reading_process_output. */
4194 #if GNUC_PREREQ (3, 0, 0) && ! GNUC_PREREQ (4, 6, 0)
4195 /* Work around a bug in GCC 3.4.2, known to be fixed in GCC 4.6.0.
4196 The bug merely causes a bogus warning, but the warning is annoying. */
4197 # define WAIT_READING_MAX min (TYPE_MAXIMUM (time_t), INTMAX_MAX)
4199 # define WAIT_READING_MAX INTMAX_MAX
4202 extern void add_timer_wait_descriptor (int);
4204 extern void add_keyboard_wait_descriptor (int);
4205 extern void delete_keyboard_wait_descriptor (int);
4207 extern void add_gpm_wait_descriptor (int);
4208 extern void delete_gpm_wait_descriptor (int);
4210 extern void init_process_emacs (int);
4211 extern void syms_of_process (void);
4212 extern void setup_process_coding_systems (Lisp_Object
);
4214 /* Defined in callproc.c. */
4216 # define CHILD_SETUP_TYPE _Noreturn void
4218 # define CHILD_SETUP_TYPE int
4220 extern CHILD_SETUP_TYPE
child_setup (int, int, int, char **, bool, Lisp_Object
);
4221 extern void init_callproc_1 (void);
4222 extern void init_callproc (void);
4223 extern void set_initial_environment (void);
4224 extern void syms_of_callproc (void);
4226 /* Defined in doc.c. */
4227 enum text_quoting_style
4229 /* Use curved single quotes ‘like this’. */
4230 CURVE_QUOTING_STYLE
,
4232 /* Use grave accent and apostrophe `like this'. */
4233 GRAVE_QUOTING_STYLE
,
4235 /* Use apostrophes 'like this'. */
4236 STRAIGHT_QUOTING_STYLE
4238 extern enum text_quoting_style
text_quoting_style (void);
4239 extern Lisp_Object
read_doc_string (Lisp_Object
);
4240 extern Lisp_Object
get_doc_string (Lisp_Object
, bool, bool);
4241 extern void syms_of_doc (void);
4242 extern int read_bytecode_char (bool);
4244 /* Defined in bytecode.c. */
4245 extern void syms_of_bytecode (void);
4246 extern Lisp_Object
exec_byte_code (Lisp_Object
, Lisp_Object
, Lisp_Object
,
4247 Lisp_Object
, ptrdiff_t, Lisp_Object
*);
4248 extern Lisp_Object
get_byte_code_arity (Lisp_Object
);
4250 /* Defined in macros.c. */
4251 extern void init_macros (void);
4252 extern void syms_of_macros (void);
4254 /* Defined in undo.c. */
4255 extern void truncate_undo_list (struct buffer
*);
4256 extern void record_insert (ptrdiff_t, ptrdiff_t);
4257 extern void record_delete (ptrdiff_t, Lisp_Object
, bool);
4258 extern void record_first_change (void);
4259 extern void record_change (ptrdiff_t, ptrdiff_t);
4260 extern void record_property_change (ptrdiff_t, ptrdiff_t,
4261 Lisp_Object
, Lisp_Object
,
4263 extern void syms_of_undo (void);
4265 /* Defined in textprop.c. */
4266 extern void report_interval_modification (Lisp_Object
, Lisp_Object
);
4268 /* Defined in menu.c. */
4269 extern void syms_of_menu (void);
4271 /* Defined in xmenu.c. */
4272 extern void syms_of_xmenu (void);
4274 /* Defined in termchar.h. */
4275 struct tty_display_info
;
4277 /* Defined in sysdep.c. */
4278 #ifdef HAVE_PERSONALITY_ADDR_NO_RANDOMIZE
4279 extern bool disable_address_randomization (void);
4281 INLINE
bool disable_address_randomization (void) { return false; }
4283 extern int emacs_exec_file (char const *, char *const *, char *const *);
4284 extern void init_standard_fds (void);
4285 extern char *emacs_get_current_dir_name (void);
4286 extern void stuff_char (char c
);
4287 extern void init_foreground_group (void);
4288 extern void sys_subshell (void);
4289 extern void sys_suspend (void);
4290 extern void discard_tty_input (void);
4291 extern void init_sys_modes (struct tty_display_info
*);
4292 extern void reset_sys_modes (struct tty_display_info
*);
4293 extern void init_all_sys_modes (void);
4294 extern void reset_all_sys_modes (void);
4295 extern void child_setup_tty (int);
4296 extern void setup_pty (int);
4297 extern int set_window_size (int, int, int);
4298 extern EMACS_INT
get_random (void);
4299 extern void seed_random (void *, ptrdiff_t);
4300 extern void init_random (void);
4301 extern void emacs_backtrace (int);
4302 extern _Noreturn
void emacs_abort (void) NO_INLINE
;
4303 extern int emacs_open (const char *, int, int);
4304 extern int emacs_pipe (int[2]);
4305 extern int emacs_close (int);
4306 extern ptrdiff_t emacs_read (int, void *, ptrdiff_t);
4307 extern ptrdiff_t emacs_read_quit (int, void *, ptrdiff_t);
4308 extern ptrdiff_t emacs_write (int, void const *, ptrdiff_t);
4309 extern ptrdiff_t emacs_write_sig (int, void const *, ptrdiff_t);
4310 extern ptrdiff_t emacs_write_quit (int, void const *, ptrdiff_t);
4311 extern void emacs_perror (char const *);
4313 extern void unlock_all_files (void);
4314 extern void lock_file (Lisp_Object
);
4315 extern void unlock_file (Lisp_Object
);
4316 extern void unlock_buffer (struct buffer
*);
4317 extern void syms_of_filelock (void);
4318 extern int str_collate (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
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 decompress.c. */
4410 extern void syms_of_decompress (void);
4414 /* Defined in dbusbind.c. */
4415 void init_dbusbind (void);
4416 void syms_of_dbusbind (void);
4420 /* Defined in profiler.c. */
4421 extern bool profiler_memory_running
;
4422 extern void malloc_probe (size_t);
4423 extern void syms_of_profiler (void);
4427 /* Defined in msdos.c, w32.c. */
4428 extern char *emacs_root_dir (void);
4431 /* Defined in lastfile.c. */
4432 extern char my_edata
[];
4433 extern char my_endbss
[];
4434 extern char *my_endbss_static
;
4436 extern void *xmalloc (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
4437 extern void *xzalloc (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
4438 extern void *xrealloc (void *, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
4439 extern void xfree (void *);
4440 extern void *xnmalloc (ptrdiff_t, ptrdiff_t) ATTRIBUTE_MALLOC_SIZE ((1,2));
4441 extern void *xnrealloc (void *, ptrdiff_t, ptrdiff_t)
4442 ATTRIBUTE_ALLOC_SIZE ((2,3));
4443 extern void *xpalloc (void *, ptrdiff_t *, ptrdiff_t, ptrdiff_t, ptrdiff_t);
4445 extern char *xstrdup (const char *) ATTRIBUTE_MALLOC
;
4446 extern char *xlispstrdup (Lisp_Object
) ATTRIBUTE_MALLOC
;
4447 extern void dupstring (char **, char const *);
4449 /* Make DEST a copy of STRING's data. Return a pointer to DEST's terminating
4450 null byte. This is like stpcpy, except the source is a Lisp string. */
4453 lispstpcpy (char *dest
, Lisp_Object string
)
4455 ptrdiff_t len
= SBYTES (string
);
4456 memcpy (dest
, SDATA (string
), len
+ 1);
4460 extern void xputenv (const char *);
4462 extern char *egetenv_internal (const char *, ptrdiff_t);
4465 egetenv (const char *var
)
4467 /* When VAR is a string literal, strlen can be optimized away. */
4468 return egetenv_internal (var
, strlen (var
));
4471 /* Set up the name of the machine we're running on. */
4472 extern void init_system_name (void);
4474 /* Return the absolute value of X. X should be a signed integer
4475 expression without side effects, and X's absolute value should not
4476 exceed the maximum for its promoted type. This is called 'eabs'
4477 because 'abs' is reserved by the C standard. */
4478 #define eabs(x) ((x) < 0 ? -(x) : (x))
4480 /* Return a fixnum or float, depending on whether the integer VAL fits
4481 in a Lisp fixnum. */
4483 #define make_fixnum_or_float(val) \
4484 (FIXNUM_OVERFLOW_P (val) ? make_float (val) : make_number (val))
4486 /* SAFE_ALLOCA normally allocates memory on the stack, but if size is
4487 larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack. */
4489 enum MAX_ALLOCA
{ MAX_ALLOCA
= 16 * 1024 };
4491 extern void *record_xmalloc (size_t) ATTRIBUTE_ALLOC_SIZE ((1));
4493 #define USE_SAFE_ALLOCA \
4494 ptrdiff_t sa_avail = MAX_ALLOCA; \
4495 ptrdiff_t sa_count = SPECPDL_INDEX (); bool sa_must_free = false
4497 #define AVAIL_ALLOCA(size) (sa_avail -= (size), alloca (size))
4499 /* SAFE_ALLOCA allocates a simple buffer. */
4501 #define SAFE_ALLOCA(size) ((size) <= sa_avail \
4502 ? AVAIL_ALLOCA (size) \
4503 : (sa_must_free = true, record_xmalloc (size)))
4505 /* SAFE_NALLOCA sets BUF to a newly allocated array of MULTIPLIER *
4506 NITEMS items, each of the same type as *BUF. MULTIPLIER must
4507 positive. The code is tuned for MULTIPLIER being a constant. */
4509 #define SAFE_NALLOCA(buf, multiplier, nitems) \
4511 if ((nitems) <= sa_avail / sizeof *(buf) / (multiplier)) \
4512 (buf) = AVAIL_ALLOCA (sizeof *(buf) * (multiplier) * (nitems)); \
4515 (buf) = xnmalloc (nitems, sizeof *(buf) * (multiplier)); \
4516 sa_must_free = true; \
4517 record_unwind_protect_ptr (xfree, buf); \
4521 /* SAFE_ALLOCA_STRING allocates a C copy of a Lisp string. */
4523 #define SAFE_ALLOCA_STRING(ptr, string) \
4525 (ptr) = SAFE_ALLOCA (SBYTES (string) + 1); \
4526 memcpy (ptr, SDATA (string), SBYTES (string) + 1); \
4529 /* SAFE_FREE frees xmalloced memory and enables GC as needed. */
4531 #define SAFE_FREE() \
4533 if (sa_must_free) { \
4534 sa_must_free = false; \
4535 unbind_to (sa_count, Qnil); \
4539 /* Set BUF to point to an allocated array of NELT Lisp_Objects,
4540 immediately followed by EXTRA spare bytes. */
4542 #define SAFE_ALLOCA_LISP_EXTRA(buf, nelt, extra) \
4544 ptrdiff_t alloca_nbytes; \
4545 if (INT_MULTIPLY_WRAPV (nelt, word_size, &alloca_nbytes) \
4546 || INT_ADD_WRAPV (alloca_nbytes, extra, &alloca_nbytes) \
4547 || SIZE_MAX < alloca_nbytes) \
4548 memory_full (SIZE_MAX); \
4549 else if (alloca_nbytes <= sa_avail) \
4550 (buf) = AVAIL_ALLOCA (alloca_nbytes); \
4554 (buf) = xmalloc (alloca_nbytes); \
4555 arg_ = make_save_memory (buf, nelt); \
4556 sa_must_free = true; \
4557 record_unwind_protect (free_save_value, arg_); \
4561 /* Set BUF to point to an allocated array of NELT Lisp_Objects. */
4563 #define SAFE_ALLOCA_LISP(buf, nelt) SAFE_ALLOCA_LISP_EXTRA (buf, nelt, 0)
4566 /* If USE_STACK_LISP_OBJECTS, define macros that and functions that allocate
4567 block-scoped conses and strings. These objects are not
4568 managed by the garbage collector, so they are dangerous: passing them
4569 out of their scope (e.g., to user code) results in undefined behavior.
4570 Conversely, they have better performance because GC is not involved.
4572 This feature is experimental and requires careful debugging.
4573 Build with CPPFLAGS='-DUSE_STACK_LISP_OBJECTS=0' to disable it. */
4575 #if (!defined USE_STACK_LISP_OBJECTS \
4576 && defined __GNUC__ && !defined __clang__ && ! GNUC_PREREQ (4, 3, 2))
4577 /* Work around GCC bugs 36584 and 35271, which were fixed in GCC 4.3.2. */
4578 # define USE_STACK_LISP_OBJECTS false
4580 #ifndef USE_STACK_LISP_OBJECTS
4581 # define USE_STACK_LISP_OBJECTS true
4584 #ifdef GC_CHECK_STRING_BYTES
4585 enum { defined_GC_CHECK_STRING_BYTES
= true };
4587 enum { defined_GC_CHECK_STRING_BYTES
= false };
4590 /* Struct inside unions that are typically no larger and aligned enough. */
4595 double d
; intmax_t i
; void *p
;
4598 union Aligned_String
4600 struct Lisp_String s
;
4601 double d
; intmax_t i
; void *p
;
4604 /* True for stack-based cons and string implementations, respectively.
4605 Use stack-based strings only if stack-based cons also works.
4606 Otherwise, STACK_CONS would create heap-based cons cells that
4607 could point to stack-based strings, which is a no-no. */
4611 USE_STACK_CONS
= (USE_STACK_LISP_OBJECTS
4612 && alignof (union Aligned_Cons
) % GCALIGNMENT
== 0),
4613 USE_STACK_STRING
= (USE_STACK_CONS
4614 && !defined_GC_CHECK_STRING_BYTES
4615 && alignof (union Aligned_String
) % GCALIGNMENT
== 0)
4618 /* Auxiliary macros used for auto allocation of Lisp objects. Please
4619 use these only in macros like AUTO_CONS that declare a local
4620 variable whose lifetime will be clear to the programmer. */
4621 #define STACK_CONS(a, b) \
4622 make_lisp_ptr (&((union Aligned_Cons) { { a, { b } } }).s, Lisp_Cons)
4623 #define AUTO_CONS_EXPR(a, b) \
4624 (USE_STACK_CONS ? STACK_CONS (a, b) : Fcons (a, b))
4626 /* Declare NAME as an auto Lisp cons or short list if possible, a
4627 GC-based one otherwise. This is in the sense of the C keyword
4628 'auto'; i.e., the object has the lifetime of the containing block.
4629 The resulting object should not be made visible to user Lisp code. */
4631 #define AUTO_CONS(name, a, b) Lisp_Object name = AUTO_CONS_EXPR (a, b)
4632 #define AUTO_LIST1(name, a) \
4633 Lisp_Object name = (USE_STACK_CONS ? STACK_CONS (a, Qnil) : list1 (a))
4634 #define AUTO_LIST2(name, a, b) \
4635 Lisp_Object name = (USE_STACK_CONS \
4636 ? STACK_CONS (a, STACK_CONS (b, Qnil)) \
4638 #define AUTO_LIST3(name, a, b, c) \
4639 Lisp_Object name = (USE_STACK_CONS \
4640 ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c, Qnil))) \
4642 #define AUTO_LIST4(name, a, b, c, d) \
4645 ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c, \
4646 STACK_CONS (d, Qnil)))) \
4647 : list4 (a, b, c, d))
4649 /* Declare NAME as an auto Lisp string if possible, a GC-based one if not.
4650 Take its unibyte value from the null-terminated string STR,
4651 an expression that should not have side effects.
4652 STR's value is not necessarily copied. The resulting Lisp string
4653 should not be modified or made visible to user code. */
4655 #define AUTO_STRING(name, str) \
4656 AUTO_STRING_WITH_LEN (name, str, strlen (str))
4658 /* Declare NAME as an auto Lisp string if possible, a GC-based one if not.
4659 Take its unibyte value from the null-terminated string STR with length LEN.
4660 STR may have side effects and may contain null bytes.
4661 STR's value is not necessarily copied. The resulting Lisp string
4662 should not be modified or made visible to user code. */
4664 #define AUTO_STRING_WITH_LEN(name, str, len) \
4665 Lisp_Object name = \
4668 ((&((union Aligned_String) {{len, -1, 0, (unsigned char *) (str)}}).s), \
4670 : make_unibyte_string (str, len))
4672 /* Loop over conses of the list TAIL, signaling if a cycle is found,
4673 and possibly quitting after each loop iteration. In the loop body,
4674 set TAIL to the current cons. If the loop exits normally,
4675 set TAIL to the terminating non-cons, typically nil. The loop body
4676 should not modify the list’s top level structure other than by
4677 perhaps deleting the current cons. */
4679 #define FOR_EACH_TAIL(tail) \
4680 FOR_EACH_TAIL_INTERNAL (tail, circular_list (tail), true)
4682 /* Like FOR_EACH_TAIL (LIST), except do not signal or quit.
4683 If the loop exits due to a cycle, TAIL’s value is undefined. */
4685 #define FOR_EACH_TAIL_SAFE(tail) \
4686 FOR_EACH_TAIL_INTERNAL (tail, (void) ((tail) = Qnil), false)
4688 /* Iterator intended for use only within FOR_EACH_TAIL_INTERNAL. */
4689 struct for_each_tail_internal
4691 Lisp_Object tortoise
;
4693 unsigned short int q
;
4696 /* Like FOR_EACH_TAIL (LIST), except evaluate CYCLE if a cycle is
4697 found, and check for quit if CHECK_QUIT. This is an internal macro
4698 intended for use only by the above macros.
4700 Use Brent’s teleporting tortoise-hare algorithm. See:
4701 Brent RP. BIT. 1980;20(2):176-84. doi:10.1007/BF01933190
4702 http://maths-people.anu.edu.au/~brent/pd/rpb051i.pdf
4704 This macro uses maybe_quit because of an excess of caution. The
4705 call to maybe_quit should not be needed in practice, as a very long
4706 list, whether circular or not, will cause Emacs to be so slow in
4707 other uninterruptible areas (e.g., garbage collection) that there
4708 is little point to calling maybe_quit here. */
4710 #define FOR_EACH_TAIL_INTERNAL(tail, cycle, check_quit) \
4711 for (struct for_each_tail_internal li = { tail, 2, 0, 2 }; \
4713 ((tail) = XCDR (tail), \
4715 || ((check_quit) ? maybe_quit () : (void) 0, 0 < --li.n) \
4716 || (li.q = li.n = li.max <<= 1, li.n >>= USHRT_WIDTH, \
4717 li.tortoise = (tail), false)) \
4718 && EQ (tail, li.tortoise)) \
4719 ? (cycle) : (void) 0))
4721 /* Do a `for' loop over alist values. */
4723 #define FOR_EACH_ALIST_VALUE(head_var, list_var, value_var) \
4724 for ((list_var) = (head_var); \
4725 (CONSP (list_var) && ((value_var) = XCDR (XCAR (list_var)), true)); \
4726 (list_var) = XCDR (list_var))
4728 /* Check whether it's time for GC, and run it if so. */
4733 if ((consing_since_gc
> gc_cons_threshold
4734 && consing_since_gc
> gc_relative_threshold
)
4735 || (!NILP (Vmemory_full
)
4736 && consing_since_gc
> memory_full_cons_threshold
))
4737 Fgarbage_collect ();
4742 #endif /* EMACS_LISP_H */