1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
3 Copyright (C) 1985-1987, 1993-1995, 1997-2014 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
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
37 /* Define a TYPE constant ID as an externally visible name. Use like this:
39 #define ID_val (some integer preprocessor expression)
41 DEFINE_GDB_SYMBOL_ENUM (ID)
43 DEFINE_GDB_SYMBOL_BEGIN (TYPE, ID)
45 DEFINE_GDB_SYMBOL_END (ID)
48 This hack is for the benefit of compilers that do not make macro
49 definitions visible to the debugger. It's used for symbols that
50 .gdbinit needs, symbols whose values may not fit in 'int' (where an
53 Some GCC versions before GCC 4.2 omit enums in debugging output;
54 see GCC bug 23336. So don't use enums with older GCC. */
56 #if !defined __GNUC__ || 4 < __GNUC__ + (2 <= __GNUC_MINOR__)
57 # define ENUMABLE(val) (INT_MIN <= (val) && (val) <= INT_MAX)
59 # define ENUMABLE(val) 0
62 #define DEFINE_GDB_SYMBOL_ENUM(id) enum { id = id##_val };
63 #if defined MAIN_PROGRAM
64 # define DEFINE_GDB_SYMBOL_BEGIN(type, id) type const id EXTERNALLY_VISIBLE
65 # define DEFINE_GDB_SYMBOL_END(id) = id;
67 # define DEFINE_GDB_SYMBOL_BEGIN(type, id)
68 # define DEFINE_GDB_SYMBOL_END(val)
71 /* The ubiquitous max and min macros. */
74 #define max(a, b) ((a) > (b) ? (a) : (b))
75 #define min(a, b) ((a) < (b) ? (a) : (b))
77 /* Number of elements in an array. */
78 #define ARRAYELTS(arr) (sizeof (arr) / sizeof (arr)[0])
80 /* Number of bits in a Lisp_Object tag. */
81 DEFINE_GDB_SYMBOL_BEGIN (int, GCTYPEBITS
)
83 DEFINE_GDB_SYMBOL_END (GCTYPEBITS
)
85 /* The number of bits needed in an EMACS_INT over and above the number
86 of bits in a pointer. This is 0 on systems where:
87 1. We can specify multiple-of-8 alignment on static variables.
88 2. We know malloc returns a multiple of 8. */
89 #if (defined alignas \
90 && (defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ \
91 || defined DARWIN_OS || defined __sun || defined __MINGW32__))
92 # define NONPOINTER_BITS 0
94 # define NONPOINTER_BITS GCTYPEBITS
97 /* EMACS_INT - signed integer wide enough to hold an Emacs value
98 EMACS_INT_MAX - maximum value of EMACS_INT; can be used in #if
99 pI - printf length modifier for EMACS_INT
100 EMACS_UINT - unsigned variant of EMACS_INT */
102 typedef scm_t_signed_bits EMACS_INT
;
103 typedef scm_t_bits EMACS_UINT
;
104 #define EMACS_INT_MAX SCM_T_SIGNED_BITS_MAX
106 #if INTPTR_MAX == INT_MAX
108 #elif INTPTR_MAX == LONG_MAX
110 #elif INTPTR_MAX == LLONG_MAX
112 #elif INTPTR_MAX == INTMAX_MAX
115 #error "Cannot determine length modifier for EMACS_INT"
118 /* Number of bits to put in each character in the internal representation
119 of bool vectors. This should not vary across implementations. */
120 enum { BOOL_VECTOR_BITS_PER_CHAR
=
121 #define BOOL_VECTOR_BITS_PER_CHAR 8
122 BOOL_VECTOR_BITS_PER_CHAR
125 /* An unsigned integer type representing a fixed-length bit sequence,
126 suitable for bool vector words, GC mark bits, etc. Normally it is size_t
127 for speed, but it is unsigned char on weird platforms. */
128 #if BOOL_VECTOR_BITS_PER_CHAR == CHAR_BIT
129 typedef size_t bits_word
;
130 # define BITS_WORD_MAX SIZE_MAX
131 enum { BITS_PER_BITS_WORD
= CHAR_BIT
* sizeof (bits_word
) };
133 typedef unsigned char bits_word
;
134 # define BITS_WORD_MAX ((1u << BOOL_VECTOR_BITS_PER_CHAR) - 1)
135 enum { BITS_PER_BITS_WORD
= BOOL_VECTOR_BITS_PER_CHAR
};
137 verify (BITS_WORD_MAX
>> (BITS_PER_BITS_WORD
- 1) == 1);
139 /* Number of bits in some machine integer types. */
142 BITS_PER_CHAR
= CHAR_BIT
,
143 BITS_PER_SHORT
= CHAR_BIT
* sizeof (short),
144 BITS_PER_LONG
= CHAR_BIT
* sizeof (long int),
145 BITS_PER_EMACS_INT
= CHAR_BIT
* sizeof (EMACS_INT
)
148 /* printmax_t and uprintmax_t are types for printing large integers.
149 These are the widest integers that are supported for printing.
150 pMd etc. are conversions for printing them.
151 On C99 hosts, there's no problem, as even the widest integers work.
152 Fall back on EMACS_INT on pre-C99 hosts. */
154 typedef intmax_t printmax_t
;
155 typedef uintmax_t uprintmax_t
;
159 typedef EMACS_INT printmax_t
;
160 typedef EMACS_UINT uprintmax_t
;
165 /* Use pD to format ptrdiff_t values, which suffice for indexes into
166 buffers and strings. Emacs never allocates objects larger than
167 PTRDIFF_MAX bytes, as they cause problems with pointer subtraction.
168 In C99, pD can always be "t"; configure it here for the sake of
169 pre-C99 libraries such as glibc 2.0 and Solaris 8. */
170 #if PTRDIFF_MAX == INT_MAX
172 #elif PTRDIFF_MAX == LONG_MAX
174 #elif PTRDIFF_MAX == LLONG_MAX
180 /* Extra internal type checking? */
182 /* Define Emacs versions of <assert.h>'s 'assert (COND)' and <verify.h>'s
183 'assume (COND)'. COND should be free of side effects, as it may or
184 may not be evaluated.
186 'eassert (COND)' checks COND at runtime if ENABLE_CHECKING is
187 defined and suppress_checking is false, and does nothing otherwise.
188 Emacs dies if COND is checked and is false. The suppress_checking
189 variable is initialized to 0 in alloc.c. Set it to 1 using a
190 debugger to temporarily disable aborting on detected internal
191 inconsistencies or error conditions.
193 In some cases, a good compiler may be able to optimize away the
194 eassert macro even if ENABLE_CHECKING is true, e.g., if XSTRING (x)
195 uses eassert to test STRINGP (x), but a particular use of XSTRING
196 is invoked only after testing that STRINGP (x) is true, making the
199 eassume is like eassert except that it also causes the compiler to
200 assume that COND is true afterwards, regardless of whether runtime
201 checking is enabled. This can improve performance in some cases,
202 though it can degrade performance in others. It's often suboptimal
203 for COND to call external functions or access volatile storage. */
205 #ifndef ENABLE_CHECKING
206 # define eassert(cond) ((void) (false && (cond))) /* Check COND compiles. */
207 # define eassume(cond) assume (cond)
208 #else /* ENABLE_CHECKING */
210 extern _Noreturn
void die (const char *, const char *, int);
212 extern bool suppress_checking EXTERNALLY_VISIBLE
;
214 # define eassert(cond) \
215 (suppress_checking || (cond) \
217 : die (# cond, __FILE__, __LINE__))
218 # define eassume(cond) \
223 : die (# cond, __FILE__, __LINE__))
224 #endif /* ENABLE_CHECKING */
229 /* 2**GCTYPEBITS. This must be a macro that expands to a literal
230 integer constant, for MSVC. */
231 #define GCALIGNMENT 8
233 /* Number of bits in a Lisp fixnum value, not counting the tag. */
234 FIXNUM_BITS
= SCM_I_FIXNUM_BIT
237 #if GCALIGNMENT != 1 << GCTYPEBITS
238 # error "GCALIGNMENT and GCTYPEBITS are inconsistent"
241 DEFINE_GDB_SYMBOL_BEGIN (bool, USE_LSB_TAG
)
242 #define USE_LSB_TAG 1
243 DEFINE_GDB_SYMBOL_END (USE_LSB_TAG
)
246 # define alignas(alignment) /* empty */
248 # error "USE_LSB_TAG requires alignas"
252 /* Some operations are so commonly executed that they are implemented
253 as macros, not functions, because otherwise runtime performance would
254 suffer too much when compiling with GCC without optimization.
255 There's no need to inline everything, just the operations that
256 would otherwise cause a serious performance problem.
258 For each such operation OP, define a macro lisp_h_OP that contains
259 the operation's implementation. That way, OP can be implemented
260 via a macro definition like this:
262 #define OP(x) lisp_h_OP (x)
264 and/or via a function definition like this:
266 LISP_MACRO_DEFUN (OP, Lisp_Object, (Lisp_Object x), (x))
268 which macro-expands to this:
270 Lisp_Object (OP) (Lisp_Object x) { return lisp_h_OP (x); }
272 without worrying about the implementations diverging, since
273 lisp_h_OP defines the actual implementation. The lisp_h_OP macros
274 are intended to be private to this include file, and should not be
277 FIXME: Remove the lisp_h_OP macros, and define just the inline OP
278 functions, once most developers have access to GCC 4.8 or later and
279 can use "gcc -Og" to debug. Maybe in the year 2016. See
282 Commentary for these macros can be found near their corresponding
285 #define SMOB_PTR(a) ((void *) SCM_SMOB_DATA (a))
286 #define SMOB_TYPEP(x, tag) (x && SCM_SMOB_PREDICATE (tag, x))
287 #define lisp_h_XLI(o) (SCM_UNPACK (o))
288 #define lisp_h_XIL(i) (SCM_PACK (i))
289 #define lisp_h_CHECK_LIST_CONS(x, y) CHECK_TYPE (CONSP (x), Qlistp, y)
290 #define lisp_h_CHECK_NUMBER(x) CHECK_TYPE (INTEGERP (x), Qintegerp, x)
291 #define lisp_h_CHECK_SYMBOL(x) CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
292 #define lisp_h_CHECK_TYPE(ok, predicate, x) \
293 ((ok) ? (void) 0 : (void) wrong_type_argument (predicate, x))
294 #define lisp_h_CONSP(x) (x && scm_is_pair (x))
295 #define lisp_h_EQ(x, y) (scm_is_eq (x, y))
296 #define lisp_h_FLOATP(x) (x && SCM_INEXACTP (x))
297 #define lisp_h_INTEGERP(x) (SCM_I_INUMP (x))
298 #define lisp_h_MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
299 #define lisp_h_MISCP(x) (SMOB_TYPEP (x, lisp_misc_tag))
300 #define lisp_h_NILP(x) (scm_is_lisp_false (x))
301 #define lisp_h_SET_SYMBOL_VAL(sym, v) \
302 (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v))
303 #define lisp_h_SYMBOL_CONSTANT_P(sym) (XSYMBOL (sym)->constant)
304 #define lisp_h_SYMBOL_VAL(sym) \
305 (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value)
306 #define lisp_h_SYMBOLP(x) \
307 (x && (scm_is_symbol (x) || EQ (x, Qnil) || EQ (x, Qt)))
308 #define lisp_h_VECTORLIKEP(x) (SMOB_TYPEP (x, lisp_vectorlike_tag))
309 #define lisp_h_XCAR(c) (scm_car (c))
310 #define lisp_h_XCDR(c) (scm_cdr (c))
311 #define lisp_h_XHASH(a) (SCM_UNPACK (a))
313 /* Define NAME as a lisp.h inline function that returns TYPE and has
314 arguments declared as ARGDECLS and passed as ARGS. ARGDECLS and
315 ARGS should be parenthesized. Implement the function by calling
317 #define LISP_MACRO_DEFUN(name, type, argdecls, args) \
318 INLINE type (name) argdecls { return lisp_h_##name args; }
320 /* like LISP_MACRO_DEFUN, except NAME returns void. */
321 #define LISP_MACRO_DEFUN_VOID(name, argdecls, args) \
322 INLINE void (name) argdecls { lisp_h_##name args; }
325 /* Define the fundamental Lisp data structures. */
327 /* This is the set of Lisp data types. If you want to define a new
328 data type, read the comments after Lisp_Fwd_Type definition
331 #define INTMASK SCM_MOST_POSITIVE_FIXNUM
332 #define case_Lisp_Int case Lisp_Int
334 /* Idea stolen from GDB. Pedantic GCC complains about enum bitfields,
335 MSVC doesn't support them, and xlc and Oracle Studio c99 complain
336 vociferously about them. */
337 #if (defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__ \
338 || (defined __SUNPRO_C && __STDC__))
339 #define ENUM_BF(TYPE) unsigned int
341 #define ENUM_BF(TYPE) enum TYPE
344 scm_t_bits lisp_misc_tag
;
345 scm_t_bits lisp_string_tag
;
346 scm_t_bits lisp_vectorlike_tag
;
352 /* Integer. XINT (obj) is the integer value. */
355 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
358 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
359 whose first member indicates the subtype. */
362 /* String. XSTRING (object) points to a struct Lisp_String.
363 The length of the string, and its contents, are stored therein. */
366 /* Vector of Lisp objects, or something resembling it.
367 XVECTOR (object) points to a struct Lisp_Vector, which contains
368 the size and contents. The size field also contains the type
369 information, if it's not a real vector object. */
372 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
378 /* This is the set of data types that share a common structure.
379 The first member of the structure is a type code from this set.
380 The enum values are arbitrary, but we'll use large numbers to make it
381 more likely that we'll spot the error if a random word in memory is
382 mistakenly interpreted as a Lisp_Misc. */
385 Lisp_Misc_Free
= 0x5eab,
388 Lisp_Misc_Save_Value
,
389 /* Currently floats are not a misc type,
390 but let's define this in case we want to change that. */
392 /* This is not a type code. It is for range checking. */
396 /* These are the types of forwarding objects used in the value slot
397 of symbols for special built-in variables whose value is stored in
401 Lisp_Fwd_Int
, /* Fwd to a C `int' variable. */
402 Lisp_Fwd_Bool
, /* Fwd to a C boolean var. */
403 Lisp_Fwd_Obj
, /* Fwd to a C Lisp_Object variable. */
404 Lisp_Fwd_Buffer_Obj
, /* Fwd to a Lisp_Object field of buffers. */
405 Lisp_Fwd_Kboard_Obj
/* Fwd to a Lisp_Object field of kboards. */
408 typedef SCM Lisp_Object
;
410 #define LISP_INITIALLY_ZERO SCM_INUM0
412 /* Convert a Lisp_Object to the corresponding EMACS_INT and vice versa.
413 At the machine level, these operations are no-ops. */
414 LISP_MACRO_DEFUN (XLI
, EMACS_INT
, (Lisp_Object o
), (o
))
415 LISP_MACRO_DEFUN (XIL
, Lisp_Object
, (EMACS_INT i
), (i
))
417 /* In the size word of a struct Lisp_Vector, this bit means it's really
418 some other vector-like object. */
419 #define PSEUDOVECTOR_FLAG_val (PTRDIFF_MAX - PTRDIFF_MAX / 2)
420 #if ENUMABLE (PSEUDOVECTOR_FLAG_val)
421 DEFINE_GDB_SYMBOL_ENUM (PSEUDOVECTOR_FLAG
)
423 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, PSEUDOVECTOR_FLAG
)
424 # define PSEUDOVECTOR_FLAG PSEUDOVECTOR_FLAG_val
425 DEFINE_GDB_SYMBOL_END (PSEUDOVECTOR_FLAG
)
428 /* In a pseudovector, the size field actually contains a word with one
429 PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
430 with PVEC_TYPE_MASK to indicate the actual type. */
442 PVEC_WINDOW_CONFIGURATION
,
444 /* These should be last, check internal_equal to see why. */
448 PVEC_FONT
/* Should be last because it's used for range checking. */
453 /* For convenience, we also store the number of elements in these bits.
454 Note that this size is not necessarily the memory-footprint size, but
455 only the number of Lisp_Object fields (that need to be traced by GC).
456 The distinction is used, e.g., by Lisp_Process, which places extra
457 non-Lisp_Object fields at the end of the structure. */
458 PSEUDOVECTOR_SIZE_BITS
= 12,
459 PSEUDOVECTOR_SIZE_MASK
= (1 << PSEUDOVECTOR_SIZE_BITS
) - 1,
461 /* To calculate the memory footprint of the pseudovector, it's useful
462 to store the size of non-Lisp area in word_size units here. */
463 PSEUDOVECTOR_REST_BITS
= 12,
464 PSEUDOVECTOR_REST_MASK
= (((1 << PSEUDOVECTOR_REST_BITS
) - 1)
465 << PSEUDOVECTOR_SIZE_BITS
),
467 /* Used to extract pseudovector subtype information. */
468 PSEUDOVECTOR_AREA_BITS
= PSEUDOVECTOR_SIZE_BITS
+ PSEUDOVECTOR_REST_BITS
,
469 PVEC_TYPE_MASK
= 0x3f << PSEUDOVECTOR_AREA_BITS
472 /* These functions extract various sorts of values from a Lisp_Object.
473 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
474 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for
477 /* Largest and smallest representable fixnum values. These are the C
478 values. They are macros for use in static initializers. */
479 #define MOST_POSITIVE_FIXNUM SCM_MOST_POSITIVE_FIXNUM
480 #define MOST_NEGATIVE_FIXNUM SCM_MOST_NEGATIVE_FIXNUM
482 /* Make a Lisp integer representing the value of the low order
485 make_number (EMACS_INT n
)
487 return SCM_I_MAKINUM (n
);
490 /* Extract A's value as a signed integer. */
494 return SCM_I_INUM (a
);
497 /* Like XINT (A), but may be faster. A must be nonnegative.
498 If ! USE_LSB_TAG, this takes advantage of the fact that Lisp
499 integers have zero-bits in their tags. */
501 XFASTINT (Lisp_Object a
)
503 EMACS_INT n
= XINT (a
);
508 /* Extract A's value as an unsigned integer. */
510 XUINT (Lisp_Object a
)
512 return SCM_I_INUM (a
);
515 /* Return A's (Lisp-integer sized) hash. Happens to be like XUINT
516 right now, but XUINT should only be applied to objects we know are
518 LISP_MACRO_DEFUN (XHASH
, EMACS_INT
, (Lisp_Object a
), (a
))
520 /* Like make_number (N), but may be faster. N must be in nonnegative range. */
522 make_natnum (EMACS_INT n
)
524 eassert (0 <= n
&& n
<= MOST_POSITIVE_FIXNUM
);
525 return make_number (n
);
528 /* Return true if X and Y are the same object. */
529 LISP_MACRO_DEFUN (EQ
, bool, (Lisp_Object x
, Lisp_Object y
), (x
, y
))
531 /* Value is true if I doesn't fit into a Lisp fixnum. It is
532 written this way so that it also works if I is of unsigned
533 type or if I is a NaN. */
535 #define FIXNUM_OVERFLOW_P(i) \
536 (! ((0 <= (i) || MOST_NEGATIVE_FIXNUM <= (i)) && (i) <= MOST_POSITIVE_FIXNUM))
539 clip_to_bounds (ptrdiff_t lower
, EMACS_INT num
, ptrdiff_t upper
)
541 return num
< lower
? lower
: num
<= upper
? num
: upper
;
544 /* Forward declarations. */
546 /* Defined in this file. */
548 INLINE
bool BOOL_VECTOR_P (Lisp_Object
);
549 INLINE
bool BUFFER_OBJFWDP (union Lisp_Fwd
*);
550 INLINE
bool BUFFERP (Lisp_Object
);
551 INLINE
bool CHAR_TABLE_P (Lisp_Object
);
552 INLINE Lisp_Object
CHAR_TABLE_REF_ASCII (Lisp_Object
, ptrdiff_t);
553 INLINE
bool (CONSP
) (Lisp_Object
);
554 INLINE
bool (FLOATP
) (Lisp_Object
);
555 INLINE
bool functionp (Lisp_Object
);
556 INLINE
bool (INTEGERP
) (Lisp_Object
);
557 INLINE
bool (MARKERP
) (Lisp_Object
);
558 INLINE
bool (MISCP
) (Lisp_Object
);
559 INLINE
bool (NILP
) (Lisp_Object
);
560 INLINE
bool OVERLAYP (Lisp_Object
);
561 INLINE
bool PROCESSP (Lisp_Object
);
562 INLINE
bool PSEUDOVECTORP (Lisp_Object
, int);
563 INLINE
bool SAVE_VALUEP (Lisp_Object
);
564 INLINE
void set_sub_char_table_contents (Lisp_Object
, ptrdiff_t,
566 INLINE
bool STRINGP (Lisp_Object
);
567 INLINE
bool SUB_CHAR_TABLE_P (Lisp_Object
);
568 INLINE
bool (SYMBOLP
) (Lisp_Object
);
569 INLINE
bool (VECTORLIKEP
) (Lisp_Object
);
570 INLINE
bool WINDOWP (Lisp_Object
);
571 INLINE
struct Lisp_Save_Value
*XSAVE_VALUE (Lisp_Object
);
573 /* Defined in chartab.c. */
574 extern Lisp_Object
char_table_ref (Lisp_Object
, int);
575 extern void char_table_set (Lisp_Object
, int, Lisp_Object
);
576 extern int char_table_translate (Lisp_Object
, int);
578 /* Defined in data.c. */
579 extern Lisp_Object Qarrayp
, Qbufferp
, Qbuffer_or_string_p
, Qchar_table_p
;
580 extern Lisp_Object Qconsp
, Qfloatp
, Qintegerp
, Qlambda
, Qlistp
, Qmarkerp
, Qnil
;
581 extern Lisp_Object Qnumberp
, Qstringp
, Qsymbolp
, Qt
, Qvectorp
;
582 extern Lisp_Object Qbool_vector_p
;
583 extern Lisp_Object Qvector_or_char_table_p
, Qwholenump
;
584 extern Lisp_Object Qwindow
;
585 extern _Noreturn Lisp_Object
wrong_type_argument (Lisp_Object
, Lisp_Object
);
587 /* Defined in emacs.c. */
588 extern bool might_dump
;
589 /* True means Emacs has already been initialized.
590 Used during startup to detect startup of dumped Emacs. */
591 extern bool initialized
;
593 /* Defined in eval.c. */
594 extern Lisp_Object Qautoload
;
596 /* Defined in floatfns.c. */
597 extern double extract_float (Lisp_Object
);
599 /* Defined in process.c. */
600 extern Lisp_Object Qprocessp
;
602 /* Defined in window.c. */
603 extern Lisp_Object Qwindowp
;
605 /* Defined in xdisp.c. */
606 extern Lisp_Object Qimage
;
608 /* Extract A's type. */
609 INLINE
enum Lisp_Type
610 XTYPE (Lisp_Object o
)
614 else if (SYMBOLP (o
))
618 else if (STRINGP (o
))
620 else if (VECTORLIKEP (o
))
621 return Lisp_Vectorlike
;
630 /* Extract a value or address from a Lisp_Object. */
632 INLINE
struct Lisp_Vector
*
633 XVECTOR (Lisp_Object a
)
635 eassert (VECTORLIKEP (a
));
639 INLINE
struct Lisp_String
*
640 XSTRING (Lisp_Object a
)
642 eassert (STRINGP (a
));
646 extern void initialize_symbol (Lisp_Object
, Lisp_Object
);
647 INLINE Lisp_Object
build_string (const char *);
648 extern Lisp_Object symbol_module
;
649 extern Lisp_Object function_module
;
650 extern Lisp_Object plist_module
;
651 extern Lisp_Object Qt
, Qnil
, Qt_
, Qnil_
;
653 INLINE
struct Lisp_Symbol
*
654 XSYMBOL (Lisp_Object a
)
657 if (EQ (a
, Qt
)) a
= Qt_
;
658 if (EQ (a
, Qnil
)) a
= Qnil_
;
659 eassert (SYMBOLP (a
));
660 tem
= scm_variable_ref (scm_module_lookup (symbol_module
, a
));
661 return scm_to_pointer (tem
);
664 /* Pseudovector types. */
666 INLINE
struct Lisp_Process
*
667 XPROCESS (Lisp_Object a
)
669 eassert (PROCESSP (a
));
673 INLINE
struct window
*
674 XWINDOW (Lisp_Object a
)
676 eassert (WINDOWP (a
));
680 INLINE
struct terminal
*
681 XTERMINAL (Lisp_Object a
)
686 INLINE
struct buffer
*
687 XBUFFER (Lisp_Object a
)
689 eassert (BUFFERP (a
));
693 INLINE
struct Lisp_Char_Table
*
694 XCHAR_TABLE (Lisp_Object a
)
696 eassert (CHAR_TABLE_P (a
));
700 INLINE
struct Lisp_Sub_Char_Table
*
701 XSUB_CHAR_TABLE (Lisp_Object a
)
703 eassert (SUB_CHAR_TABLE_P (a
));
707 INLINE
struct Lisp_Bool_Vector
*
708 XBOOL_VECTOR (Lisp_Object a
)
710 eassert (BOOL_VECTOR_P (a
));
715 make_lisp_proc (struct Lisp_Process
*p
)
717 return scm_new_smob (lisp_vectorlike_tag
, (scm_t_bits
) p
);
720 #define XSETINT(a, b) ((a) = make_number (b))
721 #define XSETFASTINT(a, b) ((a) = make_natnum (b))
722 #define XSETVECTOR(a, b) ((a) = (b)->header.self)
723 #define XSETSTRING(a, b) ((a) = (b)->self)
724 #define XSETSYMBOL(a, b) ((a) = (b)->self)
725 #define XSETMISC(a, b) (a) = ((union Lisp_Misc *) (b))->u_any.self
727 /* Pseudovector types. */
729 #define XSETPVECTYPE(v, code) \
730 ((v)->header.size |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS))
731 #define XSETPVECTYPESIZE(v, code, lispsize, restsize) \
732 ((v)->header.size = (PSEUDOVECTOR_FLAG \
733 | ((code) << PSEUDOVECTOR_AREA_BITS) \
734 | ((restsize) << PSEUDOVECTOR_SIZE_BITS) \
737 /* The cast to struct vectorlike_header * avoids aliasing issues. */
738 #define XSETPSEUDOVECTOR(a, b, code) \
739 XSETTYPED_PSEUDOVECTOR (a, b, \
740 (((struct vectorlike_header *) \
744 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code) \
745 (XSETVECTOR (a, b), \
746 eassert ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) \
747 == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS))))
749 #define XSETWINDOW_CONFIGURATION(a, b) \
750 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
751 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
752 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
753 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
754 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
755 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
756 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
757 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
758 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
759 #define XSETSUB_CHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUB_CHAR_TABLE))
763 LISP_MACRO_DEFUN_VOID (CHECK_TYPE
,
764 (int ok
, Lisp_Object predicate
, Lisp_Object x
),
767 /* Deprecated and will be removed soon. */
769 #define INTERNAL_FIELD(field) field ## _
771 /* See the macros in intervals.h. */
773 typedef struct interval
*INTERVAL
;
775 LISP_MACRO_DEFUN (XCAR
, Lisp_Object
, (Lisp_Object c
), (c
))
776 LISP_MACRO_DEFUN (XCDR
, Lisp_Object
, (Lisp_Object c
), (c
))
778 /* Use these to set the fields of a cons cell.
780 Note that both arguments may refer to the same object, so 'n'
781 should not be read after 'c' is first modified. */
783 XSETCAR (Lisp_Object c
, Lisp_Object n
)
785 scm_set_car_x (c
, n
);
788 XSETCDR (Lisp_Object c
, Lisp_Object n
)
790 scm_set_cdr_x (c
, n
);
793 /* Take the car or cdr of something whose type is not known. */
797 return (CONSP (c
) ? XCAR (c
)
799 : wrong_type_argument (Qlistp
, c
));
804 return (CONSP (c
) ? XCDR (c
)
806 : wrong_type_argument (Qlistp
, c
));
809 /* Take the car or cdr of something whose type is not known. */
811 CAR_SAFE (Lisp_Object c
)
813 return CONSP (c
) ? XCAR (c
) : Qnil
;
816 CDR_SAFE (Lisp_Object c
)
818 return CONSP (c
) ? XCDR (c
) : Qnil
;
821 /* In a string or vector, the sign bit of the `size' is the gc mark bit. */
828 INTERVAL intervals
; /* Text properties in this string. */
832 /* True if STR is a multibyte string. */
834 STRING_MULTIBYTE (Lisp_Object str
)
836 return 0 <= XSTRING (str
)->size_byte
;
839 /* An upper bound on the number of bytes in a Lisp string, not
840 counting the terminating null. This a tight enough bound to
841 prevent integer overflow errors that would otherwise occur during
842 string size calculations. A string cannot contain more bytes than
843 a fixnum can represent, nor can it be so long that C pointer
844 arithmetic stops working on the string plus its terminating null.
845 Although the actual size limit (see STRING_BYTES_MAX in alloc.c)
846 may be a bit smaller than STRING_BYTES_BOUND, calculating it here
847 would expose alloc.c internal details that we'd rather keep
850 This is a macro for use in static initializers. The cast to
851 ptrdiff_t ensures that the macro is signed. */
852 #define STRING_BYTES_BOUND \
853 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1))
855 /* Mark STR as a unibyte string. */
856 #define STRING_SET_UNIBYTE(STR) \
858 if (EQ (STR, empty_multibyte_string)) \
859 (STR) = empty_unibyte_string; \
861 XSTRING (STR)->size_byte = -1; \
864 /* Mark STR as a multibyte string. Assure that STR contains only
865 ASCII characters in advance. */
866 #define STRING_SET_MULTIBYTE(STR) \
868 if (EQ (STR, empty_unibyte_string)) \
869 (STR) = empty_multibyte_string; \
871 XSTRING (STR)->size_byte = XSTRING (STR)->size; \
874 /* Convenience functions for dealing with Lisp strings. */
876 INLINE
unsigned char *
877 SDATA (Lisp_Object string
)
879 return XSTRING (string
)->data
;
882 SSDATA (Lisp_Object string
)
884 /* Avoid "differ in sign" warnings. */
885 return (char *) SDATA (string
);
888 SREF (Lisp_Object string
, ptrdiff_t index
)
890 return SDATA (string
)[index
];
893 SSET (Lisp_Object string
, ptrdiff_t index
, unsigned char new)
895 SDATA (string
)[index
] = new;
898 SCHARS (Lisp_Object string
)
900 return XSTRING (string
)->size
;
904 STRING_BYTES (struct Lisp_String
*s
)
906 return s
->size_byte
< 0 ? s
->size
: s
->size_byte
;
910 SBYTES (Lisp_Object string
)
912 return STRING_BYTES (XSTRING (string
));
915 STRING_SET_CHARS (Lisp_Object string
, ptrdiff_t newsize
)
917 XSTRING (string
)->size
= newsize
;
920 /* Header of vector-like objects. This documents the layout constraints on
921 vectors and pseudovectors (objects of PVEC_xxx subtype). It also prevents
922 compilers from being fooled by Emacs's type punning: XSETPSEUDOVECTOR
923 and PSEUDOVECTORP cast their pointers to struct vectorlike_header *,
924 because when two such pointers potentially alias, a compiler won't
925 incorrectly reorder loads and stores to their size fields. See
927 struct vectorlike_header
931 /* This field contains various pieces of information:
932 - The second bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
933 vector (0) or a pseudovector (1).
934 - If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
935 of slots) of the vector.
936 - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
937 - a) pseudovector subtype held in PVEC_TYPE_MASK field;
938 - b) number of Lisp_Objects slots at the beginning of the object
939 held in PSEUDOVECTOR_SIZE_MASK field. These objects are always
941 - c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
942 measured in word_size units. Rest fields may also include
943 Lisp_Objects, but these objects usually needs some special treatment
945 There are some exceptions. For PVEC_FREE, b) is always zero. For
946 PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
947 Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
948 4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots. */
952 /* A regular vector is just a header plus an array of Lisp_Objects. */
956 struct vectorlike_header header
;
957 Lisp_Object contents
[FLEXIBLE_ARRAY_MEMBER
];
960 /* C11 prohibits alignof (struct Lisp_Vector), so compute it manually. */
963 ALIGNOF_STRUCT_LISP_VECTOR
964 = alignof (union { struct vectorlike_header a
; Lisp_Object b
; })
967 /* A boolvector is a kind of vectorlike, with contents like a string. */
969 struct Lisp_Bool_Vector
971 /* HEADER.SIZE is the vector's size field. It doesn't have the real size,
972 just the subtype information. */
973 struct vectorlike_header header
;
974 /* This is the size in bits. */
976 /* The actual bits, packed into bytes.
977 Zeros fill out the last word if needed.
978 The bits are in little-endian order in the bytes, and
979 the bytes are in little-endian order in the words. */
980 bits_word data
[FLEXIBLE_ARRAY_MEMBER
];
984 bool_vector_size (Lisp_Object a
)
986 EMACS_INT size
= XBOOL_VECTOR (a
)->size
;
992 bool_vector_data (Lisp_Object a
)
994 return XBOOL_VECTOR (a
)->data
;
997 INLINE
unsigned char *
998 bool_vector_uchar_data (Lisp_Object a
)
1000 return (unsigned char *) bool_vector_data (a
);
1003 /* The number of data words and bytes in a bool vector with SIZE bits. */
1006 bool_vector_words (EMACS_INT size
)
1008 eassume (0 <= size
&& size
<= EMACS_INT_MAX
- (BITS_PER_BITS_WORD
- 1));
1009 return (size
+ BITS_PER_BITS_WORD
- 1) / BITS_PER_BITS_WORD
;
1013 bool_vector_bytes (EMACS_INT size
)
1015 eassume (0 <= size
&& size
<= EMACS_INT_MAX
- (BITS_PER_BITS_WORD
- 1));
1016 return (size
+ BOOL_VECTOR_BITS_PER_CHAR
- 1) / BOOL_VECTOR_BITS_PER_CHAR
;
1019 /* True if A's Ith bit is set. */
1022 bool_vector_bitref (Lisp_Object a
, EMACS_INT i
)
1024 eassume (0 <= i
&& i
< bool_vector_size (a
));
1025 return !! (bool_vector_uchar_data (a
)[i
/ BOOL_VECTOR_BITS_PER_CHAR
]
1026 & (1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
)));
1030 bool_vector_ref (Lisp_Object a
, EMACS_INT i
)
1032 return bool_vector_bitref (a
, i
) ? Qt
: Qnil
;
1035 /* Set A's Ith bit to B. */
1038 bool_vector_set (Lisp_Object a
, EMACS_INT i
, bool b
)
1040 unsigned char *addr
;
1042 eassume (0 <= i
&& i
< bool_vector_size (a
));
1043 addr
= &bool_vector_uchar_data (a
)[i
/ BOOL_VECTOR_BITS_PER_CHAR
];
1046 *addr
|= 1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
);
1048 *addr
&= ~ (1 << (i
% BOOL_VECTOR_BITS_PER_CHAR
));
1051 /* Some handy constants for calculating sizes
1052 and offsets, mostly of vectorlike objects. */
1056 header_size
= offsetof (struct Lisp_Vector
, contents
),
1057 bool_header_size
= offsetof (struct Lisp_Bool_Vector
, data
),
1058 word_size
= sizeof (Lisp_Object
)
1061 /* Conveniences for dealing with Lisp arrays. */
1064 AREF (Lisp_Object array
, ptrdiff_t idx
)
1066 return XVECTOR (array
)->contents
[idx
];
1069 INLINE Lisp_Object
*
1070 aref_addr (Lisp_Object array
, ptrdiff_t idx
)
1072 return & XVECTOR (array
)->contents
[idx
];
1076 ASIZE (Lisp_Object array
)
1078 return XVECTOR (array
)->header
.size
;
1082 ASET (Lisp_Object array
, ptrdiff_t idx
, Lisp_Object val
)
1084 eassert (0 <= idx
&& idx
< ASIZE (array
));
1085 XVECTOR (array
)->contents
[idx
] = val
;
1089 gc_aset (Lisp_Object array
, ptrdiff_t idx
, Lisp_Object val
)
1091 /* Like ASET, but also can be used in the garbage collector:
1092 sweep_weak_table calls set_hash_key etc. while the table is marked. */
1093 eassert (0 <= idx
&& idx
< (ASIZE (array
)));
1094 XVECTOR (array
)->contents
[idx
] = val
;
1097 /* If a struct is made to look like a vector, this macro returns the length
1098 of the shortest vector that would hold that struct. */
1100 #define VECSIZE(type) \
1101 ((sizeof (type) - header_size + word_size - 1) / word_size)
1103 /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields
1104 at the end and we need to compute the number of Lisp_Object fields (the
1105 ones that the GC needs to trace). */
1107 #define PSEUDOVECSIZE(type, nonlispfield) \
1108 ((offsetof (type, nonlispfield) - header_size) / word_size)
1110 /* Compute A OP B, using the unsigned comparison operator OP. A and B
1111 should be integer expressions. This is not the same as
1112 mathematical comparison; for example, UNSIGNED_CMP (0, <, -1)
1113 returns true. For efficiency, prefer plain unsigned comparison if A
1114 and B's sizes both fit (after integer promotion). */
1115 #define UNSIGNED_CMP(a, op, b) \
1116 (max (sizeof ((a) + 0), sizeof ((b) + 0)) <= sizeof (unsigned) \
1117 ? ((a) + (unsigned) 0) op ((b) + (unsigned) 0) \
1118 : ((a) + (uintmax_t) 0) op ((b) + (uintmax_t) 0))
1120 /* True iff C is an ASCII character. */
1121 #define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80)
1123 /* A char-table is a kind of vectorlike, with contents are like a
1124 vector but with a few other slots. For some purposes, it makes
1125 sense to handle a char-table with type struct Lisp_Vector. An
1126 element of a char table can be any Lisp objects, but if it is a sub
1127 char-table, we treat it a table that contains information of a
1128 specific range of characters. A sub char-table has the same
1129 structure as a vector. A sub char table appears only in an element
1130 of a char-table, and there's no way to access it directly from
1131 Emacs Lisp program. */
1133 enum CHARTAB_SIZE_BITS
1135 CHARTAB_SIZE_BITS_0
= 6,
1136 CHARTAB_SIZE_BITS_1
= 4,
1137 CHARTAB_SIZE_BITS_2
= 5,
1138 CHARTAB_SIZE_BITS_3
= 7
1141 extern const int chartab_size
[4];
1143 struct Lisp_Char_Table
1145 /* HEADER.SIZE is the vector's size field, which also holds the
1146 pseudovector type information. It holds the size, too.
1147 The size counts the defalt, parent, purpose, ascii,
1148 contents, and extras slots. */
1149 struct vectorlike_header header
;
1151 /* This holds a default value,
1152 which is used whenever the value for a specific character is nil. */
1155 /* This points to another char table, which we inherit from when the
1156 value for a specific character is nil. The `defalt' slot takes
1157 precedence over this. */
1160 /* This is a symbol which says what kind of use this char-table is
1162 Lisp_Object purpose
;
1164 /* The bottom sub char-table for characters of the range 0..127. It
1165 is nil if none of ASCII character has a specific value. */
1168 Lisp_Object contents
[(1 << CHARTAB_SIZE_BITS_0
)];
1170 /* These hold additional data. It is a vector. */
1171 Lisp_Object extras
[FLEXIBLE_ARRAY_MEMBER
];
1174 struct Lisp_Sub_Char_Table
1176 /* HEADER.SIZE is the vector's size field, which also holds the
1177 pseudovector type information. It holds the size, too. */
1178 struct vectorlike_header header
;
1180 /* Depth of this sub char-table. It should be 1, 2, or 3. A sub
1181 char-table of depth 1 contains 16 elements, and each element
1182 covers 4096 (128*32) characters. A sub char-table of depth 2
1183 contains 32 elements, and each element covers 128 characters. A
1184 sub char-table of depth 3 contains 128 elements, and each element
1185 is for one character. */
1188 /* Minimum character covered by the sub char-table. */
1189 Lisp_Object min_char
;
1191 /* Use set_sub_char_table_contents to set this. */
1192 Lisp_Object contents
[FLEXIBLE_ARRAY_MEMBER
];
1196 CHAR_TABLE_REF_ASCII (Lisp_Object ct
, ptrdiff_t idx
)
1198 struct Lisp_Char_Table
*tbl
= NULL
;
1202 tbl
= tbl
? XCHAR_TABLE (tbl
->parent
) : XCHAR_TABLE (ct
);
1203 val
= (! SUB_CHAR_TABLE_P (tbl
->ascii
) ? tbl
->ascii
1204 : XSUB_CHAR_TABLE (tbl
->ascii
)->contents
[idx
]);
1208 while (NILP (val
) && ! NILP (tbl
->parent
));
1213 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
1214 characters. Do not check validity of CT. */
1216 CHAR_TABLE_REF (Lisp_Object ct
, int idx
)
1218 return (ASCII_CHAR_P (idx
)
1219 ? CHAR_TABLE_REF_ASCII (ct
, idx
)
1220 : char_table_ref (ct
, idx
));
1223 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
1224 8-bit European characters. Do not check validity of CT. */
1226 CHAR_TABLE_SET (Lisp_Object ct
, int idx
, Lisp_Object val
)
1228 if (ASCII_CHAR_P (idx
) && SUB_CHAR_TABLE_P (XCHAR_TABLE (ct
)->ascii
))
1229 set_sub_char_table_contents (XCHAR_TABLE (ct
)->ascii
, idx
, val
);
1231 char_table_set (ct
, idx
, val
);
1234 /* This is the number of slots that every char table must have. This
1235 counts the ordinary slots and the top, defalt, parent, and purpose
1237 enum CHAR_TABLE_STANDARD_SLOTS
1239 CHAR_TABLE_STANDARD_SLOTS
= PSEUDOVECSIZE (struct Lisp_Char_Table
, extras
)
1242 /* Return the number of "extra" slots in the char table CT. */
1245 CHAR_TABLE_EXTRA_SLOTS (struct Lisp_Char_Table
*ct
)
1247 return ((ct
->header
.size
& PSEUDOVECTOR_SIZE_MASK
)
1248 - CHAR_TABLE_STANDARD_SLOTS
);
1252 /***********************************************************************
1254 ***********************************************************************/
1256 enum symbol_redirect
1258 SYMBOL_PLAINVAL
= 4,
1259 SYMBOL_VARALIAS
= 1,
1260 SYMBOL_LOCALIZED
= 2,
1261 SYMBOL_FORWARDED
= 3
1268 /* Indicates where the value can be found:
1269 0 : it's a plain var, the value is in the `value' field.
1270 1 : it's a varalias, the value is really in the `alias' symbol.
1271 2 : it's a localized var, the value is in the `blv' object.
1272 3 : it's a forwarding variable, the value is in `forward'. */
1273 ENUM_BF (symbol_redirect
) redirect
: 3;
1275 /* Non-zero means symbol is constant, i.e. changing its value
1276 should signal an error. If the value is 3, then the var
1277 can be changed, but only by `defconst'. */
1278 unsigned constant
: 2;
1280 /* True means that this variable has been explicitly declared
1281 special (with `defvar' etc), and shouldn't be lexically bound. */
1282 bool_bf declared_special
: 1;
1284 /* True if pointed to from purespace and hence can't be GC'd. */
1287 /* Value of the symbol or Qunbound if unbound. Which alternative of the
1288 union is used depends on the `redirect' field above. */
1291 struct Lisp_Symbol
*alias
;
1292 struct Lisp_Buffer_Local_Value
*blv
;
1293 union Lisp_Fwd
*fwd
;
1297 /* Value is name of symbol. */
1299 LISP_MACRO_DEFUN (SYMBOL_VAL
, Lisp_Object
, (struct Lisp_Symbol
*sym
), (sym
))
1301 INLINE
struct Lisp_Symbol
*
1302 SYMBOL_ALIAS (struct Lisp_Symbol
*sym
)
1304 eassert (sym
->redirect
== SYMBOL_VARALIAS
);
1305 return sym
->val
.alias
;
1307 INLINE
struct Lisp_Buffer_Local_Value
*
1308 SYMBOL_BLV (struct Lisp_Symbol
*sym
)
1310 eassert (sym
->redirect
== SYMBOL_LOCALIZED
);
1311 return sym
->val
.blv
;
1313 INLINE
union Lisp_Fwd
*
1314 SYMBOL_FWD (struct Lisp_Symbol
*sym
)
1316 eassert (sym
->redirect
== SYMBOL_FORWARDED
);
1317 return sym
->val
.fwd
;
1320 LISP_MACRO_DEFUN_VOID (SET_SYMBOL_VAL
,
1321 (struct Lisp_Symbol
*sym
, Lisp_Object v
), (sym
, v
))
1324 SET_SYMBOL_ALIAS (struct Lisp_Symbol
*sym
, struct Lisp_Symbol
*v
)
1326 eassert (sym
->redirect
== SYMBOL_VARALIAS
);
1330 SET_SYMBOL_BLV (struct Lisp_Symbol
*sym
, struct Lisp_Buffer_Local_Value
*v
)
1332 eassert (sym
->redirect
== SYMBOL_LOCALIZED
);
1336 SET_SYMBOL_FWD (struct Lisp_Symbol
*sym
, union Lisp_Fwd
*v
)
1338 eassert (sym
->redirect
== SYMBOL_FORWARDED
);
1343 SYMBOL_NAME (Lisp_Object sym
)
1345 if (EQ (sym
, Qnil
)) sym
= Qnil_
;
1346 if (EQ (sym
, Qt
)) sym
= Qt_
;
1347 return build_string (scm_to_locale_string (scm_symbol_to_string (sym
)));
1350 /* Value is true if SYM is an interned symbol. */
1353 SYMBOL_INTERNED_P (Lisp_Object sym
)
1355 if (EQ (sym
, Qnil
)) sym
= Qnil_
;
1356 if (EQ (sym
, Qt
)) sym
= Qt_
;
1357 return scm_is_true (scm_symbol_interned_p (sym
));
1361 SYMBOL_FUNCTION (Lisp_Object sym
)
1363 if (EQ (sym
, Qnil
)) sym
= Qnil_
;
1364 if (EQ (sym
, Qt
)) sym
= Qt_
;
1365 return scm_variable_ref (scm_module_lookup (function_module
, sym
));
1368 /* Value is non-zero if symbol is considered a constant, i.e. its
1369 value cannot be changed (there is an exception for keyword symbols,
1370 whose value can be set to the keyword symbol itself). */
1372 LISP_MACRO_DEFUN (SYMBOL_CONSTANT_P
, int, (Lisp_Object sym
), (sym
))
1374 #define DEFSYM(sym, name) \
1375 do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (false)
1378 /***********************************************************************
1380 ***********************************************************************/
1382 /* The structure of a Lisp hash table. */
1384 struct hash_table_test
1386 /* Name of the function used to compare keys. */
1389 /* User-supplied hash function, or nil. */
1390 Lisp_Object user_hash_function
;
1392 /* User-supplied key comparison function, or nil. */
1393 Lisp_Object user_cmp_function
;
1395 /* C function to compare two keys. */
1396 bool (*cmpfn
) (struct hash_table_test
*t
, Lisp_Object
, Lisp_Object
);
1398 /* C function to compute hash code. */
1399 EMACS_UINT (*hashfn
) (struct hash_table_test
*t
, Lisp_Object
);
1402 struct Lisp_Hash_Table
1404 /* This is for Lisp; the hash table code does not refer to it. */
1405 struct vectorlike_header header
;
1407 /* Nil if table is non-weak. Otherwise a symbol describing the
1408 weakness of the table. */
1411 /* When the table is resized, and this is an integer, compute the
1412 new size by adding this to the old size. If a float, compute the
1413 new size by multiplying the old size with this factor. */
1414 Lisp_Object rehash_size
;
1416 /* Resize hash table when number of entries/ table size is >= this
1418 Lisp_Object rehash_threshold
;
1420 /* Vector of hash codes. If hash[I] is nil, this means that the
1421 I-th entry is unused. */
1424 /* Vector used to chain entries. If entry I is free, next[I] is the
1425 entry number of the next free item. If entry I is non-free,
1426 next[I] is the index of the next entry in the collision chain. */
1429 /* Index of first free entry in free list. */
1430 Lisp_Object next_free
;
1432 /* Bucket vector. A non-nil entry is the index of the first item in
1433 a collision chain. This vector's size can be larger than the
1434 hash table size to reduce collisions. */
1437 /* Only the fields above are traced normally by the GC. The ones below
1438 `count' are special and are either ignored by the GC or traced in
1439 a special way (e.g. because of weakness). */
1441 /* Number of key/value entries in the table. */
1444 /* Vector of keys and values. The key of item I is found at index
1445 2 * I, the value is found at index 2 * I + 1.
1446 This is gc_marked specially if the table is weak. */
1447 Lisp_Object key_and_value
;
1449 /* The comparison and hash functions. */
1450 struct hash_table_test test
;
1452 /* Next weak hash table if this is a weak hash table. The head
1453 of the list is in weak_hash_tables. */
1454 struct Lisp_Hash_Table
*next_weak
;
1458 INLINE
struct Lisp_Hash_Table
*
1459 XHASH_TABLE (Lisp_Object a
)
1461 return SMOB_PTR (a
);
1464 #define XSET_HASH_TABLE(VAR, PTR) \
1465 (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
1468 HASH_TABLE_P (Lisp_Object a
)
1470 return PSEUDOVECTORP (a
, PVEC_HASH_TABLE
);
1473 /* Value is the key part of entry IDX in hash table H. */
1475 HASH_KEY (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
1477 return AREF (h
->key_and_value
, 2 * idx
);
1480 /* Value is the value part of entry IDX in hash table H. */
1482 HASH_VALUE (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
1484 return AREF (h
->key_and_value
, 2 * idx
+ 1);
1487 /* Value is the index of the next entry following the one at IDX
1490 HASH_NEXT (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
1492 return AREF (h
->next
, idx
);
1495 /* Value is the hash code computed for entry IDX in hash table H. */
1497 HASH_HASH (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
1499 return AREF (h
->hash
, idx
);
1502 /* Value is the index of the element in hash table H that is the
1503 start of the collision list at index IDX in the index vector of H. */
1505 HASH_INDEX (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
)
1507 return AREF (h
->index
, idx
);
1510 /* Value is the size of hash table H. */
1512 HASH_TABLE_SIZE (struct Lisp_Hash_Table
*h
)
1514 return ASIZE (h
->next
);
1517 /* Default size for hash tables if not specified. */
1519 enum DEFAULT_HASH_SIZE
{ DEFAULT_HASH_SIZE
= 65 };
1521 /* Default threshold specifying when to resize a hash table. The
1522 value gives the ratio of current entries in the hash table and the
1523 size of the hash table. */
1525 static double const DEFAULT_REHASH_THRESHOLD
= 0.8;
1527 /* Default factor by which to increase the size of a hash table. */
1529 static double const DEFAULT_REHASH_SIZE
= 1.5;
1531 /* Combine two integers X and Y for hashing. The result might not fit
1532 into a Lisp integer. */
1535 sxhash_combine (EMACS_UINT x
, EMACS_UINT y
)
1537 return (x
<< 4) + (x
>> (BITS_PER_EMACS_INT
- 4)) + y
;
1540 /* Hash X, returning a value that fits into a fixnum. */
1543 SXHASH_REDUCE (EMACS_UINT x
)
1545 return (x
^ x
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
+ 1)) & INTMASK
;
1548 /* These structures are used for various misc types. */
1550 struct Lisp_Misc_Any
/* Supertype of all Misc types. */
1553 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_??? */
1559 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Marker */
1560 /* This flag is temporarily used in the functions
1561 decode/encode_coding_object to record that the marker position
1562 must be adjusted after the conversion. */
1563 bool_bf need_adjustment
: 1;
1564 /* True means normal insertion at the marker's position
1565 leaves the marker after the inserted text. */
1566 bool_bf insertion_type
: 1;
1567 /* This is the buffer that the marker points into, or 0 if it points nowhere.
1568 Note: a chain of markers can contain markers pointing into different
1569 buffers (the chain is per buffer_text rather than per buffer, so it's
1570 shared between indirect buffers). */
1571 /* This is used for (other than NULL-checking):
1573 - Fset_marker: check eq(oldbuf, newbuf) to avoid unchain+rechain.
1574 - unchain_marker: to find the list from which to unchain.
1575 - Fkill_buffer: to only unchain the markers of current indirect buffer.
1577 struct buffer
*buffer
;
1579 /* The remaining fields are meaningless in a marker that
1580 does not point anywhere. */
1582 /* For markers that point somewhere,
1583 this is used to chain of all the markers in a given buffer. */
1584 /* We could remove it and use an array in buffer_text instead.
1585 That would also allow to preserve it ordered. */
1586 struct Lisp_Marker
*next
;
1587 /* This is the char position where the marker points. */
1589 /* This is the byte position.
1590 It's mostly used as a charpos<->bytepos cache (i.e. it's not directly
1591 used to implement the functionality of markers, but rather to (ab)use
1592 markers as a cache for char<->byte mappings). */
1596 /* START and END are markers in the overlay's buffer, and
1597 PLIST is the overlay's property list. */
1599 /* An overlay's real data content is:
1601 - buffer (really there are two buffer pointers, one per marker,
1602 and both points to the same buffer)
1603 - insertion type of both ends (per-marker fields)
1604 - start & start byte (of start marker)
1605 - end & end byte (of end marker)
1606 - next (singly linked list of overlays)
1607 - next fields of start and end markers (singly linked list of markers).
1608 I.e. 9words plus 2 bits, 3words of which are for external linked lists.
1612 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Overlay */
1613 struct Lisp_Overlay
*next
;
1619 /* Types of data which may be saved in a Lisp_Save_Value. */
1630 /* Number of bits needed to store one of the above values. */
1631 enum { SAVE_SLOT_BITS
= 3 };
1633 /* Number of slots in a save value where save_type is nonzero. */
1634 enum { SAVE_VALUE_SLOTS
= 4 };
1636 /* Bit-width and values for struct Lisp_Save_Value's save_type member. */
1638 enum { SAVE_TYPE_BITS
= SAVE_VALUE_SLOTS
* SAVE_SLOT_BITS
+ 1 };
1642 SAVE_TYPE_INT_INT
= SAVE_INTEGER
+ (SAVE_INTEGER
<< SAVE_SLOT_BITS
),
1643 SAVE_TYPE_INT_INT_INT
1644 = (SAVE_INTEGER
+ (SAVE_TYPE_INT_INT
<< SAVE_SLOT_BITS
)),
1645 SAVE_TYPE_OBJ_OBJ
= SAVE_OBJECT
+ (SAVE_OBJECT
<< SAVE_SLOT_BITS
),
1646 SAVE_TYPE_OBJ_OBJ_OBJ
= SAVE_OBJECT
+ (SAVE_TYPE_OBJ_OBJ
<< SAVE_SLOT_BITS
),
1647 SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
1648 = SAVE_OBJECT
+ (SAVE_TYPE_OBJ_OBJ_OBJ
<< SAVE_SLOT_BITS
),
1649 SAVE_TYPE_PTR_INT
= SAVE_POINTER
+ (SAVE_INTEGER
<< SAVE_SLOT_BITS
),
1650 SAVE_TYPE_PTR_OBJ
= SAVE_POINTER
+ (SAVE_OBJECT
<< SAVE_SLOT_BITS
),
1651 SAVE_TYPE_PTR_PTR
= SAVE_POINTER
+ (SAVE_POINTER
<< SAVE_SLOT_BITS
),
1652 SAVE_TYPE_FUNCPTR_PTR_OBJ
1653 = SAVE_FUNCPOINTER
+ (SAVE_TYPE_PTR_OBJ
<< SAVE_SLOT_BITS
),
1655 /* This has an extra bit indicating it's raw memory. */
1656 SAVE_TYPE_MEMORY
= SAVE_TYPE_PTR_INT
+ (1 << (SAVE_TYPE_BITS
- 1))
1659 /* Special object used to hold a different values for later use.
1661 This is mostly used to package C integers and pointers to call
1662 record_unwind_protect when two or more values need to be saved.
1666 struct my_data *md = get_my_data ();
1667 ptrdiff_t mi = get_my_integer ();
1668 record_unwind_protect (my_unwind, make_save_ptr_int (md, mi));
1671 Lisp_Object my_unwind (Lisp_Object arg)
1673 struct my_data *md = XSAVE_POINTER (arg, 0);
1674 ptrdiff_t mi = XSAVE_INTEGER (arg, 1);
1678 If ENABLE_CHECKING is in effect, XSAVE_xxx macros do type checking of the
1679 saved objects and raise eassert if type of the saved object doesn't match
1680 the type which is extracted. In the example above, XSAVE_INTEGER (arg, 2)
1681 and XSAVE_OBJECT (arg, 0) are wrong because nothing was saved in slot 2 and
1682 slot 0 is a pointer. */
1684 typedef void (*voidfuncptr
) (void);
1686 struct Lisp_Save_Value
1689 ENUM_BF (Lisp_Misc_Type
) type
: 16; /* = Lisp_Misc_Save_Value */
1690 unsigned spacer
: 32 - (16 + SAVE_TYPE_BITS
);
1692 /* V->data may hold up to SAVE_VALUE_SLOTS entries. The type of
1693 V's data entries are determined by V->save_type. E.g., if
1694 V->save_type == SAVE_TYPE_PTR_OBJ, V->data[0] is a pointer,
1695 V->data[1] is an integer, and V's other data entries are unused.
1697 If V->save_type == SAVE_TYPE_MEMORY, V->data[0].pointer is the address of
1698 a memory area containing V->data[1].integer potential Lisp_Objects. */
1699 ENUM_BF (Lisp_Save_Type
) save_type
: SAVE_TYPE_BITS
;
1702 voidfuncptr funcpointer
;
1705 } data
[SAVE_VALUE_SLOTS
];
1708 /* Return the type of V's Nth saved value. */
1710 save_type (struct Lisp_Save_Value
*v
, int n
)
1712 eassert (0 <= n
&& n
< SAVE_VALUE_SLOTS
);
1713 return (v
->save_type
>> (SAVE_SLOT_BITS
* n
) & ((1 << SAVE_SLOT_BITS
) - 1));
1716 /* Get and set the Nth saved pointer. */
1719 XSAVE_POINTER (Lisp_Object obj
, int n
)
1721 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_POINTER
);
1722 return XSAVE_VALUE (obj
)->data
[n
].pointer
;
1725 set_save_pointer (Lisp_Object obj
, int n
, void *val
)
1727 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_POINTER
);
1728 XSAVE_VALUE (obj
)->data
[n
].pointer
= val
;
1731 XSAVE_FUNCPOINTER (Lisp_Object obj
, int n
)
1733 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_FUNCPOINTER
);
1734 return XSAVE_VALUE (obj
)->data
[n
].funcpointer
;
1737 /* Likewise for the saved integer. */
1740 XSAVE_INTEGER (Lisp_Object obj
, int n
)
1742 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_INTEGER
);
1743 return XSAVE_VALUE (obj
)->data
[n
].integer
;
1746 set_save_integer (Lisp_Object obj
, int n
, ptrdiff_t val
)
1748 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_INTEGER
);
1749 XSAVE_VALUE (obj
)->data
[n
].integer
= val
;
1752 /* Extract Nth saved object. */
1755 XSAVE_OBJECT (Lisp_Object obj
, int n
)
1757 eassert (save_type (XSAVE_VALUE (obj
), n
) == SAVE_OBJECT
);
1758 return XSAVE_VALUE (obj
)->data
[n
].object
;
1761 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
1762 It uses one of these struct subtypes to get the type field. */
1766 struct Lisp_Misc_Any u_any
; /* Supertype of all Misc types. */
1767 struct Lisp_Marker u_marker
;
1768 struct Lisp_Overlay u_overlay
;
1769 struct Lisp_Save_Value u_save_value
;
1772 INLINE
union Lisp_Misc
*
1773 XMISC (Lisp_Object a
)
1775 return SMOB_PTR (a
);
1778 INLINE
struct Lisp_Misc_Any
*
1779 XMISCANY (Lisp_Object a
)
1781 eassert (MISCP (a
));
1782 return & XMISC (a
)->u_any
;
1785 INLINE
enum Lisp_Misc_Type
1786 XMISCTYPE (Lisp_Object a
)
1788 return XMISCANY (a
)->type
;
1791 INLINE
struct Lisp_Marker
*
1792 XMARKER (Lisp_Object a
)
1794 eassert (MARKERP (a
));
1795 return & XMISC (a
)->u_marker
;
1798 INLINE
struct Lisp_Overlay
*
1799 XOVERLAY (Lisp_Object a
)
1801 eassert (OVERLAYP (a
));
1802 return & XMISC (a
)->u_overlay
;
1805 INLINE
struct Lisp_Save_Value
*
1806 XSAVE_VALUE (Lisp_Object a
)
1808 eassert (SAVE_VALUEP (a
));
1809 return & XMISC (a
)->u_save_value
;
1812 /* Forwarding pointer to an int variable.
1813 This is allowed only in the value cell of a symbol,
1814 and it means that the symbol's value really lives in the
1815 specified int variable. */
1818 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Int */
1822 /* Boolean forwarding pointer to an int variable.
1823 This is like Lisp_Intfwd except that the ostensible
1824 "value" of the symbol is t if the bool variable is true,
1825 nil if it is false. */
1828 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Bool */
1832 /* Forwarding pointer to a Lisp_Object variable.
1833 This is allowed only in the value cell of a symbol,
1834 and it means that the symbol's value really lives in the
1835 specified variable. */
1838 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Obj */
1839 Lisp_Object
*objvar
;
1842 /* Like Lisp_Objfwd except that value lives in a slot in the
1843 current buffer. Value is byte index of slot within buffer. */
1844 struct Lisp_Buffer_Objfwd
1846 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Buffer_Obj */
1848 /* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp. */
1849 Lisp_Object predicate
;
1852 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
1853 the symbol has buffer-local or frame-local bindings. (Exception:
1854 some buffer-local variables are built-in, with their values stored
1855 in the buffer structure itself. They are handled differently,
1856 using struct Lisp_Buffer_Objfwd.)
1858 The `realvalue' slot holds the variable's current value, or a
1859 forwarding pointer to where that value is kept. This value is the
1860 one that corresponds to the loaded binding. To read or set the
1861 variable, you must first make sure the right binding is loaded;
1862 then you can access the value in (or through) `realvalue'.
1864 `buffer' and `frame' are the buffer and frame for which the loaded
1865 binding was found. If those have changed, to make sure the right
1866 binding is loaded it is necessary to find which binding goes with
1867 the current buffer and selected frame, then load it. To load it,
1868 first unload the previous binding, then copy the value of the new
1869 binding into `realvalue' (or through it). Also update
1870 LOADED-BINDING to point to the newly loaded binding.
1872 `local_if_set' indicates that merely setting the variable creates a
1873 local binding for the current buffer. Otherwise the latter, setting
1874 the variable does not do that; only make-local-variable does that. */
1876 struct Lisp_Buffer_Local_Value
1878 /* True means that merely setting the variable creates a local
1879 binding for the current buffer. */
1880 bool_bf local_if_set
: 1;
1881 /* True means this variable can have frame-local bindings, otherwise, it is
1882 can have buffer-local bindings. The two cannot be combined. */
1883 bool_bf frame_local
: 1;
1884 /* True means that the binding now loaded was found.
1885 Presumably equivalent to (defcell!=valcell). */
1887 /* If non-NULL, a forwarding to the C var where it should also be set. */
1888 union Lisp_Fwd
*fwd
; /* Should never be (Buffer|Kboard)_Objfwd. */
1889 /* The buffer or frame for which the loaded binding was found. */
1891 /* A cons cell that holds the default value. It has the form
1892 (SYMBOL . DEFAULT-VALUE). */
1893 Lisp_Object defcell
;
1894 /* The cons cell from `where's parameter alist.
1895 It always has the form (SYMBOL . VALUE)
1896 Note that if `forward' is non-nil, VALUE may be out of date.
1897 Also if the currently loaded binding is the default binding, then
1898 this is `eq'ual to defcell. */
1899 Lisp_Object valcell
;
1902 /* Like Lisp_Objfwd except that value lives in a slot in the
1904 struct Lisp_Kboard_Objfwd
1906 enum Lisp_Fwd_Type type
; /* = Lisp_Fwd_Kboard_Obj */
1912 struct Lisp_Intfwd u_intfwd
;
1913 struct Lisp_Boolfwd u_boolfwd
;
1914 struct Lisp_Objfwd u_objfwd
;
1915 struct Lisp_Buffer_Objfwd u_buffer_objfwd
;
1916 struct Lisp_Kboard_Objfwd u_kboard_objfwd
;
1919 INLINE
enum Lisp_Fwd_Type
1920 XFWDTYPE (union Lisp_Fwd
*a
)
1922 return a
->u_intfwd
.type
;
1925 INLINE
struct Lisp_Buffer_Objfwd
*
1926 XBUFFER_OBJFWD (union Lisp_Fwd
*a
)
1928 eassert (BUFFER_OBJFWDP (a
));
1929 return &a
->u_buffer_objfwd
;
1932 #define XFLOAT_DATA(f) (scm_to_double (f))
1934 /* Most hosts nowadays use IEEE floating point, so they use IEC 60559
1935 representations, have infinities and NaNs, and do not trap on
1936 exceptions. Define IEEE_FLOATING_POINT if this host is one of the
1937 typical ones. The C11 macro __STDC_IEC_559__ is close to what is
1938 wanted here, but is not quite right because Emacs does not require
1939 all the features of C11 Annex F (and does not require C11 at all,
1940 for that matter). */
1944 = (FLT_RADIX
== 2 && FLT_MANT_DIG
== 24
1945 && FLT_MIN_EXP
== -125 && FLT_MAX_EXP
== 128)
1948 /* A character, declared with the following typedef, is a member
1949 of some character set associated with the current buffer. */
1950 #ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
1952 typedef unsigned char UCHAR
;
1955 /* Meanings of slots in a Lisp_Compiled: */
1959 COMPILED_ARGLIST
= 0,
1960 COMPILED_BYTECODE
= 1,
1961 COMPILED_CONSTANTS
= 2,
1962 COMPILED_STACK_DEPTH
= 3,
1963 COMPILED_DOC_STRING
= 4,
1964 COMPILED_INTERACTIVE
= 5
1967 /* Flag bits in a character. These also get used in termhooks.h.
1968 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
1969 (MUlti-Lingual Emacs) might need 22 bits for the character value
1970 itself, so we probably shouldn't use any bits lower than 0x0400000. */
1973 CHAR_ALT
= 0x0400000,
1974 CHAR_SUPER
= 0x0800000,
1975 CHAR_HYPER
= 0x1000000,
1976 CHAR_SHIFT
= 0x2000000,
1977 CHAR_CTL
= 0x4000000,
1978 CHAR_META
= 0x8000000,
1980 CHAR_MODIFIER_MASK
=
1981 CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
| CHAR_SHIFT
| CHAR_CTL
| CHAR_META
,
1983 /* Actually, the current Emacs uses 22 bits for the character value
1988 /* Data type checking. */
1990 LISP_MACRO_DEFUN (NILP
, bool, (Lisp_Object x
), (x
))
1993 NUMBERP (Lisp_Object x
)
1995 return INTEGERP (x
) || FLOATP (x
);
1998 NATNUMP (Lisp_Object x
)
2000 return INTEGERP (x
) && 0 <= XINT (x
);
2004 RANGED_INTEGERP (intmax_t lo
, Lisp_Object x
, intmax_t hi
)
2006 return INTEGERP (x
) && lo
<= XINT (x
) && XINT (x
) <= hi
;
2009 #define TYPE_RANGED_INTEGERP(type, x) \
2011 && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \
2012 && XINT (x) <= TYPE_MAXIMUM (type))
2014 LISP_MACRO_DEFUN (CONSP
, bool, (Lisp_Object x
), (x
))
2015 LISP_MACRO_DEFUN (FLOATP
, bool, (Lisp_Object x
), (x
))
2016 LISP_MACRO_DEFUN (MISCP
, bool, (Lisp_Object x
), (x
))
2017 LISP_MACRO_DEFUN (SYMBOLP
, bool, (Lisp_Object x
), (x
))
2018 LISP_MACRO_DEFUN (INTEGERP
, bool, (Lisp_Object x
), (x
))
2019 LISP_MACRO_DEFUN (VECTORLIKEP
, bool, (Lisp_Object x
), (x
))
2020 LISP_MACRO_DEFUN (MARKERP
, bool, (Lisp_Object x
), (x
))
2023 STRINGP (Lisp_Object x
)
2025 return SMOB_TYPEP (x
, lisp_string_tag
);
2028 VECTORP (Lisp_Object x
)
2030 return VECTORLIKEP (x
) && ! (ASIZE (x
) & PSEUDOVECTOR_FLAG
);
2033 OVERLAYP (Lisp_Object x
)
2035 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Overlay
;
2038 SAVE_VALUEP (Lisp_Object x
)
2040 return MISCP (x
) && XMISCTYPE (x
) == Lisp_Misc_Save_Value
;
2044 AUTOLOADP (Lisp_Object x
)
2046 return CONSP (x
) && EQ (Qautoload
, XCAR (x
));
2050 BUFFER_OBJFWDP (union Lisp_Fwd
*a
)
2052 return XFWDTYPE (a
) == Lisp_Fwd_Buffer_Obj
;
2056 PSEUDOVECTOR_TYPEP (struct vectorlike_header
*a
, int code
)
2058 return ((a
->size
& (PSEUDOVECTOR_FLAG
| PVEC_TYPE_MASK
))
2059 == (PSEUDOVECTOR_FLAG
| (code
<< PSEUDOVECTOR_AREA_BITS
)));
2062 /* True if A is a pseudovector whose code is CODE. */
2064 PSEUDOVECTORP (Lisp_Object a
, int code
)
2066 if (! VECTORLIKEP (a
))
2070 /* Converting to struct vectorlike_header * avoids aliasing issues. */
2071 struct vectorlike_header
*h
= SMOB_PTR (a
);
2072 return PSEUDOVECTOR_TYPEP (h
, code
);
2076 /* Test for specific pseudovector types. */
2079 WINDOW_CONFIGURATIONP (Lisp_Object a
)
2081 return PSEUDOVECTORP (a
, PVEC_WINDOW_CONFIGURATION
);
2085 PROCESSP (Lisp_Object a
)
2087 return PSEUDOVECTORP (a
, PVEC_PROCESS
);
2091 WINDOWP (Lisp_Object a
)
2093 return PSEUDOVECTORP (a
, PVEC_WINDOW
);
2097 TERMINALP (Lisp_Object a
)
2099 return PSEUDOVECTORP (a
, PVEC_TERMINAL
);
2103 COMPILEDP (Lisp_Object a
)
2105 return PSEUDOVECTORP (a
, PVEC_COMPILED
);
2109 BUFFERP (Lisp_Object a
)
2111 return PSEUDOVECTORP (a
, PVEC_BUFFER
);
2115 CHAR_TABLE_P (Lisp_Object a
)
2117 return PSEUDOVECTORP (a
, PVEC_CHAR_TABLE
);
2121 SUB_CHAR_TABLE_P (Lisp_Object a
)
2123 return PSEUDOVECTORP (a
, PVEC_SUB_CHAR_TABLE
);
2127 BOOL_VECTOR_P (Lisp_Object a
)
2129 return PSEUDOVECTORP (a
, PVEC_BOOL_VECTOR
);
2133 FRAMEP (Lisp_Object a
)
2135 return PSEUDOVECTORP (a
, PVEC_FRAME
);
2138 /* Test for image (image . spec) */
2140 IMAGEP (Lisp_Object x
)
2142 return CONSP (x
) && EQ (XCAR (x
), Qimage
);
2147 ARRAYP (Lisp_Object x
)
2149 return VECTORP (x
) || STRINGP (x
) || CHAR_TABLE_P (x
) || BOOL_VECTOR_P (x
);
2153 CHECK_LIST (Lisp_Object x
)
2155 CHECK_TYPE (CONSP (x
) || NILP (x
), Qlistp
, x
);
2158 LISP_MACRO_DEFUN_VOID (CHECK_LIST_CONS
, (Lisp_Object x
, Lisp_Object y
), (x
, y
))
2159 LISP_MACRO_DEFUN_VOID (CHECK_SYMBOL
, (Lisp_Object x
), (x
))
2160 LISP_MACRO_DEFUN_VOID (CHECK_NUMBER
, (Lisp_Object x
), (x
))
2163 CHECK_STRING (Lisp_Object x
)
2165 CHECK_TYPE (STRINGP (x
), Qstringp
, x
);
2168 CHECK_STRING_CAR (Lisp_Object x
)
2170 CHECK_TYPE (STRINGP (XCAR (x
)), Qstringp
, XCAR (x
));
2173 CHECK_CONS (Lisp_Object x
)
2175 CHECK_TYPE (CONSP (x
), Qconsp
, x
);
2178 CHECK_VECTOR (Lisp_Object x
)
2180 CHECK_TYPE (VECTORP (x
), Qvectorp
, x
);
2183 CHECK_BOOL_VECTOR (Lisp_Object x
)
2185 CHECK_TYPE (BOOL_VECTOR_P (x
), Qbool_vector_p
, x
);
2188 CHECK_VECTOR_OR_STRING (Lisp_Object x
)
2190 CHECK_TYPE (VECTORP (x
) || STRINGP (x
), Qarrayp
, x
);
2193 CHECK_ARRAY (Lisp_Object x
, Lisp_Object predicate
)
2195 CHECK_TYPE (ARRAYP (x
), predicate
, x
);
2198 CHECK_BUFFER (Lisp_Object x
)
2200 CHECK_TYPE (BUFFERP (x
), Qbufferp
, x
);
2203 CHECK_WINDOW (Lisp_Object x
)
2205 CHECK_TYPE (WINDOWP (x
), Qwindowp
, x
);
2209 CHECK_PROCESS (Lisp_Object x
)
2211 CHECK_TYPE (PROCESSP (x
), Qprocessp
, x
);
2215 CHECK_NATNUM (Lisp_Object x
)
2217 CHECK_TYPE (NATNUMP (x
), Qwholenump
, x
);
2220 #define CHECK_RANGED_INTEGER(x, lo, hi) \
2223 if (! ((lo) <= XINT (x) && XINT (x) <= (hi))) \
2224 args_out_of_range_3 \
2226 make_number ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM \
2227 ? MOST_NEGATIVE_FIXNUM \
2229 make_number (min (hi, MOST_POSITIVE_FIXNUM))); \
2231 #define CHECK_TYPE_RANGED_INTEGER(type, x) \
2233 if (TYPE_SIGNED (type)) \
2234 CHECK_RANGED_INTEGER (x, TYPE_MINIMUM (type), TYPE_MAXIMUM (type)); \
2236 CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type)); \
2239 #define CHECK_NUMBER_COERCE_MARKER(x) \
2241 if (MARKERP ((x))) \
2242 XSETFASTINT (x, marker_position (x)); \
2244 CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); \
2248 XFLOATINT (Lisp_Object n
)
2250 return extract_float (n
);
2254 CHECK_NUMBER_OR_FLOAT (Lisp_Object x
)
2256 CHECK_TYPE (FLOATP (x
) || INTEGERP (x
), Qnumberp
, x
);
2259 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
2262 XSETFASTINT (x, marker_position (x)); \
2264 CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x); \
2267 /* Since we can't assign directly to the CAR or CDR fields of a cons
2268 cell, use these when checking that those fields contain numbers. */
2270 CHECK_NUMBER_CAR (Lisp_Object x
)
2272 Lisp_Object tmp
= XCAR (x
);
2278 CHECK_NUMBER_CDR (Lisp_Object x
)
2280 Lisp_Object tmp
= XCDR (x
);
2285 /* Define a built-in function for calling from Lisp.
2286 `lname' should be the name to give the function in Lisp,
2287 as a null-terminated C string.
2288 `fnname' should be the name of the function in C.
2289 By convention, it starts with F.
2290 `sname' should be the name for the C constant structure
2291 that records information on this function for internal use.
2292 By convention, it should be the same as `fnname' but with S instead of F.
2293 It's too bad that C macros can't compute this from `fnname'.
2294 `minargs' should be a number, the minimum number of arguments allowed.
2295 `maxargs' should be a number, the maximum number of arguments allowed,
2296 or else MANY or UNEVALLED.
2297 MANY means pass a vector of evaluated arguments,
2298 in the form of an integer number-of-arguments
2299 followed by the address of a vector of Lisp_Objects
2300 which contains the argument values.
2301 UNEVALLED means pass the list of unevaluated arguments
2302 `intspec' says how interactive arguments are to be fetched.
2303 If the string starts with a `(', `intspec' is evaluated and the resulting
2304 list is the list of arguments.
2305 If it's a string that doesn't start with `(', the value should follow
2306 the one of the doc string for `interactive'.
2307 A null string means call interactively with no arguments.
2308 `doc' is documentation for the user. */
2310 /* This version of DEFUN declares a function prototype with the right
2311 arguments, so we can catch errors with maxargs at compile-time. */
2312 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
2313 SCM_SNARF_INIT (defsubr (lname, gsubr_ ## fnname, minargs, maxargs, intspec)) \
2314 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
2315 DEFUN_GSUBR_ ## maxargs (lname, fnname, minargs, maxargs) \
2318 #define GSUBR_ARGS_1(f) f (arg1)
2319 #define GSUBR_ARGS_2(f) GSUBR_ARGS_1 (f), f (arg2)
2320 #define GSUBR_ARGS_3(f) GSUBR_ARGS_2 (f), f (arg3)
2321 #define GSUBR_ARGS_4(f) GSUBR_ARGS_3 (f), f (arg4)
2322 #define GSUBR_ARGS_5(f) GSUBR_ARGS_4 (f), f (arg5)
2323 #define GSUBR_ARGS_6(f) GSUBR_ARGS_5 (f), f (arg6)
2324 #define GSUBR_ARGS_7(f) GSUBR_ARGS_6 (f), f (arg7)
2325 #define GSUBR_ARGS_8(f) GSUBR_ARGS_7 (f), f (arg8)
2327 #define GSUBR_ARGS(n) GSUBR_ARGS_PASTE (GSUBR_ARGS_, n)
2328 #define GSUBR_ARGS_PASTE(a, b) a ## b
2330 #define DEFUN_GSUBR_N(fn, maxargs) \
2333 (GSUBR_ARGS (maxargs) (Lisp_Object)) \
2335 return fn (GSUBR_ARGS (maxargs) (GSUBR_ARG)); \
2337 #define GSUBR_ARG(x) (SCM_UNBNDP (x) ? Qnil : x)
2339 #define DEFUN_GSUBR_0(lname, fn, minargs, maxargs) \
2340 Lisp_Object gsubr_ ## fn (void) { return fn (); }
2341 #define DEFUN_GSUBR_1(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
2342 #define DEFUN_GSUBR_2(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
2343 #define DEFUN_GSUBR_3(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
2344 #define DEFUN_GSUBR_4(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
2345 #define DEFUN_GSUBR_5(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
2346 #define DEFUN_GSUBR_6(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
2347 #define DEFUN_GSUBR_7(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
2348 #define DEFUN_GSUBR_8(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
2350 #define DEFUN_GSUBR_UNEVALLED(lname, fn, minargs, maxargs) \
2352 gsubr_ ## fn (Lisp_Object rest) \
2354 Lisp_Object len = Flength (rest); \
2355 if (XINT (len) < minargs) \
2356 xsignal2 (Qwrong_number_of_arguments, \
2357 intern (lname), len); \
2360 #define DEFUN_GSUBR_MANY(lname, fn, minargs, maxargs) \
2362 gsubr_ ## fn (Lisp_Object rest) \
2364 int len = scm_to_int (scm_length (rest)); \
2365 Lisp_Object *args; \
2366 SAFE_ALLOCA_LISP (args, len); \
2369 i < len && scm_is_pair (rest); \
2370 i++, rest = SCM_CDR (rest)) \
2371 args[i] = SCM_CAR (rest); \
2373 xsignal2 (Qwrong_number_of_arguments, \
2374 intern (lname), make_number (i)); \
2375 return fn (i, args); \
2378 /* Note that the weird token-substitution semantics of ANSI C makes
2379 this work for MANY and UNEVALLED. */
2380 #define DEFUN_ARGS_MANY (ptrdiff_t, Lisp_Object *)
2381 #define DEFUN_ARGS_UNEVALLED (Lisp_Object)
2382 #define DEFUN_ARGS_0 (void)
2383 #define DEFUN_ARGS_1 (Lisp_Object)
2384 #define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
2385 #define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
2386 #define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
2387 #define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
2389 #define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
2390 Lisp_Object, Lisp_Object)
2391 #define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
2392 Lisp_Object, Lisp_Object, Lisp_Object)
2393 #define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
2394 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
2396 /* True if OBJ is a Lisp function. */
2398 FUNCTIONP (Lisp_Object obj
)
2400 return functionp (obj
);
2404 is how we define the symbol for function `name' at start-up time. */
2405 extern void defsubr (const char *, scm_t_subr
, short, short, const char *);
2413 extern void defvar_lisp (struct Lisp_Objfwd
*, const char *, Lisp_Object
*);
2414 extern void defvar_lisp_nopro (struct Lisp_Objfwd
*, const char *, Lisp_Object
*);
2415 extern void defvar_bool (struct Lisp_Boolfwd
*, const char *, bool *);
2416 extern void defvar_int (struct Lisp_Intfwd
*, const char *, EMACS_INT
*);
2417 extern void defvar_kboard (struct Lisp_Kboard_Objfwd
*, const char *, int);
2419 /* Macros we use to define forwarded Lisp variables.
2420 These are used in the syms_of_FILENAME functions.
2422 An ordinary (not in buffer_defaults, per-buffer, or per-keyboard)
2423 lisp variable is actually a field in `struct emacs_globals'. The
2424 field's name begins with "f_", which is a convention enforced by
2425 these macros. Each such global has a corresponding #define in
2426 globals.h; the plain name should be used in the code.
2428 E.g., the global "cons_cells_consed" is declared as "int
2429 f_cons_cells_consed" in globals.h, but there is a define:
2431 #define cons_cells_consed globals.f_cons_cells_consed
2433 All C code uses the `cons_cells_consed' name. This is all done
2434 this way to support indirection for multi-threaded Emacs. */
2436 #define DEFVAR_LISP(lname, vname, doc) \
2438 static struct Lisp_Objfwd o_fwd; \
2439 defvar_lisp (&o_fwd, lname, &globals.f_ ## vname); \
2441 #define DEFVAR_LISP_NOPRO(lname, vname, doc) \
2443 static struct Lisp_Objfwd o_fwd; \
2444 defvar_lisp_nopro (&o_fwd, lname, &globals.f_ ## vname); \
2446 #define DEFVAR_BOOL(lname, vname, doc) \
2448 static struct Lisp_Boolfwd b_fwd; \
2449 defvar_bool (&b_fwd, lname, &globals.f_ ## vname); \
2451 #define DEFVAR_INT(lname, vname, doc) \
2453 static struct Lisp_Intfwd i_fwd; \
2454 defvar_int (&i_fwd, lname, &globals.f_ ## vname); \
2457 #define DEFVAR_BUFFER_DEFAULTS(lname, vname, doc) \
2459 static struct Lisp_Objfwd o_fwd; \
2460 defvar_lisp_nopro (&o_fwd, lname, &BVAR (&buffer_defaults, vname)); \
2463 #define DEFVAR_KBOARD(lname, vname, doc) \
2465 static struct Lisp_Kboard_Objfwd ko_fwd; \
2466 defvar_kboard (&ko_fwd, lname, offsetof (KBOARD, vname ## _)); \
2469 /* Save and restore the instruction and environment pointers,
2470 without affecting the signal mask. */
2473 typedef jmp_buf sys_jmp_buf
;
2474 # define sys_setjmp(j) _setjmp (j)
2475 # define sys_longjmp(j, v) _longjmp (j, v)
2476 #elif defined HAVE_SIGSETJMP
2477 typedef sigjmp_buf sys_jmp_buf
;
2478 # define sys_setjmp(j) sigsetjmp (j, 0)
2479 # define sys_longjmp(j, v) siglongjmp (j, v)
2481 /* A platform that uses neither _longjmp nor siglongjmp; assume
2482 longjmp does not affect the sigmask. */
2483 typedef jmp_buf sys_jmp_buf
;
2484 # define sys_setjmp(j) setjmp (j)
2485 # define sys_longjmp(j, v) longjmp (j, v)
2489 /* Elisp uses several stacks:
2491 - the bytecode stack: used internally by the bytecode interpreter.
2492 Allocated from the C stack.
2493 - The specpdl stack: keeps track of active unwind-protect and
2494 dynamic-let-bindings. Allocated from the `specpdl' array, a manually
2496 - The handler stack: keeps track of active catch tags and condition-case
2497 handlers. Allocated in a manually managed stack implemented by a
2498 doubly-linked list allocated via xmalloc and never freed. */
2500 /* Structure for recording Lisp call stack for backtrace purposes. */
2502 /* The special binding stack holds the outer values of variables while
2503 they are bound by a function application or a let form, stores the
2504 code to be executed for unwind-protect forms.
2506 NOTE: The specbinding union is defined here, because SPECPDL_INDEX is
2507 used all over the place, needs to be fast, and needs to know the size of
2508 union specbinding. But only eval.c should access it. */
2511 SPECPDL_BACKTRACE
, /* An element of the backtrace. */
2512 SPECPDL_LET
, /* A plain and simple dynamic let-binding. */
2513 /* Tags greater than SPECPDL_LET must be "subkinds" of LET. */
2514 SPECPDL_LET_LOCAL
, /* A buffer-local let-binding. */
2515 SPECPDL_LET_DEFAULT
/* A global binding for a localized var. */
2520 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
2522 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
2525 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
2526 bool wind_explicitly
;
2527 void (*func
) (Lisp_Object
);
2531 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
2532 bool wind_explicitly
;
2533 void (*func
) (void *);
2537 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
2538 bool wind_explicitly
;
2543 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
2544 bool wind_explicitly
;
2545 void (*func
) (void);
2548 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
2549 /* `where' is not used in the case of SPECPDL_LET. */
2550 Lisp_Object symbol
, old_value
, where
;
2553 ENUM_BF (specbind_tag
) kind
: CHAR_BIT
;
2554 bool_bf debug_on_exit
: 1;
2555 Lisp_Object function
;
2561 extern union specbinding
*specpdl
;
2562 extern union specbinding
*specpdl_ptr
;
2563 extern ptrdiff_t specpdl_size
;
2566 SPECPDL_INDEX (void)
2568 return specpdl_ptr
- specpdl
;
2571 /* This structure helps implement the `catch/throw' and `condition-case/signal'
2572 control structures. A struct handler contains all the information needed to
2573 restore the state of the interpreter after a non-local jump.
2575 handler structures are chained together in a doubly linked list; the `next'
2576 member points to the next outer catchtag and the `nextfree' member points in
2577 the other direction to the next inner element (which is typically the next
2578 free element since we mostly use it on the deepest handler).
2580 A call like (throw TAG VAL) searches for a catchtag whose `tag_or_ch'
2581 member is TAG, and then unbinds to it. The `val' member is used to
2582 hold VAL while the stack is unwound; `val' is returned as the value
2585 All the other members are concerned with restoring the interpreter
2588 Members are volatile if their values need to survive _longjmp when
2589 a 'struct handler' is a local variable. */
2591 enum handlertype
{ CATCHER
, CONDITION_CASE
};
2595 enum handlertype type
;
2597 Lisp_Object tag_or_ch
;
2601 struct handler
*next
;
2602 EMACS_INT lisp_eval_depth
;
2603 int poll_suppress_count
;
2604 int interrupt_input_blocked
;
2607 extern Lisp_Object memory_signal_data
;
2609 /* Check quit-flag and quit if it is non-nil.
2610 Typing C-g does not directly cause a quit; it only sets Vquit_flag.
2611 So the program needs to do QUIT at times when it is safe to quit.
2612 Every loop that might run for a long time or might not exit
2613 ought to do QUIT at least once, at a safe place.
2614 Unless that is impossible, of course.
2615 But it is very desirable to avoid creating loops where QUIT is impossible.
2617 Exception: if you set immediate_quit to true,
2618 then the handler that responds to the C-g does the quit itself.
2619 This is a good thing to do around a loop that has no side effects
2620 and (in particular) cannot call arbitrary Lisp code.
2622 If quit-flag is set to `kill-emacs' the SIGINT handler has received
2623 a request to exit Emacs when it is safe to do. */
2625 extern void process_pending_signals (void);
2626 extern bool volatile pending_signals
;
2628 extern void process_quit_flag (void);
2631 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
2632 process_quit_flag (); \
2633 else if (pending_signals) \
2634 process_pending_signals (); \
2638 /* True if ought to quit now. */
2640 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
2642 extern Lisp_Object Vascii_downcase_table
;
2643 extern Lisp_Object Vascii_canon_table
;
2645 /* Structure for recording stack slots that need marking. */
2647 /* This is a chain of structures, each of which points at a Lisp_Object
2648 variable whose value should be marked in garbage collection.
2649 Normally every link of the chain is an automatic variable of a function,
2650 and its `val' points to some argument or local variable of the function.
2651 On exit to the function, the chain is set back to the value it had on entry.
2652 This way, no link remains in the chain when the stack frame containing the
2655 Every function that can call Feval must protect in this fashion all
2656 Lisp_Object variables whose contents will be used again. */
2658 extern struct gcpro
*gcprolist
;
2664 /* Address of first protected variable. */
2665 volatile Lisp_Object
*var
;
2667 /* Number of consecutive protected variables. */
2675 /* Do something silly with gcproN vars just so gcc shuts up. */
2676 /* You get warnings from MIPSPro... */
2678 #define GCPRO1(varname) ((void) gcpro1)
2679 #define GCPRO2(varname1, varname2) ((void) gcpro2, (void) gcpro1)
2680 #define GCPRO3(varname1, varname2, varname3) \
2681 ((void) gcpro3, (void) gcpro2, (void) gcpro1)
2682 #define GCPRO4(varname1, varname2, varname3, varname4) \
2683 ((void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1)
2684 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
2685 ((void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1)
2686 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
2687 ((void) gcpro6, (void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, \
2689 #define GCPRO7(a, b, c, d, e, f, g) (GCPRO6 (a, b, c, d, e, f), (void) gcpro7)
2690 #define UNGCPRO ((void) 0)
2692 /* Evaluate expr, UNGCPRO, and then return the value of expr. */
2693 #define RETURN_UNGCPRO(expr) \
2696 Lisp_Object ret_ungc_val; \
2697 ret_ungc_val = (expr); \
2699 return ret_ungc_val; \
2703 /* Call staticpro (&var) to protect static variable `var'. */
2705 void staticpro (Lisp_Object
*);
2707 /* Declare a Lisp-callable function. The MAXARGS parameter has the same
2708 meaning as in the DEFUN macro, and is used to construct a prototype. */
2709 /* We can use the same trick as in the DEFUN macro to generate the
2710 appropriate prototype. */
2711 #define EXFUN(fnname, maxargs) \
2712 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
2714 #include "globals.h"
2716 /* Forward declarations for prototypes. */
2720 /* Copy COUNT Lisp_Objects from ARGS to contents of V starting from OFFSET. */
2723 vcopy (Lisp_Object v
, ptrdiff_t offset
, Lisp_Object
*args
, ptrdiff_t count
)
2725 eassert (0 <= offset
&& 0 <= count
&& offset
+ count
<= ASIZE (v
));
2726 memcpy (XVECTOR (v
)->contents
+ offset
, args
, count
* sizeof *args
);
2729 /* Functions to modify hash tables. */
2732 set_hash_key_slot (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
, Lisp_Object val
)
2734 gc_aset (h
->key_and_value
, 2 * idx
, val
);
2738 set_hash_value_slot (struct Lisp_Hash_Table
*h
, ptrdiff_t idx
, Lisp_Object val
)
2740 gc_aset (h
->key_and_value
, 2 * idx
+ 1, val
);
2743 /* Use these functions to set Lisp_Object
2744 or pointer slots of struct Lisp_Symbol. */
2747 set_symbol_function (Lisp_Object sym
, Lisp_Object function
)
2749 if (EQ (sym
, Qnil
)) sym
= Qnil_
;
2750 if (EQ (sym
, Qt
)) sym
= Qt_
;
2751 scm_variable_set_x (scm_module_lookup (function_module
, sym
), function
);
2755 symbol_plist (Lisp_Object sym
)
2757 if (EQ (sym
, Qnil
)) sym
= Qnil_
;
2758 if (EQ (sym
, Qt
)) sym
= Qt_
;
2759 return scm_variable_ref (scm_module_lookup (plist_module
, sym
));
2763 set_symbol_plist (Lisp_Object sym
, Lisp_Object plist
)
2765 if (EQ (sym
, Qnil
)) sym
= Qnil_
;
2766 if (EQ (sym
, Qt
)) sym
= Qt_
;
2767 scm_variable_set_x (scm_module_lookup (plist_module
, sym
), plist
);
2770 /* Buffer-local (also frame-local) variable access functions. */
2773 blv_found (struct Lisp_Buffer_Local_Value
*blv
)
2775 eassert (blv
->found
== !EQ (blv
->defcell
, blv
->valcell
));
2779 /* Set overlay's property list. */
2782 set_overlay_plist (Lisp_Object overlay
, Lisp_Object plist
)
2784 XOVERLAY (overlay
)->plist
= plist
;
2787 /* Get text properties of S. */
2790 string_intervals (Lisp_Object s
)
2792 return XSTRING (s
)->intervals
;
2795 /* Set text properties of S to I. */
2798 set_string_intervals (Lisp_Object s
, INTERVAL i
)
2800 XSTRING (s
)->intervals
= i
;
2803 /* Set a Lisp slot in TABLE to VAL. Most code should use this instead
2804 of setting slots directly. */
2807 set_char_table_defalt (Lisp_Object table
, Lisp_Object val
)
2809 XCHAR_TABLE (table
)->defalt
= val
;
2812 set_char_table_purpose (Lisp_Object table
, Lisp_Object val
)
2814 XCHAR_TABLE (table
)->purpose
= val
;
2817 /* Set different slots in (sub)character tables. */
2820 set_char_table_extras (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
2822 eassert (0 <= idx
&& idx
< CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (table
)));
2823 XCHAR_TABLE (table
)->extras
[idx
] = val
;
2827 set_char_table_contents (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
2829 eassert (0 <= idx
&& idx
< (1 << CHARTAB_SIZE_BITS_0
));
2830 XCHAR_TABLE (table
)->contents
[idx
] = val
;
2834 set_sub_char_table_contents (Lisp_Object table
, ptrdiff_t idx
, Lisp_Object val
)
2836 XSUB_CHAR_TABLE (table
)->contents
[idx
] = val
;
2839 /* Defined in data.c. */
2840 extern Lisp_Object Qnil_
, Qt_
;
2841 extern Lisp_Object Qquote
, Qunbound
;
2842 extern Lisp_Object Qerror_conditions
, Qerror_message
, Qtop_level
;
2843 extern Lisp_Object Qerror
, Qquit
, Qargs_out_of_range
;
2844 extern Lisp_Object Qvoid_variable
, Qvoid_function
;
2845 extern Lisp_Object Qinvalid_read_syntax
;
2846 extern Lisp_Object Qinvalid_function
, Qwrong_number_of_arguments
, Qno_catch
;
2847 extern Lisp_Object Quser_error
, Qend_of_file
, Qarith_error
, Qmark_inactive
;
2848 extern Lisp_Object Qbeginning_of_buffer
, Qend_of_buffer
, Qbuffer_read_only
;
2849 extern Lisp_Object Qtext_read_only
;
2850 extern Lisp_Object Qinteractive_form
;
2851 extern Lisp_Object Qcircular_list
;
2852 extern Lisp_Object Qsequencep
;
2853 extern Lisp_Object Qchar_or_string_p
, Qinteger_or_marker_p
;
2854 extern Lisp_Object Qfboundp
;
2855 extern Lisp_Object Qspecial_operator
;
2857 extern Lisp_Object Qcdr
;
2859 extern Lisp_Object Qrange_error
, Qoverflow_error
;
2861 extern Lisp_Object Qnumber_or_marker_p
;
2863 extern Lisp_Object Qbuffer
, Qinteger
, Qsymbol
;
2865 /* Defined in data.c. */
2866 extern Lisp_Object
indirect_function (Lisp_Object
);
2867 extern Lisp_Object
find_symbol_value (Lisp_Object
);
2868 enum Arith_Comparison
{
2873 ARITH_LESS_OR_EQUAL
,
2876 extern Lisp_Object
arithcompare (Lisp_Object num1
, Lisp_Object num2
,
2877 enum Arith_Comparison comparison
);
2879 /* Convert the integer I to an Emacs representation, either the integer
2880 itself, or a cons of two or three integers, or if all else fails a float.
2881 I should not have side effects. */
2882 #define INTEGER_TO_CONS(i) \
2883 (! FIXNUM_OVERFLOW_P (i) \
2885 : ! ((FIXNUM_OVERFLOW_P (INTMAX_MIN >> 16) \
2886 || FIXNUM_OVERFLOW_P (UINTMAX_MAX >> 16)) \
2887 && FIXNUM_OVERFLOW_P ((i) >> 16)) \
2888 ? Fcons (make_number ((i) >> 16), make_number ((i) & 0xffff)) \
2889 : ! ((FIXNUM_OVERFLOW_P (INTMAX_MIN >> 16 >> 24) \
2890 || FIXNUM_OVERFLOW_P (UINTMAX_MAX >> 16 >> 24)) \
2891 && FIXNUM_OVERFLOW_P ((i) >> 16 >> 24)) \
2892 ? Fcons (make_number ((i) >> 16 >> 24), \
2893 Fcons (make_number ((i) >> 16 & 0xffffff), \
2894 make_number ((i) & 0xffff))) \
2897 /* Convert the Emacs representation CONS back to an integer of type
2898 TYPE, storing the result the variable VAR. Signal an error if CONS
2899 is not a valid representation or is out of range for TYPE. */
2900 #define CONS_TO_INTEGER(cons, type, var) \
2901 (TYPE_SIGNED (type) \
2902 ? ((var) = cons_to_signed (cons, TYPE_MINIMUM (type), TYPE_MAXIMUM (type))) \
2903 : ((var) = cons_to_unsigned (cons, TYPE_MAXIMUM (type))))
2904 extern intmax_t cons_to_signed (Lisp_Object
, intmax_t, intmax_t);
2905 extern uintmax_t cons_to_unsigned (Lisp_Object
, uintmax_t);
2907 extern struct Lisp_Symbol
*indirect_variable (struct Lisp_Symbol
*);
2908 extern _Noreturn
void args_out_of_range (Lisp_Object
, Lisp_Object
);
2909 extern _Noreturn
void args_out_of_range_3 (Lisp_Object
, Lisp_Object
,
2911 extern Lisp_Object
do_symval_forwarding (union Lisp_Fwd
*);
2912 extern void set_internal (Lisp_Object
, Lisp_Object
, Lisp_Object
, bool);
2913 extern void syms_of_data (void);
2914 extern void swap_in_global_binding (struct Lisp_Symbol
*);
2916 /* Defined in cmds.c */
2917 extern void syms_of_cmds (void);
2918 extern void keys_of_cmds (void);
2920 /* Defined in coding.c. */
2921 extern Lisp_Object Qcharset
;
2922 extern Lisp_Object
detect_coding_system (const unsigned char *, ptrdiff_t,
2923 ptrdiff_t, bool, bool, Lisp_Object
);
2924 extern void init_coding (void);
2925 extern void init_coding_once (void);
2926 extern void syms_of_coding (void);
2928 /* Defined in character.c. */
2929 extern ptrdiff_t chars_in_text (const unsigned char *, ptrdiff_t);
2930 extern ptrdiff_t multibyte_chars_in_text (const unsigned char *, ptrdiff_t);
2931 extern void syms_of_character (void);
2933 /* Defined in charset.c. */
2934 extern void init_charset (void);
2935 extern void init_charset_once (void);
2936 extern void syms_of_charset (void);
2937 /* Structure forward declarations. */
2940 /* Defined in syntax.c. */
2941 extern void init_syntax_once (void);
2942 extern void syms_of_syntax (void);
2944 /* Defined in fns.c. */
2945 extern Lisp_Object QCrehash_size
, QCrehash_threshold
;
2946 enum { NEXT_ALMOST_PRIME_LIMIT
= 11 };
2947 extern EMACS_INT
next_almost_prime (EMACS_INT
) ATTRIBUTE_CONST
;
2948 extern Lisp_Object
larger_vector (Lisp_Object
, ptrdiff_t, ptrdiff_t);
2949 extern void sweep_weak_hash_tables (void);
2950 extern Lisp_Object Qcursor_in_echo_area
;
2951 extern Lisp_Object Qstring_lessp
;
2952 extern Lisp_Object QCsize
, QCtest
, QCweakness
, Qequal
, Qeq
;
2953 EMACS_UINT
hash_string (char const *, ptrdiff_t);
2954 EMACS_UINT
sxhash (Lisp_Object
, int);
2955 Lisp_Object
make_hash_table (struct hash_table_test
, Lisp_Object
, Lisp_Object
,
2956 Lisp_Object
, Lisp_Object
);
2957 ptrdiff_t hash_lookup (struct Lisp_Hash_Table
*, Lisp_Object
, EMACS_UINT
*);
2958 ptrdiff_t hash_put (struct Lisp_Hash_Table
*, Lisp_Object
, Lisp_Object
,
2960 extern struct hash_table_test hashtest_eql
, hashtest_equal
;
2961 extern void validate_subarray (Lisp_Object
, Lisp_Object
, Lisp_Object
,
2962 ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
2963 extern Lisp_Object
substring_both (Lisp_Object
, ptrdiff_t, ptrdiff_t,
2964 ptrdiff_t, ptrdiff_t);
2965 extern Lisp_Object
merge (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2966 extern Lisp_Object
do_yes_or_no_p (Lisp_Object
);
2967 extern Lisp_Object
concat2 (Lisp_Object
, Lisp_Object
);
2968 extern Lisp_Object
concat3 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2969 extern Lisp_Object
nconc2 (Lisp_Object
, Lisp_Object
);
2970 extern Lisp_Object
assq_no_quit (Lisp_Object
, Lisp_Object
);
2971 extern Lisp_Object
assoc_no_quit (Lisp_Object
, Lisp_Object
);
2972 extern void clear_string_char_byte_cache (void);
2973 extern ptrdiff_t string_char_to_byte (Lisp_Object
, ptrdiff_t);
2974 extern ptrdiff_t string_byte_to_char (Lisp_Object
, ptrdiff_t);
2975 extern Lisp_Object
string_to_multibyte (Lisp_Object
);
2976 extern Lisp_Object
string_make_unibyte (Lisp_Object
);
2977 extern void init_fns_once (void);
2978 extern void syms_of_fns (void);
2980 /* Defined in floatfns.c. */
2981 extern void syms_of_floatfns (void);
2982 extern Lisp_Object
fmod_float (Lisp_Object x
, Lisp_Object y
);
2984 /* Defined in fringe.c. */
2985 extern void syms_of_fringe (void);
2986 extern void init_fringe (void);
2987 #ifdef HAVE_WINDOW_SYSTEM
2988 extern void mark_fringe_data (void);
2989 extern void init_fringe_once (void);
2990 #endif /* HAVE_WINDOW_SYSTEM */
2992 /* Defined in image.c. */
2993 extern Lisp_Object QCascent
, QCmargin
, QCrelief
;
2994 extern Lisp_Object QCconversion
;
2995 extern int x_bitmap_mask (struct frame
*, ptrdiff_t);
2996 extern void reset_image_types (void);
2997 extern void syms_of_image (void);
2999 /* Defined in insdel.c. */
3000 extern Lisp_Object Qinhibit_modification_hooks
;
3001 extern Lisp_Object Qregion_extract_function
;
3002 extern void move_gap_both (ptrdiff_t, ptrdiff_t);
3003 extern _Noreturn
void buffer_overflow (void);
3004 extern void make_gap (ptrdiff_t);
3005 extern void make_gap_1 (struct buffer
*, ptrdiff_t);
3006 extern ptrdiff_t copy_text (const unsigned char *, unsigned char *,
3007 ptrdiff_t, bool, bool);
3008 extern int count_combining_before (const unsigned char *,
3009 ptrdiff_t, ptrdiff_t, ptrdiff_t);
3010 extern int count_combining_after (const unsigned char *,
3011 ptrdiff_t, ptrdiff_t, ptrdiff_t);
3012 extern void insert (const char *, ptrdiff_t);
3013 extern void insert_and_inherit (const char *, ptrdiff_t);
3014 extern void insert_1_both (const char *, ptrdiff_t, ptrdiff_t,
3016 extern void insert_from_gap (ptrdiff_t, ptrdiff_t, bool text_at_gap_tail
);
3017 extern void insert_from_string (Lisp_Object
, ptrdiff_t, ptrdiff_t,
3018 ptrdiff_t, ptrdiff_t, bool);
3019 extern void insert_from_buffer (struct buffer
*, ptrdiff_t, ptrdiff_t, bool);
3020 extern void insert_char (int);
3021 extern void insert_string (const char *);
3022 extern void insert_before_markers (const char *, ptrdiff_t);
3023 extern void insert_before_markers_and_inherit (const char *, ptrdiff_t);
3024 extern void insert_from_string_before_markers (Lisp_Object
, ptrdiff_t,
3025 ptrdiff_t, ptrdiff_t,
3027 extern void del_range (ptrdiff_t, ptrdiff_t);
3028 extern Lisp_Object
del_range_1 (ptrdiff_t, ptrdiff_t, bool, bool);
3029 extern void del_range_byte (ptrdiff_t, ptrdiff_t, bool);
3030 extern void del_range_both (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, bool);
3031 extern Lisp_Object
del_range_2 (ptrdiff_t, ptrdiff_t,
3032 ptrdiff_t, ptrdiff_t, bool);
3033 extern void modify_text (ptrdiff_t, ptrdiff_t);
3034 extern void prepare_to_modify_buffer (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
3035 extern void prepare_to_modify_buffer_1 (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
3036 extern void invalidate_buffer_caches (struct buffer
*, ptrdiff_t, ptrdiff_t);
3037 extern void signal_after_change (ptrdiff_t, ptrdiff_t, ptrdiff_t);
3038 extern void adjust_after_insert (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3039 ptrdiff_t, ptrdiff_t);
3040 extern void adjust_markers_for_delete (ptrdiff_t, ptrdiff_t,
3041 ptrdiff_t, ptrdiff_t);
3042 extern void replace_range (ptrdiff_t, ptrdiff_t, Lisp_Object
, bool, bool, bool);
3043 extern void replace_range_2 (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
3044 const char *, ptrdiff_t, ptrdiff_t, bool);
3045 extern void syms_of_insdel (void);
3047 /* Defined in dispnew.c. */
3048 #if (defined PROFILING \
3049 && (defined __FreeBSD__ || defined GNU_LINUX || defined __MINGW32__))
3050 _Noreturn
void __executable_start (void);
3052 extern Lisp_Object Vwindow_system
;
3053 extern Lisp_Object
sit_for (Lisp_Object
, bool, int);
3055 /* Defined in xdisp.c. */
3056 extern Lisp_Object Qinhibit_point_motion_hooks
;
3057 extern Lisp_Object Qinhibit_redisplay
;
3058 extern Lisp_Object Qmenu_bar_update_hook
;
3059 extern Lisp_Object Qwindow_scroll_functions
;
3060 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
3061 extern Lisp_Object Qtext
, Qboth
, Qboth_horiz
, Qtext_image_horiz
;
3062 extern Lisp_Object Qspace
, Qcenter
, QCalign_to
;
3063 extern Lisp_Object Qbar
, Qhbar
, Qhollow
;
3064 extern Lisp_Object Qleft_margin
, Qright_margin
;
3065 extern Lisp_Object QCdata
, QCfile
;
3066 extern Lisp_Object QCmap
;
3067 extern Lisp_Object Qrisky_local_variable
;
3068 extern bool noninteractive_need_newline
;
3069 extern Lisp_Object echo_area_buffer
[2];
3070 extern void add_to_log (const char *, Lisp_Object
, Lisp_Object
);
3071 extern void check_message_stack (void);
3072 extern void setup_echo_area_for_printing (int);
3073 extern bool push_message (void);
3074 extern void pop_message_unwind (void);
3075 extern Lisp_Object
restore_message_unwind (Lisp_Object
);
3076 extern void restore_message (void);
3077 extern Lisp_Object
current_message (void);
3078 extern void clear_message (bool, bool);
3079 extern void message (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3080 extern void message1 (const char *);
3081 extern void message1_nolog (const char *);
3082 extern void message3 (Lisp_Object
);
3083 extern void message3_nolog (Lisp_Object
);
3084 extern void message_dolog (const char *, ptrdiff_t, bool, bool);
3085 extern void message_with_string (const char *, Lisp_Object
, int);
3086 extern void message_log_maybe_newline (void);
3087 extern void update_echo_area (void);
3088 extern void truncate_echo_area (ptrdiff_t);
3089 extern void redisplay (void);
3091 void set_frame_cursor_types (struct frame
*, Lisp_Object
);
3092 extern void syms_of_xdisp (void);
3093 extern void init_xdisp (void);
3094 extern Lisp_Object
safe_eval (Lisp_Object
);
3095 extern int pos_visible_p (struct window
*, ptrdiff_t, int *,
3096 int *, int *, int *, int *, int *);
3098 /* Defined in xsettings.c. */
3099 extern void syms_of_xsettings (void);
3101 /* Defined in vm-limit.c. */
3102 extern void memory_warnings (void *, void (*warnfun
) (const char *));
3104 /* Defined in alloc.c. */
3105 extern void check_pure_size (void);
3106 extern void free_misc (Lisp_Object
);
3107 extern void allocate_string_data (struct Lisp_String
*, EMACS_INT
, EMACS_INT
);
3108 extern void malloc_warning (const char *);
3109 extern _Noreturn
void memory_full (size_t);
3110 extern _Noreturn
void buffer_memory_full (ptrdiff_t);
3111 #if defined REL_ALLOC && !defined SYSTEM_MALLOC
3112 extern void refill_memory_reserve (void);
3114 extern const char *pending_malloc_warning
;
3115 extern Lisp_Object zero_vector
;
3116 extern Lisp_Object
list1 (Lisp_Object
);
3117 extern Lisp_Object
list2 (Lisp_Object
, Lisp_Object
);
3118 extern Lisp_Object
list3 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3119 extern Lisp_Object
list4 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3120 extern Lisp_Object
list5 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
,
3122 enum constype
{CONSTYPE_HEAP
, CONSTYPE_PURE
};
3123 extern Lisp_Object
listn (enum constype
, ptrdiff_t, Lisp_Object
, ...);
3125 /* Build a frequently used 2/3/4-integer lists. */
3128 list2i (EMACS_INT x
, EMACS_INT y
)
3130 return list2 (make_number (x
), make_number (y
));
3134 list3i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
)
3136 return list3 (make_number (x
), make_number (y
), make_number (w
));
3140 list4i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
, EMACS_INT h
)
3142 return list4 (make_number (x
), make_number (y
),
3143 make_number (w
), make_number (h
));
3146 extern Lisp_Object
make_uninit_bool_vector (EMACS_INT
);
3147 extern Lisp_Object
bool_vector_fill (Lisp_Object
, Lisp_Object
);
3148 extern _Noreturn
void string_overflow (void);
3149 extern Lisp_Object
make_string (const char *, ptrdiff_t);
3150 extern Lisp_Object
make_formatted_string (char *, const char *, ...)
3151 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3152 extern Lisp_Object
make_unibyte_string (const char *, ptrdiff_t);
3154 /* Make unibyte string from C string when the length isn't known. */
3157 build_unibyte_string (const char *str
)
3159 return make_unibyte_string (str
, strlen (str
));
3162 extern Lisp_Object
make_multibyte_string (const char *, ptrdiff_t, ptrdiff_t);
3163 extern Lisp_Object
make_event_array (ptrdiff_t, Lisp_Object
*);
3164 extern Lisp_Object
make_uninit_string (EMACS_INT
);
3165 extern Lisp_Object
make_uninit_multibyte_string (EMACS_INT
, EMACS_INT
);
3166 extern Lisp_Object
make_string_from_bytes (const char *, ptrdiff_t, ptrdiff_t);
3167 extern Lisp_Object
make_specified_string (const char *,
3168 ptrdiff_t, ptrdiff_t, bool);
3169 extern Lisp_Object
make_pure_string (const char *, ptrdiff_t, ptrdiff_t, bool);
3170 extern Lisp_Object
make_pure_c_string (const char *, ptrdiff_t);
3172 /* Make a string allocated in pure space, use STR as string data. */
3175 build_pure_c_string (const char *str
)
3177 return make_pure_c_string (str
, strlen (str
));
3180 /* Make a string from the data at STR, treating it as multibyte if the
3184 build_string (const char *str
)
3186 return make_string (str
, strlen (str
));
3189 extern Lisp_Object
pure_cons (Lisp_Object
, Lisp_Object
);
3190 extern void make_byte_code (struct Lisp_Vector
*);
3191 extern Lisp_Object Qchar_table_extra_slots
;
3192 extern struct Lisp_Vector
*allocate_vector (EMACS_INT
);
3194 /* Make an uninitialized vector for SIZE objects. NOTE: you must
3195 be sure that GC cannot happen until the vector is completely
3196 initialized. E.g. the following code is likely to crash:
3198 v = make_uninit_vector (3);
3200 ASET (v, 1, Ffunction_can_gc ());
3201 ASET (v, 2, obj1); */
3204 make_uninit_vector (ptrdiff_t size
)
3207 struct Lisp_Vector
*p
;
3209 p
= allocate_vector (size
);
3214 extern struct Lisp_Vector
*allocate_pseudovector (int, int, enum pvec_type
);
3215 #define ALLOCATE_PSEUDOVECTOR(typ,field,tag) \
3217 allocate_pseudovector \
3218 (VECSIZE (typ), PSEUDOVECSIZE (typ, field), tag))
3219 extern struct Lisp_Hash_Table
*allocate_hash_table (void);
3220 extern struct window
*allocate_window (void);
3221 extern struct frame
*allocate_frame (void);
3222 extern struct Lisp_Process
*allocate_process (void);
3223 extern struct terminal
*allocate_terminal (void);
3224 extern Lisp_Object
make_float (double);
3225 extern void display_malloc_warning (void);
3226 extern Lisp_Object
make_save_int_int_int (ptrdiff_t, ptrdiff_t, ptrdiff_t);
3227 extern Lisp_Object
make_save_obj_obj_obj_obj (Lisp_Object
, Lisp_Object
,
3228 Lisp_Object
, Lisp_Object
);
3229 extern Lisp_Object
make_save_ptr (void *);
3230 extern Lisp_Object
make_save_ptr_int (void *, ptrdiff_t);
3231 extern Lisp_Object
make_save_ptr_ptr (void *, void *);
3232 extern Lisp_Object
make_save_funcptr_ptr_obj (void (*) (void), void *,
3234 extern Lisp_Object
make_save_memory (Lisp_Object
*, ptrdiff_t);
3235 extern void free_save_value (Lisp_Object
);
3236 extern Lisp_Object
build_overlay (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3237 extern void init_alloc_once (void);
3238 extern void init_alloc (void);
3239 extern void syms_of_alloc (void);
3240 extern struct buffer
* allocate_buffer (void);
3241 extern int valid_lisp_object_p (Lisp_Object
);
3242 extern int relocatable_string_data_p (const char *);
3245 /* Defined in ralloc.c. */
3246 extern void *r_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3247 extern void r_alloc_free (void **);
3248 extern void *r_re_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3249 extern void r_alloc_reset_variable (void **, void **);
3250 extern void r_alloc_inhibit_buffer_relocation (int);
3253 /* Defined in chartab.c. */
3254 extern Lisp_Object
copy_char_table (Lisp_Object
);
3255 extern Lisp_Object
char_table_ref_and_range (Lisp_Object
, int,
3257 extern void char_table_set_range (Lisp_Object
, int, int, Lisp_Object
);
3258 extern void map_char_table (void (*) (Lisp_Object
, Lisp_Object
,
3260 Lisp_Object
, Lisp_Object
, Lisp_Object
);
3261 extern void map_char_table_for_charset (void (*c_function
) (Lisp_Object
, Lisp_Object
),
3262 Lisp_Object
, Lisp_Object
,
3263 Lisp_Object
, struct charset
*,
3264 unsigned, unsigned);
3265 extern Lisp_Object
uniprop_table (Lisp_Object
);
3266 extern void syms_of_chartab (void);
3268 /* Defined in print.c. */
3269 extern Lisp_Object Vprin1_to_string_buffer
;
3270 extern void debug_print (Lisp_Object
) EXTERNALLY_VISIBLE
;
3271 extern Lisp_Object Qstandard_output
;
3272 extern Lisp_Object Qexternal_debugging_output
;
3273 extern void temp_output_buffer_setup (const char *);
3274 extern int print_level
;
3275 extern Lisp_Object Qprint_escape_newlines
;
3276 extern void write_string (const char *, int);
3277 extern void print_error_message (Lisp_Object
, Lisp_Object
, const char *,
3279 extern Lisp_Object internal_with_output_to_temp_buffer
3280 (const char *, Lisp_Object (*) (Lisp_Object
), Lisp_Object
);
3281 #define FLOAT_TO_STRING_BUFSIZE 350
3282 extern int float_to_string (char *, double);
3283 extern void init_print_once (void);
3284 extern void syms_of_print (void);
3286 /* Defined in doprnt.c. */
3287 extern ptrdiff_t doprnt (char *, ptrdiff_t, const char *, const char *,
3289 extern ptrdiff_t esprintf (char *, char const *, ...)
3290 ATTRIBUTE_FORMAT_PRINTF (2, 3);
3291 extern ptrdiff_t exprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3293 ATTRIBUTE_FORMAT_PRINTF (5, 6);
3294 extern ptrdiff_t evxprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
3295 char const *, va_list)
3296 ATTRIBUTE_FORMAT_PRINTF (5, 0);
3298 /* Defined in lread.c. */
3299 extern Lisp_Object Qvariable_documentation
, Qstandard_input
;
3300 extern Lisp_Object Qbackquote
, Qcomma
, Qcomma_at
, Qcomma_dot
, Qfunction
;
3301 extern Lisp_Object Qlexical_binding
;
3302 extern Lisp_Object
check_obarray (Lisp_Object
);
3303 extern Lisp_Object
intern_1 (const char *, ptrdiff_t);
3304 extern Lisp_Object
intern_c_string_1 (const char *, ptrdiff_t);
3305 extern Lisp_Object
obhash (Lisp_Object
);
3306 extern Lisp_Object
oblookup (Lisp_Object
, const char *, ptrdiff_t, ptrdiff_t);
3308 LOADHIST_ATTACH (Lisp_Object x
)
3311 Vcurrent_load_list
= Fcons (x
, Vcurrent_load_list
);
3313 extern int openp (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3314 Lisp_Object
*, Lisp_Object
, bool);
3315 extern Lisp_Object
string_to_number (char const *, int, bool);
3316 extern void map_obarray (Lisp_Object
, void (*) (Lisp_Object
, Lisp_Object
),
3318 extern void dir_warning (const char *, Lisp_Object
);
3319 extern void init_obarray (void);
3320 extern void init_lread (void);
3321 extern void syms_of_lread (void);
3324 intern (const char *str
)
3326 return intern_1 (str
, strlen (str
));
3330 intern_c_string (const char *str
)
3332 return intern_c_string_1 (str
, strlen (str
));
3335 /* Defined in eval.c. */
3336 extern Lisp_Object Qexit
, Qinteractive
, Qcommandp
, Qmacro
;
3337 extern Lisp_Object Qinhibit_quit
, Qinternal_interpreter_environment
, Qclosure
;
3338 extern Lisp_Object Qand_rest
;
3339 extern Lisp_Object Vautoload_queue
;
3340 extern Lisp_Object Vsignaling_function
;
3341 extern Lisp_Object inhibit_lisp_code
;
3342 extern struct handler
*handlerlist
;
3344 /* To run a normal hook, use the appropriate function from the list below.
3345 The calling convention:
3347 if (!NILP (Vrun_hooks))
3348 call1 (Vrun_hooks, Qmy_funny_hook);
3350 should no longer be used. */
3351 extern Lisp_Object Vrun_hooks
;
3352 extern void run_hook_with_args_2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3353 extern Lisp_Object
run_hook_with_args (ptrdiff_t nargs
, Lisp_Object
*args
,
3354 Lisp_Object (*funcall
)
3355 (ptrdiff_t nargs
, Lisp_Object
*args
));
3356 extern _Noreturn
void xsignal (Lisp_Object
, Lisp_Object
);
3357 extern _Noreturn
void xsignal0 (Lisp_Object
);
3358 extern _Noreturn
void xsignal1 (Lisp_Object
, Lisp_Object
);
3359 extern _Noreturn
void xsignal2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3360 extern _Noreturn
void xsignal3 (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3362 extern _Noreturn
void signal_error (const char *, Lisp_Object
);
3363 extern Lisp_Object
eval_sub (Lisp_Object form
);
3364 extern Lisp_Object
Ffuncall (ptrdiff_t nargs
, Lisp_Object
*args
);
3365 extern Lisp_Object
apply1 (Lisp_Object
, Lisp_Object
);
3366 extern Lisp_Object
call0 (Lisp_Object
);
3367 extern Lisp_Object
call1 (Lisp_Object
, Lisp_Object
);
3368 extern Lisp_Object
call2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3369 extern Lisp_Object
call3 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3370 extern Lisp_Object
call4 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3371 extern Lisp_Object
call5 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3372 extern Lisp_Object
call6 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3373 extern Lisp_Object
call7 (Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
);
3374 extern Lisp_Object
internal_catch (Lisp_Object
, Lisp_Object (*) (Lisp_Object
), Lisp_Object
);
3375 extern Lisp_Object
internal_lisp_condition_case (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3376 extern Lisp_Object
internal_condition_case (Lisp_Object (*) (void), Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3377 extern Lisp_Object
internal_condition_case_1 (Lisp_Object (*) (Lisp_Object
), Lisp_Object
, Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3378 extern Lisp_Object
internal_condition_case_2 (Lisp_Object (*) (Lisp_Object
, Lisp_Object
), Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object (*) (Lisp_Object
));
3379 extern Lisp_Object internal_condition_case_n
3380 (Lisp_Object (*) (ptrdiff_t, Lisp_Object
*), ptrdiff_t, Lisp_Object
*,
3381 Lisp_Object
, Lisp_Object (*) (Lisp_Object
, ptrdiff_t, Lisp_Object
*));
3382 extern void specbind (Lisp_Object
, Lisp_Object
);
3383 extern void record_unwind_protect_1 (void (*) (Lisp_Object
), Lisp_Object
, bool);
3384 extern void record_unwind_protect (void (*) (Lisp_Object
), Lisp_Object
);
3385 extern void record_unwind_protect_ptr_1 (void (*) (void *), void *, bool);
3386 extern void record_unwind_protect_ptr (void (*) (void *), void *);
3387 extern void record_unwind_protect_int_1 (void (*) (int), int, bool);
3388 extern void record_unwind_protect_int (void (*) (int), int);
3389 extern void record_unwind_protect_void_1 (void (*) (void), bool);
3390 extern void record_unwind_protect_void (void (*) (void));
3391 extern void dynwind_begin (void);
3392 extern void dynwind_end (void);
3393 extern _Noreturn
void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
3394 extern _Noreturn
void verror (const char *, va_list)
3395 ATTRIBUTE_FORMAT_PRINTF (1, 0);
3396 extern void un_autoload (Lisp_Object
);
3397 extern Lisp_Object
call_debugger (Lisp_Object arg
);
3398 extern void init_eval_once (void);
3399 extern Lisp_Object
safe_call (ptrdiff_t, Lisp_Object
, ...);
3400 extern Lisp_Object
safe_call1 (Lisp_Object
, Lisp_Object
);
3401 extern Lisp_Object
safe_call2 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3402 extern void init_eval (void);
3403 extern void syms_of_eval (void);
3404 extern void unwind_body (Lisp_Object
);
3405 extern void record_in_backtrace (Lisp_Object function
,
3406 Lisp_Object
*args
, ptrdiff_t nargs
);
3407 extern void mark_specpdl (void);
3408 extern void get_backtrace (Lisp_Object array
);
3409 Lisp_Object
backtrace_top_function (void);
3410 extern bool let_shadows_buffer_binding_p (struct Lisp_Symbol
*symbol
);
3411 extern bool let_shadows_global_binding_p (Lisp_Object symbol
);
3412 extern _Noreturn SCM
abort_to_prompt (SCM
, SCM
);
3413 extern SCM
call_with_prompt (SCM
, SCM
, SCM
);
3414 extern SCM
make_prompt_tag (void);
3417 /* Defined in editfns.c. */
3418 extern Lisp_Object Qfield
;
3419 extern void insert1 (Lisp_Object
);
3420 extern Lisp_Object
format2 (const char *, Lisp_Object
, Lisp_Object
);
3421 extern Lisp_Object
save_excursion_save (void);
3422 extern Lisp_Object
save_restriction_save (void);
3423 extern void save_excursion_restore (Lisp_Object
);
3424 extern void save_restriction_restore (Lisp_Object
);
3425 extern _Noreturn
void time_overflow (void);
3426 extern Lisp_Object
make_buffer_string (ptrdiff_t, ptrdiff_t, bool);
3427 extern Lisp_Object
make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
3429 extern void init_editfns (void);
3430 extern void syms_of_editfns (void);
3431 extern void set_time_zone_rule (const char *);
3433 /* Defined in buffer.c. */
3434 extern bool mouse_face_overlay_overlaps (Lisp_Object
);
3435 extern _Noreturn
void nsberror (Lisp_Object
);
3436 extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
3437 extern void adjust_overlays_for_delete (ptrdiff_t, ptrdiff_t);
3438 extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
3439 extern void report_overlay_modification (Lisp_Object
, Lisp_Object
, bool,
3440 Lisp_Object
, Lisp_Object
, Lisp_Object
);
3441 extern bool overlay_touches_p (ptrdiff_t);
3442 extern Lisp_Object
other_buffer_safely (Lisp_Object
);
3443 extern Lisp_Object
get_truename_buffer (Lisp_Object
);
3444 extern void init_buffer_once (void);
3445 extern void init_buffer (int);
3446 extern void syms_of_buffer (void);
3447 extern void keys_of_buffer (void);
3449 /* Defined in marker.c. */
3451 extern ptrdiff_t marker_position (Lisp_Object
);
3452 extern ptrdiff_t marker_byte_position (Lisp_Object
);
3453 extern void clear_charpos_cache (struct buffer
*);
3454 extern ptrdiff_t buf_charpos_to_bytepos (struct buffer
*, ptrdiff_t);
3455 extern ptrdiff_t buf_bytepos_to_charpos (struct buffer
*, ptrdiff_t);
3456 extern void unchain_marker (struct Lisp_Marker
*marker
);
3457 extern Lisp_Object
set_marker_restricted (Lisp_Object
, Lisp_Object
, Lisp_Object
);
3458 extern Lisp_Object
set_marker_both (Lisp_Object
, Lisp_Object
, ptrdiff_t, ptrdiff_t);
3459 extern Lisp_Object
set_marker_restricted_both (Lisp_Object
, Lisp_Object
,
3460 ptrdiff_t, ptrdiff_t);
3461 extern Lisp_Object
build_marker (struct buffer
*, ptrdiff_t, ptrdiff_t);
3462 extern void syms_of_marker (void);
3464 /* Defined in fileio.c. */
3466 extern Lisp_Object Qfile_error
;
3467 extern Lisp_Object Qfile_notify_error
;
3468 extern Lisp_Object Qfile_exists_p
;
3469 extern Lisp_Object Qfile_directory_p
;
3470 extern Lisp_Object Qinsert_file_contents
;
3471 extern Lisp_Object Qfile_name_history
;
3472 extern Lisp_Object
expand_and_dir_to_file (Lisp_Object
, Lisp_Object
);
3473 extern Lisp_Object
write_region (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3474 Lisp_Object
, Lisp_Object
, Lisp_Object
,
3476 extern void close_file_unwind (int);
3477 extern void close_file_ptr_unwind (void *);
3478 extern void fclose_unwind (void *);
3479 extern void fclose_ptr_unwind (void *);
3480 extern void restore_point_unwind (Lisp_Object
);
3481 extern _Noreturn
void report_file_errno (const char *, Lisp_Object
, int);
3482 extern _Noreturn
void report_file_error (const char *, Lisp_Object
);
3483 extern bool internal_delete_file (Lisp_Object
);
3484 extern Lisp_Object
emacs_readlinkat (int, const char *);
3485 extern bool file_directory_p (const char *);
3486 extern bool file_accessible_directory_p (const char *);
3487 extern void init_fileio (void);
3488 extern void syms_of_fileio (void);
3489 extern Lisp_Object
make_temp_name (Lisp_Object
, bool);
3490 extern Lisp_Object Qdelete_file
;
3492 /* Defined in search.c. */
3493 extern void shrink_regexp_cache (void);
3494 extern void restore_search_regs (void);
3495 extern void record_unwind_save_match_data (void);
3496 struct re_registers
;
3497 extern struct re_pattern_buffer
*compile_pattern (Lisp_Object
,
3498 struct re_registers
*,
3499 Lisp_Object
, bool, bool);
3500 extern ptrdiff_t fast_string_match (Lisp_Object
, Lisp_Object
);
3501 extern ptrdiff_t fast_c_string_match_ignore_case (Lisp_Object
, const char *,
3503 extern ptrdiff_t fast_string_match_ignore_case (Lisp_Object
, Lisp_Object
);
3504 extern ptrdiff_t fast_looking_at (Lisp_Object
, ptrdiff_t, ptrdiff_t,
3505 ptrdiff_t, ptrdiff_t, Lisp_Object
);
3506 extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
3507 ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
3508 extern ptrdiff_t scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
3510 extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t,
3511 ptrdiff_t, ptrdiff_t *);
3512 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
3513 ptrdiff_t, ptrdiff_t *);
3514 extern void syms_of_search (void);
3515 extern void clear_regexp_cache (void);
3517 /* Defined in minibuf.c. */
3519 extern Lisp_Object Qcompletion_ignore_case
;
3520 extern Lisp_Object Vminibuffer_list
;
3521 extern Lisp_Object last_minibuf_string
;
3522 extern Lisp_Object
get_minibuffer (EMACS_INT
);
3523 extern void init_minibuf_once (void);
3524 extern void syms_of_minibuf (void);
3526 /* Defined in callint.c. */
3528 extern Lisp_Object Qminus
, Qplus
;
3529 extern Lisp_Object Qprogn
;
3530 extern Lisp_Object Qwhen
;
3531 extern Lisp_Object Qmouse_leave_buffer_hook
;
3532 extern void syms_of_callint (void);
3534 /* Defined in casefiddle.c. */
3536 extern Lisp_Object Qidentity
;
3537 extern void syms_of_casefiddle (void);
3538 extern void keys_of_casefiddle (void);
3540 /* Defined in casetab.c. */
3542 extern void init_casetab_once (void);
3543 extern void syms_of_casetab (void);
3545 /* Defined in keyboard.c. */
3547 extern Lisp_Object echo_message_buffer
;
3548 extern struct kboard
*echo_kboard
;
3549 extern void cancel_echoing (void);
3550 extern Lisp_Object Qdisabled
, QCfilter
;
3551 extern Lisp_Object Qup
, Qdown
;
3552 extern Lisp_Object last_undo_boundary
;
3553 extern bool input_pending
;
3554 extern Lisp_Object
menu_bar_items (Lisp_Object
);
3555 extern Lisp_Object
tool_bar_items (Lisp_Object
, int *);
3556 extern void discard_mouse_events (void);
3558 void handle_input_available_signal (int);
3560 extern Lisp_Object pending_funcalls
;
3561 extern bool detect_input_pending (void);
3562 extern bool detect_input_pending_ignore_squeezables (void);
3563 extern bool detect_input_pending_run_timers (bool);
3564 extern void safe_run_hooks (Lisp_Object
);
3565 extern void cmd_error_internal (Lisp_Object
, const char *);
3566 extern Lisp_Object
command_loop_1 (void);
3567 extern Lisp_Object
read_menu_command (void);
3568 extern Lisp_Object
recursive_edit_1 (void);
3569 extern void record_auto_save (void);
3570 extern void force_auto_save_soon (void);
3571 extern void init_keyboard (void);
3572 extern void syms_of_keyboard (void);
3573 extern void keys_of_keyboard (void);
3575 /* Defined in indent.c. */
3576 extern ptrdiff_t current_column (void);
3577 extern void invalidate_current_column (void);
3578 extern bool indented_beyond_p (ptrdiff_t, ptrdiff_t, EMACS_INT
);
3579 extern void syms_of_indent (void);
3581 /* Defined in frame.c. */
3582 extern Lisp_Object Qonly
, Qnone
;
3583 extern void set_frame_param (struct frame
*, Lisp_Object
, Lisp_Object
);
3584 extern void store_frame_param (struct frame
*, Lisp_Object
, Lisp_Object
);
3585 extern void store_in_alist (Lisp_Object
*, Lisp_Object
, Lisp_Object
);
3586 extern Lisp_Object
do_switch_frame (Lisp_Object
, int, int, Lisp_Object
);
3587 extern Lisp_Object
get_frame_param (struct frame
*, Lisp_Object
);
3588 extern void frames_discard_buffer (Lisp_Object
);
3589 extern void syms_of_frame (void);
3591 /* Defined in emacs.c. */
3592 extern char **initial_argv
;
3593 extern int initial_argc
;
3594 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS)
3595 extern bool display_arg
;
3597 extern Lisp_Object
decode_env_path (const char *, const char *, bool);
3598 extern Lisp_Object empty_unibyte_string
, empty_multibyte_string
;
3599 extern Lisp_Object Qfile_name_handler_alist
;
3600 extern _Noreturn
void terminate_due_to_signal (int, int);
3601 extern Lisp_Object Qkill_emacs
;
3603 extern Lisp_Object Vlibrary_cache
;
3606 void fixup_locale (void);
3607 void synchronize_system_messages_locale (void);
3608 void synchronize_system_time_locale (void);
3610 INLINE
void fixup_locale (void) {}
3611 INLINE
void synchronize_system_messages_locale (void) {}
3612 INLINE
void synchronize_system_time_locale (void) {}
3614 extern void shut_down_emacs (int, Lisp_Object
);
3616 /* True means don't do interactive redisplay and don't change tty modes. */
3617 extern bool noninteractive
;
3619 /* True means remove site-lisp directories from load-path. */
3620 extern bool no_site_lisp
;
3622 /* Pipe used to send exit notification to the daemon parent at
3624 extern int daemon_pipe
[2];
3625 #define IS_DAEMON (daemon_pipe[1] != 0)
3627 /* True if handling a fatal error already. */
3628 extern bool fatal_error_in_progress
;
3630 /* True means don't do use window-system-specific display code. */
3631 extern bool inhibit_window_system
;
3632 /* True means that a filter or a sentinel is running. */
3633 extern bool running_asynch_code
;
3635 /* Defined in process.c. */
3636 extern Lisp_Object QCtype
, Qlocal
;
3637 extern void kill_buffer_processes (Lisp_Object
);
3638 extern int wait_reading_process_output (intmax_t, int, int, bool, Lisp_Object
,
3639 struct Lisp_Process
*, int);
3640 /* Max value for the first argument of wait_reading_process_output. */
3641 #if __GNUC__ == 3 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 5)
3642 /* Work around a bug in GCC 3.4.2, known to be fixed in GCC 4.6.3.
3643 The bug merely causes a bogus warning, but the warning is annoying. */
3644 # define WAIT_READING_MAX min (TYPE_MAXIMUM (time_t), INTMAX_MAX)
3646 # define WAIT_READING_MAX INTMAX_MAX
3648 extern void add_keyboard_wait_descriptor (int);
3649 extern void delete_keyboard_wait_descriptor (int);
3651 extern void add_gpm_wait_descriptor (int);
3652 extern void delete_gpm_wait_descriptor (int);
3654 extern void init_process_emacs (void);
3655 extern void syms_of_process (void);
3656 extern void setup_process_coding_systems (Lisp_Object
);
3658 /* Defined in callproc.c. */
3662 extern int child_setup (int, int, int, char **, bool, Lisp_Object
);
3663 extern void init_callproc_1 (void);
3664 extern void init_callproc (void);
3665 extern void set_initial_environment (void);
3666 extern void syms_of_callproc (void);
3668 /* Defined in doc.c. */
3669 extern Lisp_Object Qfunction_documentation
;
3670 extern Lisp_Object
read_doc_string (Lisp_Object
);
3671 extern Lisp_Object
get_doc_string (Lisp_Object
, bool, bool);
3672 extern void syms_of_doc (void);
3673 extern int read_bytecode_char (bool);
3675 /* Defined in bytecode.c. */
3676 extern void syms_of_bytecode (void);
3677 extern Lisp_Object
exec_byte_code (Lisp_Object
, Lisp_Object
, Lisp_Object
,
3678 Lisp_Object
, ptrdiff_t, Lisp_Object
*);
3680 /* Defined in macros.c. */
3681 extern void init_macros (void);
3682 extern void syms_of_macros (void);
3684 /* Defined in undo.c. */
3685 extern Lisp_Object Qapply
;
3686 extern Lisp_Object Qinhibit_read_only
;
3687 extern void truncate_undo_list (struct buffer
*);
3688 extern void record_insert (ptrdiff_t, ptrdiff_t);
3689 extern void record_delete (ptrdiff_t, Lisp_Object
, bool);
3690 extern void record_first_change (void);
3691 extern void record_change (ptrdiff_t, ptrdiff_t);
3692 extern void record_property_change (ptrdiff_t, ptrdiff_t,
3693 Lisp_Object
, Lisp_Object
,
3695 extern void syms_of_undo (void);
3696 /* Defined in textprop.c. */
3697 extern Lisp_Object Qmouse_face
;
3698 extern Lisp_Object Qinsert_in_front_hooks
, Qinsert_behind_hooks
;
3699 extern Lisp_Object Qminibuffer_prompt
;
3701 extern void report_interval_modification (Lisp_Object
, Lisp_Object
);
3703 /* Defined in menu.c. */
3704 extern void syms_of_menu (void);
3706 /* Defined in xmenu.c. */
3707 extern void syms_of_xmenu (void);
3709 /* Defined in termchar.h. */
3710 struct tty_display_info
;
3712 /* Defined in termhooks.h. */
3715 /* Defined in sysdep.c. */
3716 #ifndef HAVE_GET_CURRENT_DIR_NAME
3717 extern char *get_current_dir_name (void);
3719 extern void stuff_char (char c
);
3720 extern void init_foreground_group (void);
3721 extern void sys_subshell (void);
3722 extern void sys_suspend (void);
3723 extern void discard_tty_input (void);
3724 extern void init_sys_modes (struct tty_display_info
*);
3725 extern void reset_sys_modes (struct tty_display_info
*);
3726 extern void init_all_sys_modes (void);
3727 extern void reset_all_sys_modes (void);
3728 extern void child_setup_tty (int);
3729 extern void setup_pty (int);
3730 extern int set_window_size (int, int, int);
3731 extern EMACS_INT
get_random (void);
3732 extern void seed_random (void *, ptrdiff_t);
3733 extern void init_random (void);
3734 extern void emacs_backtrace (int);
3735 extern _Noreturn
void emacs_abort (void) NO_INLINE
;
3736 extern int emacs_open (const char *, int, int);
3737 extern int emacs_pipe (int[2]);
3738 extern int emacs_close (int);
3739 extern ptrdiff_t emacs_read (int, void *, ptrdiff_t);
3740 extern ptrdiff_t emacs_write (int, void const *, ptrdiff_t);
3741 extern ptrdiff_t emacs_write_sig (int, void const *, ptrdiff_t);
3742 extern void emacs_perror (char const *);
3744 extern void unlock_all_files (void);
3745 extern void lock_file (Lisp_Object
);
3746 extern void unlock_file (Lisp_Object
);
3747 extern void unlock_buffer (struct buffer
*);
3748 extern void syms_of_filelock (void);
3750 /* Defined in sound.c. */
3751 extern void syms_of_sound (void);
3753 /* Defined in category.c. */
3754 extern void init_category_once (void);
3755 extern Lisp_Object
char_category_set (int);
3756 extern void syms_of_category (void);
3758 /* Defined in ccl.c. */
3759 extern void syms_of_ccl (void);
3761 /* Defined in dired.c. */
3762 extern void syms_of_dired (void);
3763 extern Lisp_Object
directory_files_internal (Lisp_Object
, Lisp_Object
,
3764 Lisp_Object
, Lisp_Object
,
3767 /* Defined in term.c. */
3768 extern int *char_ins_del_vector
;
3769 extern void syms_of_term (void);
3770 extern _Noreturn
void fatal (const char *msgid
, ...)
3771 ATTRIBUTE_FORMAT_PRINTF (1, 2);
3773 /* Defined in terminal.c. */
3774 extern void syms_of_terminal (void);
3776 /* Defined in font.c. */
3777 extern void syms_of_font (void);
3778 extern void init_font (void);
3780 #ifdef HAVE_WINDOW_SYSTEM
3781 /* Defined in fontset.c. */
3782 extern void syms_of_fontset (void);
3784 /* Defined in xfns.c, w32fns.c, or macfns.c. */
3785 extern Lisp_Object Qfont_param
;
3788 /* Defined in gfilenotify.c */
3789 #ifdef HAVE_GFILENOTIFY
3790 extern void globals_of_gfilenotify (void);
3791 extern void syms_of_gfilenotify (void);
3794 /* Defined in inotify.c */
3796 extern void syms_of_inotify (void);
3799 #ifdef HAVE_W32NOTIFY
3800 /* Defined on w32notify.c. */
3801 extern void syms_of_w32notify (void);
3804 /* Defined in xfaces.c. */
3805 extern Lisp_Object Qdefault
, Qfringe
;
3806 extern Lisp_Object Qscroll_bar
, Qcursor
;
3807 extern Lisp_Object Qmode_line_inactive
;
3808 extern Lisp_Object Qface
;
3809 extern Lisp_Object Qnormal
;
3810 extern Lisp_Object QCfamily
, QCweight
, QCslant
;
3811 extern Lisp_Object QCheight
, QCname
, QCwidth
, QCforeground
, QCbackground
;
3812 extern Lisp_Object Qextra_light
, Qlight
, Qsemi_light
, Qsemi_bold
;
3813 extern Lisp_Object Qbold
, Qextra_bold
, Qultra_bold
;
3814 extern Lisp_Object Qoblique
, Qitalic
;
3815 extern Lisp_Object Vface_alternative_font_family_alist
;
3816 extern Lisp_Object Vface_alternative_font_registry_alist
;
3817 extern void syms_of_xfaces (void);
3819 #ifdef HAVE_X_WINDOWS
3820 /* Defined in xfns.c. */
3821 extern void syms_of_xfns (void);
3823 /* Defined in xsmfns.c. */
3824 extern void syms_of_xsmfns (void);
3826 /* Defined in xselect.c. */
3827 extern void syms_of_xselect (void);
3829 /* Defined in xterm.c. */
3830 extern void syms_of_xterm (void);
3831 #endif /* HAVE_X_WINDOWS */
3833 #ifdef HAVE_WINDOW_SYSTEM
3834 /* Defined in xterm.c, nsterm.m, w32term.c. */
3835 extern char *x_get_keysym_name (int);
3836 #endif /* HAVE_WINDOW_SYSTEM */
3839 /* Defined in xml.c. */
3840 extern void syms_of_xml (void);
3841 extern void xml_cleanup_parser (void);
3845 /* Defined in decompress.c. */
3846 extern void syms_of_decompress (void);
3850 /* Defined in dbusbind.c. */
3851 void syms_of_dbusbind (void);
3855 /* Defined in profiler.c. */
3856 extern bool profiler_memory_running
;
3857 extern void malloc_probe (size_t);
3858 extern void syms_of_profiler (void);
3862 /* Defined in msdos.c, w32.c. */
3863 extern char *emacs_root_dir (void);
3866 /* True means ^G can quit instantly. */
3867 extern bool immediate_quit
;
3869 extern void *xmalloc (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
3870 extern void *xzalloc (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
3871 extern void *xrealloc (void *, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
3872 extern void xfree (void *);
3873 extern void *xmalloc_uncollectable (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
3874 extern void *xmalloc_unsafe (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
3875 extern void *xnmalloc (ptrdiff_t, ptrdiff_t) ATTRIBUTE_MALLOC_SIZE ((1,2));
3876 extern void *xnrealloc (void *, ptrdiff_t, ptrdiff_t)
3877 ATTRIBUTE_ALLOC_SIZE ((2,3));
3878 extern void *xpalloc (void *, ptrdiff_t *, ptrdiff_t, ptrdiff_t, ptrdiff_t);
3879 extern void *xmalloc_atomic (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
3880 extern void *xzalloc_atomic (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
3881 extern void *xmalloc_atomic_unsafe (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
3882 extern void *xnmalloc_atomic (ptrdiff_t, ptrdiff_t) ATTRIBUTE_MALLOC_SIZE ((1,2));
3884 extern char *xstrdup (const char *) ATTRIBUTE_MALLOC
;
3885 extern char *xlispstrdup (Lisp_Object
) ATTRIBUTE_MALLOC
;
3886 extern void dupstring (char **, char const *);
3887 extern void xputenv (const char *);
3889 extern char *egetenv (const char *);
3891 /* Copy Lisp string to temporary (allocated on stack) C string. */
3893 #define xlispstrdupa(string) \
3894 memcpy (alloca (SBYTES (string) + 1), \
3895 SSDATA (string), SBYTES (string) + 1)
3897 /* Set up the name of the machine we're running on. */
3898 extern void init_system_name (void);
3900 /* Return the absolute value of X. X should be a signed integer
3901 expression without side effects, and X's absolute value should not
3902 exceed the maximum for its promoted type. This is called 'eabs'
3903 because 'abs' is reserved by the C standard. */
3904 #define eabs(x) ((x) < 0 ? -(x) : (x))
3906 /* Return a fixnum or float, depending on whether VAL fits in a Lisp
3909 #define make_fixnum_or_float(val) \
3910 (FIXNUM_OVERFLOW_P (val) ? make_float (val) : make_number (val))
3912 /* SAFE_ALLOCA normally allocates memory on the stack, but if size is
3913 larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack. */
3915 enum MAX_ALLOCA
{ MAX_ALLOCA
= 16 * 1024 };
3917 #define USE_SAFE_ALLOCA ((void) 0)
3919 /* SAFE_ALLOCA allocates a simple buffer. */
3921 #define SAFE_ALLOCA(size) ((size) < MAX_ALLOCA \
3925 /* SAFE_NALLOCA sets BUF to a newly allocated array of MULTIPLIER *
3926 NITEMS items, each of the same type as *BUF. MULTIPLIER must
3927 positive. The code is tuned for MULTIPLIER being a constant. */
3929 #define SAFE_NALLOCA(buf, multiplier, nitems) \
3931 if ((nitems) <= MAX_ALLOCA / sizeof *(buf) / (multiplier)) \
3932 (buf) = alloca (sizeof *(buf) * (multiplier) * (nitems)); \
3934 (buf) = xnmalloc (nitems, sizeof *(buf) * (multiplier)); \
3937 /* SAFE_FREE frees xmalloced memory and enables GC as needed. */
3939 #define SAFE_FREE() ((void) 0)
3941 /* SAFE_ALLOCA_LISP allocates an array of Lisp_Objects. */
3943 #define SAFE_ALLOCA_LISP(buf, nelt) \
3945 if ((nelt) < MAX_ALLOCA / word_size) \
3946 (buf) = alloca ((nelt) * word_size); \
3947 else if ((nelt) < min (PTRDIFF_MAX, SIZE_MAX) / word_size) \
3948 buf = xmalloc ((nelt) * word_size); \
3950 memory_full (SIZE_MAX); \
3953 /* Loop over all tails of a list, checking for cycles.
3954 FIXME: Make tortoise and n internal declarations.
3955 FIXME: Unroll the loop body so we don't need `n'. */
3956 #define FOR_EACH_TAIL(hare, list, tortoise, n) \
3957 for ((tortoise) = (hare) = (list), (n) = true; \
3959 (hare = XCDR (hare), (n) = !(n), \
3961 ? (EQ (hare, tortoise) \
3962 ? xsignal1 (Qcircular_list, list) \
3964 /* Move tortoise before the next iteration, in case */ \
3965 /* the next iteration does an Fsetcdr. */ \
3966 : (void) ((tortoise) = XCDR (tortoise)))))
3968 /* Do a `for' loop over alist values. */
3970 #define FOR_EACH_ALIST_VALUE(head_var, list_var, value_var) \
3971 for ((list_var) = (head_var); \
3972 (CONSP (list_var) && ((value_var) = XCDR (XCAR (list_var)), true)); \
3973 (list_var) = XCDR (list_var))
3975 /* Check whether it's time for GC, and run it if so. */
3984 functionp (Lisp_Object object
)
3986 if (SYMBOLP (object
) && !NILP (Ffboundp (object
)))
3988 object
= Findirect_function (object
, Qt
);
3990 if (CONSP (object
) && EQ (XCAR (object
), Qautoload
))
3992 /* Autoloaded symbols are functions, except if they load
3993 macros or keymaps. */
3995 for (i
= 0; i
< 4 && CONSP (object
); i
++)
3996 object
= XCDR (object
);
3998 return ! (CONSP (object
) && !NILP (XCAR (object
)));
4002 if (scm_is_true (scm_procedure_p (object
)))
4004 else if (COMPILEDP (object
))
4006 else if (CONSP (object
))
4008 Lisp_Object car
= XCAR (object
);
4009 return EQ (car
, Qlambda
) || EQ (car
, Qclosure
);
4014 #endif /* EMACS_LISP_H */