test/manual/etags/c-src/emacs/src/lisp.h

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
DEFINE_GDB_SYMBOL_END
LISP_MACRO_DEFUN
XINT
XFASTINT
XSYMBOL
XTYPE
XUNTAG
LISP_MACRO_DEFUN
LISP_MACRO_DEFUN
clip_to_bounds
LISP_MACRO_DEFUN
XSTRING
XFLOAT
XPROCESS
XWINDOW
XTERMINAL
XSUBR
XBUFFER
XCHAR_TABLE
XSUB_CHAR_TABLE
XBOOL_VECTOR
make_lisp_ptr
make_lisp_symbol
builtin_lisp_symbol
XINTPTR
make_pointer_integer
LISP_MACRO_DEFUN_VOID
xcar_addr
xcdr_addr
LISP_MACRO_DEFUN
XSETCDR
CAR
CDR
CAR_SAFE
CDR_SAFE
STRING_MULTIBYTE
SDATA
SSDATA
SREF
SSET
SCHARS
STRING_BYTES
SBYTES
STRING_SET_CHARS
bool_vector_size
bool_vector_data
bool_vector_uchar_data
bool_vector_words
bool_vector_bytes
bool_vector_bitref
bool_vector_ref
bool_vector_set
AREF
aref_addr
ASIZE
ASET
gc_aset
memclear
CHAR_TABLE_REF_ASCII
CHAR_TABLE_REF
CHAR_TABLE_SET
CHAR_TABLE_EXTRA_SLOTS
LISP_MACRO_DEFUN
SYMBOL_BLV
SYMBOL_FWD
LISP_MACRO_DEFUN_VOID
SET_SYMBOL_BLV
SET_SYMBOL_FWD
SYMBOL_NAME
SYMBOL_INTERNED_P
SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P
XHASH_TABLE
HASH_TABLE_P
HASH_KEY
HASH_VALUE
HASH_NEXT
HASH_HASH
HASH_INDEX
HASH_TABLE_SIZE
sxhash_combine
SXHASH_REDUCE
save_type
XSAVE_POINTER
set_save_pointer
XSAVE_FUNCPOINTER
XSAVE_INTEGER
set_save_integer
XSAVE_OBJECT
XMISC
XMISCANY
XMISCTYPE
XMARKER
XOVERLAY
XSAVE_VALUE
XFINALIZER
XFWDTYPE
XBUFFER_OBJFWD
XFLOAT_DATA
LISP_MACRO_DEFUN
NATNUMP
RANGED_INTEGERP
LISP_MACRO_DEFUN
VECTORP
OVERLAYP
SAVE_VALUEP
FINALIZERP
AUTOLOADP
BUFFER_OBJFWDP
PSEUDOVECTOR_TYPEP
PSEUDOVECTORP
WINDOW_CONFIGURATIONP
PROCESSP
WINDOWP
TERMINALP
SUBRP
COMPILEDP
BUFFERP
CHAR_TABLE_P
SUB_CHAR_TABLE_P
BOOL_VECTOR_P
FRAMEP
IMAGEP
ARRAYP
CHECK_LIST
LISP_MACRO_DEFUN_VOID
CHECK_STRING_CAR
CHECK_CONS
CHECK_VECTOR
CHECK_BOOL_VECTOR
CHECK_VECTOR_OR_STRING
CHECK_ARRAY
CHECK_BUFFER
CHECK_WINDOW
CHECK_PROCESS
CHECK_NATNUM
XFLOATINT
CHECK_NUMBER_OR_FLOAT
CHECK_NUMBER_CAR
CHECK_NUMBER_CDR
FUNCTIONP
SPECPDL_INDEX
vcopy
set_hash_key_slot
set_hash_value_slot
set_symbol_function
set_symbol_plist
set_symbol_next
blv_found
set_overlay_plist
string_intervals
set_string_intervals
set_char_table_defalt
set_char_table_purpose
set_char_table_extras
set_char_table_contents
set_sub_char_table_contents
next_almost_prime
list2i
list3i
list4i
make_formatted_string
build_pure_c_string
build_string
make_uninit_vector
make_uninit_sub_char_table
esprintf
intern
intern_c_string
error
fast_string_match_ignore_case
fixup_locale
synchronize_system_messages_locale
synchronize_system_time_locale
emacs_abort
egetenv
lisp_word_count
maybe_gc
functionp
     1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
     2 
     3 Copyright (C) 1985-1987, 1993-1995, 1997-2023 Free Software Foundation,
     4 Inc.
     5 
     6 This file is part of GNU Emacs.
     7 
     8 GNU Emacs is free software: you can redistribute it and/or modify
     9 it under the terms of the GNU General Public License as published by
    10 the Free Software Foundation, either version 3 of the License, or (at
    11 your option) any later version.
    12 
    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.
    17 
    18 You should have received a copy of the GNU General Public License
    19 along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
    20 
    21 #ifndef EMACS_LISP_H
    22 #define EMACS_LISP_H
    23 
    24 #include <setjmp.h>
    25 #include <stdalign.h>
    26 #include <stdarg.h>
    27 #include <stddef.h>
    28 #include <float.h>
    29 #include <inttypes.h>
    30 #include <limits.h>
    31 
    32 #include <intprops.h>
    33 #include <verify.h>
    34 
    35 INLINE_HEADER_BEGIN
    36 
    37 /* Define a TYPE constant ID as an externally visible name.  Use like this:
    38 
    39       DEFINE_GDB_SYMBOL_BEGIN (TYPE, ID)
    40       # define ID (some integer preprocessor expression of type TYPE)
    41       DEFINE_GDB_SYMBOL_END (ID)
    42 
    43    This hack is for the benefit of compilers that do not make macro
    44    definitions or enums visible to the debugger.  It's used for symbols
    45    that .gdbinit needs.  */
    46 
    47 #define DECLARE_GDB_SYM(type, id) type const id EXTERNALLY_VISIBLE
    48 #ifdef MAIN_PROGRAM
    49 # define DEFINE_GDB_SYMBOL_BEGIN(type, id) DECLARE_GDB_SYM (type, id)
    50 # define DEFINE_GDB_SYMBOL_END(id) = id;
    51 #else
    52 # define DEFINE_GDB_SYMBOL_BEGIN(type, id) extern DECLARE_GDB_SYM (type, id)
    53 # define DEFINE_GDB_SYMBOL_END(val) ;
    54 #endif
    55 
    56 /* The ubiquitous max and min macros.  */
    57 #undef min
    58 #undef max
    59 #define max(a, b) ((a) > (b) ? (a) : (b))
    60 #define min(a, b) ((a) < (b) ? (a) : (b))
    61 
    62 /* Number of elements in an array.  */
    63 #define ARRAYELTS(arr) (sizeof (arr) / sizeof (arr)[0])
    64 
    65 /* Number of bits in a Lisp_Object tag.  */
    66 DEFINE_GDB_SYMBOL_BEGIN (int, GCTYPEBITS)
    67 #define GCTYPEBITS 3
    68 DEFINE_GDB_SYMBOL_END (GCTYPEBITS)
    69 
    70 /* The number of bits needed in an EMACS_INT over and above the number
    71    of bits in a pointer.  This is 0 on systems where:
    72    1.  We can specify multiple-of-8 alignment on static variables.
    73    2.  We know malloc returns a multiple of 8.  */
    74 #if (defined alignas \
    75      && (defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ \
    76          || defined DARWIN_OS || defined __sun || defined __MINGW32__ \
    77          || defined CYGWIN))
    78 # define NONPOINTER_BITS 0
    79 #else
    80 # define NONPOINTER_BITS GCTYPEBITS
    81 #endif
    82 
    83 /* EMACS_INT - signed integer wide enough to hold an Emacs value
    84    EMACS_INT_MAX - maximum value of EMACS_INT; can be used in #if
    85    pI - printf length modifier for EMACS_INT
    86    EMACS_UINT - unsigned variant of EMACS_INT */
    87 #ifndef EMACS_INT_MAX
    88 # if INTPTR_MAX <= 0
    89 #  error "INTPTR_MAX misconfigured"
    90 # elif INTPTR_MAX <= INT_MAX >> NONPOINTER_BITS && !defined WIDE_EMACS_INT
    91 typedef int EMACS_INT;
    92 typedef unsigned int EMACS_UINT;
    93 #  define EMACS_INT_MAX INT_MAX
    94 #  define pI ""
    95 # elif INTPTR_MAX <= LONG_MAX >> NONPOINTER_BITS && !defined WIDE_EMACS_INT
    96 typedef long int EMACS_INT;
    97 typedef unsigned long EMACS_UINT;
    98 #  define EMACS_INT_MAX LONG_MAX
    99 #  define pI "l"
   100 /* Check versus LLONG_MAX, not LLONG_MAX >> NONPOINTER_BITS.
   101    In theory this is not safe, but in practice it seems to be OK.  */
   102 # elif INTPTR_MAX <= LLONG_MAX
   103 typedef long long int EMACS_INT;
   104 typedef unsigned long long int EMACS_UINT;
   105 #  define EMACS_INT_MAX LLONG_MAX
   106 #  define pI "ll"
   107 # else
   108 #  error "INTPTR_MAX too large"
   109 # endif
   110 #endif
   111 
   112 /* Number of bits to put in each character in the internal representation
   113    of bool vectors.  This should not vary across implementations.  */
   114 enum {  BOOL_VECTOR_BITS_PER_CHAR =
   115 #define BOOL_VECTOR_BITS_PER_CHAR 8
   116         BOOL_VECTOR_BITS_PER_CHAR
   117 };
   118 
   119 /* An unsigned integer type representing a fixed-length bit sequence,
   120    suitable for bool vector words, GC mark bits, etc.  Normally it is size_t
   121    for speed, but it is unsigned char on weird platforms.  */
   122 #if BOOL_VECTOR_BITS_PER_CHAR == CHAR_BIT
   123 typedef size_t bits_word;
   124 # define BITS_WORD_MAX SIZE_MAX
   125 enum { BITS_PER_BITS_WORD = CHAR_BIT * sizeof (bits_word) };
   126 #else
   127 typedef unsigned char bits_word;
   128 # define BITS_WORD_MAX ((1u << BOOL_VECTOR_BITS_PER_CHAR) - 1)
   129 enum { BITS_PER_BITS_WORD = BOOL_VECTOR_BITS_PER_CHAR };
   130 #endif
   131 verify (BITS_WORD_MAX >> (BITS_PER_BITS_WORD - 1) == 1);
   132 
   133 /* Number of bits in some machine integer types.  */
   134 enum
   135   {
   136     BITS_PER_CHAR      = CHAR_BIT,
   137     BITS_PER_SHORT     = CHAR_BIT * sizeof (short),
   138     BITS_PER_LONG      = CHAR_BIT * sizeof (long int),
   139     BITS_PER_EMACS_INT = CHAR_BIT * sizeof (EMACS_INT)
   140   };
   141 
   142 /* printmax_t and uprintmax_t are types for printing large integers.
   143    These are the widest integers that are supported for printing.
   144    pMd etc. are conversions for printing them.
   145    On C99 hosts, there's no problem, as even the widest integers work.
   146    Fall back on EMACS_INT on pre-C99 hosts.  */
   147 #ifdef PRIdMAX
   148 typedef intmax_t printmax_t;
   149 typedef uintmax_t uprintmax_t;
   150 # define pMd PRIdMAX
   151 # define pMu PRIuMAX
   152 #else
   153 typedef EMACS_INT printmax_t;
   154 typedef EMACS_UINT uprintmax_t;
   155 # define pMd pI"d"
   156 # define pMu pI"u"
   157 #endif
   158 
   159 /* Use pD to format ptrdiff_t values, which suffice for indexes into
   160    buffers and strings.  Emacs never allocates objects larger than
   161    PTRDIFF_MAX bytes, as they cause problems with pointer subtraction.
   162    In C99, pD can always be "t"; configure it here for the sake of
   163    pre-C99 libraries such as glibc 2.0 and Solaris 8.  */
   164 #if PTRDIFF_MAX == INT_MAX
   165 # define pD ""
   166 #elif PTRDIFF_MAX == LONG_MAX
   167 # define pD "l"
   168 #elif PTRDIFF_MAX == LLONG_MAX
   169 # define pD "ll"
   170 #else
   171 # define pD "t"
   172 #endif
   173 
   174 /* Extra internal type checking?  */
   175 
   176 /* Define Emacs versions of <assert.h>'s 'assert (COND)' and <verify.h>'s
   177    'assume (COND)'.  COND should be free of side effects, as it may or
   178    may not be evaluated.
   179 
   180    'eassert (COND)' checks COND at runtime if ENABLE_CHECKING is
   181    defined and suppress_checking is false, and does nothing otherwise.
   182    Emacs dies if COND is checked and is false.  The suppress_checking
   183    variable is initialized to 0 in alloc.c.  Set it to 1 using a
   184    debugger to temporarily disable aborting on detected internal
   185    inconsistencies or error conditions.
   186 
   187    In some cases, a good compiler may be able to optimize away the
   188    eassert macro even if ENABLE_CHECKING is true, e.g., if XSTRING (x)
   189    uses eassert to test STRINGP (x), but a particular use of XSTRING
   190    is invoked only after testing that STRINGP (x) is true, making the
   191    test redundant.
   192 
   193    eassume is like eassert except that it also causes the compiler to
   194    assume that COND is true afterwards, regardless of whether runtime
   195    checking is enabled.  This can improve performance in some cases,
   196    though it can degrade performance in others.  It's often suboptimal
   197    for COND to call external functions or access volatile storage.  */
   198 
   199 #ifndef ENABLE_CHECKING
   200 # define eassert(cond) ((void) (false && (cond))) /* Check COND compiles.  */
   201 # define eassume(cond) assume (cond)
   202 #else /* ENABLE_CHECKING */
   203 
   204 extern _Noreturn void die (const char *, const char *, int);
   205 
   206 extern bool suppress_checking EXTERNALLY_VISIBLE;
   207 
   208 # define eassert(cond)                                          \
   209    (suppress_checking || (cond)                                 \
   210     ? (void) 0                                                  \
   211     : die (# cond, __FILE__, __LINE__))
   212 # define eassume(cond)                                          \
   213    (suppress_checking                                           \
   214     ? assume (cond)                                             \
   215     : (cond)                                                    \
   216     ? (void) 0                                                  \
   217     : die (# cond, __FILE__, __LINE__))
   218 #endif /* ENABLE_CHECKING */
   219 
   220 
   221 /* Use the configure flag --enable-check-lisp-object-type to make
   222    Lisp_Object use a struct type instead of the default int.  The flag
   223    causes CHECK_LISP_OBJECT_TYPE to be defined.  */
   224 
   225 /***** Select the tagging scheme.  *****/
   226 /* The following option controls the tagging scheme:
   227    - USE_LSB_TAG means that we can assume the least 3 bits of pointers are
   228      always 0, and we can thus use them to hold tag bits, without
   229      restricting our addressing space.
   230 
   231    If ! USE_LSB_TAG, then use the top 3 bits for tagging, thus
   232    restricting our possible address range.
   233 
   234    USE_LSB_TAG not only requires the least 3 bits of pointers returned by
   235    malloc to be 0 but also needs to be able to impose a mult-of-8 alignment
   236    on the few static Lisp_Objects used: lispsym, all the defsubr, and
   237    the two special buffers buffer_defaults and buffer_local_symbols.  */
   238 
   239 enum Lisp_Bits
   240   {
   241     /* 2**GCTYPEBITS.  This must be a macro that expands to a literal
   242        integer constant, for MSVC.  */
   243 #define GCALIGNMENT 8
   244 
   245     /* Number of bits in a Lisp_Object value, not counting the tag.  */
   246     VALBITS = BITS_PER_EMACS_INT - GCTYPEBITS,
   247 
   248     /* Number of bits in a Lisp fixnum tag.  */
   249     INTTYPEBITS = GCTYPEBITS - 1,
   250 
   251     /* Number of bits in a Lisp fixnum value, not counting the tag.  */
   252     FIXNUM_BITS = VALBITS + 1
   253   };
   254 
   255 #if GCALIGNMENT != 1 << GCTYPEBITS
   256 # error "GCALIGNMENT and GCTYPEBITS are inconsistent"
   257 #endif
   258 
   259 /* The maximum value that can be stored in a EMACS_INT, assuming all
   260    bits other than the type bits contribute to a nonnegative signed value.
   261    This can be used in #if, e.g., '#if USB_TAG' below expands to an
   262    expression involving VAL_MAX.  */
   263 #define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1))
   264 
   265 /* Whether the least-significant bits of an EMACS_INT contain the tag.
   266    On hosts where pointers-as-ints do not exceed VAL_MAX / 2, USE_LSB_TAG is:
   267     a. unnecessary, because the top bits of an EMACS_INT are unused, and
   268     b. slower, because it typically requires extra masking.
   269    So, USE_LSB_TAG is true only on hosts where it might be useful.  */
   270 DEFINE_GDB_SYMBOL_BEGIN (bool, USE_LSB_TAG)
   271 #define USE_LSB_TAG (VAL_MAX / 2 < INTPTR_MAX)
   272 DEFINE_GDB_SYMBOL_END (USE_LSB_TAG)
   273 
   274 #if !USE_LSB_TAG && !defined WIDE_EMACS_INT
   275 # error "USE_LSB_TAG not supported on this platform; please report this." \
   276         "Try 'configure --with-wide-int' to work around the problem."
   277 error !;
   278 #endif
   279 
   280 #ifndef alignas
   281 # define alignas(alignment) /* empty */
   282 # if USE_LSB_TAG
   283 #  error "USE_LSB_TAG requires alignas"
   284 # endif
   285 #endif
   286 
   287 #ifdef HAVE_STRUCT_ATTRIBUTE_ALIGNED
   288 # define GCALIGNED __attribute__ ((aligned (GCALIGNMENT)))
   289 #else
   290 # define GCALIGNED /* empty */
   291 #endif
   292 
   293 /* Some operations are so commonly executed that they are implemented
   294    as macros, not functions, because otherwise runtime performance would
   295    suffer too much when compiling with GCC without optimization.
   296    There's no need to inline everything, just the operations that
   297    would otherwise cause a serious performance problem.
   298 
   299    For each such operation OP, define a macro lisp_h_OP that contains
   300    the operation's implementation.  That way, OP can be implemented
   301    via a macro definition like this:
   302 
   303      #define OP(x) lisp_h_OP (x)
   304 
   305    and/or via a function definition like this:
   306 
   307      LISP_MACRO_DEFUN (OP, Lisp_Object, (Lisp_Object x), (x))
   308 
   309    which macro-expands to this:
   310 
   311      Lisp_Object (OP) (Lisp_Object x) { return lisp_h_OP (x); }
   312 
   313    without worrying about the implementations diverging, since
   314    lisp_h_OP defines the actual implementation.  The lisp_h_OP macros
   315    are intended to be private to this include file, and should not be
   316    used elsewhere.
   317 
   318    FIXME: Remove the lisp_h_OP macros, and define just the inline OP
   319    functions, once most developers have access to GCC 4.8 or later and
   320    can use "gcc -Og" to debug.  Maybe in the year 2016.  See
   321    Bug#11935.
   322 
   323    Commentary for these macros can be found near their corresponding
   324    functions, below.  */
   325 
   326 #if CHECK_LISP_OBJECT_TYPE
   327 # define lisp_h_XLI(o) ((o).i)
   328 # define lisp_h_XIL(i) ((Lisp_Object) { i })
   329 #else
   330 # define lisp_h_XLI(o) (o)
   331 # define lisp_h_XIL(i) (i)
   332 #endif
   333 #define lisp_h_CHECK_LIST_CONS(x, y) CHECK_TYPE (CONSP (x), Qlistp, y)
   334 #define lisp_h_CHECK_NUMBER(x) CHECK_TYPE (INTEGERP (x), Qintegerp, x)
   335 #define lisp_h_CHECK_SYMBOL(x) CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
   336 #define lisp_h_CHECK_TYPE(ok, predicate, x) \
   337    ((ok) ? (void) 0 : (void) wrong_type_argument (predicate, x))
   338 #define lisp_h_CONSP(x) (XTYPE (x) == Lisp_Cons)
   339 #define lisp_h_EQ(x, y) (XLI (x) == XLI (y))
   340 #define lisp_h_FLOATP(x) (XTYPE (x) == Lisp_Float)
   341 #define lisp_h_INTEGERP(x) ((XTYPE (x) & (Lisp_Int0 | ~Lisp_Int1)) == Lisp_Int0)
   342 #define lisp_h_MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
   343 #define lisp_h_MISCP(x) (XTYPE (x) == Lisp_Misc)
   344 #define lisp_h_NILP(x) EQ (x, Qnil)
   345 #define lisp_h_SET_SYMBOL_VAL(sym, v) \
   346    (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v))
   347 #define lisp_h_SYMBOL_CONSTANT_P(sym) (XSYMBOL (sym)->constant)
   348 #define lisp_h_SYMBOL_VAL(sym) \
   349    (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value)
   350 #define lisp_h_SYMBOLP(x) (XTYPE (x) == Lisp_Symbol)
   351 #define lisp_h_VECTORLIKEP(x) (XTYPE (x) == Lisp_Vectorlike)
   352 #define lisp_h_XCAR(c) XCONS (c)->car
   353 #define lisp_h_XCDR(c) XCONS (c)->u.cdr
   354 #define lisp_h_XCONS(a) \
   355    (eassert (CONSP (a)), (struct Lisp_Cons *) XUNTAG (a, Lisp_Cons))
   356 #define lisp_h_XHASH(a) XUINT (a)
   357 #define lisp_h_XPNTR(a) \
   358    (SYMBOLP (a) ? XSYMBOL (a) : (void *) ((intptr_t) (XLI (a) & VALMASK)))
   359 #ifndef GC_CHECK_CONS_LIST
   360 # define lisp_h_check_cons_list() ((void) 0)
   361 #endif
   362 #if USE_LSB_TAG
   363 # define lisp_h_make_number(n) \
   364     XIL ((EMACS_INT) (((EMACS_UINT) (n) << INTTYPEBITS) + Lisp_Int0))
   365 # define lisp_h_XFASTINT(a) XINT (a)
   366 # define lisp_h_XINT(a) (XLI (a) >> INTTYPEBITS)
   367 # define lisp_h_XSYMBOL(a) \
   368     (eassert (SYMBOLP (a)), \
   369      (struct Lisp_Symbol *) ((uintptr_t) XLI (a) - Lisp_Symbol \
   370                              + (char *) lispsym))
   371 # define lisp_h_XTYPE(a) ((enum Lisp_Type) (XLI (a) & ~VALMASK))
   372 # define lisp_h_XUNTAG(a, type) ((void *) (intptr_t) (XLI (a) - (type)))
   373 #endif
   374 
   375 /* When compiling via gcc -O0, define the key operations as macros, as
   376    Emacs is too slow otherwise.  To disable this optimization, compile
   377    with -DINLINING=false.  */
   378 #if (defined __NO_INLINE__ \
   379      && ! defined __OPTIMIZE__ && ! defined __OPTIMIZE_SIZE__ \
   380      && ! (defined INLINING && ! INLINING))
   381 # define XLI(o) lisp_h_XLI (o)
   382 # define XIL(i) lisp_h_XIL (i)
   383 # define CHECK_LIST_CONS(x, y) lisp_h_CHECK_LIST_CONS (x, y)
   384 # define CHECK_NUMBER(x) lisp_h_CHECK_NUMBER (x)
   385 # define CHECK_SYMBOL(x) lisp_h_CHECK_SYMBOL (x)
   386 # define CHECK_TYPE(ok, predicate, x) lisp_h_CHECK_TYPE (ok, predicate, x)
   387 # define CONSP(x) lisp_h_CONSP (x)
   388 # define EQ(x, y) lisp_h_EQ (x, y)
   389 # define FLOATP(x) lisp_h_FLOATP (x)
   390 # define INTEGERP(x) lisp_h_INTEGERP (x)
   391 # define MARKERP(x) lisp_h_MARKERP (x)
   392 # define MISCP(x) lisp_h_MISCP (x)
   393 # define NILP(x) lisp_h_NILP (x)
   394 # define SET_SYMBOL_VAL(sym, v) lisp_h_SET_SYMBOL_VAL (sym, v)
   395 # define SYMBOL_CONSTANT_P(sym) lisp_h_SYMBOL_CONSTANT_P (sym)
   396 # define SYMBOL_VAL(sym) lisp_h_SYMBOL_VAL (sym)
   397 # define SYMBOLP(x) lisp_h_SYMBOLP (x)
   398 # define VECTORLIKEP(x) lisp_h_VECTORLIKEP (x)
   399 # define XCAR(c) lisp_h_XCAR (c)
   400 # define XCDR(c) lisp_h_XCDR (c)
   401 # define XCONS(a) lisp_h_XCONS (a)
   402 # define XHASH(a) lisp_h_XHASH (a)
   403 # define XPNTR(a) lisp_h_XPNTR (a)
   404 # ifndef GC_CHECK_CONS_LIST
   405 #  define check_cons_list() lisp_h_check_cons_list ()
   406 # endif
   407 # if USE_LSB_TAG
   408 #  define make_number(n) lisp_h_make_number (n)
   409 #  define XFASTINT(a) lisp_h_XFASTINT (a)
   410 #  define XINT(a) lisp_h_XINT (a)
   411 #  define XSYMBOL(a) lisp_h_XSYMBOL (a)
   412 #  define XTYPE(a) lisp_h_XTYPE (a)
   413 #  define XUNTAG(a, type) lisp_h_XUNTAG (a, type)
   414 # endif
   415 #endif
   416 
   417 /* Define NAME as a lisp.h inline function that returns TYPE and has
   418    arguments declared as ARGDECLS and passed as ARGS.  ARGDECLS and
   419    ARGS should be parenthesized.  Implement the function by calling
   420    lisp_h_NAME ARGS.  */
   421 #define LISP_MACRO_DEFUN(name, type, argdecls, args) \
   422   INLINE type (name) argdecls { return lisp_h_##name args; }
   423 
   424 /* like LISP_MACRO_DEFUN, except NAME returns void.  */
   425 #define LISP_MACRO_DEFUN_VOID(name, argdecls, args) \
   426   INLINE void (name) argdecls { lisp_h_##name args; }
   427 
   428 
   429 /* Define the fundamental Lisp data structures.  */
   430 
   431 /* This is the set of Lisp data types.  If you want to define a new
   432    data type, read the comments after Lisp_Fwd_Type definition
   433    below.  */
   434 
   435 /* Lisp integers use 2 tags, to give them one extra bit, thus
   436    extending their range from, e.g., -2^28..2^28-1 to -2^29..2^29-1.  */
   437 #define INTMASK (EMACS_INT_MAX >> (INTTYPEBITS - 1))
   438 #define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
   439 
   440 /* Idea stolen from GDB.  Pedantic GCC complains about enum bitfields,
   441    MSVC doesn't support them, and xlc and Oracle Studio c99 complain
   442    vociferously about them.  */
   443 #if (defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__ \
   444      || (defined __SUNPRO_C && __STDC__))
   445 #define ENUM_BF(TYPE) unsigned int
   446 #else
   447 #define ENUM_BF(TYPE) enum TYPE
   448 #endif
   449 
   450 
   451 enum Lisp_Type
   452   {
   453     /* Symbol.  XSYMBOL (object) points to a struct Lisp_Symbol.  */
   454     Lisp_Symbol = 0,
   455 
   456     /* Miscellaneous.  XMISC (object) points to a union Lisp_Misc,
   457        whose first member indicates the subtype.  */
   458     Lisp_Misc = 1,
   459 
   460     /* Integer.  XINT (obj) is the integer value.  */
   461     Lisp_Int0 = 2,
   462     Lisp_Int1 = USE_LSB_TAG ? 6 : 3,
   463 
   464     /* String.  XSTRING (object) points to a struct Lisp_String.
   465        The length of the string, and its contents, are stored therein.  */
   466     Lisp_String = 4,
   467 
   468     /* Vector of Lisp objects, or something resembling it.
   469        XVECTOR (object) points to a struct Lisp_Vector, which contains
   470        the size and contents.  The size field also contains the type
   471        information, if it's not a real vector object.  */
   472     Lisp_Vectorlike = 5,
   473 
   474     /* Cons.  XCONS (object) points to a struct Lisp_Cons.  */
   475     Lisp_Cons = USE_LSB_TAG ? 3 : 6,
   476 
   477     Lisp_Float = 7
   478   };
   479 
   480 /* This is the set of data types that share a common structure.
   481    The first member of the structure is a type code from this set.
   482    The enum values are arbitrary, but we'll use large numbers to make it
   483    more likely that we'll spot the error if a random word in memory is
   484    mistakenly interpreted as a Lisp_Misc.  */
   485 enum Lisp_Misc_Type
   486   {
   487     Lisp_Misc_Free = 0x5eab,
   488     Lisp_Misc_Marker,
   489     Lisp_Misc_Overlay,
   490     Lisp_Misc_Save_Value,
   491     Lisp_Misc_Finalizer,
   492     /* Currently floats are not a misc type,
   493        but let's define this in case we want to change that.  */
   494     Lisp_Misc_Float,
   495     /* This is not a type code.  It is for range checking.  */
   496     Lisp_Misc_Limit
   497   };
   498 
   499 /* These are the types of forwarding objects used in the value slot
   500    of symbols for special built-in variables whose value is stored in
   501    C variables.  */
   502 enum Lisp_Fwd_Type
   503   {
   504     Lisp_Fwd_Int,               /* Fwd to a C `int' variable.  */
   505     Lisp_Fwd_Bool,              /* Fwd to a C boolean var.  */
   506     Lisp_Fwd_Obj,               /* Fwd to a C Lisp_Object variable.  */
   507     Lisp_Fwd_Buffer_Obj,        /* Fwd to a Lisp_Object field of buffers.  */
   508     Lisp_Fwd_Kboard_Obj         /* Fwd to a Lisp_Object field of kboards.  */
   509   };
   510 
   511 /* If you want to define a new Lisp data type, here are some
   512    instructions.  See the thread at
   513    https://lists.gnu.org/r/emacs-devel/2012-10/msg00561.html
   514    for more info.
   515 
   516    First, there are already a couple of Lisp types that can be used if
   517    your new type does not need to be exposed to Lisp programs nor
   518    displayed to users.  These are Lisp_Save_Value, a Lisp_Misc
   519    subtype; and PVEC_OTHER, a kind of vectorlike object.  The former
   520    is suitable for temporarily stashing away pointers and integers in
   521    a Lisp object.  The latter is useful for vector-like Lisp objects
   522    that need to be used as part of other objects, but which are never
   523    shown to users or Lisp code (search for PVEC_OTHER in xterm.c for
   524    an example).
   525 
   526    These two types don't look pretty when printed, so they are
   527    unsuitable for Lisp objects that can be exposed to users.
   528 
   529    To define a new data type, add one more Lisp_Misc subtype or one
   530    more pseudovector subtype.  Pseudovectors are more suitable for
   531    objects with several slots that need to support fast random access,
   532    while Lisp_Misc types are for everything else.  A pseudovector object
   533    provides one or more slots for Lisp objects, followed by struct
   534    members that are accessible only from C.  A Lisp_Misc object is a
   535    wrapper for a C struct that can contain anything you like.
   536 
   537    Explicit freeing is discouraged for Lisp objects in general.  But if
   538    you really need to exploit this, use Lisp_Misc (check free_misc in
   539    alloc.c to see why).  There is no way to free a vectorlike object.
   540 
   541    To add a new pseudovector type, extend the pvec_type enumeration;
   542    to add a new Lisp_Misc, extend the Lisp_Misc_Type enumeration.
   543 
   544    For a Lisp_Misc, you will also need to add your entry to union
   545    Lisp_Misc (but make sure the first word has the same structure as
   546    the others, starting with a 16-bit member of the Lisp_Misc_Type
   547    enumeration and a 1-bit GC markbit) and make sure the overall size
   548    of the union is not increased by your addition.
   549 
   550    For a new pseudovector, it's highly desirable to limit the size
   551    of your data type by VBLOCK_BYTES_MAX bytes (defined in alloc.c).
   552    Otherwise you will need to change sweep_vectors (also in alloc.c).
   553 
   554    Then you will need to add switch branches in print.c (in
   555    print_object, to print your object, and possibly also in
   556    print_preprocess) and to alloc.c, to mark your object (in
   557    mark_object) and to free it (in gc_sweep).  The latter is also the
   558    right place to call any code specific to your data type that needs
   559    to run when the object is recycled -- e.g., free any additional
   560    resources allocated for it that are not Lisp objects.  You can even
   561    make a pointer to the function that frees the resources a slot in
   562    your object -- this way, the same object could be used to represent
   563    several disparate C structures.  */
   564 
   565 #ifdef CHECK_LISP_OBJECT_TYPE
   566 
   567 typedef struct { EMACS_INT i; } Lisp_Object;
   568 
   569 #define LISP_INITIALLY(i) {i}
   570 
   571 #undef CHECK_LISP_OBJECT_TYPE
   572 enum CHECK_LISP_OBJECT_TYPE { CHECK_LISP_OBJECT_TYPE = true };
   573 #else /* CHECK_LISP_OBJECT_TYPE */
   574 
   575 /* If a struct type is not wanted, define Lisp_Object as just a number.  */
   576 
   577 typedef EMACS_INT Lisp_Object;
   578 #define LISP_INITIALLY(i) (i)
   579 enum CHECK_LISP_OBJECT_TYPE { CHECK_LISP_OBJECT_TYPE = false };
   580 #endif /* CHECK_LISP_OBJECT_TYPE */
   581 
   582 #define LISP_INITIALLY_ZERO LISP_INITIALLY (0)
   583 
   584 /* Forward declarations.  */
   585 
   586 /* Defined in this file.  */
   587 union Lisp_Fwd;
   588 INLINE bool BOOL_VECTOR_P (Lisp_Object);
   589 INLINE bool BUFFER_OBJFWDP (union Lisp_Fwd *);
   590 INLINE bool BUFFERP (Lisp_Object);
   591 INLINE bool CHAR_TABLE_P (Lisp_Object);
   592 INLINE Lisp_Object CHAR_TABLE_REF_ASCII (Lisp_Object, ptrdiff_t);
   593 INLINE bool (CONSP) (Lisp_Object);
   594 INLINE bool (FLOATP) (Lisp_Object);
   595 INLINE bool functionp (Lisp_Object);
   596 INLINE bool (INTEGERP) (Lisp_Object);
   597 INLINE bool (MARKERP) (Lisp_Object);
   598 INLINE bool (MISCP) (Lisp_Object);
   599 INLINE bool (NILP) (Lisp_Object);
   600 INLINE bool OVERLAYP (Lisp_Object);
   601 INLINE bool PROCESSP (Lisp_Object);
   602 INLINE bool PSEUDOVECTORP (Lisp_Object, int);
   603 INLINE bool SAVE_VALUEP (Lisp_Object);
   604 INLINE bool FINALIZERP (Lisp_Object);
   605 INLINE void set_sub_char_table_contents (Lisp_Object, ptrdiff_t,
   606                                               Lisp_Object);
   607 INLINE bool STRINGP (Lisp_Object);
   608 INLINE bool SUB_CHAR_TABLE_P (Lisp_Object);
   609 INLINE bool SUBRP (Lisp_Object);
   610 INLINE bool (SYMBOLP) (Lisp_Object);
   611 INLINE bool (VECTORLIKEP) (Lisp_Object);
   612 INLINE bool WINDOWP (Lisp_Object);
   613 INLINE bool TERMINALP (Lisp_Object);
   614 INLINE struct Lisp_Save_Value *XSAVE_VALUE (Lisp_Object);
   615 INLINE struct Lisp_Finalizer *XFINALIZER (Lisp_Object);
   616 INLINE struct Lisp_Symbol *(XSYMBOL) (Lisp_Object);
   617 INLINE void *(XUNTAG) (Lisp_Object, int);
   618 
   619 /* Defined in chartab.c.  */
   620 extern Lisp_Object char_table_ref (Lisp_Object, int);
   621 extern void char_table_set (Lisp_Object, int, Lisp_Object);
   622 
   623 /* Defined in data.c.  */
   624 extern _Noreturn Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object);
   625 extern _Noreturn void wrong_choice (Lisp_Object, Lisp_Object);
   626 
   627 /* Defined in emacs.c.  */
   628 extern bool might_dump;
   629 /* True means Emacs has already been initialized.
   630    Used during startup to detect startup of dumped Emacs.  */
   631 extern bool initialized;
   632 
   633 /* Defined in floatfns.c.  */
   634 extern double extract_float (Lisp_Object);
   635 
   636 
   637 /* Interned state of a symbol.  */
   638 
   639 enum symbol_interned
   640 {
   641   SYMBOL_UNINTERNED = 0,
   642   SYMBOL_INTERNED = 1,
   643   SYMBOL_INTERNED_IN_INITIAL_OBARRAY = 2
   644 };
   645 
   646 enum symbol_redirect
   647 {
   648   SYMBOL_PLAINVAL  = 4,
   649   SYMBOL_VARALIAS  = 1,
   650   SYMBOL_LOCALIZED = 2,
   651   SYMBOL_FORWARDED = 3
   652 };
   653 
   654 struct Lisp_Symbol
   655 {
   656   bool_bf gcmarkbit : 1;
   657 
   658   /* Indicates where the value can be found:
   659      0 : it's a plain var, the value is in the `value' field.
   660      1 : it's a varalias, the value is really in the `alias' symbol.
   661      2 : it's a localized var, the value is in the `blv' object.
   662      3 : it's a forwarding variable, the value is in `forward'.  */
   663   ENUM_BF (symbol_redirect) redirect : 3;
   664 
   665   /* Non-zero means symbol is constant, i.e. changing its value
   666      should signal an error.  If the value is 3, then the var
   667      can be changed, but only by `defconst'.  */
   668   unsigned constant : 2;
   669 
   670   /* Interned state of the symbol.  This is an enumerator from
   671      enum symbol_interned.  */
   672   unsigned interned : 2;
   673 
   674   /* True means that this variable has been explicitly declared
   675      special (with `defvar' etc), and shouldn't be lexically bound.  */
   676   bool_bf declared_special : 1;
   677 
   678   /* True if pointed to from purespace and hence can't be GC'd.  */
   679   bool_bf pinned : 1;
   680 
   681   /* The symbol's name, as a Lisp string.  */
   682   Lisp_Object name;
   683 
   684   /* Value of the symbol or Qunbound if unbound.  Which alternative of the
   685      union is used depends on the `redirect' field above.  */
   686   union {
   687     Lisp_Object value;
   688     struct Lisp_Symbol *alias;
   689     struct Lisp_Buffer_Local_Value *blv;
   690     union Lisp_Fwd *fwd;
   691   } val;
   692 
   693   /* Function value of the symbol or Qnil if not fboundp.  */
   694   Lisp_Object function;
   695 
   696   /* The symbol's property list.  */
   697   Lisp_Object plist;
   698 
   699   /* Next symbol in obarray bucket, if the symbol is interned.  */
   700   struct Lisp_Symbol *next;
   701 };
   702 
   703 /* Declare a Lisp-callable function.  The MAXARGS parameter has the same
   704    meaning as in the DEFUN macro, and is used to construct a prototype.  */
   705 /* We can use the same trick as in the DEFUN macro to generate the
   706    appropriate prototype.  */
   707 #define EXFUN(fnname, maxargs) \
   708   extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
   709 
   710 /* Note that the weird token-substitution semantics of ANSI C makes
   711    this work for MANY and UNEVALLED.  */
   712 #define DEFUN_ARGS_MANY         (ptrdiff_t, Lisp_Object *)
   713 #define DEFUN_ARGS_UNEVALLED    (Lisp_Object)
   714 #define DEFUN_ARGS_0    (void)
   715 #define DEFUN_ARGS_1    (Lisp_Object)
   716 #define DEFUN_ARGS_2    (Lisp_Object, Lisp_Object)
   717 #define DEFUN_ARGS_3    (Lisp_Object, Lisp_Object, Lisp_Object)
   718 #define DEFUN_ARGS_4    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
   719 #define DEFUN_ARGS_5    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
   720                          Lisp_Object)
   721 #define DEFUN_ARGS_6    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
   722                          Lisp_Object, Lisp_Object)
   723 #define DEFUN_ARGS_7    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
   724                          Lisp_Object, Lisp_Object, Lisp_Object)
   725 #define DEFUN_ARGS_8    (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
   726                          Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
   727 
   728 /* Yield an integer that contains TAG along with PTR.  */
   729 #define TAG_PTR(tag, ptr) \
   730   ((USE_LSB_TAG ? (tag) : (EMACS_UINT) (tag) << VALBITS) + (uintptr_t) (ptr))
   731 
   732 /* Yield an integer that contains a symbol tag along with OFFSET.
   733    OFFSET should be the offset in bytes from 'lispsym' to the symbol.  */
   734 #define TAG_SYMOFFSET(offset)                               \
   735   TAG_PTR (Lisp_Symbol,                                     \
   736            ((uintptr_t) (offset) >> (USE_LSB_TAG ? 0 : GCTYPEBITS)))
   737 
   738 /* XLI_BUILTIN_LISPSYM (iQwhatever) is equivalent to
   739    XLI (builtin_lisp_symbol (Qwhatever)),
   740    except the former expands to an integer constant expression.  */
   741 #define XLI_BUILTIN_LISPSYM(iname) TAG_SYMOFFSET ((iname) * sizeof *lispsym)
   742 
   743 /* Declare extern constants for Lisp symbols.  These can be helpful
   744    when using a debugger like GDB, on older platforms where the debug
   745    format does not represent C macros.  */
   746 #define DEFINE_LISP_SYMBOL(name) \
   747   DEFINE_GDB_SYMBOL_BEGIN (Lisp_Object, name) \
   748   DEFINE_GDB_SYMBOL_END (LISP_INITIALLY (XLI_BUILTIN_LISPSYM (i##name)))
   749 
   750 /* By default, define macros for Qt, etc., as this leads to a bit
   751    better performance in the core Emacs interpreter.  A plugin can
   752    define DEFINE_NON_NIL_Q_SYMBOL_MACROS to be false, to be portable to
   753    other Emacs instances that assign different values to Qt, etc.  */
   754 #ifndef DEFINE_NON_NIL_Q_SYMBOL_MACROS
   755 # define DEFINE_NON_NIL_Q_SYMBOL_MACROS true
   756 #endif
   757 
   758 #include "globals.h"
   759 
   760 /* Convert a Lisp_Object to the corresponding EMACS_INT and vice versa.
   761    At the machine level, these operations are no-ops.  */
   762 LISP_MACRO_DEFUN (XLI, EMACS_INT, (Lisp_Object o), (o))
   763 LISP_MACRO_DEFUN (XIL, Lisp_Object, (EMACS_INT i), (i))
   764 
   765 /* In the size word of a vector, this bit means the vector has been marked.  */
   766 
   767 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, ARRAY_MARK_FLAG)
   768 # define ARRAY_MARK_FLAG PTRDIFF_MIN
   769 DEFINE_GDB_SYMBOL_END (ARRAY_MARK_FLAG)
   770 
   771 /* In the size word of a struct Lisp_Vector, this bit means it's really
   772    some other vector-like object.  */
   773 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, PSEUDOVECTOR_FLAG)
   774 # define PSEUDOVECTOR_FLAG (PTRDIFF_MAX - PTRDIFF_MAX / 2)
   775 DEFINE_GDB_SYMBOL_END (PSEUDOVECTOR_FLAG)
   776 
   777 /* In a pseudovector, the size field actually contains a word with one
   778    PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
   779    with PVEC_TYPE_MASK to indicate the actual type.  */
   780 enum pvec_type
   781 {
   782   PVEC_NORMAL_VECTOR,
   783   PVEC_FREE,
   784   PVEC_PROCESS,
   785   PVEC_FRAME,
   786   PVEC_WINDOW,
   787   PVEC_BOOL_VECTOR,
   788   PVEC_BUFFER,
   789   PVEC_HASH_TABLE,
   790   PVEC_TERMINAL,
   791   PVEC_WINDOW_CONFIGURATION,
   792   PVEC_SUBR,
   793   PVEC_OTHER,
   794   /* These should be last, check internal_equal to see why.  */
   795   PVEC_COMPILED,
   796   PVEC_CHAR_TABLE,
   797   PVEC_SUB_CHAR_TABLE,
   798   PVEC_FONT /* Should be last because it's used for range checking.  */
   799 };
   800 
   801 enum More_Lisp_Bits
   802   {
   803     /* For convenience, we also store the number of elements in these bits.
   804        Note that this size is not necessarily the memory-footprint size, but
   805        only the number of Lisp_Object fields (that need to be traced by GC).
   806        The distinction is used, e.g., by Lisp_Process, which places extra
   807        non-Lisp_Object fields at the end of the structure.  */
   808     PSEUDOVECTOR_SIZE_BITS = 12,
   809     PSEUDOVECTOR_SIZE_MASK = (1 << PSEUDOVECTOR_SIZE_BITS) - 1,
   810 
   811     /* To calculate the memory footprint of the pseudovector, it's useful
   812        to store the size of non-Lisp area in word_size units here.  */
   813     PSEUDOVECTOR_REST_BITS = 12,
   814     PSEUDOVECTOR_REST_MASK = (((1 << PSEUDOVECTOR_REST_BITS) - 1)
   815                               << PSEUDOVECTOR_SIZE_BITS),
   816 
   817     /* Used to extract pseudovector subtype information.  */
   818     PSEUDOVECTOR_AREA_BITS = PSEUDOVECTOR_SIZE_BITS + PSEUDOVECTOR_REST_BITS,
   819     PVEC_TYPE_MASK = 0x3f << PSEUDOVECTOR_AREA_BITS
   820   };
   821 
   822 /* These functions extract various sorts of values from a Lisp_Object.
   823    For example, if tem is a Lisp_Object whose type is Lisp_Cons,
   824    XCONS (tem) is the struct Lisp_Cons * pointing to the memory for
   825    that cons.  */
   826 
   827 /* Mask for the value (as opposed to the type bits) of a Lisp object.  */
   828 DEFINE_GDB_SYMBOL_BEGIN (EMACS_INT, VALMASK)
   829 # define VALMASK (USE_LSB_TAG ? - (1 << GCTYPEBITS) : VAL_MAX)
   830 DEFINE_GDB_SYMBOL_END (VALMASK)
   831 
   832 /* Largest and smallest representable fixnum values.  These are the C
   833    values.  They are macros for use in static initializers.  */
   834 #define MOST_POSITIVE_FIXNUM (EMACS_INT_MAX >> INTTYPEBITS)
   835 #define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_FIXNUM)
   836 
   837 #if USE_LSB_TAG
   838 
   839 LISP_MACRO_DEFUN (make_number, Lisp_Object, (EMACS_INT n), (n))
   840 LISP_MACRO_DEFUN (XINT, EMACS_INT, (Lisp_Object a), (a))
   841 LISP_MACRO_DEFUN (XFASTINT, EMACS_INT, (Lisp_Object a), (a))
   842 LISP_MACRO_DEFUN (XSYMBOL, struct Lisp_Symbol *, (Lisp_Object a), (a))
   843 LISP_MACRO_DEFUN (XTYPE, enum Lisp_Type, (Lisp_Object a), (a))
   844 LISP_MACRO_DEFUN (XUNTAG, void *, (Lisp_Object a, int type), (a, type))
   845 
   846 #else /* ! USE_LSB_TAG */
   847 
   848 /* Although compiled only if ! USE_LSB_TAG, the following functions
   849    also work when USE_LSB_TAG; this is to aid future maintenance when
   850    the lisp_h_* macros are eventually removed.  */
   851 
   852 /* Make a Lisp integer representing the value of the low order
   853    bits of N.  */
   854 INLINE Lisp_Object
   855 make_number (EMACS_INT n)
   856 {
   857   EMACS_INT int0 = Lisp_Int0;
   858   if (USE_LSB_TAG)
   859     {
   860       EMACS_UINT u = n;
   861       n = u << INTTYPEBITS;
   862       n += int0;
   863     }
   864   else
   865     {
   866       n &= INTMASK;
   867       n += (int0 << VALBITS);
   868     }
   869   return XIL (n);
   870 }
   871 
   872 /* Extract A's value as a signed integer.  */
   873 INLINE EMACS_INT
   874 XINT (Lisp_Object a)
   875 {
   876   EMACS_INT i = XLI (a);
   877   if (! USE_LSB_TAG)
   878     {
   879       EMACS_UINT u = i;
   880       i = u << INTTYPEBITS;
   881     }
   882   return i >> INTTYPEBITS;
   883 }
   884 
   885 /* Like XINT (A), but may be faster.  A must be nonnegative.
   886    If ! USE_LSB_TAG, this takes advantage of the fact that Lisp
   887    integers have zero-bits in their tags.  */
   888 INLINE EMACS_INT
   889 XFASTINT (Lisp_Object a)
   890 {
   891   EMACS_INT int0 = Lisp_Int0;
   892   EMACS_INT n = USE_LSB_TAG ? XINT (a) : XLI (a) - (int0 << VALBITS);
   893   eassert (0 <= n);
   894   return n;
   895 }
   896 
   897 /* Extract A's value as a symbol.  */
   898 INLINE struct Lisp_Symbol *
   899 XSYMBOL (Lisp_Object a)
   900 {
   901   uintptr_t i = (uintptr_t) XUNTAG (a, Lisp_Symbol);
   902   if (! USE_LSB_TAG)
   903     i <<= GCTYPEBITS;
   904   void *p = (char *) lispsym + i;
   905   return p;
   906 }
   907 
   908 /* Extract A's type.  */
   909 INLINE enum Lisp_Type
   910 XTYPE (Lisp_Object a)
   911 {
   912   EMACS_UINT i = XLI (a);
   913   return USE_LSB_TAG ? i & ~VALMASK : i >> VALBITS;
   914 }
   915 
   916 /* Extract A's pointer value, assuming A's type is TYPE.  */
   917 INLINE void *
   918 XUNTAG (Lisp_Object a, int type)
   919 {
   920   intptr_t i = USE_LSB_TAG ? XLI (a) - type : XLI (a) & VALMASK;
   921   return (void *) i;
   922 }
   923 
   924 #endif /* ! USE_LSB_TAG */
   925 
   926 /* Extract the pointer hidden within A.  */
   927 LISP_MACRO_DEFUN (XPNTR, void *, (Lisp_Object a), (a))
   928 
   929 /* Extract A's value as an unsigned integer.  */
   930 INLINE EMACS_UINT
   931 XUINT (Lisp_Object a)
   932 {
   933   EMACS_UINT i = XLI (a);
   934   return USE_LSB_TAG ? i >> INTTYPEBITS : i & INTMASK;
   935 }
   936 
   937 /* Return A's (Lisp-integer sized) hash.  Happens to be like XUINT
   938    right now, but XUINT should only be applied to objects we know are
   939    integers.  */
   940 LISP_MACRO_DEFUN (XHASH, EMACS_INT, (Lisp_Object a), (a))
   941 
   942 /* Like make_number (N), but may be faster.  N must be in nonnegative range.  */
   943 INLINE Lisp_Object
   944 make_natnum (EMACS_INT n)
   945 {
   946   eassert (0 <= n && n <= MOST_POSITIVE_FIXNUM);
   947   EMACS_INT int0 = Lisp_Int0;
   948   return USE_LSB_TAG ? make_number (n) : XIL (n + (int0 << VALBITS));
   949 }
   950 
   951 /* Return true if X and Y are the same object.  */
   952 LISP_MACRO_DEFUN (EQ, bool, (Lisp_Object x, Lisp_Object y), (x, y))
   953 
   954 /* Value is true if I doesn't fit into a Lisp fixnum.  It is
   955    written this way so that it also works if I is of unsigned
   956    type or if I is a NaN.  */
   957 
   958 #define FIXNUM_OVERFLOW_P(i) \
   959   (! ((0 <= (i) || MOST_NEGATIVE_FIXNUM <= (i)) && (i) <= MOST_POSITIVE_FIXNUM))
   960 
   961 INLINE ptrdiff_t
   962 clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
   963 {
   964   return num < lower ? lower : num <= upper ? num : upper;
   965 }
   966 
   967 
   968 /* Extract a value or address from a Lisp_Object.  */
   969 
   970 LISP_MACRO_DEFUN (XCONS, struct Lisp_Cons *, (Lisp_Object a), (a))
   971 
   972 INLINE struct Lisp_Vector *
   973 XVECTOR (Lisp_Object a)
   974 {
   975   eassert (VECTORLIKEP (a));
   976   return XUNTAG (a, Lisp_Vectorlike);
   977 }
   978 
   979 INLINE struct Lisp_String *
   980 XSTRING (Lisp_Object a)
   981 {
   982   eassert (STRINGP (a));
   983   return XUNTAG (a, Lisp_String);
   984 }
   985 
   986 /* The index of the C-defined Lisp symbol SYM.
   987    This can be used in a static initializer.  */
   988 #define SYMBOL_INDEX(sym) i##sym
   989 
   990 INLINE struct Lisp_Float *
   991 XFLOAT (Lisp_Object a)
   992 {
   993   eassert (FLOATP (a));
   994   return XUNTAG (a, Lisp_Float);
   995 }
   996 
   997 /* Pseudovector types.  */
   998 
   999 INLINE struct Lisp_Process *
  1000 XPROCESS (Lisp_Object a)
  1001 {
  1002   eassert (PROCESSP (a));
  1003   return XUNTAG (a, Lisp_Vectorlike);
  1004 }
  1005 
  1006 INLINE struct window *
  1007 XWINDOW (Lisp_Object a)
  1008 {
  1009   eassert (WINDOWP (a));
  1010   return XUNTAG (a, Lisp_Vectorlike);
  1011 }
  1012 
  1013 INLINE struct terminal *
  1014 XTERMINAL (Lisp_Object a)
  1015 {
  1016   eassert (TERMINALP (a));
  1017   return XUNTAG (a, Lisp_Vectorlike);
  1018 }
  1019 
  1020 INLINE struct Lisp_Subr *
  1021 XSUBR (Lisp_Object a)
  1022 {
  1023   eassert (SUBRP (a));
  1024   return XUNTAG (a, Lisp_Vectorlike);
  1025 }
  1026 
  1027 INLINE struct buffer *
  1028 XBUFFER (Lisp_Object a)
  1029 {
  1030   eassert (BUFFERP (a));
  1031   return XUNTAG (a, Lisp_Vectorlike);
  1032 }
  1033 
  1034 INLINE struct Lisp_Char_Table *
  1035 XCHAR_TABLE (Lisp_Object a)
  1036 {
  1037   eassert (CHAR_TABLE_P (a));
  1038   return XUNTAG (a, Lisp_Vectorlike);
  1039 }
  1040 
  1041 INLINE struct Lisp_Sub_Char_Table *
  1042 XSUB_CHAR_TABLE (Lisp_Object a)
  1043 {
  1044   eassert (SUB_CHAR_TABLE_P (a));
  1045   return XUNTAG (a, Lisp_Vectorlike);
  1046 }
  1047 
  1048 INLINE struct Lisp_Bool_Vector *
  1049 XBOOL_VECTOR (Lisp_Object a)
  1050 {
  1051   eassert (BOOL_VECTOR_P (a));
  1052   return XUNTAG (a, Lisp_Vectorlike);
  1053 }
  1054 
  1055 /* Construct a Lisp_Object from a value or address.  */
  1056 
  1057 INLINE Lisp_Object
  1058 make_lisp_ptr (void *ptr, enum Lisp_Type type)
  1059 {
  1060   Lisp_Object a = XIL (TAG_PTR (type, ptr));
  1061   eassert (XTYPE (a) == type && XUNTAG (a, type) == ptr);
  1062   return a;
  1063 }
  1064 
  1065 INLINE Lisp_Object
  1066 make_lisp_symbol (struct Lisp_Symbol *sym)
  1067 {
  1068   Lisp_Object a = XIL (TAG_SYMOFFSET ((char *) sym - (char *) lispsym));
  1069   eassert (XSYMBOL (a) == sym);
  1070   return a;
  1071 }
  1072 
  1073 INLINE Lisp_Object
  1074 builtin_lisp_symbol (int index)
  1075 {
  1076   return make_lisp_symbol (lispsym + index);
  1077 }
  1078 
  1079 #define XSETINT(a, b) ((a) = make_number (b))
  1080 #define XSETFASTINT(a, b) ((a) = make_natnum (b))
  1081 #define XSETCONS(a, b) ((a) = make_lisp_ptr (b, Lisp_Cons))
  1082 #define XSETVECTOR(a, b) ((a) = make_lisp_ptr (b, Lisp_Vectorlike))
  1083 #define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
  1084 #define XSETSYMBOL(a, b) ((a) = make_lisp_symbol (b))
  1085 #define XSETFLOAT(a, b) ((a) = make_lisp_ptr (b, Lisp_Float))
  1086 #define XSETMISC(a, b) ((a) = make_lisp_ptr (b, Lisp_Misc))
  1087 
  1088 /* Pseudovector types.  */
  1089 
  1090 #define XSETPVECTYPE(v, code)                                           \
  1091   ((v)->header.size |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS))
  1092 #define XSETPVECTYPESIZE(v, code, lispsize, restsize)           \
  1093   ((v)->header.size = (PSEUDOVECTOR_FLAG                        \
  1094                        | ((code) << PSEUDOVECTOR_AREA_BITS)     \
  1095                        | ((restsize) << PSEUDOVECTOR_SIZE_BITS) \
  1096                        | (lispsize)))
  1097 
  1098 /* The cast to struct vectorlike_header * avoids aliasing issues.  */
  1099 #define XSETPSEUDOVECTOR(a, b, code) \
  1100   XSETTYPED_PSEUDOVECTOR (a, b,                                 \
  1101                           (((struct vectorlike_header *)        \
  1102                             XUNTAG (a, Lisp_Vectorlike))        \
  1103                            ->size),                             \
  1104                           code)
  1105 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code)                        \
  1106   (XSETVECTOR (a, b),                                                   \
  1107    eassert ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK))               \
  1108             == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS))))
  1109 
  1110 #define XSETWINDOW_CONFIGURATION(a, b) \
  1111   (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
  1112 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
  1113 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
  1114 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
  1115 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
  1116 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
  1117 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
  1118 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
  1119 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
  1120 #define XSETSUB_CHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUB_CHAR_TABLE))
  1121 
  1122 /* Efficiently convert a pointer to a Lisp object and back.  The
  1123    pointer is represented as a Lisp integer, so the garbage collector
  1124    does not know about it.  The pointer should not have both Lisp_Int1
  1125    bits set, which makes this conversion inherently unportable.  */
  1126 
  1127 INLINE void *
  1128 XINTPTR (Lisp_Object a)
  1129 {
  1130   return XUNTAG (a, Lisp_Int0);
  1131 }
  1132 
  1133 INLINE Lisp_Object
  1134 make_pointer_integer (void *p)
  1135 {
  1136   Lisp_Object a = XIL (TAG_PTR (Lisp_Int0, p));
  1137   eassert (INTEGERP (a) && XINTPTR (a) == p);
  1138   return a;
  1139 }
  1140 
  1141 /* Type checking.  */
  1142 
  1143 LISP_MACRO_DEFUN_VOID (CHECK_TYPE,
  1144                        (int ok, Lisp_Object predicate, Lisp_Object x),
  1145                        (ok, predicate, x))
  1146 
  1147 /* See the macros in intervals.h.  */
  1148 
  1149 typedef struct interval *INTERVAL;
  1150 
  1151 struct GCALIGNED Lisp_Cons
  1152   {
  1153     /* Car of this cons cell.  */
  1154     Lisp_Object car;
  1155 
  1156     union
  1157     {
  1158       /* Cdr of this cons cell.  */
  1159       Lisp_Object cdr;
  1160 
  1161       /* Used to chain conses on a free list.  */
  1162       struct Lisp_Cons *chain;
  1163     } u;
  1164   };
  1165 
  1166 /* Take the car or cdr of something known to be a cons cell.  */
  1167 /* The _addr functions shouldn't be used outside of the minimal set
  1168    of code that has to know what a cons cell looks like.  Other code not
  1169    part of the basic lisp implementation should assume that the car and cdr
  1170    fields are not accessible.  (What if we want to switch to
  1171    a copying collector someday?  Cached cons cell field addresses may be
  1172    invalidated at arbitrary points.)  */
  1173 INLINE Lisp_Object *
  1174 xcar_addr (Lisp_Object c)
  1175 {
  1176   return &XCONS (c)->car;
  1177 }
  1178 INLINE Lisp_Object *
  1179 xcdr_addr (Lisp_Object c)
  1180 {
  1181   return &XCONS (c)->u.cdr;
  1182 }
  1183 
  1184 /* Use these from normal code.  */
  1185 LISP_MACRO_DEFUN (XCAR, Lisp_Object, (Lisp_Object c), (c))
  1186 LISP_MACRO_DEFUN (XCDR, Lisp_Object, (Lisp_Object c), (c))
  1187 
  1188 /* Use these to set the fields of a cons cell.
  1189 
  1190    Note that both arguments may refer to the same object, so 'n'
  1191    should not be read after 'c' is first modified.  */
  1192 INLINE void
  1193 XSETCAR (Lisp_Object c, Lisp_Object n)
  1194 {
  1195   *xcar_addr (c) = n;
  1196 }
  1197 INLINE void
  1198 XSETCDR (Lisp_Object c, Lisp_Object n)
  1199 {
  1200   *xcdr_addr (c) = n;
  1201 }
  1202 
  1203 /* Take the car or cdr of something whose type is not known.  */
  1204 INLINE Lisp_Object
  1205 CAR (Lisp_Object c)
  1206 {
  1207   return (CONSP (c) ? XCAR (c)
  1208           : NILP (c) ? Qnil
  1209           : wrong_type_argument (Qlistp, c));
  1210 }
  1211 INLINE Lisp_Object
  1212 CDR (Lisp_Object c)
  1213 {
  1214   return (CONSP (c) ? XCDR (c)
  1215           : NILP (c) ? Qnil
  1216           : wrong_type_argument (Qlistp, c));
  1217 }
  1218 
  1219 /* Take the car or cdr of something whose type is not known.  */
  1220 INLINE Lisp_Object
  1221 CAR_SAFE (Lisp_Object c)
  1222 {
  1223   return CONSP (c) ? XCAR (c) : Qnil;
  1224 }
  1225 INLINE Lisp_Object
  1226 CDR_SAFE (Lisp_Object c)
  1227 {
  1228   return CONSP (c) ? XCDR (c) : Qnil;
  1229 }
  1230 
  1231 /* In a string or vector, the sign bit of the `size' is the gc mark bit.  */
  1232 
  1233 struct GCALIGNED Lisp_String
  1234   {
  1235     ptrdiff_t size;
  1236     ptrdiff_t size_byte;
  1237     INTERVAL intervals;         /* Text properties in this string.  */
  1238     unsigned char *data;
  1239   };
  1240 
  1241 /* True if STR is a multibyte string.  */
  1242 INLINE bool
  1243 STRING_MULTIBYTE (Lisp_Object str)
  1244 {
  1245   return 0 <= XSTRING (str)->size_byte;
  1246 }
  1247 
  1248 /* An upper bound on the number of bytes in a Lisp string, not
  1249    counting the terminating null.  This a tight enough bound to
  1250    prevent integer overflow errors that would otherwise occur during
  1251    string size calculations.  A string cannot contain more bytes than
  1252    a fixnum can represent, nor can it be so long that C pointer
  1253    arithmetic stops working on the string plus its terminating null.
  1254    Although the actual size limit (see STRING_BYTES_MAX in alloc.c)
  1255    may be a bit smaller than STRING_BYTES_BOUND, calculating it here
  1256    would expose alloc.c internal details that we'd rather keep
  1257    private.
  1258 
  1259    This is a macro for use in static initializers.  The cast to
  1260    ptrdiff_t ensures that the macro is signed.  */
  1261 #define STRING_BYTES_BOUND  \
  1262   ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1))
  1263 
  1264 /* Mark STR as a unibyte string.  */
  1265 #define STRING_SET_UNIBYTE(STR)                         \
  1266   do {                                                  \
  1267     if (EQ (STR, empty_multibyte_string))               \
  1268       (STR) = empty_unibyte_string;                     \
  1269     else                                                \
  1270       XSTRING (STR)->size_byte = -1;                    \
  1271   } while (false)
  1272 
  1273 /* Mark STR as a multibyte string.  Assure that STR contains only
  1274    ASCII characters in advance.  */
  1275 #define STRING_SET_MULTIBYTE(STR)                       \
  1276   do {                                                  \
  1277     if (EQ (STR, empty_unibyte_string))                 \
  1278       (STR) = empty_multibyte_string;                   \
  1279     else                                                \
  1280       XSTRING (STR)->size_byte = XSTRING (STR)->size;   \
  1281   } while (false)
  1282 
  1283 /* Convenience functions for dealing with Lisp strings.  */
  1284 
  1285 INLINE unsigned char *
  1286 SDATA (Lisp_Object string)
  1287 {
  1288   return XSTRING (string)->data;
  1289 }
  1290 INLINE char *
  1291 SSDATA (Lisp_Object string)
  1292 {
  1293   /* Avoid "differ in sign" warnings.  */
  1294   return (char *) SDATA (string);
  1295 }
  1296 INLINE unsigned char
  1297 SREF (Lisp_Object string, ptrdiff_t index)
  1298 {
  1299   return SDATA (string)[index];
  1300 }
  1301 INLINE void
  1302 SSET (Lisp_Object string, ptrdiff_t index, unsigned char new)
  1303 {
  1304   SDATA (string)[index] = new;
  1305 }
  1306 INLINE ptrdiff_t
  1307 SCHARS (Lisp_Object string)
  1308 {
  1309   return XSTRING (string)->size;
  1310 }
  1311 
  1312 #ifdef GC_CHECK_STRING_BYTES
  1313 extern ptrdiff_t string_bytes (struct Lisp_String *);
  1314 #endif
  1315 INLINE ptrdiff_t
  1316 STRING_BYTES (struct Lisp_String *s)
  1317 {
  1318 #ifdef GC_CHECK_STRING_BYTES
  1319   return string_bytes (s);
  1320 #else
  1321   return s->size_byte < 0 ? s->size : s->size_byte;
  1322 #endif
  1323 }
  1324 
  1325 INLINE ptrdiff_t
  1326 SBYTES (Lisp_Object string)
  1327 {
  1328   return STRING_BYTES (XSTRING (string));
  1329 }
  1330 INLINE void
  1331 STRING_SET_CHARS (Lisp_Object string, ptrdiff_t newsize)
  1332 {
  1333   XSTRING (string)->size = newsize;
  1334 }
  1335 
  1336 /* Header of vector-like objects.  This documents the layout constraints on
  1337    vectors and pseudovectors (objects of PVEC_xxx subtype).  It also prevents
  1338    compilers from being fooled by Emacs's type punning: XSETPSEUDOVECTOR
  1339    and PSEUDOVECTORP cast their pointers to struct vectorlike_header *,
  1340    because when two such pointers potentially alias, a compiler won't
  1341    incorrectly reorder loads and stores to their size fields.  See
  1342    Bug#8546.  */
  1343 struct vectorlike_header
  1344   {
  1345     /* The only field contains various pieces of information:
  1346        - The MSB (ARRAY_MARK_FLAG) holds the gcmarkbit.
  1347        - The next bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
  1348          vector (0) or a pseudovector (1).
  1349        - If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
  1350          of slots) of the vector.
  1351        - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
  1352          - a) pseudovector subtype held in PVEC_TYPE_MASK field;
  1353          - b) number of Lisp_Objects slots at the beginning of the object
  1354            held in PSEUDOVECTOR_SIZE_MASK field.  These objects are always
  1355            traced by the GC;
  1356          - c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
  1357            measured in word_size units.  Rest fields may also include
  1358            Lisp_Objects, but these objects usually needs some special treatment
  1359            during GC.
  1360          There are some exceptions.  For PVEC_FREE, b) is always zero.  For
  1361          PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
  1362          Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
  1363          4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots.  */
  1364     ptrdiff_t size;
  1365   };
  1366 
  1367 /* A regular vector is just a header plus an array of Lisp_Objects.  */
  1368 
  1369 struct Lisp_Vector
  1370   {
  1371     struct vectorlike_header header;
  1372     Lisp_Object contents[FLEXIBLE_ARRAY_MEMBER];
  1373   };
  1374 
  1375 /* C11 prohibits alignof (struct Lisp_Vector), so compute it manually.  */
  1376 enum
  1377   {
  1378     ALIGNOF_STRUCT_LISP_VECTOR
  1379       = alignof (union { struct vectorlike_header a; Lisp_Object b; })
  1380   };
  1381 
  1382 /* A boolvector is a kind of vectorlike, with contents like a string.  */
  1383 
  1384 struct Lisp_Bool_Vector
  1385   {
  1386     /* HEADER.SIZE is the vector's size field.  It doesn't have the real size,
  1387        just the subtype information.  */
  1388     struct vectorlike_header header;
  1389     /* This is the size in bits.  */
  1390     EMACS_INT size;
  1391     /* The actual bits, packed into bytes.
  1392        Zeros fill out the last word if needed.
  1393        The bits are in little-endian order in the bytes, and
  1394        the bytes are in little-endian order in the words.  */
  1395     bits_word data[FLEXIBLE_ARRAY_MEMBER];
  1396   };
  1397 
  1398 INLINE EMACS_INT
  1399 bool_vector_size (Lisp_Object a)
  1400 {
  1401   EMACS_INT size = XBOOL_VECTOR (a)->size;
  1402   eassume (0 <= size);
  1403   return size;
  1404 }
  1405 
  1406 INLINE bits_word *
  1407 bool_vector_data (Lisp_Object a)
  1408 {
  1409   return XBOOL_VECTOR (a)->data;
  1410 }
  1411 
  1412 INLINE unsigned char *
  1413 bool_vector_uchar_data (Lisp_Object a)
  1414 {
  1415   return (unsigned char *) bool_vector_data (a);
  1416 }
  1417 
  1418 /* The number of data words and bytes in a bool vector with SIZE bits.  */
  1419 
  1420 INLINE EMACS_INT
  1421 bool_vector_words (EMACS_INT size)
  1422 {
  1423   eassume (0 <= size && size <= EMACS_INT_MAX - (BITS_PER_BITS_WORD - 1));
  1424   return (size + BITS_PER_BITS_WORD - 1) / BITS_PER_BITS_WORD;
  1425 }
  1426 
  1427 INLINE EMACS_INT
  1428 bool_vector_bytes (EMACS_INT size)
  1429 {
  1430   eassume (0 <= size && size <= EMACS_INT_MAX - (BITS_PER_BITS_WORD - 1));
  1431   return (size + BOOL_VECTOR_BITS_PER_CHAR - 1) / BOOL_VECTOR_BITS_PER_CHAR;
  1432 }
  1433 
  1434 /* True if A's Ith bit is set.  */
  1435 
  1436 INLINE bool
  1437 bool_vector_bitref (Lisp_Object a, EMACS_INT i)
  1438 {
  1439   eassume (0 <= i && i < bool_vector_size (a));
  1440   return !! (bool_vector_uchar_data (a)[i / BOOL_VECTOR_BITS_PER_CHAR]
  1441              & (1 << (i % BOOL_VECTOR_BITS_PER_CHAR)));
  1442 }
  1443 
  1444 INLINE Lisp_Object
  1445 bool_vector_ref (Lisp_Object a, EMACS_INT i)
  1446 {
  1447   return bool_vector_bitref (a, i) ? Qt : Qnil;
  1448 }
  1449 
  1450 /* Set A's Ith bit to B.  */
  1451 
  1452 INLINE void
  1453 bool_vector_set (Lisp_Object a, EMACS_INT i, bool b)
  1454 {
  1455   unsigned char *addr;
  1456 
  1457   eassume (0 <= i && i < bool_vector_size (a));
  1458   addr = &bool_vector_uchar_data (a)[i / BOOL_VECTOR_BITS_PER_CHAR];
  1459 
  1460   if (b)
  1461     *addr |= 1 << (i % BOOL_VECTOR_BITS_PER_CHAR);
  1462   else
  1463     *addr &= ~ (1 << (i % BOOL_VECTOR_BITS_PER_CHAR));
  1464 }
  1465 
  1466 /* Some handy constants for calculating sizes
  1467    and offsets, mostly of vectorlike objects.   */
  1468 
  1469 enum
  1470   {
  1471     header_size = offsetof (struct Lisp_Vector, contents),
  1472     bool_header_size = offsetof (struct Lisp_Bool_Vector, data),
  1473     word_size = sizeof (Lisp_Object)
  1474   };
  1475 
  1476 /* Conveniences for dealing with Lisp arrays.  */
  1477 
  1478 INLINE Lisp_Object
  1479 AREF (Lisp_Object array, ptrdiff_t idx)
  1480 {
  1481   return XVECTOR (array)->contents[idx];
  1482 }
  1483 
  1484 INLINE Lisp_Object *
  1485 aref_addr (Lisp_Object array, ptrdiff_t idx)
  1486 {
  1487   return & XVECTOR (array)->contents[idx];
  1488 }
  1489 
  1490 INLINE ptrdiff_t
  1491 ASIZE (Lisp_Object array)
  1492 {
  1493   return XVECTOR (array)->header.size;
  1494 }
  1495 
  1496 INLINE void
  1497 ASET (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
  1498 {
  1499   eassert (0 <= idx && idx < ASIZE (array));
  1500   XVECTOR (array)->contents[idx] = val;
  1501 }
  1502 
  1503 INLINE void
  1504 gc_aset (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
  1505 {
  1506   /* Like ASET, but also can be used in the garbage collector:
  1507      sweep_weak_table calls set_hash_key etc. while the table is marked.  */
  1508   eassert (0 <= idx && idx < (ASIZE (array) & ~ARRAY_MARK_FLAG));
  1509   XVECTOR (array)->contents[idx] = val;
  1510 }
  1511 
  1512 /* True, since Qnil's representation is zero.  Every place in the code
  1513    that assumes Qnil is zero should verify (NIL_IS_ZERO), to make it easy
  1514    to find such assumptions later if we change Qnil to be nonzero.  */
  1515 enum { NIL_IS_ZERO = XLI_BUILTIN_LISPSYM (iQnil) == 0 };
  1516 
  1517 /* Clear the object addressed by P, with size NBYTES, so that all its
  1518    bytes are zero and all its Lisp values are nil.  */
  1519 INLINE void
  1520 memclear (void *p, ptrdiff_t nbytes)
  1521 {
  1522   eassert (0 <= nbytes);
  1523   verify (NIL_IS_ZERO);
  1524   /* Since Qnil is zero, memset suffices.  */
  1525   memset (p, 0, nbytes);
  1526 }
  1527 
  1528 /* If a struct is made to look like a vector, this macro returns the length
  1529    of the shortest vector that would hold that struct.  */
  1530 
  1531 #define VECSIZE(type)                                           \
  1532   ((sizeof (type) - header_size + word_size - 1) / word_size)
  1533 
  1534 /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields
  1535    at the end and we need to compute the number of Lisp_Object fields (the
  1536    ones that the GC needs to trace).  */
  1537 
  1538 #define PSEUDOVECSIZE(type, nonlispfield)                       \
  1539   ((offsetof (type, nonlispfield) - header_size) / word_size)
  1540 
  1541 /* Compute A OP B, using the unsigned comparison operator OP.  A and B
  1542    should be integer expressions.  This is not the same as
  1543    mathematical comparison; for example, UNSIGNED_CMP (0, <, -1)
  1544    returns true.  For efficiency, prefer plain unsigned comparison if A
  1545    and B's sizes both fit (after integer promotion).  */
  1546 #define UNSIGNED_CMP(a, op, b)                                          \
  1547   (max (sizeof ((a) + 0), sizeof ((b) + 0)) <= sizeof (unsigned)        \
  1548    ? ((a) + (unsigned) 0) op ((b) + (unsigned) 0)                       \
  1549    : ((a) + (uintmax_t) 0) op ((b) + (uintmax_t) 0))
  1550 
  1551 /* True iff C is an ASCII character.  */
  1552 #define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80)
  1553 
  1554 /* A char-table is a kind of vectorlike, with contents are like a
  1555    vector but with a few other slots.  For some purposes, it makes
  1556    sense to handle a char-table with type struct Lisp_Vector.  An
  1557    element of a char table can be any Lisp objects, but if it is a sub
  1558    char-table, we treat it a table that contains information of a
  1559    specific range of characters.  A sub char-table is like a vector but
  1560    with two integer fields between the header and Lisp data, which means
  1561    that it has to be marked with some precautions (see mark_char_table
  1562    in alloc.c).  A sub char-table appears only in an element of a char-table,
  1563    and there's no way to access it directly from Emacs Lisp program.  */
  1564 
  1565 enum CHARTAB_SIZE_BITS
  1566   {
  1567     CHARTAB_SIZE_BITS_0 = 6,
  1568     CHARTAB_SIZE_BITS_1 = 4,
  1569     CHARTAB_SIZE_BITS_2 = 5,
  1570     CHARTAB_SIZE_BITS_3 = 7
  1571   };
  1572 
  1573 extern const int chartab_size[4];
  1574 
  1575 struct Lisp_Char_Table
  1576   {
  1577     /* HEADER.SIZE is the vector's size field, which also holds the
  1578        pseudovector type information.  It holds the size, too.
  1579        The size counts the defalt, parent, purpose, ascii,
  1580        contents, and extras slots.  */
  1581     struct vectorlike_header header;
  1582 
  1583     /* This holds a default value,
  1584        which is used whenever the value for a specific character is nil.  */
  1585     Lisp_Object defalt;
  1586 
  1587     /* This points to another char table, which we inherit from when the
  1588        value for a specific character is nil.  The `defalt' slot takes
  1589        precedence over this.  */
  1590     Lisp_Object parent;
  1591 
  1592     /* This is a symbol which says what kind of use this char-table is
  1593        meant for.  */
  1594     Lisp_Object purpose;
  1595 
  1596     /* The bottom sub char-table for characters of the range 0..127.  It
  1597        is nil if none of ASCII character has a specific value.  */
  1598     Lisp_Object ascii;
  1599 
  1600     Lisp_Object contents[(1 << CHARTAB_SIZE_BITS_0)];
  1601 
  1602     /* These hold additional data.  It is a vector.  */
  1603     Lisp_Object extras[FLEXIBLE_ARRAY_MEMBER];
  1604   };
  1605 
  1606 struct Lisp_Sub_Char_Table
  1607   {
  1608     /* HEADER.SIZE is the vector's size field, which also holds the
  1609        pseudovector type information.  It holds the size, too.  */
  1610     struct vectorlike_header header;
  1611 
  1612     /* Depth of this sub char-table.  It should be 1, 2, or 3.  A sub
  1613        char-table of depth 1 contains 16 elements, and each element
  1614        covers 4096 (128*32) characters.  A sub char-table of depth 2
  1615        contains 32 elements, and each element covers 128 characters.  A
  1616        sub char-table of depth 3 contains 128 elements, and each element
  1617        is for one character.  */
  1618     int depth;
  1619 
  1620     /* Minimum character covered by the sub char-table.  */
  1621     int min_char;
  1622 
  1623     /* Use set_sub_char_table_contents to set this.  */
  1624     Lisp_Object contents[FLEXIBLE_ARRAY_MEMBER];
  1625   };
  1626 
  1627 INLINE Lisp_Object
  1628 CHAR_TABLE_REF_ASCII (Lisp_Object ct, ptrdiff_t idx)
  1629 {
  1630   struct Lisp_Char_Table *tbl = NULL;
  1631   Lisp_Object val;
  1632   do
  1633     {
  1634       tbl = tbl ? XCHAR_TABLE (tbl->parent) : XCHAR_TABLE (ct);
  1635       val = (! SUB_CHAR_TABLE_P (tbl->ascii) ? tbl->ascii
  1636              : XSUB_CHAR_TABLE (tbl->ascii)->contents[idx]);
  1637       if (NILP (val))
  1638         val = tbl->defalt;
  1639     }
  1640   while (NILP (val) && ! NILP (tbl->parent));
  1641 
  1642   return val;
  1643 }
  1644 
  1645 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
  1646    characters.  Do not check validity of CT.  */
  1647 INLINE Lisp_Object
  1648 CHAR_TABLE_REF (Lisp_Object ct, int idx)
  1649 {
  1650   return (ASCII_CHAR_P (idx)
  1651           ? CHAR_TABLE_REF_ASCII (ct, idx)
  1652           : char_table_ref (ct, idx));
  1653 }
  1654 
  1655 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
  1656    8-bit European characters.  Do not check validity of CT.  */
  1657 INLINE void
  1658 CHAR_TABLE_SET (Lisp_Object ct, int idx, Lisp_Object val)
  1659 {
  1660   if (ASCII_CHAR_P (idx) && SUB_CHAR_TABLE_P (XCHAR_TABLE (ct)->ascii))
  1661     set_sub_char_table_contents (XCHAR_TABLE (ct)->ascii, idx, val);
  1662   else
  1663     char_table_set (ct, idx, val);
  1664 }
  1665 
  1666 /* This structure describes a built-in function.
  1667    It is generated by the DEFUN macro only.
  1668    defsubr makes it into a Lisp object.  */
  1669 
  1670 struct Lisp_Subr
  1671   {
  1672     struct vectorlike_header header;
  1673     union {
  1674       Lisp_Object (*a0) (void);
  1675       Lisp_Object (*a1) (Lisp_Object);
  1676       Lisp_Object (*a2) (Lisp_Object, Lisp_Object);
  1677       Lisp_Object (*a3) (Lisp_Object, Lisp_Object, Lisp_Object);
  1678       Lisp_Object (*a4) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  1679       Lisp_Object (*a5) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  1680       Lisp_Object (*a6) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  1681       Lisp_Object (*a7) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  1682       Lisp_Object (*a8) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  1683       Lisp_Object (*aUNEVALLED) (Lisp_Object args);
  1684       Lisp_Object (*aMANY) (ptrdiff_t, Lisp_Object *);
  1685     } function;
  1686     short min_args, max_args;
  1687     const char *symbol_name;
  1688     const char *intspec;
  1689     const char *doc;
  1690   };
  1691 
  1692 enum char_table_specials
  1693   {
  1694     /* This is the number of slots that every char table must have.  This
  1695        counts the ordinary slots and the top, defalt, parent, and purpose
  1696        slots.  */
  1697     CHAR_TABLE_STANDARD_SLOTS = PSEUDOVECSIZE (struct Lisp_Char_Table, extras),
  1698 
  1699     /* This is an index of first Lisp_Object field in Lisp_Sub_Char_Table
  1700        when the latter is treated as an ordinary Lisp_Vector.  */
  1701     SUB_CHAR_TABLE_OFFSET = PSEUDOVECSIZE (struct Lisp_Sub_Char_Table, contents)
  1702   };
  1703 
  1704 /* Return the number of "extra" slots in the char table CT.  */
  1705 
  1706 INLINE int
  1707 CHAR_TABLE_EXTRA_SLOTS (struct Lisp_Char_Table *ct)
  1708 {
  1709   return ((ct->header.size & PSEUDOVECTOR_SIZE_MASK)
  1710           - CHAR_TABLE_STANDARD_SLOTS);
  1711 }
  1712 
  1713 /* Make sure that sub char-table contents slot is where we think it is.  */
  1714 verify (offsetof (struct Lisp_Sub_Char_Table, contents)
  1715         == offsetof (struct Lisp_Vector, contents[SUB_CHAR_TABLE_OFFSET]));
  1716 
  1717 /***********************************************************************
  1718                                Symbols
  1719  ***********************************************************************/
  1720 
  1721 /* Value is name of symbol.  */
  1722 
  1723 LISP_MACRO_DEFUN (SYMBOL_VAL, Lisp_Object, (struct Lisp_Symbol *sym), (sym))
  1724 
  1725 INLINE struct Lisp_Symbol *
  1726 SYMBOL_ALIAS (struct Lisp_Symbol *sym)
  1727 {
  1728   eassert (sym->redirect == SYMBOL_VARALIAS);
  1729   return sym->val.alias;
  1730 }
  1731 INLINE struct Lisp_Buffer_Local_Value *
  1732 SYMBOL_BLV (struct Lisp_Symbol *sym)
  1733 {
  1734   eassert (sym->redirect == SYMBOL_LOCALIZED);
  1735   return sym->val.blv;
  1736 }
  1737 INLINE union Lisp_Fwd *
  1738 SYMBOL_FWD (struct Lisp_Symbol *sym)
  1739 {
  1740   eassert (sym->redirect == SYMBOL_FORWARDED);
  1741   return sym->val.fwd;
  1742 }
  1743 
  1744 LISP_MACRO_DEFUN_VOID (SET_SYMBOL_VAL,
  1745                        (struct Lisp_Symbol *sym, Lisp_Object v), (sym, v))
  1746 
  1747 INLINE void
  1748 SET_SYMBOL_ALIAS (struct Lisp_Symbol *sym, struct Lisp_Symbol *v)
  1749 {
  1750   eassert (sym->redirect == SYMBOL_VARALIAS);
  1751   sym->val.alias = v;
  1752 }
  1753 INLINE void
  1754 SET_SYMBOL_BLV (struct Lisp_Symbol *sym, struct Lisp_Buffer_Local_Value *v)
  1755 {
  1756   eassert (sym->redirect == SYMBOL_LOCALIZED);
  1757   sym->val.blv = v;
  1758 }
  1759 INLINE void
  1760 SET_SYMBOL_FWD (struct Lisp_Symbol *sym, union Lisp_Fwd *v)
  1761 {
  1762   eassert (sym->redirect == SYMBOL_FORWARDED);
  1763   sym->val.fwd = v;
  1764 }
  1765 
  1766 INLINE Lisp_Object
  1767 SYMBOL_NAME (Lisp_Object sym)
  1768 {
  1769   return XSYMBOL (sym)->name;
  1770 }
  1771 
  1772 /* Value is true if SYM is an interned symbol.  */
  1773 
  1774 INLINE bool
  1775 SYMBOL_INTERNED_P (Lisp_Object sym)
  1776 {
  1777   return XSYMBOL (sym)->interned != SYMBOL_UNINTERNED;
  1778 }
  1779 
  1780 /* Value is true if SYM is interned in initial_obarray.  */
  1781 
  1782 INLINE bool
  1783 SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P (Lisp_Object sym)
  1784 {
  1785   return XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY;
  1786 }
  1787 
  1788 /* Value is non-zero if symbol is considered a constant, i.e. its
  1789    value cannot be changed (there is an exception for keyword symbols,
  1790    whose value can be set to the keyword symbol itself).  */
  1791 
  1792 LISP_MACRO_DEFUN (SYMBOL_CONSTANT_P, int, (Lisp_Object sym), (sym))
  1793 
  1794 /* Placeholder for make-docfile to process.  The actual symbol
  1795    definition is done by lread.c's defsym.  */
  1796 #define DEFSYM(sym, name) /* empty */
  1797 
  1798 
  1799 /***********************************************************************
  1800                              Hash Tables
  1801  ***********************************************************************/
  1802 
  1803 /* The structure of a Lisp hash table.  */
  1804 
  1805 struct hash_table_test
  1806 {
  1807   /* Name of the function used to compare keys.  */
  1808   Lisp_Object name;
  1809 
  1810   /* User-supplied hash function, or nil.  */
  1811   Lisp_Object user_hash_function;
  1812 
  1813   /* User-supplied key comparison function, or nil.  */
  1814   Lisp_Object user_cmp_function;
  1815 
  1816   /* C function to compare two keys.  */
  1817   bool (*cmpfn) (struct hash_table_test *t, Lisp_Object, Lisp_Object);
  1818 
  1819   /* C function to compute hash code.  */
  1820   EMACS_UINT (*hashfn) (struct hash_table_test *t, Lisp_Object);
  1821 };
  1822 
  1823 struct Lisp_Hash_Table
  1824 {
  1825   /* This is for Lisp; the hash table code does not refer to it.  */
  1826   struct vectorlike_header header;
  1827 
  1828   /* Nil if table is non-weak.  Otherwise a symbol describing the
  1829      weakness of the table.  */
  1830   Lisp_Object weak;
  1831 
  1832   /* When the table is resized, and this is an integer, compute the
  1833      new size by adding this to the old size.  If a float, compute the
  1834      new size by multiplying the old size with this factor.  */
  1835   Lisp_Object rehash_size;
  1836 
  1837   /* Resize hash table when number of entries/ table size is >= this
  1838      ratio, a float.  */
  1839   Lisp_Object rehash_threshold;
  1840 
  1841   /* Vector of hash codes.  If hash[I] is nil, this means that the
  1842      I-th entry is unused.  */
  1843   Lisp_Object hash;
  1844 
  1845   /* Vector used to chain entries.  If entry I is free, next[I] is the
  1846      entry number of the next free item.  If entry I is non-free,
  1847      next[I] is the index of the next entry in the collision chain.  */
  1848   Lisp_Object next;
  1849 
  1850   /* Index of first free entry in free list.  */
  1851   Lisp_Object next_free;
  1852 
  1853   /* Bucket vector.  A non-nil entry is the index of the first item in
  1854      a collision chain.  This vector's size can be larger than the
  1855      hash table size to reduce collisions.  */
  1856   Lisp_Object index;
  1857 
  1858   /* Only the fields above are traced normally by the GC.  The ones below
  1859      `count' are special and are either ignored by the GC or traced in
  1860      a special way (e.g. because of weakness).  */
  1861 
  1862   /* Number of key/value entries in the table.  */
  1863   ptrdiff_t count;
  1864 
  1865   /* Vector of keys and values.  The key of item I is found at index
  1866      2 * I, the value is found at index 2 * I + 1.
  1867      This is gc_marked specially if the table is weak.  */
  1868   Lisp_Object key_and_value;
  1869 
  1870   /* The comparison and hash functions.  */
  1871   struct hash_table_test test;
  1872 
  1873   /* Next weak hash table if this is a weak hash table.  The head
  1874      of the list is in weak_hash_tables.  */
  1875   struct Lisp_Hash_Table *next_weak;
  1876 };
  1877 
  1878 
  1879 INLINE struct Lisp_Hash_Table *
  1880 XHASH_TABLE (Lisp_Object a)
  1881 {
  1882   return XUNTAG (a, Lisp_Vectorlike);
  1883 }
  1884 
  1885 #define XSET_HASH_TABLE(VAR, PTR) \
  1886      (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
  1887 
  1888 INLINE bool
  1889 HASH_TABLE_P (Lisp_Object a)
  1890 {
  1891   return PSEUDOVECTORP (a, PVEC_HASH_TABLE);
  1892 }
  1893 
  1894 /* Value is the key part of entry IDX in hash table H.  */
  1895 INLINE Lisp_Object
  1896 HASH_KEY (struct Lisp_Hash_Table *h, ptrdiff_t idx)
  1897 {
  1898   return AREF (h->key_and_value, 2 * idx);
  1899 }
  1900 
  1901 /* Value is the value part of entry IDX in hash table H.  */
  1902 INLINE Lisp_Object
  1903 HASH_VALUE (struct Lisp_Hash_Table *h, ptrdiff_t idx)
  1904 {
  1905   return AREF (h->key_and_value, 2 * idx + 1);
  1906 }
  1907 
  1908 /* Value is the index of the next entry following the one at IDX
  1909    in hash table H.  */
  1910 INLINE Lisp_Object
  1911 HASH_NEXT (struct Lisp_Hash_Table *h, ptrdiff_t idx)
  1912 {
  1913   return AREF (h->next, idx);
  1914 }
  1915 
  1916 /* Value is the hash code computed for entry IDX in hash table H.  */
  1917 INLINE Lisp_Object
  1918 HASH_HASH (struct Lisp_Hash_Table *h, ptrdiff_t idx)
  1919 {
  1920   return AREF (h->hash, idx);
  1921 }
  1922 
  1923 /* Value is the index of the element in hash table H that is the
  1924    start of the collision list at index IDX in the index vector of H.  */
  1925 INLINE Lisp_Object
  1926 HASH_INDEX (struct Lisp_Hash_Table *h, ptrdiff_t idx)
  1927 {
  1928   return AREF (h->index, idx);
  1929 }
  1930 
  1931 /* Value is the size of hash table H.  */
  1932 INLINE ptrdiff_t
  1933 HASH_TABLE_SIZE (struct Lisp_Hash_Table *h)
  1934 {
  1935   return ASIZE (h->next);
  1936 }
  1937 
  1938 /* Default size for hash tables if not specified.  */
  1939 
  1940 enum DEFAULT_HASH_SIZE { DEFAULT_HASH_SIZE = 65 };
  1941 
  1942 /* Default threshold specifying when to resize a hash table.  The
  1943    value gives the ratio of current entries in the hash table and the
  1944    size of the hash table.  */
  1945 
  1946 static double const DEFAULT_REHASH_THRESHOLD = 0.8;
  1947 
  1948 /* Default factor by which to increase the size of a hash table.  */
  1949 
  1950 static double const DEFAULT_REHASH_SIZE = 1.5;
  1951 
  1952 /* Combine two integers X and Y for hashing.  The result might not fit
  1953    into a Lisp integer.  */
  1954 
  1955 INLINE EMACS_UINT
  1956 sxhash_combine (EMACS_UINT x, EMACS_UINT y)
  1957 {
  1958   return (x << 4) + (x >> (BITS_PER_EMACS_INT - 4)) + y;
  1959 }
  1960 
  1961 /* Hash X, returning a value that fits into a fixnum.  */
  1962 
  1963 INLINE EMACS_UINT
  1964 SXHASH_REDUCE (EMACS_UINT x)
  1965 {
  1966   return (x ^ x >> (BITS_PER_EMACS_INT - FIXNUM_BITS)) & INTMASK;
  1967 }
  1968 
  1969 /* These structures are used for various misc types.  */
  1970 
  1971 struct Lisp_Misc_Any            /* Supertype of all Misc types.  */
  1972 {
  1973   ENUM_BF (Lisp_Misc_Type) type : 16;           /* = Lisp_Misc_??? */
  1974   bool_bf gcmarkbit : 1;
  1975   unsigned spacer : 15;
  1976 };
  1977 
  1978 struct Lisp_Marker
  1979 {
  1980   ENUM_BF (Lisp_Misc_Type) type : 16;           /* = Lisp_Misc_Marker */
  1981   bool_bf gcmarkbit : 1;
  1982   unsigned spacer : 13;
  1983   /* This flag is temporarily used in the functions
  1984      decode/encode_coding_object to record that the marker position
  1985      must be adjusted after the conversion.  */
  1986   bool_bf need_adjustment : 1;
  1987   /* True means normal insertion at the marker's position
  1988      leaves the marker after the inserted text.  */
  1989   bool_bf insertion_type : 1;
  1990   /* This is the buffer that the marker points into, or 0 if it points nowhere.
  1991      Note: a chain of markers can contain markers pointing into different
  1992      buffers (the chain is per buffer_text rather than per buffer, so it's
  1993      shared between indirect buffers).  */
  1994   /* This is used for (other than NULL-checking):
  1995      - Fmarker_buffer
  1996      - Fset_marker: check eq(oldbuf, newbuf) to avoid unchain+rechain.
  1997      - unchain_marker: to find the list from which to unchain.
  1998      - Fkill_buffer: to only unchain the markers of current indirect buffer.
  1999      */
  2000   struct buffer *buffer;
  2001 
  2002   /* The remaining fields are meaningless in a marker that
  2003      does not point anywhere.  */
  2004 
  2005   /* For markers that point somewhere,
  2006      this is used to chain of all the markers in a given buffer.  */
  2007   /* We could remove it and use an array in buffer_text instead.
  2008      That would also allow us to preserve it ordered.  */
  2009   struct Lisp_Marker *next;
  2010   /* This is the char position where the marker points.  */
  2011   ptrdiff_t charpos;
  2012   /* This is the byte position.
  2013      It's mostly used as a charpos<->bytepos cache (i.e. it's not directly
  2014      used to implement the functionality of markers, but rather to (ab)use
  2015      markers as a cache for char<->byte mappings).  */
  2016   ptrdiff_t bytepos;
  2017 };
  2018 
  2019 /* START and END are markers in the overlay's buffer, and
  2020    PLIST is the overlay's property list.  */
  2021 struct Lisp_Overlay
  2022 /* An overlay's real data content is:
  2023    - plist
  2024    - buffer (really there are two buffer pointers, one per marker,
  2025      and both points to the same buffer)
  2026    - insertion type of both ends (per-marker fields)
  2027    - start & start byte (of start marker)
  2028    - end & end byte (of end marker)
  2029    - next (singly linked list of overlays)
  2030    - next fields of start and end markers (singly linked list of markers).
  2031    I.e. 9words plus 2 bits, 3words of which are for external linked lists.
  2032 */
  2033   {
  2034     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Overlay */
  2035     bool_bf gcmarkbit : 1;
  2036     unsigned spacer : 15;
  2037     struct Lisp_Overlay *next;
  2038     Lisp_Object start;
  2039     Lisp_Object end;
  2040     Lisp_Object plist;
  2041   };
  2042 
  2043 /* Types of data which may be saved in a Lisp_Save_Value.  */
  2044 
  2045 enum
  2046   {
  2047     SAVE_UNUSED,
  2048     SAVE_INTEGER,
  2049     SAVE_FUNCPOINTER,
  2050     SAVE_POINTER,
  2051     SAVE_OBJECT
  2052   };
  2053 
  2054 /* Number of bits needed to store one of the above values.  */
  2055 enum { SAVE_SLOT_BITS = 3 };
  2056 
  2057 /* Number of slots in a save value where save_type is nonzero.  */
  2058 enum { SAVE_VALUE_SLOTS = 4 };
  2059 
  2060 /* Bit-width and values for struct Lisp_Save_Value's save_type member.  */
  2061 
  2062 enum { SAVE_TYPE_BITS = SAVE_VALUE_SLOTS * SAVE_SLOT_BITS + 1 };
  2063 
  2064 enum Lisp_Save_Type
  2065   {
  2066     SAVE_TYPE_INT_INT = SAVE_INTEGER + (SAVE_INTEGER << SAVE_SLOT_BITS),
  2067     SAVE_TYPE_INT_INT_INT
  2068       = (SAVE_INTEGER + (SAVE_TYPE_INT_INT << SAVE_SLOT_BITS)),
  2069     SAVE_TYPE_OBJ_OBJ = SAVE_OBJECT + (SAVE_OBJECT << SAVE_SLOT_BITS),
  2070     SAVE_TYPE_OBJ_OBJ_OBJ = SAVE_OBJECT + (SAVE_TYPE_OBJ_OBJ << SAVE_SLOT_BITS),
  2071     SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
  2072       = SAVE_OBJECT + (SAVE_TYPE_OBJ_OBJ_OBJ << SAVE_SLOT_BITS),
  2073     SAVE_TYPE_PTR_INT = SAVE_POINTER + (SAVE_INTEGER << SAVE_SLOT_BITS),
  2074     SAVE_TYPE_PTR_OBJ = SAVE_POINTER + (SAVE_OBJECT << SAVE_SLOT_BITS),
  2075     SAVE_TYPE_PTR_PTR = SAVE_POINTER + (SAVE_POINTER << SAVE_SLOT_BITS),
  2076     SAVE_TYPE_FUNCPTR_PTR_OBJ
  2077       = SAVE_FUNCPOINTER + (SAVE_TYPE_PTR_OBJ << SAVE_SLOT_BITS),
  2078 
  2079     /* This has an extra bit indicating it's raw memory.  */
  2080     SAVE_TYPE_MEMORY = SAVE_TYPE_PTR_INT + (1 << (SAVE_TYPE_BITS - 1))
  2081   };
  2082 
  2083 /* Special object used to hold a different values for later use.
  2084 
  2085    This is mostly used to package C integers and pointers to call
  2086    record_unwind_protect when two or more values need to be saved.
  2087    For example:
  2088 
  2089    ...
  2090      struct my_data *md = get_my_data ();
  2091      ptrdiff_t mi = get_my_integer ();
  2092      record_unwind_protect (my_unwind, make_save_ptr_int (md, mi));
  2093    ...
  2094 
  2095    Lisp_Object my_unwind (Lisp_Object arg)
  2096    {
  2097      struct my_data *md = XSAVE_POINTER (arg, 0);
  2098      ptrdiff_t mi = XSAVE_INTEGER (arg, 1);
  2099      ...
  2100    }
  2101 
  2102    If ENABLE_CHECKING is in effect, XSAVE_xxx macros do type checking of the
  2103    saved objects and raise eassert if type of the saved object doesn't match
  2104    the type which is extracted.  In the example above, XSAVE_INTEGER (arg, 2)
  2105    and XSAVE_OBJECT (arg, 0) are wrong because nothing was saved in slot 2 and
  2106    slot 0 is a pointer.  */
  2107 
  2108 typedef void (*voidfuncptr) (void);
  2109 
  2110 struct Lisp_Save_Value
  2111   {
  2112     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
  2113     bool_bf gcmarkbit : 1;
  2114     unsigned spacer : 32 - (16 + 1 + SAVE_TYPE_BITS);
  2115 
  2116     /* V->data may hold up to SAVE_VALUE_SLOTS entries.  The type of
  2117        V's data entries are determined by V->save_type.  E.g., if
  2118        V->save_type == SAVE_TYPE_PTR_OBJ, V->data[0] is a pointer,
  2119        V->data[1] is an integer, and V's other data entries are unused.
  2120 
  2121        If V->save_type == SAVE_TYPE_MEMORY, V->data[0].pointer is the address of
  2122        a memory area containing V->data[1].integer potential Lisp_Objects.  */
  2123     ENUM_BF (Lisp_Save_Type) save_type : SAVE_TYPE_BITS;
  2124     union {
  2125       void *pointer;
  2126       voidfuncptr funcpointer;
  2127       ptrdiff_t integer;
  2128       Lisp_Object object;
  2129     } data[SAVE_VALUE_SLOTS];
  2130   };
  2131 
  2132 /* Return the type of V's Nth saved value.  */
  2133 INLINE int
  2134 save_type (struct Lisp_Save_Value *v, int n)
  2135 {
  2136   eassert (0 <= n && n < SAVE_VALUE_SLOTS);
  2137   return (v->save_type >> (SAVE_SLOT_BITS * n) & ((1 << SAVE_SLOT_BITS) - 1));
  2138 }
  2139 
  2140 /* Get and set the Nth saved pointer.  */
  2141 
  2142 INLINE void *
  2143 XSAVE_POINTER (Lisp_Object obj, int n)
  2144 {
  2145   eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
  2146   return XSAVE_VALUE (obj)->data[n].pointer;
  2147 }
  2148 INLINE void
  2149 set_save_pointer (Lisp_Object obj, int n, void *val)
  2150 {
  2151   eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
  2152   XSAVE_VALUE (obj)->data[n].pointer = val;
  2153 }
  2154 INLINE voidfuncptr
  2155 XSAVE_FUNCPOINTER (Lisp_Object obj, int n)
  2156 {
  2157   eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_FUNCPOINTER);
  2158   return XSAVE_VALUE (obj)->data[n].funcpointer;
  2159 }
  2160 
  2161 /* Likewise for the saved integer.  */
  2162 
  2163 INLINE ptrdiff_t
  2164 XSAVE_INTEGER (Lisp_Object obj, int n)
  2165 {
  2166   eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_INTEGER);
  2167   return XSAVE_VALUE (obj)->data[n].integer;
  2168 }
  2169 INLINE void
  2170 set_save_integer (Lisp_Object obj, int n, ptrdiff_t val)
  2171 {
  2172   eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_INTEGER);
  2173   XSAVE_VALUE (obj)->data[n].integer = val;
  2174 }
  2175 
  2176 /* Extract Nth saved object.  */
  2177 
  2178 INLINE Lisp_Object
  2179 XSAVE_OBJECT (Lisp_Object obj, int n)
  2180 {
  2181   eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_OBJECT);
  2182   return XSAVE_VALUE (obj)->data[n].object;
  2183 }
  2184 
  2185 /* A finalizer sentinel.  */
  2186 struct Lisp_Finalizer
  2187   {
  2188     struct Lisp_Misc_Any base;
  2189 
  2190     /* Circular list of all active weak references.  */
  2191     struct Lisp_Finalizer *prev;
  2192     struct Lisp_Finalizer *next;
  2193 
  2194     /* Call FUNCTION when the finalizer becomes unreachable, even if
  2195        FUNCTION contains a reference to the finalizer; i.e., call
  2196        FUNCTION when it is reachable _only_ through finalizers.  */
  2197     Lisp_Object function;
  2198   };
  2199 
  2200 /* A miscellaneous object, when it's on the free list.  */
  2201 struct Lisp_Free
  2202   {
  2203     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Free */
  2204     bool_bf gcmarkbit : 1;
  2205     unsigned spacer : 15;
  2206     union Lisp_Misc *chain;
  2207   };
  2208 
  2209 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
  2210    It uses one of these struct subtypes to get the type field.  */
  2211 
  2212 union Lisp_Misc
  2213   {
  2214     struct Lisp_Misc_Any u_any;    /* Supertype of all Misc types.  */
  2215     struct Lisp_Free u_free;
  2216     struct Lisp_Marker u_marker;
  2217     struct Lisp_Overlay u_overlay;
  2218     struct Lisp_Save_Value u_save_value;
  2219     struct Lisp_Finalizer u_finalizer;
  2220   };
  2221 
  2222 INLINE union Lisp_Misc *
  2223 XMISC (Lisp_Object a)
  2224 {
  2225   return XUNTAG (a, Lisp_Misc);
  2226 }
  2227 
  2228 INLINE struct Lisp_Misc_Any *
  2229 XMISCANY (Lisp_Object a)
  2230 {
  2231   eassert (MISCP (a));
  2232   return & XMISC (a)->u_any;
  2233 }
  2234 
  2235 INLINE enum Lisp_Misc_Type
  2236 XMISCTYPE (Lisp_Object a)
  2237 {
  2238   return XMISCANY (a)->type;
  2239 }
  2240 
  2241 INLINE struct Lisp_Marker *
  2242 XMARKER (Lisp_Object a)
  2243 {
  2244   eassert (MARKERP (a));
  2245   return & XMISC (a)->u_marker;
  2246 }
  2247 
  2248 INLINE struct Lisp_Overlay *
  2249 XOVERLAY (Lisp_Object a)
  2250 {
  2251   eassert (OVERLAYP (a));
  2252   return & XMISC (a)->u_overlay;
  2253 }
  2254 
  2255 INLINE struct Lisp_Save_Value *
  2256 XSAVE_VALUE (Lisp_Object a)
  2257 {
  2258   eassert (SAVE_VALUEP (a));
  2259   return & XMISC (a)->u_save_value;
  2260 }
  2261 
  2262 INLINE struct Lisp_Finalizer *
  2263 XFINALIZER (Lisp_Object a)
  2264 {
  2265   eassert (FINALIZERP (a));
  2266   return & XMISC (a)->u_finalizer;
  2267 }
  2268 
  2269 
  2270 /* Forwarding pointer to an int variable.
  2271    This is allowed only in the value cell of a symbol,
  2272    and it means that the symbol's value really lives in the
  2273    specified int variable.  */
  2274 struct Lisp_Intfwd
  2275   {
  2276     enum Lisp_Fwd_Type type;    /* = Lisp_Fwd_Int */
  2277     EMACS_INT *intvar;
  2278   };
  2279 
  2280 /* Boolean forwarding pointer to an int variable.
  2281    This is like Lisp_Intfwd except that the ostensible
  2282    "value" of the symbol is t if the bool variable is true,
  2283    nil if it is false.  */
  2284 struct Lisp_Boolfwd
  2285   {
  2286     enum Lisp_Fwd_Type type;    /* = Lisp_Fwd_Bool */
  2287     bool *boolvar;
  2288   };
  2289 
  2290 /* Forwarding pointer to a Lisp_Object variable.
  2291    This is allowed only in the value cell of a symbol,
  2292    and it means that the symbol's value really lives in the
  2293    specified variable.  */
  2294 struct Lisp_Objfwd
  2295   {
  2296     enum Lisp_Fwd_Type type;    /* = Lisp_Fwd_Obj */
  2297     Lisp_Object *objvar;
  2298   };
  2299 
  2300 /* Like Lisp_Objfwd except that value lives in a slot in the
  2301    current buffer.  Value is byte index of slot within buffer.  */
  2302 struct Lisp_Buffer_Objfwd
  2303   {
  2304     enum Lisp_Fwd_Type type;    /* = Lisp_Fwd_Buffer_Obj */
  2305     int offset;
  2306     /* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp.  */
  2307     Lisp_Object predicate;
  2308   };
  2309 
  2310 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
  2311    the symbol has buffer-local or frame-local bindings.  (Exception:
  2312    some buffer-local variables are built-in, with their values stored
  2313    in the buffer structure itself.  They are handled differently,
  2314    using struct Lisp_Buffer_Objfwd.)
  2315 
  2316    The `realvalue' slot holds the variable's current value, or a
  2317    forwarding pointer to where that value is kept.  This value is the
  2318    one that corresponds to the loaded binding.  To read or set the
  2319    variable, you must first make sure the right binding is loaded;
  2320    then you can access the value in (or through) `realvalue'.
  2321 
  2322    `buffer' and `frame' are the buffer and frame for which the loaded
  2323    binding was found.  If those have changed, to make sure the right
  2324    binding is loaded it is necessary to find which binding goes with
  2325    the current buffer and selected frame, then load it.  To load it,
  2326    first unload the previous binding, then copy the value of the new
  2327    binding into `realvalue' (or through it).  Also update
  2328    LOADED-BINDING to point to the newly loaded binding.
  2329 
  2330    `local_if_set' indicates that merely setting the variable creates a
  2331    local binding for the current buffer.  Otherwise the latter, setting
  2332    the variable does not do that; only make-local-variable does that.  */
  2333 
  2334 struct Lisp_Buffer_Local_Value
  2335   {
  2336     /* True means that merely setting the variable creates a local
  2337        binding for the current buffer.  */
  2338     bool_bf local_if_set : 1;
  2339     /* True means this variable can have frame-local bindings, otherwise, it is
  2340        can have buffer-local bindings.  The two cannot be combined.  */
  2341     bool_bf frame_local : 1;
  2342     /* True means that the binding now loaded was found.
  2343        Presumably equivalent to (defcell!=valcell).  */
  2344     bool_bf found : 1;
  2345     /* If non-NULL, a forwarding to the C var where it should also be set.  */
  2346     union Lisp_Fwd *fwd;        /* Should never be (Buffer|Kboard)_Objfwd.  */
  2347     /* The buffer or frame for which the loaded binding was found.  */
  2348     Lisp_Object where;
  2349     /* A cons cell that holds the default value.  It has the form
  2350        (SYMBOL . DEFAULT-VALUE).  */
  2351     Lisp_Object defcell;
  2352     /* The cons cell from `where's parameter alist.
  2353        It always has the form (SYMBOL . VALUE)
  2354        Note that if `forward' is non-nil, VALUE may be out of date.
  2355        Also if the currently loaded binding is the default binding, then
  2356        this is `eq'ual to defcell.  */
  2357     Lisp_Object valcell;
  2358   };
  2359 
  2360 /* Like Lisp_Objfwd except that value lives in a slot in the
  2361    current kboard.  */
  2362 struct Lisp_Kboard_Objfwd
  2363   {
  2364     enum Lisp_Fwd_Type type;    /* = Lisp_Fwd_Kboard_Obj */
  2365     int offset;
  2366   };
  2367 
  2368 union Lisp_Fwd
  2369   {
  2370     struct Lisp_Intfwd u_intfwd;
  2371     struct Lisp_Boolfwd u_boolfwd;
  2372     struct Lisp_Objfwd u_objfwd;
  2373     struct Lisp_Buffer_Objfwd u_buffer_objfwd;
  2374     struct Lisp_Kboard_Objfwd u_kboard_objfwd;
  2375   };
  2376 
  2377 INLINE enum Lisp_Fwd_Type
  2378 XFWDTYPE (union Lisp_Fwd *a)
  2379 {
  2380   return a->u_intfwd.type;
  2381 }
  2382 
  2383 INLINE struct Lisp_Buffer_Objfwd *
  2384 XBUFFER_OBJFWD (union Lisp_Fwd *a)
  2385 {
  2386   eassert (BUFFER_OBJFWDP (a));
  2387   return &a->u_buffer_objfwd;
  2388 }
  2389 
  2390 /* Lisp floating point type.  */
  2391 struct Lisp_Float
  2392   {
  2393     union
  2394     {
  2395       double data;
  2396       struct Lisp_Float *chain;
  2397     } u;
  2398   };
  2399 
  2400 INLINE double
  2401 XFLOAT_DATA (Lisp_Object f)
  2402 {
  2403   return XFLOAT (f)->u.data;
  2404 }
  2405 
  2406 /* Most hosts nowadays use IEEE floating point, so they use IEC 60559
  2407    representations, have infinities and NaNs, and do not trap on
  2408    exceptions.  Define IEEE_FLOATING_POINT if this host is one of the
  2409    typical ones.  The C11 macro __STDC_IEC_559__ is close to what is
  2410    wanted here, but is not quite right because Emacs does not require
  2411    all the features of C11 Annex F (and does not require C11 at all,
  2412    for that matter).  */
  2413 enum
  2414   {
  2415     IEEE_FLOATING_POINT
  2416       = (FLT_RADIX == 2 && FLT_MANT_DIG == 24
  2417          && FLT_MIN_EXP == -125 && FLT_MAX_EXP == 128)
  2418   };
  2419 
  2420 /* A character, declared with the following typedef, is a member
  2421    of some character set associated with the current buffer.  */
  2422 #ifndef _UCHAR_T  /* Protect against something in ctab.h on AIX.  */
  2423 #define _UCHAR_T
  2424 typedef unsigned char UCHAR;
  2425 #endif
  2426 
  2427 /* Meanings of slots in a Lisp_Compiled:  */
  2428 
  2429 enum Lisp_Compiled
  2430   {
  2431     COMPILED_ARGLIST = 0,
  2432     COMPILED_BYTECODE = 1,
  2433     COMPILED_CONSTANTS = 2,
  2434     COMPILED_STACK_DEPTH = 3,
  2435     COMPILED_DOC_STRING = 4,
  2436     COMPILED_INTERACTIVE = 5
  2437   };
  2438 
  2439 /* Flag bits in a character.  These also get used in termhooks.h.
  2440    Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
  2441    (MUlti-Lingual Emacs) might need 22 bits for the character value
  2442    itself, so we probably shouldn't use any bits lower than 0x0400000.  */
  2443 enum char_bits
  2444   {
  2445     CHAR_ALT = 0x0400000,
  2446     CHAR_SUPER = 0x0800000,
  2447     CHAR_HYPER = 0x1000000,
  2448     CHAR_SHIFT = 0x2000000,
  2449     CHAR_CTL = 0x4000000,
  2450     CHAR_META = 0x8000000,
  2451 
  2452     CHAR_MODIFIER_MASK =
  2453       CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META,
  2454 
  2455     /* Actually, the current Emacs uses 22 bits for the character value
  2456        itself.  */
  2457     CHARACTERBITS = 22
  2458   };
  2459 
  2460 /* Data type checking.  */
  2461 
  2462 LISP_MACRO_DEFUN (NILP, bool, (Lisp_Object x), (x))
  2463 
  2464 INLINE bool
  2465 NUMBERP (Lisp_Object x)
  2466 {
  2467   return INTEGERP (x) || FLOATP (x);
  2468 }
  2469 INLINE bool
  2470 NATNUMP (Lisp_Object x)
  2471 {
  2472   return INTEGERP (x) && 0 <= XINT (x);
  2473 }
  2474 
  2475 INLINE bool
  2476 RANGED_INTEGERP (intmax_t lo, Lisp_Object x, intmax_t hi)
  2477 {
  2478   return INTEGERP (x) && lo <= XINT (x) && XINT (x) <= hi;
  2479 }
  2480 
  2481 #define TYPE_RANGED_INTEGERP(type, x) \
  2482   (INTEGERP (x)                       \
  2483    && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \
  2484    && XINT (x) <= TYPE_MAXIMUM (type))
  2485 
  2486 LISP_MACRO_DEFUN (CONSP, bool, (Lisp_Object x), (x))
  2487 LISP_MACRO_DEFUN (FLOATP, bool, (Lisp_Object x), (x))
  2488 LISP_MACRO_DEFUN (MISCP, bool, (Lisp_Object x), (x))
  2489 LISP_MACRO_DEFUN (SYMBOLP, bool, (Lisp_Object x), (x))
  2490 LISP_MACRO_DEFUN (INTEGERP, bool, (Lisp_Object x), (x))
  2491 LISP_MACRO_DEFUN (VECTORLIKEP, bool, (Lisp_Object x), (x))
  2492 LISP_MACRO_DEFUN (MARKERP, bool, (Lisp_Object x), (x))
  2493 
  2494 INLINE bool
  2495 STRINGP (Lisp_Object x)
  2496 {
  2497   return XTYPE (x) == Lisp_String;
  2498 }
  2499 INLINE bool
  2500 VECTORP (Lisp_Object x)
  2501 {
  2502   return VECTORLIKEP (x) && ! (ASIZE (x) & PSEUDOVECTOR_FLAG);
  2503 }
  2504 INLINE bool
  2505 OVERLAYP (Lisp_Object x)
  2506 {
  2507   return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay;
  2508 }
  2509 INLINE bool
  2510 SAVE_VALUEP (Lisp_Object x)
  2511 {
  2512   return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Save_Value;
  2513 }
  2514 
  2515 INLINE bool
  2516 FINALIZERP (Lisp_Object x)
  2517 {
  2518   return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Finalizer;
  2519 }
  2520 
  2521 INLINE bool
  2522 AUTOLOADP (Lisp_Object x)
  2523 {
  2524   return CONSP (x) && EQ (Qautoload, XCAR (x));
  2525 }
  2526 
  2527 INLINE bool
  2528 BUFFER_OBJFWDP (union Lisp_Fwd *a)
  2529 {
  2530   return XFWDTYPE (a) == Lisp_Fwd_Buffer_Obj;
  2531 }
  2532 
  2533 INLINE bool
  2534 PSEUDOVECTOR_TYPEP (struct vectorlike_header *a, int code)
  2535 {
  2536   return ((a->size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK))
  2537           == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS)));
  2538 }
  2539 
  2540 /* True if A is a pseudovector whose code is CODE.  */
  2541 INLINE bool
  2542 PSEUDOVECTORP (Lisp_Object a, int code)
  2543 {
  2544   if (! VECTORLIKEP (a))
  2545     return false;
  2546   else
  2547     {
  2548       /* Converting to struct vectorlike_header * avoids aliasing issues.  */
  2549       struct vectorlike_header *h = XUNTAG (a, Lisp_Vectorlike);
  2550       return PSEUDOVECTOR_TYPEP (h, code);
  2551     }
  2552 }
  2553 
  2554 
  2555 /* Test for specific pseudovector types.  */
  2556 
  2557 INLINE bool
  2558 WINDOW_CONFIGURATIONP (Lisp_Object a)
  2559 {
  2560   return PSEUDOVECTORP (a, PVEC_WINDOW_CONFIGURATION);
  2561 }
  2562 
  2563 INLINE bool
  2564 PROCESSP (Lisp_Object a)
  2565 {
  2566   return PSEUDOVECTORP (a, PVEC_PROCESS);
  2567 }
  2568 
  2569 INLINE bool
  2570 WINDOWP (Lisp_Object a)
  2571 {
  2572   return PSEUDOVECTORP (a, PVEC_WINDOW);
  2573 }
  2574 
  2575 INLINE bool
  2576 TERMINALP (Lisp_Object a)
  2577 {
  2578   return PSEUDOVECTORP (a, PVEC_TERMINAL);
  2579 }
  2580 
  2581 INLINE bool
  2582 SUBRP (Lisp_Object a)
  2583 {
  2584   return PSEUDOVECTORP (a, PVEC_SUBR);
  2585 }
  2586 
  2587 INLINE bool
  2588 COMPILEDP (Lisp_Object a)
  2589 {
  2590   return PSEUDOVECTORP (a, PVEC_COMPILED);
  2591 }
  2592 
  2593 INLINE bool
  2594 BUFFERP (Lisp_Object a)
  2595 {
  2596   return PSEUDOVECTORP (a, PVEC_BUFFER);
  2597 }
  2598 
  2599 INLINE bool
  2600 CHAR_TABLE_P (Lisp_Object a)
  2601 {
  2602   return PSEUDOVECTORP (a, PVEC_CHAR_TABLE);
  2603 }
  2604 
  2605 INLINE bool
  2606 SUB_CHAR_TABLE_P (Lisp_Object a)
  2607 {
  2608   return PSEUDOVECTORP (a, PVEC_SUB_CHAR_TABLE);
  2609 }
  2610 
  2611 INLINE bool
  2612 BOOL_VECTOR_P (Lisp_Object a)
  2613 {
  2614   return PSEUDOVECTORP (a, PVEC_BOOL_VECTOR);
  2615 }
  2616 
  2617 INLINE bool
  2618 FRAMEP (Lisp_Object a)
  2619 {
  2620   return PSEUDOVECTORP (a, PVEC_FRAME);
  2621 }
  2622 
  2623 /* Test for image (image . spec)  */
  2624 INLINE bool
  2625 IMAGEP (Lisp_Object x)
  2626 {
  2627   return CONSP (x) && EQ (XCAR (x), Qimage);
  2628 }
  2629 
  2630 /* Array types.  */
  2631 INLINE bool
  2632 ARRAYP (Lisp_Object x)
  2633 {
  2634   return VECTORP (x) || STRINGP (x) || CHAR_TABLE_P (x) || BOOL_VECTOR_P (x);
  2635 }
  2636 
  2637 INLINE void
  2638 CHECK_LIST (Lisp_Object x)
  2639 {
  2640   CHECK_TYPE (CONSP (x) || NILP (x), Qlistp, x);
  2641 }
  2642 
  2643 LISP_MACRO_DEFUN_VOID (CHECK_LIST_CONS, (Lisp_Object x, Lisp_Object y), (x, y))
  2644 LISP_MACRO_DEFUN_VOID (CHECK_SYMBOL, (Lisp_Object x), (x))
  2645 LISP_MACRO_DEFUN_VOID (CHECK_NUMBER, (Lisp_Object x), (x))
  2646 
  2647 INLINE void
  2648 CHECK_STRING (Lisp_Object x)
  2649 {
  2650   CHECK_TYPE (STRINGP (x), Qstringp, x);
  2651 }
  2652 INLINE void
  2653 CHECK_STRING_CAR (Lisp_Object x)
  2654 {
  2655   CHECK_TYPE (STRINGP (XCAR (x)), Qstringp, XCAR (x));
  2656 }
  2657 INLINE void
  2658 CHECK_CONS (Lisp_Object x)
  2659 {
  2660   CHECK_TYPE (CONSP (x), Qconsp, x);
  2661 }
  2662 INLINE void
  2663 CHECK_VECTOR (Lisp_Object x)
  2664 {
  2665   CHECK_TYPE (VECTORP (x), Qvectorp, x);
  2666 }
  2667 INLINE void
  2668 CHECK_BOOL_VECTOR (Lisp_Object x)
  2669 {
  2670   CHECK_TYPE (BOOL_VECTOR_P (x), Qbool_vector_p, x);
  2671 }
  2672 /* This is a bit special because we always need size afterwards.  */
  2673 INLINE ptrdiff_t
  2674 CHECK_VECTOR_OR_STRING (Lisp_Object x)
  2675 {
  2676   if (VECTORP (x))
  2677     return ASIZE (x);
  2678   if (STRINGP (x))
  2679     return SCHARS (x);
  2680   wrong_type_argument (Qarrayp, x);
  2681 }
  2682 INLINE void
  2683 CHECK_ARRAY (Lisp_Object x, Lisp_Object predicate)
  2684 {
  2685   CHECK_TYPE (ARRAYP (x), predicate, x);
  2686 }
  2687 INLINE void
  2688 CHECK_BUFFER (Lisp_Object x)
  2689 {
  2690   CHECK_TYPE (BUFFERP (x), Qbufferp, x);
  2691 }
  2692 INLINE void
  2693 CHECK_WINDOW (Lisp_Object x)
  2694 {
  2695   CHECK_TYPE (WINDOWP (x), Qwindowp, x);
  2696 }
  2697 #ifdef subprocesses
  2698 INLINE void
  2699 CHECK_PROCESS (Lisp_Object x)
  2700 {
  2701   CHECK_TYPE (PROCESSP (x), Qprocessp, x);
  2702 }
  2703 #endif
  2704 INLINE void
  2705 CHECK_NATNUM (Lisp_Object x)
  2706 {
  2707   CHECK_TYPE (NATNUMP (x), Qwholenump, x);
  2708 }
  2709 
  2710 #define CHECK_RANGED_INTEGER(x, lo, hi)                                 \
  2711   do {                                                                  \
  2712     CHECK_NUMBER (x);                                                   \
  2713     if (! ((lo) <= XINT (x) && XINT (x) <= (hi)))                       \
  2714       args_out_of_range_3                                               \
  2715         (x,                                                             \
  2716          make_number ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM           \
  2717                       ? MOST_NEGATIVE_FIXNUM                            \
  2718                       : (lo)),                                          \
  2719          make_number (min (hi, MOST_POSITIVE_FIXNUM)));                 \
  2720   } while (false)
  2721 #define CHECK_TYPE_RANGED_INTEGER(type, x) \
  2722   do {                                                                  \
  2723     if (TYPE_SIGNED (type))                                             \
  2724       CHECK_RANGED_INTEGER (x, TYPE_MINIMUM (type), TYPE_MAXIMUM (type)); \
  2725     else                                                                \
  2726       CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type));                 \
  2727   } while (false)
  2728 
  2729 #define CHECK_NUMBER_COERCE_MARKER(x)                                   \
  2730   do {                                                                  \
  2731     if (MARKERP ((x)))                                                  \
  2732       XSETFASTINT (x, marker_position (x));                             \
  2733     else                                                                \
  2734       CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x);               \
  2735   } while (false)
  2736 
  2737 INLINE double
  2738 XFLOATINT (Lisp_Object n)
  2739 {
  2740   return extract_float (n);
  2741 }
  2742 
  2743 INLINE void
  2744 CHECK_NUMBER_OR_FLOAT (Lisp_Object x)
  2745 {
  2746   CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x);
  2747 }
  2748 
  2749 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x)                          \
  2750   do {                                                                  \
  2751     if (MARKERP (x))                                                    \
  2752       XSETFASTINT (x, marker_position (x));                             \
  2753     else                                                                \
  2754       CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x);  \
  2755   } while (false)
  2756 
  2757 /* Since we can't assign directly to the CAR or CDR fields of a cons
  2758    cell, use these when checking that those fields contain numbers.  */
  2759 INLINE void
  2760 CHECK_NUMBER_CAR (Lisp_Object x)
  2761 {
  2762   Lisp_Object tmp = XCAR (x);
  2763   CHECK_NUMBER (tmp);
  2764   XSETCAR (x, tmp);
  2765 }
  2766 
  2767 INLINE void
  2768 CHECK_NUMBER_CDR (Lisp_Object x)
  2769 {
  2770   Lisp_Object tmp = XCDR (x);
  2771   CHECK_NUMBER (tmp);
  2772   XSETCDR (x, tmp);
  2773 }
  2774 
  2775 /* Define a built-in function for calling from Lisp.
  2776  `lname' should be the name to give the function in Lisp,
  2777     as a null-terminated C string.
  2778  `fnname' should be the name of the function in C.
  2779     By convention, it starts with F.
  2780  `sname' should be the name for the C constant structure
  2781     that records information on this function for internal use.
  2782     By convention, it should be the same as `fnname' but with S instead of F.
  2783     It's too bad that C macros can't compute this from `fnname'.
  2784  `minargs' should be a number, the minimum number of arguments allowed.
  2785  `maxargs' should be a number, the maximum number of arguments allowed,
  2786     or else MANY or UNEVALLED.
  2787     MANY means pass a vector of evaluated arguments,
  2788          in the form of an integer number-of-arguments
  2789          followed by the address of a vector of Lisp_Objects
  2790          which contains the argument values.
  2791     UNEVALLED means pass the list of unevaluated arguments
  2792  `intspec' says how interactive arguments are to be fetched.
  2793     If the string starts with a `(', `intspec' is evaluated and the resulting
  2794     list is the list of arguments.
  2795     If it's a string that doesn't start with `(', the value should follow
  2796     the one of the doc string for `interactive'.
  2797     A null string means call interactively with no arguments.
  2798  `doc' is documentation for the user.  */
  2799 
  2800 /* This version of DEFUN declares a function prototype with the right
  2801    arguments, so we can catch errors with maxargs at compile-time.  */
  2802 #ifdef _MSC_VER
  2803 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)     \
  2804    Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                          \
  2805    static struct Lisp_Subr alignas (GCALIGNMENT) sname =                \
  2806    { { (PVEC_SUBR << PSEUDOVECTOR_AREA_BITS)                            \
  2807        | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)) },            \
  2808       { (Lisp_Object (__cdecl *)(void))fnname },                        \
  2809        minargs, maxargs, lname, intspec, 0};                            \
  2810    Lisp_Object fnname
  2811 #else  /* not _MSC_VER */
  2812 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)     \
  2813    static struct Lisp_Subr alignas (GCALIGNMENT) sname =                \
  2814      { { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS },                         \
  2815        { .a ## maxargs = fnname },                                      \
  2816        minargs, maxargs, lname, intspec, 0};                            \
  2817    Lisp_Object fnname
  2818 #endif
  2819 
  2820 /* True if OBJ is a Lisp function.  */
  2821 INLINE bool
  2822 FUNCTIONP (Lisp_Object obj)
  2823 {
  2824   return functionp (obj);
  2825 }
  2826 
  2827 /* defsubr (Sname);
  2828    is how we define the symbol for function `name' at start-up time.  */
  2829 extern void defsubr (struct Lisp_Subr *);
  2830 
  2831 enum maxargs
  2832   {
  2833     MANY = -2,
  2834     UNEVALLED = -1
  2835   };
  2836 
  2837 /* Call a function F that accepts many args, passing it ARRAY's elements.  */
  2838 #define CALLMANY(f, array) (f) (ARRAYELTS (array), array)
  2839 
  2840 /* Call a function F that accepts many args, passing it the remaining args,
  2841    E.g., 'return CALLN (Fformat, fmt, text);' is less error-prone than
  2842    '{ Lisp_Object a[2]; a[0] = fmt; a[1] = text; return Fformat (2, a); }'.
  2843    CALLN is overkill for simple usages like 'Finsert (1, &text);'.  */
  2844 #define CALLN(f, ...) CALLMANY (f, ((Lisp_Object []) {__VA_ARGS__}))
  2845 
  2846 extern void defvar_lisp (struct Lisp_Objfwd *, const char *, Lisp_Object *);
  2847 extern void defvar_lisp_nopro (struct Lisp_Objfwd *, const char *, Lisp_Object *);
  2848 extern void defvar_bool (struct Lisp_Boolfwd *, const char *, bool *);
  2849 extern void defvar_int (struct Lisp_Intfwd *, const char *, EMACS_INT *);
  2850 extern void defvar_kboard (struct Lisp_Kboard_Objfwd *, const char *, int);
  2851 
  2852 /* Macros we use to define forwarded Lisp variables.
  2853    These are used in the syms_of_FILENAME functions.
  2854 
  2855    An ordinary (not in buffer_defaults, per-buffer, or per-keyboard)
  2856    lisp variable is actually a field in `struct emacs_globals'.  The
  2857    field's name begins with "f_", which is a convention enforced by
  2858    these macros.  Each such global has a corresponding #define in
  2859    globals.h; the plain name should be used in the code.
  2860 
  2861    E.g., the global "cons_cells_consed" is declared as "int
  2862    f_cons_cells_consed" in globals.h, but there is a define:
  2863 
  2864       #define cons_cells_consed globals.f_cons_cells_consed
  2865 
  2866    All C code uses the `cons_cells_consed' name.  This is all done
  2867    this way to support indirection for multi-threaded Emacs.  */
  2868 
  2869 #define DEFVAR_LISP(lname, vname, doc)          \
  2870   do {                                          \
  2871     static struct Lisp_Objfwd o_fwd;            \
  2872     defvar_lisp (&o_fwd, lname, &globals.f_ ## vname);          \
  2873   } while (false)
  2874 #define DEFVAR_LISP_NOPRO(lname, vname, doc)    \
  2875   do {                                          \
  2876     static struct Lisp_Objfwd o_fwd;            \
  2877     defvar_lisp_nopro (&o_fwd, lname, &globals.f_ ## vname);    \
  2878   } while (false)
  2879 #define DEFVAR_BOOL(lname, vname, doc)          \
  2880   do {                                          \
  2881     static struct Lisp_Boolfwd b_fwd;           \
  2882     defvar_bool (&b_fwd, lname, &globals.f_ ## vname);          \
  2883   } while (false)
  2884 #define DEFVAR_INT(lname, vname, doc)           \
  2885   do {                                          \
  2886     static struct Lisp_Intfwd i_fwd;            \
  2887     defvar_int (&i_fwd, lname, &globals.f_ ## vname);           \
  2888   } while (false)
  2889 
  2890 #define DEFVAR_BUFFER_DEFAULTS(lname, vname, doc)               \
  2891   do {                                                          \
  2892     static struct Lisp_Objfwd o_fwd;                            \
  2893     defvar_lisp_nopro (&o_fwd, lname, &BVAR (&buffer_defaults, vname)); \
  2894   } while (false)
  2895 
  2896 #define DEFVAR_KBOARD(lname, vname, doc)                        \
  2897   do {                                                          \
  2898     static struct Lisp_Kboard_Objfwd ko_fwd;                    \
  2899     defvar_kboard (&ko_fwd, lname, offsetof (KBOARD, vname ## _)); \
  2900   } while (false)
  2901 
  2902 /* Save and restore the instruction and environment pointers,
  2903    without affecting the signal mask.  */
  2904 
  2905 #ifdef HAVE__SETJMP
  2906 typedef jmp_buf sys_jmp_buf;
  2907 # define sys_setjmp(j) _setjmp (j)
  2908 # define sys_longjmp(j, v) _longjmp (j, v)
  2909 #elif defined HAVE_SIGSETJMP
  2910 typedef sigjmp_buf sys_jmp_buf;
  2911 # define sys_setjmp(j) sigsetjmp (j, 0)
  2912 # define sys_longjmp(j, v) siglongjmp (j, v)
  2913 #else
  2914 /* A platform that uses neither _longjmp nor siglongjmp; assume
  2915    longjmp does not affect the sigmask.  */
  2916 typedef jmp_buf sys_jmp_buf;
  2917 # define sys_setjmp(j) setjmp (j)
  2918 # define sys_longjmp(j, v) longjmp (j, v)
  2919 #endif
  2920 
  2921 
  2922 /* Elisp uses several stacks:
  2923    - the C stack.
  2924    - the bytecode stack: used internally by the bytecode interpreter.
  2925      Allocated from the C stack.
  2926    - The specpdl stack: keeps track of active unwind-protect and
  2927      dynamic-let-bindings.  Allocated from the `specpdl' array, a manually
  2928      managed stack.
  2929    - The handler stack: keeps track of active catch tags and condition-case
  2930      handlers.  Allocated in a manually managed stack implemented by a
  2931      doubly-linked list allocated via xmalloc and never freed.  */
  2932 
  2933 /* Structure for recording Lisp call stack for backtrace purposes.  */
  2934 
  2935 /* The special binding stack holds the outer values of variables while
  2936    they are bound by a function application or a let form, stores the
  2937    code to be executed for unwind-protect forms.
  2938 
  2939    NOTE: The specbinding union is defined here, because SPECPDL_INDEX is
  2940    used all over the place, needs to be fast, and needs to know the size of
  2941    union specbinding.  But only eval.c should access it.  */
  2942 
  2943 enum specbind_tag {
  2944   SPECPDL_UNWIND,               /* An unwind_protect function on Lisp_Object.  */
  2945   SPECPDL_UNWIND_PTR,           /* Likewise, on void *.  */
  2946   SPECPDL_UNWIND_INT,           /* Likewise, on int.  */
  2947   SPECPDL_UNWIND_VOID,          /* Likewise, with no arg.  */
  2948   SPECPDL_BACKTRACE,            /* An element of the backtrace.  */
  2949   SPECPDL_LET,                  /* A plain and simple dynamic let-binding.  */
  2950   /* Tags greater than SPECPDL_LET must be "subkinds" of LET.  */
  2951   SPECPDL_LET_LOCAL,            /* A buffer-local let-binding.  */
  2952   SPECPDL_LET_DEFAULT           /* A global binding for a localized var.  */
  2953 };
  2954 
  2955 union specbinding
  2956   {
  2957     ENUM_BF (specbind_tag) kind : CHAR_BIT;
  2958     struct {
  2959       ENUM_BF (specbind_tag) kind : CHAR_BIT;
  2960       void (*func) (Lisp_Object);
  2961       Lisp_Object arg;
  2962     } unwind;
  2963     struct {
  2964       ENUM_BF (specbind_tag) kind : CHAR_BIT;
  2965       void (*func) (void *);
  2966       void *arg;
  2967     } unwind_ptr;
  2968     struct {
  2969       ENUM_BF (specbind_tag) kind : CHAR_BIT;
  2970       void (*func) (int);
  2971       int arg;
  2972     } unwind_int;
  2973     struct {
  2974       ENUM_BF (specbind_tag) kind : CHAR_BIT;
  2975       void (*func) (void);
  2976     } unwind_void;
  2977     struct {
  2978       ENUM_BF (specbind_tag) kind : CHAR_BIT;
  2979       /* `where' is not used in the case of SPECPDL_LET.  */
  2980       Lisp_Object symbol, old_value, where;
  2981     } let;
  2982     struct {
  2983       ENUM_BF (specbind_tag) kind : CHAR_BIT;
  2984       bool_bf debug_on_exit : 1;
  2985       Lisp_Object function;
  2986       Lisp_Object *args;
  2987       ptrdiff_t nargs;
  2988     } bt;
  2989   };
  2990 
  2991 extern union specbinding *specpdl;
  2992 extern union specbinding *specpdl_ptr;
  2993 extern ptrdiff_t specpdl_size;
  2994 
  2995 INLINE ptrdiff_t
  2996 SPECPDL_INDEX (void)
  2997 {
  2998   return specpdl_ptr - specpdl;
  2999 }
  3000 
  3001 /* This structure helps implement the `catch/throw' and `condition-case/signal'
  3002    control structures.  A struct handler contains all the information needed to
  3003    restore the state of the interpreter after a non-local jump.
  3004 
  3005    handler structures are chained together in a doubly linked list; the `next'
  3006    member points to the next outer catchtag and the `nextfree' member points in
  3007    the other direction to the next inner element (which is typically the next
  3008    free element since we mostly use it on the deepest handler).
  3009 
  3010    A call like (throw TAG VAL) searches for a catchtag whose `tag_or_ch'
  3011    member is TAG, and then unbinds to it.  The `val' member is used to
  3012    hold VAL while the stack is unwound; `val' is returned as the value
  3013    of the catch form.
  3014 
  3015    All the other members are concerned with restoring the interpreter
  3016    state.
  3017 
  3018    Members are volatile if their values need to survive _longjmp when
  3019    a 'struct handler' is a local variable.  */
  3020 
  3021 enum handlertype { CATCHER, CONDITION_CASE };
  3022 
  3023 struct handler
  3024 {
  3025   enum handlertype type;
  3026   Lisp_Object tag_or_ch;
  3027   Lisp_Object val;
  3028   struct handler *next;
  3029   struct handler *nextfree;
  3030 
  3031   /* The bytecode interpreter can have several handlers active at the same
  3032      time, so when we longjmp to one of them, it needs to know which handler
  3033      this was and what was the corresponding internal state.  This is stored
  3034      here, and when we longjmp we make sure that handlerlist points to the
  3035      proper handler.  */
  3036   Lisp_Object *bytecode_top;
  3037   int bytecode_dest;
  3038 
  3039   /* Most global vars are reset to their value via the specpdl mechanism,
  3040      but a few others are handled by storing their value here.  */
  3041 #if true /* GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS, but defined later.  */
  3042   struct gcpro *gcpro;
  3043 #endif
  3044   sys_jmp_buf jmp;
  3045   EMACS_INT lisp_eval_depth;
  3046   ptrdiff_t pdlcount;
  3047   int poll_suppress_count;
  3048   int interrupt_input_blocked;
  3049   struct byte_stack *byte_stack;
  3050 };
  3051 
  3052 /* Fill in the components of c, and put it on the list.  */
  3053 #define PUSH_HANDLER(c, tag_ch_val, handlertype)        \
  3054   if (handlerlist->nextfree)                            \
  3055     (c) = handlerlist->nextfree;                        \
  3056   else                                                  \
  3057     {                                                   \
  3058       (c) = xmalloc (sizeof (struct handler));          \
  3059       (c)->nextfree = NULL;                             \
  3060       handlerlist->nextfree = (c);                      \
  3061     }                                                   \
  3062   (c)->type = (handlertype);                            \
  3063   (c)->tag_or_ch = (tag_ch_val);                        \
  3064   (c)->val = Qnil;                                      \
  3065   (c)->next = handlerlist;                              \
  3066   (c)->lisp_eval_depth = lisp_eval_depth;               \
  3067   (c)->pdlcount = SPECPDL_INDEX ();                     \
  3068   (c)->poll_suppress_count = poll_suppress_count;       \
  3069   (c)->interrupt_input_blocked = interrupt_input_blocked;\
  3070   (c)->gcpro = gcprolist;                               \
  3071   (c)->byte_stack = byte_stack_list;                    \
  3072   handlerlist = (c);
  3073 
  3074 
  3075 extern Lisp_Object memory_signal_data;
  3076 
  3077 /* An address near the bottom of the stack.
  3078    Tells GC how to save a copy of the stack.  */
  3079 extern char *stack_bottom;
  3080 
  3081 /* Check quit-flag and quit if it is non-nil.
  3082    Typing C-g does not directly cause a quit; it only sets Vquit_flag.
  3083    So the program needs to do QUIT at times when it is safe to quit.
  3084    Every loop that might run for a long time or might not exit
  3085    ought to do QUIT at least once, at a safe place.
  3086    Unless that is impossible, of course.
  3087    But it is very desirable to avoid creating loops where QUIT is impossible.
  3088 
  3089    Exception: if you set immediate_quit to true,
  3090    then the handler that responds to the C-g does the quit itself.
  3091    This is a good thing to do around a loop that has no side effects
  3092    and (in particular) cannot call arbitrary Lisp code.
  3093 
  3094    If quit-flag is set to `kill-emacs' the SIGINT handler has received
  3095    a request to exit Emacs when it is safe to do.  */
  3096 
  3097 extern void process_pending_signals (void);
  3098 extern bool volatile pending_signals;
  3099 
  3100 extern void process_quit_flag (void);
  3101 #define QUIT                                            \
  3102   do {                                                  \
  3103     if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))     \
  3104       process_quit_flag ();                             \
  3105     else if (pending_signals)                           \
  3106       process_pending_signals ();                       \
  3107   } while (false)
  3108 
  3109 
  3110 /* True if ought to quit now.  */
  3111 
  3112 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
  3113 
  3114 extern Lisp_Object Vascii_downcase_table;
  3115 extern Lisp_Object Vascii_canon_table;
  3116 
  3117 /* Structure for recording stack slots that need marking.  */
  3118 
  3119 /* This is a chain of structures, each of which points at a Lisp_Object
  3120    variable whose value should be marked in garbage collection.
  3121    Normally every link of the chain is an automatic variable of a function,
  3122    and its `val' points to some argument or local variable of the function.
  3123    On exit to the function, the chain is set back to the value it had on entry.
  3124    This way, no link remains in the chain when the stack frame containing the
  3125    link disappears.
  3126 
  3127    Every function that can call Feval must protect in this fashion all
  3128    Lisp_Object variables whose contents will be used again.  */
  3129 
  3130 extern struct gcpro *gcprolist;
  3131 
  3132 struct gcpro
  3133 {
  3134   struct gcpro *next;
  3135 
  3136   /* Address of first protected variable.  */
  3137   volatile Lisp_Object *var;
  3138 
  3139   /* Number of consecutive protected variables.  */
  3140   ptrdiff_t nvars;
  3141 
  3142 #ifdef DEBUG_GCPRO
  3143   /* File name where this record is used.  */
  3144   const char *name;
  3145 
  3146   /* Line number in this file.  */
  3147   int lineno;
  3148 
  3149   /* Index in the local chain of records.  */
  3150   int idx;
  3151 
  3152   /* Nesting level.  */
  3153   int level;
  3154 #endif
  3155 };
  3156 
  3157 /* Values of GC_MARK_STACK during compilation:
  3158 
  3159    0    Use GCPRO as before
  3160    1    Do the real thing, make GCPROs and UNGCPRO no-ops.
  3161    2    Mark the stack, and check that everything GCPRO'd is
  3162         marked.
  3163    3    Mark using GCPRO's, mark stack last, and count how many
  3164         dead objects are kept alive.
  3165 
  3166    Formerly, method 0 was used.  Currently, method 1 is used unless
  3167    otherwise specified by hand when building, e.g.,
  3168    "make CPPFLAGS='-DGC_MARK_STACK=GC_USE_GCPROS_AS_BEFORE'".
  3169    Methods 2 and 3 are present mainly to debug the transition from 0 to 1.  */
  3170 
  3171 #define GC_USE_GCPROS_AS_BEFORE         0
  3172 #define GC_MAKE_GCPROS_NOOPS            1
  3173 #define GC_MARK_STACK_CHECK_GCPROS      2
  3174 #define GC_USE_GCPROS_CHECK_ZOMBIES     3
  3175 
  3176 #ifndef GC_MARK_STACK
  3177 #define GC_MARK_STACK GC_MAKE_GCPROS_NOOPS
  3178 #endif
  3179 
  3180 /* Whether we do the stack marking manually.  */
  3181 #define BYTE_MARK_STACK !(GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS         \
  3182                           || GC_MARK_STACK == GC_MARK_STACK_CHECK_GCPROS)
  3183 
  3184 
  3185 #if GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS
  3186 
  3187 /* Do something silly with gcproN vars just so gcc shuts up.  */
  3188 /* You get warnings from MIPSPro...  */
  3189 
  3190 #define GCPRO1(varname) ((void) gcpro1)
  3191 #define GCPRO2(varname1, varname2) ((void) gcpro2, (void) gcpro1)
  3192 #define GCPRO3(varname1, varname2, varname3) \
  3193   ((void) gcpro3, (void) gcpro2, (void) gcpro1)
  3194 #define GCPRO4(varname1, varname2, varname3, varname4) \
  3195   ((void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1)
  3196 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
  3197   ((void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1)
  3198 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
  3199   ((void) gcpro6, (void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, \
  3200    (void) gcpro1)
  3201 #define GCPRO7(a, b, c, d, e, f, g) (GCPRO6 (a, b, c, d, e, f), (void) gcpro7)
  3202 #define UNGCPRO ((void) 0)
  3203 
  3204 #else /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
  3205 
  3206 #ifndef DEBUG_GCPRO
  3207 
  3208 #define GCPRO1(a)                                                       \
  3209   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3210     gcprolist = &gcpro1; }
  3211 
  3212 #define GCPRO2(a, b)                                                    \
  3213   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3214     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3215     gcprolist = &gcpro2; }
  3216 
  3217 #define GCPRO3(a, b, c)                                                 \
  3218   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3219     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3220     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3221     gcprolist = &gcpro3; }
  3222 
  3223 #define GCPRO4(a, b, c, d)                                              \
  3224   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3225     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3226     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3227     gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
  3228     gcprolist = &gcpro4; }
  3229 
  3230 #define GCPRO5(a, b, c, d, e)                                           \
  3231   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3232     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3233     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3234     gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
  3235     gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
  3236     gcprolist = &gcpro5; }
  3237 
  3238 #define GCPRO6(a, b, c, d, e, f)                                        \
  3239   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3240     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3241     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3242     gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
  3243     gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
  3244     gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;         \
  3245     gcprolist = &gcpro6; }
  3246 
  3247 #define GCPRO7(a, b, c, d, e, f, g)                                     \
  3248   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3249     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3250     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3251     gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
  3252     gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
  3253     gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;         \
  3254     gcpro7.next = &gcpro6; gcpro7.var = &(g); gcpro7.nvars = 1;         \
  3255     gcprolist = &gcpro7; }
  3256 
  3257 #define UNGCPRO (gcprolist = gcpro1.next)
  3258 
  3259 #else /* !DEBUG_GCPRO */
  3260 
  3261 extern int gcpro_level;
  3262 
  3263 #define GCPRO1(a)                                                       \
  3264   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3265     gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
  3266     gcpro1.level = gcpro_level++;                                       \
  3267     gcprolist = &gcpro1; }
  3268 
  3269 #define GCPRO2(a, b)                                                    \
  3270   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3271     gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
  3272     gcpro1.level = gcpro_level;                                         \
  3273     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3274     gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
  3275     gcpro2.level = gcpro_level++;                                       \
  3276     gcprolist = &gcpro2; }
  3277 
  3278 #define GCPRO3(a, b, c)                                                 \
  3279   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3280     gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
  3281     gcpro1.level = gcpro_level;                                         \
  3282     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3283     gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
  3284     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3285     gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
  3286     gcpro3.level = gcpro_level++;                                       \
  3287     gcprolist = &gcpro3; }
  3288 
  3289 #define GCPRO4(a, b, c, d)                                              \
  3290   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3291     gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
  3292     gcpro1.level = gcpro_level;                                         \
  3293     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3294     gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
  3295     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3296     gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
  3297     gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
  3298     gcpro4.name = __FILE__; gcpro4.lineno = __LINE__; gcpro4.idx = 4;   \
  3299     gcpro4.level = gcpro_level++;                                       \
  3300     gcprolist = &gcpro4; }
  3301 
  3302 #define GCPRO5(a, b, c, d, e)                                           \
  3303   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3304     gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
  3305     gcpro1.level = gcpro_level;                                         \
  3306     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3307     gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
  3308     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3309     gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
  3310     gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
  3311     gcpro4.name = __FILE__; gcpro4.lineno = __LINE__; gcpro4.idx = 4;   \
  3312     gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
  3313     gcpro5.name = __FILE__; gcpro5.lineno = __LINE__; gcpro5.idx = 5;   \
  3314     gcpro5.level = gcpro_level++;                                       \
  3315     gcprolist = &gcpro5; }
  3316 
  3317 #define GCPRO6(a, b, c, d, e, f)                                        \
  3318   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3319     gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
  3320     gcpro1.level = gcpro_level;                                         \
  3321     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3322     gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
  3323     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3324     gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
  3325     gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
  3326     gcpro4.name = __FILE__; gcpro4.lineno = __LINE__; gcpro4.idx = 4;   \
  3327     gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
  3328     gcpro5.name = __FILE__; gcpro5.lineno = __LINE__; gcpro5.idx = 5;   \
  3329     gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;         \
  3330     gcpro6.name = __FILE__; gcpro6.lineno = __LINE__; gcpro6.idx = 6;   \
  3331     gcpro6.level = gcpro_level++;                                       \
  3332     gcprolist = &gcpro6; }
  3333 
  3334 #define GCPRO7(a, b, c, d, e, f, g)                                     \
  3335   { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
  3336     gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
  3337     gcpro1.level = gcpro_level;                                         \
  3338     gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
  3339     gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
  3340     gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
  3341     gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
  3342     gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
  3343     gcpro4.name = __FILE__; gcpro4.lineno = __LINE__; gcpro4.idx = 4;   \
  3344     gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
  3345     gcpro5.name = __FILE__; gcpro5.lineno = __LINE__; gcpro5.idx = 5;   \
  3346     gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;         \
  3347     gcpro6.name = __FILE__; gcpro6.lineno = __LINE__; gcpro6.idx = 6;   \
  3348     gcpro7.next = &gcpro6; gcpro7.var = &(g); gcpro7.nvars = 1;         \
  3349     gcpro7.name = __FILE__; gcpro7.lineno = __LINE__; gcpro7.idx = 7;   \
  3350     gcpro7.level = gcpro_level++;                                       \
  3351     gcprolist = &gcpro7; }
  3352 
  3353 #define UNGCPRO                                 \
  3354   (--gcpro_level != gcpro1.level                \
  3355    ? emacs_abort ()                             \
  3356    : (void) (gcprolist = gcpro1.next))
  3357 
  3358 #endif /* DEBUG_GCPRO */
  3359 #endif /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
  3360 
  3361 
  3362 /* Evaluate expr, UNGCPRO, and then return the value of expr.  */
  3363 #define RETURN_UNGCPRO(expr)                    \
  3364   do                                            \
  3365     {                                           \
  3366       Lisp_Object ret_ungc_val;                 \
  3367       ret_ungc_val = (expr);                    \
  3368       UNGCPRO;                                  \
  3369       return ret_ungc_val;                      \
  3370     }                                           \
  3371   while (false)
  3372 
  3373 /* Call staticpro (&var) to protect static variable `var'.  */
  3374 
  3375 void staticpro (Lisp_Object *);
  3376 
  3377 /* Forward declarations for prototypes.  */
  3378 struct window;
  3379 struct frame;
  3380 
  3381 /* Copy COUNT Lisp_Objects from ARGS to contents of V starting from OFFSET.  */
  3382 
  3383 INLINE void
  3384 vcopy (Lisp_Object v, ptrdiff_t offset, Lisp_Object *args, ptrdiff_t count)
  3385 {
  3386   eassert (0 <= offset && 0 <= count && offset + count <= ASIZE (v));
  3387   memcpy (XVECTOR (v)->contents + offset, args, count * sizeof *args);
  3388 }
  3389 
  3390 /* Functions to modify hash tables.  */
  3391 
  3392 INLINE void
  3393 set_hash_key_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)
  3394 {
  3395   gc_aset (h->key_and_value, 2 * idx, val);
  3396 }
  3397 
  3398 INLINE void
  3399 set_hash_value_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)
  3400 {
  3401   gc_aset (h->key_and_value, 2 * idx + 1, val);
  3402 }
  3403 
  3404 /* Use these functions to set Lisp_Object
  3405    or pointer slots of struct Lisp_Symbol.  */
  3406 
  3407 INLINE void
  3408 set_symbol_function (Lisp_Object sym, Lisp_Object function)
  3409 {
  3410   XSYMBOL (sym)->function = function;
  3411 }
  3412 
  3413 INLINE void
  3414 set_symbol_plist (Lisp_Object sym, Lisp_Object plist)
  3415 {
  3416   XSYMBOL (sym)->plist = plist;
  3417 }
  3418 
  3419 INLINE void
  3420 set_symbol_next (Lisp_Object sym, struct Lisp_Symbol *next)
  3421 {
  3422   XSYMBOL (sym)->next = next;
  3423 }
  3424 
  3425 /* Buffer-local (also frame-local) variable access functions.  */
  3426 
  3427 INLINE int
  3428 blv_found (struct Lisp_Buffer_Local_Value *blv)
  3429 {
  3430   eassert (blv->found == !EQ (blv->defcell, blv->valcell));
  3431   return blv->found;
  3432 }
  3433 
  3434 /* Set overlay's property list.  */
  3435 
  3436 INLINE void
  3437 set_overlay_plist (Lisp_Object overlay, Lisp_Object plist)
  3438 {
  3439   XOVERLAY (overlay)->plist = plist;
  3440 }
  3441 
  3442 /* Get text properties of S.  */
  3443 
  3444 INLINE INTERVAL
  3445 string_intervals (Lisp_Object s)
  3446 {
  3447   return XSTRING (s)->intervals;
  3448 }
  3449 
  3450 /* Set text properties of S to I.  */
  3451 
  3452 INLINE void
  3453 set_string_intervals (Lisp_Object s, INTERVAL i)
  3454 {
  3455   XSTRING (s)->intervals = i;
  3456 }
  3457 
  3458 /* Set a Lisp slot in TABLE to VAL.  Most code should use this instead
  3459    of setting slots directly.  */
  3460 
  3461 INLINE void
  3462 set_char_table_defalt (Lisp_Object table, Lisp_Object val)
  3463 {
  3464   XCHAR_TABLE (table)->defalt = val;
  3465 }
  3466 INLINE void
  3467 set_char_table_purpose (Lisp_Object table, Lisp_Object val)
  3468 {
  3469   XCHAR_TABLE (table)->purpose = val;
  3470 }
  3471 
  3472 /* Set different slots in (sub)character tables.  */
  3473 
  3474 INLINE void
  3475 set_char_table_extras (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
  3476 {
  3477   eassert (0 <= idx && idx < CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (table)));
  3478   XCHAR_TABLE (table)->extras[idx] = val;
  3479 }
  3480 
  3481 INLINE void
  3482 set_char_table_contents (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
  3483 {
  3484   eassert (0 <= idx && idx < (1 << CHARTAB_SIZE_BITS_0));
  3485   XCHAR_TABLE (table)->contents[idx] = val;
  3486 }
  3487 
  3488 INLINE void
  3489 set_sub_char_table_contents (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
  3490 {
  3491   XSUB_CHAR_TABLE (table)->contents[idx] = val;
  3492 }
  3493 
  3494 /* Defined in data.c.  */
  3495 extern Lisp_Object indirect_function (Lisp_Object);
  3496 extern Lisp_Object find_symbol_value (Lisp_Object);
  3497 enum Arith_Comparison {
  3498   ARITH_EQUAL,
  3499   ARITH_NOTEQUAL,
  3500   ARITH_LESS,
  3501   ARITH_GRTR,
  3502   ARITH_LESS_OR_EQUAL,
  3503   ARITH_GRTR_OR_EQUAL
  3504 };
  3505 extern Lisp_Object arithcompare (Lisp_Object num1, Lisp_Object num2,
  3506                                  enum Arith_Comparison comparison);
  3507 
  3508 /* Convert the integer I to an Emacs representation, either the integer
  3509    itself, or a cons of two or three integers, or if all else fails a float.
  3510    I should not have side effects.  */
  3511 #define INTEGER_TO_CONS(i)                                          \
  3512   (! FIXNUM_OVERFLOW_P (i)                                          \
  3513    ? make_number (i)                                                \
  3514    : ! ((FIXNUM_OVERFLOW_P (INTMAX_MIN >> 16)                       \
  3515          || FIXNUM_OVERFLOW_P (UINTMAX_MAX >> 16))                  \
  3516         && FIXNUM_OVERFLOW_P ((i) >> 16))                           \
  3517    ? Fcons (make_number ((i) >> 16), make_number ((i) & 0xffff))    \
  3518    : ! ((FIXNUM_OVERFLOW_P (INTMAX_MIN >> 16 >> 24)                 \
  3519          || FIXNUM_OVERFLOW_P (UINTMAX_MAX >> 16 >> 24))            \
  3520         && FIXNUM_OVERFLOW_P ((i) >> 16 >> 24))                     \
  3521    ? Fcons (make_number ((i) >> 16 >> 24),                          \
  3522             Fcons (make_number ((i) >> 16 & 0xffffff),              \
  3523                    make_number ((i) & 0xffff)))                     \
  3524    : make_float (i))
  3525 
  3526 /* Convert the Emacs representation CONS back to an integer of type
  3527    TYPE, storing the result the variable VAR.  Signal an error if CONS
  3528    is not a valid representation or is out of range for TYPE.  */
  3529 #define CONS_TO_INTEGER(cons, type, var)                                \
  3530  (TYPE_SIGNED (type)                                                    \
  3531   ? ((var) = cons_to_signed (cons, TYPE_MINIMUM (type), TYPE_MAXIMUM (type))) \
  3532   : ((var) = cons_to_unsigned (cons, TYPE_MAXIMUM (type))))
  3533 extern intmax_t cons_to_signed (Lisp_Object, intmax_t, intmax_t);
  3534 extern uintmax_t cons_to_unsigned (Lisp_Object, uintmax_t);
  3535 
  3536 extern struct Lisp_Symbol *indirect_variable (struct Lisp_Symbol *);
  3537 extern _Noreturn void args_out_of_range (Lisp_Object, Lisp_Object);
  3538 extern _Noreturn void args_out_of_range_3 (Lisp_Object, Lisp_Object,
  3539                                            Lisp_Object);
  3540 extern Lisp_Object do_symval_forwarding (union Lisp_Fwd *);
  3541 extern void set_internal (Lisp_Object, Lisp_Object, Lisp_Object, bool);
  3542 extern void syms_of_data (void);
  3543 extern void swap_in_global_binding (struct Lisp_Symbol *);
  3544 
  3545 /* Defined in cmds.c */
  3546 extern void syms_of_cmds (void);
  3547 extern void keys_of_cmds (void);
  3548 
  3549 /* Defined in coding.c.  */
  3550 extern Lisp_Object detect_coding_system (const unsigned char *, ptrdiff_t,
  3551                                          ptrdiff_t, bool, bool, Lisp_Object);
  3552 extern void init_coding (void);
  3553 extern void init_coding_once (void);
  3554 extern void syms_of_coding (void);
  3555 
  3556 /* Defined in character.c.  */
  3557 extern ptrdiff_t chars_in_text (const unsigned char *, ptrdiff_t);
  3558 extern ptrdiff_t multibyte_chars_in_text (const unsigned char *, ptrdiff_t);
  3559 extern void syms_of_character (void);
  3560 
  3561 /* Defined in charset.c.  */
  3562 extern void init_charset (void);
  3563 extern void init_charset_once (void);
  3564 extern void syms_of_charset (void);
  3565 /* Structure forward declarations.  */
  3566 struct charset;
  3567 
  3568 /* Defined in syntax.c.  */
  3569 extern void init_syntax_once (void);
  3570 extern void syms_of_syntax (void);
  3571 
  3572 /* Defined in fns.c.  */
  3573 enum { NEXT_ALMOST_PRIME_LIMIT = 11 };
  3574 extern EMACS_INT next_almost_prime (EMACS_INT) ATTRIBUTE_CONST;
  3575 extern Lisp_Object larger_vector (Lisp_Object, ptrdiff_t, ptrdiff_t);
  3576 extern void sweep_weak_hash_tables (void);
  3577 EMACS_UINT hash_string (char const *, ptrdiff_t);
  3578 EMACS_UINT sxhash (Lisp_Object, int);
  3579 Lisp_Object make_hash_table (struct hash_table_test, Lisp_Object, Lisp_Object,
  3580                              Lisp_Object, Lisp_Object);
  3581 ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, EMACS_UINT *);
  3582 ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
  3583                     EMACS_UINT);
  3584 extern struct hash_table_test hashtest_eql, hashtest_equal;
  3585 extern void validate_subarray (Lisp_Object, Lisp_Object, Lisp_Object,
  3586                                ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
  3587 extern Lisp_Object substring_both (Lisp_Object, ptrdiff_t, ptrdiff_t,
  3588                                    ptrdiff_t, ptrdiff_t);
  3589 extern Lisp_Object merge (Lisp_Object, Lisp_Object, Lisp_Object);
  3590 extern Lisp_Object do_yes_or_no_p (Lisp_Object);
  3591 extern Lisp_Object concat2 (Lisp_Object, Lisp_Object);
  3592 extern Lisp_Object concat3 (Lisp_Object, Lisp_Object, Lisp_Object);
  3593 extern Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
  3594 extern Lisp_Object assq_no_quit (Lisp_Object, Lisp_Object);
  3595 extern Lisp_Object assoc_no_quit (Lisp_Object, Lisp_Object);
  3596 extern void clear_string_char_byte_cache (void);
  3597 extern ptrdiff_t string_char_to_byte (Lisp_Object, ptrdiff_t);
  3598 extern ptrdiff_t string_byte_to_char (Lisp_Object, ptrdiff_t);
  3599 extern Lisp_Object string_to_multibyte (Lisp_Object);
  3600 extern Lisp_Object string_make_unibyte (Lisp_Object);
  3601 extern void syms_of_fns (void);
  3602 
  3603 /* Defined in floatfns.c.  */
  3604 extern void syms_of_floatfns (void);
  3605 extern Lisp_Object fmod_float (Lisp_Object x, Lisp_Object y);
  3606 
  3607 /* Defined in fringe.c.  */
  3608 extern void syms_of_fringe (void);
  3609 extern void init_fringe (void);
  3610 #ifdef HAVE_WINDOW_SYSTEM
  3611 extern void mark_fringe_data (void);
  3612 extern void init_fringe_once (void);
  3613 #endif /* HAVE_WINDOW_SYSTEM */
  3614 
  3615 /* Defined in image.c.  */
  3616 extern int x_bitmap_mask (struct frame *, ptrdiff_t);
  3617 extern void reset_image_types (void);
  3618 extern void syms_of_image (void);
  3619 
  3620 /* Defined in insdel.c.  */
  3621 extern void move_gap_both (ptrdiff_t, ptrdiff_t);
  3622 extern _Noreturn void buffer_overflow (void);
  3623 extern void make_gap (ptrdiff_t);
  3624 extern void make_gap_1 (struct buffer *, ptrdiff_t);
  3625 extern ptrdiff_t copy_text (const unsigned char *, unsigned char *,
  3626                             ptrdiff_t, bool, bool);
  3627 extern int count_combining_before (const unsigned char *,
  3628                                    ptrdiff_t, ptrdiff_t, ptrdiff_t);
  3629 extern int count_combining_after (const unsigned char *,
  3630                                   ptrdiff_t, ptrdiff_t, ptrdiff_t);
  3631 extern void insert (const char *, ptrdiff_t);
  3632 extern void insert_and_inherit (const char *, ptrdiff_t);
  3633 extern void insert_1_both (const char *, ptrdiff_t, ptrdiff_t,
  3634                            bool, bool, bool);
  3635 extern void insert_from_gap (ptrdiff_t, ptrdiff_t, bool text_at_gap_tail);
  3636 extern void insert_from_string (Lisp_Object, ptrdiff_t, ptrdiff_t,
  3637                                 ptrdiff_t, ptrdiff_t, bool);
  3638 extern void insert_from_buffer (struct buffer *, ptrdiff_t, ptrdiff_t, bool);
  3639 extern void insert_char (int);
  3640 extern void insert_string (const char *);
  3641 extern void insert_before_markers (const char *, ptrdiff_t);
  3642 extern void insert_before_markers_and_inherit (const char *, ptrdiff_t);
  3643 extern void insert_from_string_before_markers (Lisp_Object, ptrdiff_t,
  3644                                                ptrdiff_t, ptrdiff_t,
  3645                                                ptrdiff_t, bool);
  3646 extern void del_range (ptrdiff_t, ptrdiff_t);
  3647 extern Lisp_Object del_range_1 (ptrdiff_t, ptrdiff_t, bool, bool);
  3648 extern void del_range_byte (ptrdiff_t, ptrdiff_t, bool);
  3649 extern void del_range_both (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, bool);
  3650 extern Lisp_Object del_range_2 (ptrdiff_t, ptrdiff_t,
  3651                                 ptrdiff_t, ptrdiff_t, bool);
  3652 extern void modify_text (ptrdiff_t, ptrdiff_t);
  3653 extern void prepare_to_modify_buffer (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
  3654 extern void prepare_to_modify_buffer_1 (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
  3655 extern void invalidate_buffer_caches (struct buffer *, ptrdiff_t, ptrdiff_t);
  3656 extern void signal_after_change (ptrdiff_t, ptrdiff_t, ptrdiff_t);
  3657 extern void adjust_after_insert (ptrdiff_t, ptrdiff_t, ptrdiff_t,
  3658                                  ptrdiff_t, ptrdiff_t);
  3659 extern void adjust_markers_for_delete (ptrdiff_t, ptrdiff_t,
  3660                                        ptrdiff_t, ptrdiff_t);
  3661 extern void replace_range (ptrdiff_t, ptrdiff_t, Lisp_Object, bool, bool, bool);
  3662 extern void replace_range_2 (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
  3663                              const char *, ptrdiff_t, ptrdiff_t, bool);
  3664 extern void syms_of_insdel (void);
  3665 
  3666 /* Defined in dispnew.c.  */
  3667 #if (defined PROFILING \
  3668      && (defined __FreeBSD__ || defined GNU_LINUX || defined __MINGW32__))
  3669 _Noreturn void __executable_start (void);
  3670 #endif
  3671 extern Lisp_Object Vwindow_system;
  3672 extern Lisp_Object sit_for (Lisp_Object, bool, int);
  3673 
  3674 /* Defined in xdisp.c.  */
  3675 extern bool noninteractive_need_newline;
  3676 extern Lisp_Object echo_area_buffer[2];
  3677 extern void add_to_log (const char *, Lisp_Object, Lisp_Object);
  3678 extern void check_message_stack (void);
  3679 extern void setup_echo_area_for_printing (bool);
  3680 extern bool push_message (void);
  3681 extern void pop_message_unwind (void);
  3682 extern Lisp_Object restore_message_unwind (Lisp_Object);
  3683 extern void restore_message (void);
  3684 extern Lisp_Object current_message (void);
  3685 extern void clear_message (bool, bool);
  3686 extern void message (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
  3687 extern void message1 (const char *);
  3688 extern void message1_nolog (const char *);
  3689 extern void message3 (Lisp_Object);
  3690 extern void message3_nolog (Lisp_Object);
  3691 extern void message_dolog (const char *, ptrdiff_t, bool, bool);
  3692 extern void message_with_string (const char *, Lisp_Object, bool);
  3693 extern void message_log_maybe_newline (void);
  3694 extern void update_echo_area (void);
  3695 extern void truncate_echo_area (ptrdiff_t);
  3696 extern void redisplay (void);
  3697 
  3698 void set_frame_cursor_types (struct frame *, Lisp_Object);
  3699 extern void syms_of_xdisp (void);
  3700 extern void init_xdisp (void);
  3701 extern Lisp_Object safe_eval (Lisp_Object);
  3702 extern bool pos_visible_p (struct window *, ptrdiff_t, int *,
  3703                            int *, int *, int *, int *, int *);
  3704 
  3705 /* Defined in xsettings.c.  */
  3706 extern void syms_of_xsettings (void);
  3707 
  3708 /* Defined in vm-limit.c.  */
  3709 extern void memory_warnings (void *, void (*warnfun) (const char *));
  3710 
  3711 /* Defined in character.c.  */
  3712 extern void parse_str_as_multibyte (const unsigned char *, ptrdiff_t,
  3713                                     ptrdiff_t *, ptrdiff_t *);
  3714 
  3715 /* Defined in alloc.c.  */
  3716 extern void check_pure_size (void);
  3717 extern void free_misc (Lisp_Object);
  3718 extern void allocate_string_data (struct Lisp_String *, EMACS_INT, EMACS_INT);
  3719 extern void malloc_warning (const char *);
  3720 extern _Noreturn void memory_full (size_t);
  3721 extern _Noreturn void buffer_memory_full (ptrdiff_t);
  3722 extern bool survives_gc_p (Lisp_Object);
  3723 extern void mark_object (Lisp_Object);
  3724 #if defined REL_ALLOC && !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
  3725 extern void refill_memory_reserve (void);
  3726 #endif
  3727 extern const char *pending_malloc_warning;
  3728 extern Lisp_Object zero_vector;
  3729 extern Lisp_Object *stack_base;
  3730 extern EMACS_INT consing_since_gc;
  3731 extern EMACS_INT gc_relative_threshold;
  3732 extern EMACS_INT memory_full_cons_threshold;
  3733 extern Lisp_Object list1 (Lisp_Object);
  3734 extern Lisp_Object list2 (Lisp_Object, Lisp_Object);
  3735 extern Lisp_Object list3 (Lisp_Object, Lisp_Object, Lisp_Object);
  3736 extern Lisp_Object list4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  3737 extern Lisp_Object list5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
  3738                           Lisp_Object);
  3739 enum constype {CONSTYPE_HEAP, CONSTYPE_PURE};
  3740 extern Lisp_Object listn (enum constype, ptrdiff_t, Lisp_Object, ...);
  3741 
  3742 /* Build a frequently used 2/3/4-integer lists.  */
  3743 
  3744 INLINE Lisp_Object
  3745 list2i (EMACS_INT x, EMACS_INT y)
  3746 {
  3747   return list2 (make_number (x), make_number (y));
  3748 }
  3749 
  3750 INLINE Lisp_Object
  3751 list3i (EMACS_INT x, EMACS_INT y, EMACS_INT w)
  3752 {
  3753   return list3 (make_number (x), make_number (y), make_number (w));
  3754 }
  3755 
  3756 INLINE Lisp_Object
  3757 list4i (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
  3758 {
  3759   return list4 (make_number (x), make_number (y),
  3760                 make_number (w), make_number (h));
  3761 }
  3762 
  3763 extern Lisp_Object make_uninit_bool_vector (EMACS_INT);
  3764 extern Lisp_Object bool_vector_fill (Lisp_Object, Lisp_Object);
  3765 extern _Noreturn void string_overflow (void);
  3766 extern Lisp_Object make_string (const char *, ptrdiff_t);
  3767 extern Lisp_Object make_formatted_string (char *, const char *, ...)
  3768   ATTRIBUTE_FORMAT_PRINTF (2, 3);
  3769 extern Lisp_Object make_unibyte_string (const char *, ptrdiff_t);
  3770 
  3771 /* Make unibyte string from C string when the length isn't known.  */
  3772 
  3773 INLINE Lisp_Object
  3774 build_unibyte_string (const char *str)
  3775 {
  3776   return make_unibyte_string (str, strlen (str));
  3777 }
  3778 
  3779 extern Lisp_Object make_multibyte_string (const char *, ptrdiff_t, ptrdiff_t);
  3780 extern Lisp_Object make_event_array (ptrdiff_t, Lisp_Object *);
  3781 extern Lisp_Object make_uninit_string (EMACS_INT);
  3782 extern Lisp_Object make_uninit_multibyte_string (EMACS_INT, EMACS_INT);
  3783 extern Lisp_Object make_string_from_bytes (const char *, ptrdiff_t, ptrdiff_t);
  3784 extern Lisp_Object make_specified_string (const char *,
  3785                                           ptrdiff_t, ptrdiff_t, bool);
  3786 extern Lisp_Object make_pure_string (const char *, ptrdiff_t, ptrdiff_t, bool);
  3787 extern Lisp_Object make_pure_c_string (const char *, ptrdiff_t);
  3788 
  3789 /* Make a string allocated in pure space, use STR as string data.  */
  3790 
  3791 INLINE Lisp_Object
  3792 build_pure_c_string (const char *str)
  3793 {
  3794   return make_pure_c_string (str, strlen (str));
  3795 }
  3796 
  3797 /* Make a string from the data at STR, treating it as multibyte if the
  3798    data warrants.  */
  3799 
  3800 INLINE Lisp_Object
  3801 build_string (const char *str)
  3802 {
  3803   return make_string (str, strlen (str));
  3804 }
  3805 
  3806 extern Lisp_Object pure_cons (Lisp_Object, Lisp_Object);
  3807 extern void make_byte_code (struct Lisp_Vector *);
  3808 extern struct Lisp_Vector *allocate_vector (EMACS_INT);
  3809 
  3810 /* Make an uninitialized vector for SIZE objects.  NOTE: you must
  3811    be sure that GC cannot happen until the vector is completely
  3812    initialized.  E.g. the following code is likely to crash:
  3813 
  3814    v = make_uninit_vector (3);
  3815    ASET (v, 0, obj0);
  3816    ASET (v, 1, Ffunction_can_gc ());
  3817    ASET (v, 2, obj1);  */
  3818 
  3819 INLINE Lisp_Object
  3820 make_uninit_vector (ptrdiff_t size)
  3821 {
  3822   Lisp_Object v;
  3823   struct Lisp_Vector *p;
  3824 
  3825   p = allocate_vector (size);
  3826   XSETVECTOR (v, p);
  3827   return v;
  3828 }
  3829 
  3830 /* Like above, but special for sub char-tables.  */
  3831 
  3832 INLINE Lisp_Object
  3833 make_uninit_sub_char_table (int depth, int min_char)
  3834 {
  3835   int slots = SUB_CHAR_TABLE_OFFSET + chartab_size[depth];
  3836   Lisp_Object v = make_uninit_vector (slots);
  3837 
  3838   XSETPVECTYPE (XVECTOR (v), PVEC_SUB_CHAR_TABLE);
  3839   XSUB_CHAR_TABLE (v)->depth = depth;
  3840   XSUB_CHAR_TABLE (v)->min_char = min_char;
  3841   return v;
  3842 }
  3843 
  3844 extern struct Lisp_Vector *allocate_pseudovector (int, int, int,
  3845                                                   enum pvec_type);
  3846 
  3847 /* Allocate partially initialized pseudovector where all Lisp_Object
  3848    slots are set to Qnil but the rest (if any) is left uninitialized.  */
  3849 
  3850 #define ALLOCATE_PSEUDOVECTOR(type, field, tag)                        \
  3851   ((type *) allocate_pseudovector (VECSIZE (type),                     \
  3852                                    PSEUDOVECSIZE (type, field),        \
  3853                                    PSEUDOVECSIZE (type, field), tag))
  3854 
  3855 /* Allocate fully initialized pseudovector where all Lisp_Object
  3856    slots are set to Qnil and the rest (if any) is zeroed.  */
  3857 
  3858 #define ALLOCATE_ZEROED_PSEUDOVECTOR(type, field, tag)                 \
  3859   ((type *) allocate_pseudovector (VECSIZE (type),                     \
  3860                                    PSEUDOVECSIZE (type, field),        \
  3861                                    VECSIZE (type), tag))
  3862 
  3863 extern bool gc_in_progress;
  3864 extern bool abort_on_gc;
  3865 extern Lisp_Object make_float (double);
  3866 extern void display_malloc_warning (void);
  3867 extern ptrdiff_t inhibit_garbage_collection (void);
  3868 extern Lisp_Object make_save_int_int_int (ptrdiff_t, ptrdiff_t, ptrdiff_t);
  3869 extern Lisp_Object make_save_obj_obj_obj_obj (Lisp_Object, Lisp_Object,
  3870                                               Lisp_Object, Lisp_Object);
  3871 extern Lisp_Object make_save_ptr (void *);
  3872 extern Lisp_Object make_save_ptr_int (void *, ptrdiff_t);
  3873 extern Lisp_Object make_save_ptr_ptr (void *, void *);
  3874 extern Lisp_Object make_save_funcptr_ptr_obj (void (*) (void), void *,
  3875                                               Lisp_Object);
  3876 extern Lisp_Object make_save_memory (Lisp_Object *, ptrdiff_t);
  3877 extern void free_save_value (Lisp_Object);
  3878 extern Lisp_Object build_overlay (Lisp_Object, Lisp_Object, Lisp_Object);
  3879 extern void free_marker (Lisp_Object);
  3880 extern void free_cons (struct Lisp_Cons *);
  3881 extern void init_alloc_once (void);
  3882 extern void init_alloc (void);
  3883 extern void syms_of_alloc (void);
  3884 extern struct buffer * allocate_buffer (void);
  3885 extern int valid_lisp_object_p (Lisp_Object);
  3886 extern int relocatable_string_data_p (const char *);
  3887 #ifdef GC_CHECK_CONS_LIST
  3888 extern void check_cons_list (void);
  3889 #else
  3890 INLINE void (check_cons_list) (void) { lisp_h_check_cons_list (); }
  3891 #endif
  3892 
  3893 #ifdef REL_ALLOC
  3894 /* Defined in ralloc.c.  */
  3895 extern void *r_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
  3896 extern void r_alloc_free (void **);
  3897 extern void *r_re_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
  3898 extern void r_alloc_reset_variable (void **, void **);
  3899 extern void r_alloc_inhibit_buffer_relocation (int);
  3900 #endif
  3901 
  3902 /* Defined in chartab.c.  */
  3903 extern Lisp_Object copy_char_table (Lisp_Object);
  3904 extern Lisp_Object char_table_ref_and_range (Lisp_Object, int,
  3905                                              int *, int *);
  3906 extern void char_table_set_range (Lisp_Object, int, int, Lisp_Object);
  3907 extern void map_char_table (void (*) (Lisp_Object, Lisp_Object,
  3908                             Lisp_Object),
  3909                             Lisp_Object, Lisp_Object, Lisp_Object);
  3910 extern void map_char_table_for_charset (void (*c_function) (Lisp_Object, Lisp_Object),
  3911                                         Lisp_Object, Lisp_Object,
  3912                                         Lisp_Object, struct charset *,
  3913                                         unsigned, unsigned);
  3914 extern Lisp_Object uniprop_table (Lisp_Object);
  3915 extern void syms_of_chartab (void);
  3916 
  3917 /* Defined in print.c.  */
  3918 extern Lisp_Object Vprin1_to_string_buffer;
  3919 extern void debug_print (Lisp_Object) EXTERNALLY_VISIBLE;
  3920 extern void temp_output_buffer_setup (const char *);
  3921 extern int print_level;
  3922 extern void write_string (const char *);
  3923 extern void print_error_message (Lisp_Object, Lisp_Object, const char *,
  3924                                  Lisp_Object);
  3925 extern Lisp_Object internal_with_output_to_temp_buffer
  3926         (const char *, Lisp_Object (*) (Lisp_Object), Lisp_Object);
  3927 #define FLOAT_TO_STRING_BUFSIZE 350
  3928 extern int float_to_string (char *, double);
  3929 extern void init_print_once (void);
  3930 extern void syms_of_print (void);
  3931 
  3932 /* Defined in doprnt.c.  */
  3933 extern ptrdiff_t doprnt (char *, ptrdiff_t, const char *, const char *,
  3934                          va_list);
  3935 extern ptrdiff_t esprintf (char *, char const *, ...)
  3936   ATTRIBUTE_FORMAT_PRINTF (2, 3);
  3937 extern ptrdiff_t exprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
  3938                            char const *, ...)
  3939   ATTRIBUTE_FORMAT_PRINTF (5, 6);
  3940 extern ptrdiff_t evxprintf (char **, ptrdiff_t *, char const *, ptrdiff_t,
  3941                             char const *, va_list)
  3942   ATTRIBUTE_FORMAT_PRINTF (5, 0);
  3943 
  3944 /* Defined in lread.c.  */
  3945 extern Lisp_Object check_obarray (Lisp_Object);
  3946 extern Lisp_Object intern_1 (const char *, ptrdiff_t);
  3947 extern Lisp_Object intern_c_string_1 (const char *, ptrdiff_t);
  3948 extern Lisp_Object intern_driver (Lisp_Object, Lisp_Object, Lisp_Object);
  3949 extern void init_symbol (Lisp_Object, Lisp_Object);
  3950 extern Lisp_Object oblookup (Lisp_Object, const char *, ptrdiff_t, ptrdiff_t);
  3951 INLINE void
  3952 LOADHIST_ATTACH (Lisp_Object x)
  3953 {
  3954   if (initialized)
  3955     Vcurrent_load_list = Fcons (x, Vcurrent_load_list);
  3956 }
  3957 extern int openp (Lisp_Object, Lisp_Object, Lisp_Object,
  3958                   Lisp_Object *, Lisp_Object, bool);
  3959 extern Lisp_Object string_to_number (char const *, int, bool);
  3960 extern void map_obarray (Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
  3961                          Lisp_Object);
  3962 extern void dir_warning (const char *, Lisp_Object);
  3963 extern void init_obarray (void);
  3964 extern void init_lread (void);
  3965 extern void syms_of_lread (void);
  3966 
  3967 INLINE Lisp_Object
  3968 intern (const char *str)
  3969 {
  3970   return intern_1 (str, strlen (str));
  3971 }
  3972 
  3973 INLINE Lisp_Object
  3974 intern_c_string (const char *str)
  3975 {
  3976   return intern_c_string_1 (str, strlen (str));
  3977 }
  3978 
  3979 /* Defined in eval.c.  */
  3980 extern EMACS_INT lisp_eval_depth;
  3981 extern Lisp_Object Vautoload_queue;
  3982 extern Lisp_Object Vrun_hooks;
  3983 extern Lisp_Object Vsignaling_function;
  3984 extern Lisp_Object inhibit_lisp_code;
  3985 extern struct handler *handlerlist;
  3986 
  3987 /* To run a normal hook, use the appropriate function from the list below.
  3988    The calling convention:
  3989 
  3990    if (!NILP (Vrun_hooks))
  3991      call1 (Vrun_hooks, Qmy_funny_hook);
  3992 
  3993    should no longer be used.  */
  3994 extern void run_hook (Lisp_Object);
  3995 extern void run_hook_with_args_2 (Lisp_Object, Lisp_Object, Lisp_Object);
  3996 extern Lisp_Object run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args,
  3997                                        Lisp_Object (*funcall)
  3998                                        (ptrdiff_t nargs, Lisp_Object *args));
  3999 extern _Noreturn void xsignal (Lisp_Object, Lisp_Object);
  4000 extern _Noreturn void xsignal0 (Lisp_Object);
  4001 extern _Noreturn void xsignal1 (Lisp_Object, Lisp_Object);
  4002 extern _Noreturn void xsignal2 (Lisp_Object, Lisp_Object, Lisp_Object);
  4003 extern _Noreturn void xsignal3 (Lisp_Object, Lisp_Object, Lisp_Object,
  4004                                 Lisp_Object);
  4005 extern _Noreturn void signal_error (const char *, Lisp_Object);
  4006 extern Lisp_Object eval_sub (Lisp_Object form);
  4007 extern Lisp_Object apply1 (Lisp_Object, Lisp_Object);
  4008 extern Lisp_Object call0 (Lisp_Object);
  4009 extern Lisp_Object call1 (Lisp_Object, Lisp_Object);
  4010 extern Lisp_Object call2 (Lisp_Object, Lisp_Object, Lisp_Object);
  4011 extern Lisp_Object call3 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  4012 extern Lisp_Object call4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  4013 extern Lisp_Object call5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  4014 extern Lisp_Object call6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  4015 extern Lisp_Object call7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  4016 extern Lisp_Object internal_catch (Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object);
  4017 extern Lisp_Object internal_lisp_condition_case (Lisp_Object, Lisp_Object, Lisp_Object);
  4018 extern Lisp_Object internal_condition_case (Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object));
  4019 extern Lisp_Object internal_condition_case_1 (Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object));
  4020 extern Lisp_Object internal_condition_case_2 (Lisp_Object (*) (Lisp_Object, Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object));
  4021 extern Lisp_Object internal_condition_case_n
  4022     (Lisp_Object (*) (ptrdiff_t, Lisp_Object *), ptrdiff_t, Lisp_Object *,
  4023      Lisp_Object, Lisp_Object (*) (Lisp_Object, ptrdiff_t, Lisp_Object *));
  4024 extern void specbind (Lisp_Object, Lisp_Object);
  4025 extern void record_unwind_protect (void (*) (Lisp_Object), Lisp_Object);
  4026 extern void record_unwind_protect_ptr (void (*) (void *), void *);
  4027 extern void record_unwind_protect_int (void (*) (int), int);
  4028 extern void record_unwind_protect_void (void (*) (void));
  4029 extern void record_unwind_protect_nothing (void);
  4030 extern void clear_unwind_protect (ptrdiff_t);
  4031 extern void set_unwind_protect (ptrdiff_t, void (*) (Lisp_Object), Lisp_Object);
  4032 extern void set_unwind_protect_ptr (ptrdiff_t, void (*) (void *), void *);
  4033 extern Lisp_Object unbind_to (ptrdiff_t, Lisp_Object);
  4034 extern _Noreturn void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
  4035 extern _Noreturn void verror (const char *, va_list)
  4036   ATTRIBUTE_FORMAT_PRINTF (1, 0);
  4037 extern void un_autoload (Lisp_Object);
  4038 extern Lisp_Object call_debugger (Lisp_Object arg);
  4039 extern void init_eval_once (void);
  4040 extern Lisp_Object safe_call (ptrdiff_t, Lisp_Object, ...);
  4041 extern Lisp_Object safe_call1 (Lisp_Object, Lisp_Object);
  4042 extern Lisp_Object safe_call2 (Lisp_Object, Lisp_Object, Lisp_Object);
  4043 extern void init_eval (void);
  4044 extern void syms_of_eval (void);
  4045 extern void unwind_body (Lisp_Object);
  4046 extern ptrdiff_t record_in_backtrace (Lisp_Object, Lisp_Object *, ptrdiff_t);
  4047 extern void mark_specpdl (void);
  4048 extern void get_backtrace (Lisp_Object array);
  4049 Lisp_Object backtrace_top_function (void);
  4050 extern bool let_shadows_buffer_binding_p (struct Lisp_Symbol *symbol);
  4051 extern bool let_shadows_global_binding_p (Lisp_Object symbol);
  4052 
  4053 
  4054 /* Defined in editfns.c.  */
  4055 extern void insert1 (Lisp_Object);
  4056 extern Lisp_Object format2 (const char *, Lisp_Object, Lisp_Object);
  4057 extern Lisp_Object save_excursion_save (void);
  4058 extern Lisp_Object save_restriction_save (void);
  4059 extern void save_excursion_restore (Lisp_Object);
  4060 extern void save_restriction_restore (Lisp_Object);
  4061 extern _Noreturn void time_overflow (void);
  4062 extern Lisp_Object make_buffer_string (ptrdiff_t, ptrdiff_t, bool);
  4063 extern Lisp_Object make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
  4064                                             ptrdiff_t, bool);
  4065 extern void init_editfns (void);
  4066 extern void syms_of_editfns (void);
  4067 
  4068 /* Defined in buffer.c.  */
  4069 extern bool mouse_face_overlay_overlaps (Lisp_Object);
  4070 extern _Noreturn void nsberror (Lisp_Object);
  4071 extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
  4072 extern void adjust_overlays_for_delete (ptrdiff_t, ptrdiff_t);
  4073 extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
  4074 extern void report_overlay_modification (Lisp_Object, Lisp_Object, bool,
  4075                                          Lisp_Object, Lisp_Object, Lisp_Object);
  4076 extern bool overlay_touches_p (ptrdiff_t);
  4077 extern Lisp_Object other_buffer_safely (Lisp_Object);
  4078 extern Lisp_Object get_truename_buffer (Lisp_Object);
  4079 extern void init_buffer_once (void);
  4080 extern void init_buffer (int);
  4081 extern void syms_of_buffer (void);
  4082 extern void keys_of_buffer (void);
  4083 
  4084 /* Defined in marker.c.  */
  4085 
  4086 extern ptrdiff_t marker_position (Lisp_Object);
  4087 extern ptrdiff_t marker_byte_position (Lisp_Object);
  4088 extern void clear_charpos_cache (struct buffer *);
  4089 extern ptrdiff_t buf_charpos_to_bytepos (struct buffer *, ptrdiff_t);
  4090 extern ptrdiff_t buf_bytepos_to_charpos (struct buffer *, ptrdiff_t);
  4091 extern void unchain_marker (struct Lisp_Marker *marker);
  4092 extern Lisp_Object set_marker_restricted (Lisp_Object, Lisp_Object, Lisp_Object);
  4093 extern Lisp_Object set_marker_both (Lisp_Object, Lisp_Object, ptrdiff_t, ptrdiff_t);
  4094 extern Lisp_Object set_marker_restricted_both (Lisp_Object, Lisp_Object,
  4095                                                ptrdiff_t, ptrdiff_t);
  4096 extern Lisp_Object build_marker (struct buffer *, ptrdiff_t, ptrdiff_t);
  4097 extern void syms_of_marker (void);
  4098 
  4099 /* Defined in fileio.c.  */
  4100 
  4101 extern Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object);
  4102 extern Lisp_Object write_region (Lisp_Object, Lisp_Object, Lisp_Object,
  4103                                  Lisp_Object, Lisp_Object, Lisp_Object,
  4104                                  Lisp_Object, int);
  4105 extern void close_file_unwind (int);
  4106 extern void fclose_unwind (void *);
  4107 extern void restore_point_unwind (Lisp_Object);
  4108 extern _Noreturn void report_file_errno (const char *, Lisp_Object, int);
  4109 extern _Noreturn void report_file_error (const char *, Lisp_Object);
  4110 extern bool internal_delete_file (Lisp_Object);
  4111 extern Lisp_Object emacs_readlinkat (int, const char *);
  4112 extern bool file_directory_p (const char *);
  4113 extern bool file_accessible_directory_p (Lisp_Object);
  4114 extern void init_fileio (void);
  4115 extern void syms_of_fileio (void);
  4116 extern Lisp_Object make_temp_name (Lisp_Object, bool);
  4117 
  4118 /* Defined in search.c.  */
  4119 extern void shrink_regexp_cache (void);
  4120 extern void restore_search_regs (void);
  4121 extern void record_unwind_save_match_data (void);
  4122 struct re_registers;
  4123 extern struct re_pattern_buffer *compile_pattern (Lisp_Object,
  4124                                                   struct re_registers *,
  4125                                                   Lisp_Object, bool, bool);
  4126 extern ptrdiff_t fast_string_match_internal (Lisp_Object, Lisp_Object,
  4127                                              Lisp_Object);
  4128 
  4129 INLINE ptrdiff_t
  4130 fast_string_match (Lisp_Object regexp, Lisp_Object string)
  4131 {
  4132   return fast_string_match_internal (regexp, string, Qnil);
  4133 }
  4134 
  4135 INLINE ptrdiff_t
  4136 fast_string_match_ignore_case (Lisp_Object regexp, Lisp_Object string)
  4137 {
  4138   return fast_string_match_internal (regexp, string, Vascii_canon_table);
  4139 }
  4140 
  4141 extern ptrdiff_t fast_c_string_match_ignore_case (Lisp_Object, const char *,
  4142                                                   ptrdiff_t);
  4143 extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t,
  4144                                   ptrdiff_t, ptrdiff_t, Lisp_Object);
  4145 extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
  4146                                ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
  4147 extern ptrdiff_t scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
  4148                                ptrdiff_t, bool);
  4149 extern ptrdiff_t scan_newline_from_point (ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
  4150 extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t,
  4151                                        ptrdiff_t, ptrdiff_t *);
  4152 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
  4153                                            ptrdiff_t, ptrdiff_t *);
  4154 extern void syms_of_search (void);
  4155 extern void clear_regexp_cache (void);
  4156 
  4157 /* Defined in minibuf.c.  */
  4158 
  4159 extern Lisp_Object Vminibuffer_list;
  4160 extern Lisp_Object last_minibuf_string;
  4161 extern Lisp_Object get_minibuffer (EMACS_INT);
  4162 extern void init_minibuf_once (void);
  4163 extern void syms_of_minibuf (void);
  4164 
  4165 /* Defined in callint.c.  */
  4166 
  4167 extern void syms_of_callint (void);
  4168 
  4169 /* Defined in casefiddle.c.  */
  4170 
  4171 extern void syms_of_casefiddle (void);
  4172 extern void keys_of_casefiddle (void);
  4173 
  4174 /* Defined in casetab.c.  */
  4175 
  4176 extern void init_casetab_once (void);
  4177 extern void syms_of_casetab (void);
  4178 
  4179 /* Defined in keyboard.c.  */
  4180 
  4181 extern Lisp_Object echo_message_buffer;
  4182 extern struct kboard *echo_kboard;
  4183 extern void cancel_echoing (void);
  4184 extern Lisp_Object last_undo_boundary;
  4185 extern bool input_pending;
  4186 #ifdef HAVE_STACK_OVERFLOW_HANDLING
  4187 extern sigjmp_buf return_to_command_loop;
  4188 #endif
  4189 extern Lisp_Object menu_bar_items (Lisp_Object);
  4190 extern Lisp_Object tool_bar_items (Lisp_Object, int *);
  4191 extern void discard_mouse_events (void);
  4192 #ifdef USABLE_SIGIO
  4193 void handle_input_available_signal (int);
  4194 #endif
  4195 extern Lisp_Object pending_funcalls;
  4196 extern bool detect_input_pending (void);
  4197 extern bool detect_input_pending_ignore_squeezables (void);
  4198 extern bool detect_input_pending_run_timers (bool);
  4199 extern void safe_run_hooks (Lisp_Object);
  4200 extern void cmd_error_internal (Lisp_Object, const char *);
  4201 extern Lisp_Object command_loop_1 (void);
  4202 extern Lisp_Object read_menu_command (void);
  4203 extern Lisp_Object recursive_edit_1 (void);
  4204 extern void record_auto_save (void);
  4205 extern void force_auto_save_soon (void);
  4206 extern void init_keyboard (void);
  4207 extern void syms_of_keyboard (void);
  4208 extern void keys_of_keyboard (void);
  4209 
  4210 /* Defined in indent.c.  */
  4211 extern ptrdiff_t current_column (void);
  4212 extern void invalidate_current_column (void);
  4213 extern bool indented_beyond_p (ptrdiff_t, ptrdiff_t, EMACS_INT);
  4214 extern void syms_of_indent (void);
  4215 
  4216 /* Defined in frame.c.  */
  4217 extern void store_frame_param (struct frame *, Lisp_Object, Lisp_Object);
  4218 extern void store_in_alist (Lisp_Object *, Lisp_Object, Lisp_Object);
  4219 extern Lisp_Object do_switch_frame (Lisp_Object, int, int, Lisp_Object);
  4220 extern Lisp_Object get_frame_param (struct frame *, Lisp_Object);
  4221 extern void frames_discard_buffer (Lisp_Object);
  4222 extern void syms_of_frame (void);
  4223 
  4224 /* Defined in emacs.c.  */
  4225 extern char **initial_argv;
  4226 extern int initial_argc;
  4227 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS)
  4228 extern bool display_arg;
  4229 #endif
  4230 extern Lisp_Object decode_env_path (const char *, const char *, bool);
  4231 extern Lisp_Object empty_unibyte_string, empty_multibyte_string;
  4232 extern _Noreturn void terminate_due_to_signal (int, int);
  4233 #ifdef WINDOWSNT
  4234 extern Lisp_Object Vlibrary_cache;
  4235 #endif
  4236 #if HAVE_SETLOCALE
  4237 void fixup_locale (void);
  4238 void synchronize_system_messages_locale (void);
  4239 void synchronize_system_time_locale (void);
  4240 #else
  4241 INLINE void fixup_locale (void) {}
  4242 INLINE void synchronize_system_messages_locale (void) {}
  4243 INLINE void synchronize_system_time_locale (void) {}
  4244 #endif
  4245 extern void shut_down_emacs (int, Lisp_Object);
  4246 
  4247 /* True means don't do interactive redisplay and don't change tty modes.  */
  4248 extern bool noninteractive;
  4249 
  4250 /* True means remove site-lisp directories from load-path.  */
  4251 extern bool no_site_lisp;
  4252 
  4253 /* Pipe used to send exit notification to the daemon parent at
  4254    startup.  On Windows, we use a kernel event instead.  */
  4255 #ifndef WINDOWSNT
  4256 extern int daemon_pipe[2];
  4257 #define IS_DAEMON (daemon_pipe[1] != 0)
  4258 #define DAEMON_RUNNING (daemon_pipe[1] >= 0)
  4259 #else  /* WINDOWSNT */
  4260 extern void *w32_daemon_event;
  4261 #define IS_DAEMON (w32_daemon_event != NULL)
  4262 #define DAEMON_RUNNING (w32_daemon_event != INVALID_HANDLE_VALUE)
  4263 #endif
  4264 
  4265 /* True if handling a fatal error already.  */
  4266 extern bool fatal_error_in_progress;
  4267 
  4268 /* True means don't do use window-system-specific display code.  */
  4269 extern bool inhibit_window_system;
  4270 /* True means that a filter or a sentinel is running.  */
  4271 extern bool running_asynch_code;
  4272 
  4273 /* Defined in process.c.  */
  4274 extern void kill_buffer_processes (Lisp_Object);
  4275 extern int wait_reading_process_output (intmax_t, int, int, bool, Lisp_Object,
  4276                                         struct Lisp_Process *, int);
  4277 /* Max value for the first argument of wait_reading_process_output.  */
  4278 #if __GNUC__ == 3 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 5)
  4279 /* Work around a bug in GCC 3.4.2, known to be fixed in GCC 4.6.3.
  4280    The bug merely causes a bogus warning, but the warning is annoying.  */
  4281 # define WAIT_READING_MAX min (TYPE_MAXIMUM (time_t), INTMAX_MAX)
  4282 #else
  4283 # define WAIT_READING_MAX INTMAX_MAX
  4284 #endif
  4285 #ifdef HAVE_TIMERFD
  4286 extern void add_timer_wait_descriptor (int);
  4287 #endif
  4288 extern void add_keyboard_wait_descriptor (int);
  4289 extern void delete_keyboard_wait_descriptor (int);
  4290 #ifdef HAVE_GPM
  4291 extern void add_gpm_wait_descriptor (int);
  4292 extern void delete_gpm_wait_descriptor (int);
  4293 #endif
  4294 extern void init_process_emacs (void);
  4295 extern void syms_of_process (void);
  4296 extern void setup_process_coding_systems (Lisp_Object);
  4297 
  4298 /* Defined in callproc.c.  */
  4299 #ifndef DOS_NT
  4300  _Noreturn
  4301 #endif
  4302 extern int child_setup (int, int, int, char **, bool, Lisp_Object);
  4303 extern void init_callproc_1 (void);
  4304 extern void init_callproc (void);
  4305 extern void set_initial_environment (void);
  4306 extern void syms_of_callproc (void);
  4307 
  4308 /* Defined in doc.c.  */
  4309 extern Lisp_Object read_doc_string (Lisp_Object);
  4310 extern Lisp_Object get_doc_string (Lisp_Object, bool, bool);
  4311 extern void syms_of_doc (void);
  4312 extern int read_bytecode_char (bool);
  4313 
  4314 /* Defined in bytecode.c.  */
  4315 extern void syms_of_bytecode (void);
  4316 extern struct byte_stack *byte_stack_list;
  4317 #if BYTE_MARK_STACK
  4318 extern void mark_byte_stack (void);
  4319 #endif
  4320 extern void unmark_byte_stack (void);
  4321 extern Lisp_Object exec_byte_code (Lisp_Object, Lisp_Object, Lisp_Object,
  4322                                    Lisp_Object, ptrdiff_t, Lisp_Object *);
  4323 
  4324 /* Defined in macros.c.  */
  4325 extern void init_macros (void);
  4326 extern void syms_of_macros (void);
  4327 
  4328 /* Defined in undo.c.  */
  4329 extern void truncate_undo_list (struct buffer *);
  4330 extern void record_insert (ptrdiff_t, ptrdiff_t);
  4331 extern void record_delete (ptrdiff_t, Lisp_Object, bool);
  4332 extern void record_first_change (void);
  4333 extern void record_change (ptrdiff_t, ptrdiff_t);
  4334 extern void record_property_change (ptrdiff_t, ptrdiff_t,
  4335                                     Lisp_Object, Lisp_Object,
  4336                                     Lisp_Object);
  4337 extern void syms_of_undo (void);
  4338 
  4339 /* Defined in textprop.c.  */
  4340 extern void report_interval_modification (Lisp_Object, Lisp_Object);
  4341 
  4342 /* Defined in menu.c.  */
  4343 extern void syms_of_menu (void);
  4344 
  4345 /* Defined in xmenu.c.  */
  4346 extern void syms_of_xmenu (void);
  4347 
  4348 /* Defined in termchar.h.  */
  4349 struct tty_display_info;
  4350 
  4351 /* Defined in termhooks.h.  */
  4352 struct terminal;
  4353 
  4354 /* Defined in sysdep.c.  */
  4355 #ifndef HAVE_GET_CURRENT_DIR_NAME
  4356 extern char *get_current_dir_name (void);
  4357 #endif
  4358 extern void stuff_char (char c);
  4359 extern void init_foreground_group (void);
  4360 extern void sys_subshell (void);
  4361 extern void sys_suspend (void);
  4362 extern void discard_tty_input (void);
  4363 extern void init_sys_modes (struct tty_display_info *);
  4364 extern void reset_sys_modes (struct tty_display_info *);
  4365 extern void init_all_sys_modes (void);
  4366 extern void reset_all_sys_modes (void);
  4367 extern void child_setup_tty (int);
  4368 extern void setup_pty (int);
  4369 extern int set_window_size (int, int, int);
  4370 extern EMACS_INT get_random (void);
  4371 extern void seed_random (void *, ptrdiff_t);
  4372 extern void init_random (void);
  4373 extern void emacs_backtrace (int);
  4374 extern _Noreturn void emacs_abort (void) NO_INLINE;
  4375 extern int emacs_open (const char *, int, int);
  4376 extern int emacs_pipe (int[2]);
  4377 extern int emacs_close (int);
  4378 extern ptrdiff_t emacs_read (int, void *, ptrdiff_t);
  4379 extern ptrdiff_t emacs_write (int, void const *, ptrdiff_t);
  4380 extern ptrdiff_t emacs_write_sig (int, void const *, ptrdiff_t);
  4381 extern void emacs_perror (char const *);
  4382 
  4383 extern void unlock_all_files (void);
  4384 extern void lock_file (Lisp_Object);
  4385 extern void unlock_file (Lisp_Object);
  4386 extern void unlock_buffer (struct buffer *);
  4387 extern void syms_of_filelock (void);
  4388 extern int str_collate (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
  4389 
  4390 /* Defined in sound.c.  */
  4391 extern void syms_of_sound (void);
  4392 
  4393 /* Defined in category.c.  */
  4394 extern void init_category_once (void);
  4395 extern Lisp_Object char_category_set (int);
  4396 extern void syms_of_category (void);
  4397 
  4398 /* Defined in ccl.c.  */
  4399 extern void syms_of_ccl (void);
  4400 
  4401 /* Defined in dired.c.  */
  4402 extern void syms_of_dired (void);
  4403 extern Lisp_Object directory_files_internal (Lisp_Object, Lisp_Object,
  4404                                              Lisp_Object, Lisp_Object,
  4405                                              bool, Lisp_Object);
  4406 
  4407 /* Defined in term.c.  */
  4408 extern int *char_ins_del_vector;
  4409 extern void syms_of_term (void);
  4410 extern _Noreturn void fatal (const char *msgid, ...)
  4411   ATTRIBUTE_FORMAT_PRINTF (1, 2);
  4412 
  4413 /* Defined in terminal.c.  */
  4414 extern void syms_of_terminal (void);
  4415 
  4416 /* Defined in font.c.  */
  4417 extern void syms_of_font (void);
  4418 extern void init_font (void);
  4419 
  4420 #ifdef HAVE_WINDOW_SYSTEM
  4421 /* Defined in fontset.c.  */
  4422 extern void syms_of_fontset (void);
  4423 #endif
  4424 
  4425 /* Defined in gfilenotify.c */
  4426 #ifdef HAVE_GFILENOTIFY
  4427 extern void globals_of_gfilenotify (void);
  4428 extern void syms_of_gfilenotify (void);
  4429 #endif
  4430 
  4431 /* Defined in inotify.c */
  4432 #ifdef HAVE_INOTIFY
  4433 extern void syms_of_inotify (void);
  4434 #endif
  4435 
  4436 #ifdef HAVE_W32NOTIFY
  4437 /* Defined on w32notify.c.  */
  4438 extern void syms_of_w32notify (void);
  4439 #endif
  4440 
  4441 /* Defined in xfaces.c.  */
  4442 extern Lisp_Object Vface_alternative_font_family_alist;
  4443 extern Lisp_Object Vface_alternative_font_registry_alist;
  4444 extern void syms_of_xfaces (void);
  4445 
  4446 #ifdef HAVE_X_WINDOWS
  4447 /* Defined in xfns.c.  */
  4448 extern void syms_of_xfns (void);
  4449 
  4450 /* Defined in xsmfns.c.  */
  4451 extern void syms_of_xsmfns (void);
  4452 
  4453 /* Defined in xselect.c.  */
  4454 extern void syms_of_xselect (void);
  4455 
  4456 /* Defined in xterm.c.  */
  4457 extern void init_xterm (void);
  4458 extern void syms_of_xterm (void);
  4459 #endif /* HAVE_X_WINDOWS */
  4460 
  4461 #ifdef HAVE_WINDOW_SYSTEM
  4462 /* Defined in xterm.c, nsterm.m, w32term.c.  */
  4463 extern char *x_get_keysym_name (int);
  4464 #endif /* HAVE_WINDOW_SYSTEM */
  4465 
  4466 #ifdef HAVE_LIBXML2
  4467 /* Defined in xml.c.  */
  4468 extern void syms_of_xml (void);
  4469 extern void xml_cleanup_parser (void);
  4470 #endif
  4471 
  4472 #ifdef HAVE_ZLIB
  4473 /* Defined in decompress.c.  */
  4474 extern void syms_of_decompress (void);
  4475 #endif
  4476 
  4477 #ifdef HAVE_DBUS
  4478 /* Defined in dbusbind.c.  */
  4479 void init_dbusbind (void);
  4480 void syms_of_dbusbind (void);
  4481 #endif
  4482 
  4483 
  4484 /* Defined in profiler.c.  */
  4485 extern bool profiler_memory_running;
  4486 extern void malloc_probe (size_t);
  4487 extern void syms_of_profiler (void);
  4488 
  4489 
  4490 #ifdef DOS_NT
  4491 /* Defined in msdos.c, w32.c.  */
  4492 extern char *emacs_root_dir (void);
  4493 #endif /* DOS_NT */
  4494 
  4495 /* Defined in lastfile.c.  */
  4496 extern char my_edata[];
  4497 extern char my_endbss[];
  4498 extern char *my_endbss_static;
  4499 
  4500 /* True means ^G can quit instantly.  */
  4501 extern bool immediate_quit;
  4502 
  4503 extern void *xmalloc (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
  4504 extern void *xzalloc (size_t) ATTRIBUTE_MALLOC_SIZE ((1));
  4505 extern void *xrealloc (void *, size_t) ATTRIBUTE_ALLOC_SIZE ((2));
  4506 extern void xfree (void *);
  4507 extern void *xnmalloc (ptrdiff_t, ptrdiff_t) ATTRIBUTE_MALLOC_SIZE ((1,2));
  4508 extern void *xnrealloc (void *, ptrdiff_t, ptrdiff_t)
  4509   ATTRIBUTE_ALLOC_SIZE ((2,3));
  4510 extern void *xpalloc (void *, ptrdiff_t *, ptrdiff_t, ptrdiff_t, ptrdiff_t);
  4511 
  4512 extern char *xstrdup (const char *) ATTRIBUTE_MALLOC;
  4513 extern char *xlispstrdup (Lisp_Object) ATTRIBUTE_MALLOC;
  4514 extern void dupstring (char **, char const *);
  4515 
  4516 /* Make DEST a copy of STRING's data.  Return a pointer to DEST's terminating
  4517    null byte.  This is like stpcpy, except the source is a Lisp string.  */
  4518 
  4519 INLINE char *
  4520 lispstpcpy (char *dest, Lisp_Object string)
  4521 {
  4522   ptrdiff_t len = SBYTES (string);
  4523   memcpy (dest, SDATA (string), len + 1);
  4524   return dest + len;
  4525 }
  4526 
  4527 extern void xputenv (const char *);
  4528 
  4529 extern char *egetenv_internal (const char *, ptrdiff_t);
  4530 
  4531 INLINE char *
  4532 egetenv (const char *var)
  4533 {
  4534   /* When VAR is a string literal, strlen can be optimized away.  */
  4535   return egetenv_internal (var, strlen (var));
  4536 }
  4537 
  4538 /* Set up the name of the machine we're running on.  */
  4539 extern void init_system_name (void);
  4540 
  4541 /* Return the absolute value of X.  X should be a signed integer
  4542    expression without side effects, and X's absolute value should not
  4543    exceed the maximum for its promoted type.  This is called 'eabs'
  4544    because 'abs' is reserved by the C standard.  */
  4545 #define eabs(x)         ((x) < 0 ? -(x) : (x))
  4546 
  4547 /* Return a fixnum or float, depending on whether VAL fits in a Lisp
  4548    fixnum.  */
  4549 
  4550 #define make_fixnum_or_float(val) \
  4551    (FIXNUM_OVERFLOW_P (val) ? make_float (val) : make_number (val))
  4552 
  4553 /* SAFE_ALLOCA normally allocates memory on the stack, but if size is
  4554    larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack.  */
  4555 
  4556 enum MAX_ALLOCA { MAX_ALLOCA = 16 * 1024 };
  4557 
  4558 extern void *record_xmalloc (size_t) ATTRIBUTE_ALLOC_SIZE ((1));
  4559 
  4560 #define USE_SAFE_ALLOCA                 \
  4561   ptrdiff_t sa_avail = MAX_ALLOCA;      \
  4562   ptrdiff_t sa_count = SPECPDL_INDEX (); bool sa_must_free = false
  4563 
  4564 #define AVAIL_ALLOCA(size) (sa_avail -= (size), alloca (size))
  4565 
  4566 /* SAFE_ALLOCA allocates a simple buffer.  */
  4567 
  4568 #define SAFE_ALLOCA(size) ((size) <= sa_avail                           \
  4569                            ? AVAIL_ALLOCA (size)                        \
  4570                            : (sa_must_free = true, record_xmalloc (size)))
  4571 
  4572 /* SAFE_NALLOCA sets BUF to a newly allocated array of MULTIPLIER *
  4573    NITEMS items, each of the same type as *BUF.  MULTIPLIER must
  4574    positive.  The code is tuned for MULTIPLIER being a constant.  */
  4575 
  4576 #define SAFE_NALLOCA(buf, multiplier, nitems)                    \
  4577   do {                                                           \
  4578     if ((nitems) <= sa_avail / sizeof *(buf) / (multiplier))     \
  4579       (buf) = AVAIL_ALLOCA (sizeof *(buf) * (multiplier) * (nitems)); \
  4580     else                                                         \
  4581       {                                                          \
  4582         (buf) = xnmalloc (nitems, sizeof *(buf) * (multiplier)); \
  4583         sa_must_free = true;                                     \
  4584         record_unwind_protect_ptr (xfree, buf);                  \
  4585       }                                                          \
  4586   } while (false)
  4587 
  4588 /* SAFE_ALLOCA_STRING allocates a C copy of a Lisp string.  */
  4589 
  4590 #define SAFE_ALLOCA_STRING(ptr, string)                 \
  4591   do {                                                  \
  4592     (ptr) = SAFE_ALLOCA (SBYTES (string) + 1);          \
  4593     memcpy (ptr, SDATA (string), SBYTES (string) + 1);  \
  4594   } while (false)
  4595 
  4596 /* SAFE_FREE frees xmalloced memory and enables GC as needed.  */
  4597 
  4598 #define SAFE_FREE()                     \
  4599   do {                                  \
  4600     if (sa_must_free) {                 \
  4601       sa_must_free = false;             \
  4602       unbind_to (sa_count, Qnil);       \
  4603     }                                   \
  4604   } while (false)
  4605 
  4606 
  4607 /* Return floor (NBYTES / WORD_SIZE).  */
  4608 
  4609 INLINE ptrdiff_t
  4610 lisp_word_count (ptrdiff_t nbytes)
  4611 {
  4612   if (-1 >> 1 == -1)
  4613     switch (word_size)
  4614       {
  4615       case 2: return nbytes >> 1;
  4616       case 4: return nbytes >> 2;
  4617       case 8: return nbytes >> 3;
  4618       case 16: return nbytes >> 4;
  4619       }
  4620   return nbytes / word_size - (nbytes % word_size < 0);
  4621 }
  4622 
  4623 /* SAFE_ALLOCA_LISP allocates an array of Lisp_Objects.  */
  4624 
  4625 #define SAFE_ALLOCA_LISP(buf, nelt)                            \
  4626   do {                                                         \
  4627     if ((nelt) <= lisp_word_count (sa_avail))                  \
  4628       (buf) = AVAIL_ALLOCA ((nelt) * word_size);               \
  4629     else if ((nelt) <= min (PTRDIFF_MAX, SIZE_MAX) / word_size) \
  4630       {                                                        \
  4631         Lisp_Object arg_;                                      \
  4632         (buf) = xmalloc ((nelt) * word_size);                  \
  4633         arg_ = make_save_memory (buf, nelt);                   \
  4634         sa_must_free = true;                                   \
  4635         record_unwind_protect (free_save_value, arg_);         \
  4636       }                                                        \
  4637     else                                                       \
  4638       memory_full (SIZE_MAX);                                  \
  4639   } while (false)
  4640 
  4641 
  4642 /* If USE_STACK_LISP_OBJECTS, define macros that and functions that allocate
  4643    block-scoped conses and strings.  These objects are not
  4644    managed by the garbage collector, so they are dangerous: passing them
  4645    out of their scope (e.g., to user code) results in undefined behavior.
  4646    Conversely, they have better performance because GC is not involved.
  4647 
  4648    This feature is experimental and requires careful debugging.
  4649    Build with CPPFLAGS='-DUSE_STACK_LISP_OBJECTS=0' to disable it.  */
  4650 
  4651 #ifndef USE_STACK_LISP_OBJECTS
  4652 # define USE_STACK_LISP_OBJECTS true
  4653 #endif
  4654 
  4655 /* USE_STACK_LISP_OBJECTS requires GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS.  */
  4656 
  4657 #if GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS
  4658 # undef USE_STACK_LISP_OBJECTS
  4659 # define USE_STACK_LISP_OBJECTS false
  4660 #endif
  4661 
  4662 #ifdef GC_CHECK_STRING_BYTES
  4663 enum { defined_GC_CHECK_STRING_BYTES = true };
  4664 #else
  4665 enum { defined_GC_CHECK_STRING_BYTES = false };
  4666 #endif
  4667 
  4668 /* Struct inside unions that are typically no larger and aligned enough.  */
  4669 
  4670 union Aligned_Cons
  4671 {
  4672   struct Lisp_Cons s;
  4673   double d; intmax_t i; void *p;
  4674 };
  4675 
  4676 union Aligned_String
  4677 {
  4678   struct Lisp_String s;
  4679   double d; intmax_t i; void *p;
  4680 };
  4681 
  4682 /* True for stack-based cons and string implementations, respectively.
  4683    Use stack-based strings only if stack-based cons also works.
  4684    Otherwise, STACK_CONS would create heap-based cons cells that
  4685    could point to stack-based strings, which is a no-no.  */
  4686 
  4687 enum
  4688   {
  4689     USE_STACK_CONS = (USE_STACK_LISP_OBJECTS
  4690                       && alignof (union Aligned_Cons) % GCALIGNMENT == 0),
  4691     USE_STACK_STRING = (USE_STACK_CONS
  4692                         && !defined_GC_CHECK_STRING_BYTES
  4693                         && alignof (union Aligned_String) % GCALIGNMENT == 0)
  4694   };
  4695 
  4696 /* Auxiliary macros used for auto allocation of Lisp objects.  Please
  4697    use these only in macros like AUTO_CONS that declare a local
  4698    variable whose lifetime will be clear to the programmer.  */
  4699 #define STACK_CONS(a, b) \
  4700   make_lisp_ptr (&(union Aligned_Cons) { { a, { b } } }.s, Lisp_Cons)
  4701 #define AUTO_CONS_EXPR(a, b) \
  4702   (USE_STACK_CONS ? STACK_CONS (a, b) : Fcons (a, b))
  4703 
  4704 /* Declare NAME as an auto Lisp cons or short list if possible, a
  4705    GC-based one otherwise.  This is in the sense of the C keyword
  4706    'auto'; i.e., the object has the lifetime of the containing block.
  4707    The resulting object should not be made visible to user Lisp code.  */
  4708 
  4709 #define AUTO_CONS(name, a, b) Lisp_Object name = AUTO_CONS_EXPR (a, b)
  4710 #define AUTO_LIST1(name, a)                                             \
  4711   Lisp_Object name = (USE_STACK_CONS ? STACK_CONS (a, Qnil) : list1 (a))
  4712 #define AUTO_LIST2(name, a, b)                                          \
  4713   Lisp_Object name = (USE_STACK_CONS                                    \
  4714                       ? STACK_CONS (a, STACK_CONS (b, Qnil))            \
  4715                       : list2 (a, b))
  4716 #define AUTO_LIST3(name, a, b, c)                                       \
  4717   Lisp_Object name = (USE_STACK_CONS                                    \
  4718                       ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c, Qnil))) \
  4719                       : list3 (a, b, c))
  4720 #define AUTO_LIST4(name, a, b, c, d)                                    \
  4721     Lisp_Object name                                                    \
  4722       = (USE_STACK_CONS                                                 \
  4723          ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c,                 \
  4724                                                      STACK_CONS (d, Qnil)))) \
  4725          : list4 (a, b, c, d))
  4726 
  4727 /* Check whether stack-allocated strings are ASCII-only.  */
  4728 
  4729 #if defined (ENABLE_CHECKING) && USE_STACK_LISP_OBJECTS
  4730 extern const char *verify_ascii (const char *);
  4731 #else
  4732 # define verify_ascii(str) (str)
  4733 #endif
  4734 
  4735 /* Declare NAME as an auto Lisp string if possible, a GC-based one if not.
  4736    Take its value from STR.  STR is not necessarily copied and should
  4737    contain only ASCII characters.  The resulting Lisp string should
  4738    not be modified or made visible to user code.  */
  4739 
  4740 #define AUTO_STRING(name, str)                                          \
  4741   Lisp_Object name =                                                    \
  4742     (USE_STACK_STRING                                                   \
  4743      ? (make_lisp_ptr                                                   \
  4744         ((&(union Aligned_String)                                       \
  4745           {{strlen (str), -1, 0, (unsigned char *) verify_ascii (str)}}.s), \
  4746           Lisp_String))                                                 \
  4747      : build_string (verify_ascii (str)))
  4748 
  4749 /* Loop over all tails of a list, checking for cycles.
  4750    FIXME: Make tortoise and n internal declarations.
  4751    FIXME: Unroll the loop body so we don't need `n'.  */
  4752 #define FOR_EACH_TAIL(hare, list, tortoise, n)  \
  4753   for ((tortoise) = (hare) = (list), (n) = true;                \
  4754        CONSP (hare);                                            \
  4755        (hare = XCDR (hare), (n) = !(n),                         \
  4756         ((n)                                                    \
  4757          ? (EQ (hare, tortoise)                                 \
  4758             ? xsignal1 (Qcircular_list, list)                   \
  4759             : (void) 0)                                         \
  4760          /* Move tortoise before the next iteration, in case */ \
  4761          /* the next iteration does an Fsetcdr.  */             \
  4762          : (void) ((tortoise) = XCDR (tortoise)))))
  4763 
  4764 /* Do a `for' loop over alist values.  */
  4765 
  4766 #define FOR_EACH_ALIST_VALUE(head_var, list_var, value_var)             \
  4767   for ((list_var) = (head_var);                                         \
  4768        (CONSP (list_var) && ((value_var) = XCDR (XCAR (list_var)), true)); \
  4769        (list_var) = XCDR (list_var))
  4770 
  4771 /* Check whether it's time for GC, and run it if so.  */
  4772 
  4773 INLINE void
  4774 maybe_gc (void)
  4775 {
  4776   if ((consing_since_gc > gc_cons_threshold
  4777        && consing_since_gc > gc_relative_threshold)
  4778       || (!NILP (Vmemory_full)
  4779           && consing_since_gc > memory_full_cons_threshold))
  4780     Fgarbage_collect ();
  4781 }
  4782 
  4783 INLINE bool
  4784 functionp (Lisp_Object object)
  4785 {
  4786   if (SYMBOLP (object) && !NILP (Ffboundp (object)))
  4787     {
  4788       object = Findirect_function (object, Qt);
  4789 
  4790       if (CONSP (object) && EQ (XCAR (object), Qautoload))
  4791         {
  4792           /* Autoloaded symbols are functions, except if they load
  4793              macros or keymaps.  */
  4794           int i;
  4795           for (i = 0; i < 4 && CONSP (object); i++)
  4796             object = XCDR (object);
  4797 
  4798           return ! (CONSP (object) && !NILP (XCAR (object)));
  4799         }
  4800     }
  4801 
  4802   if (SUBRP (object))
  4803     return XSUBR (object)->max_args != UNEVALLED;
  4804   else if (COMPILEDP (object))
  4805     return true;
  4806   else if (CONSP (object))
  4807     {
  4808       Lisp_Object car = XCAR (object);
  4809       return EQ (car, Qlambda) || EQ (car, Qclosure);
  4810     }
  4811   else
  4812     return false;
  4813 }
  4814 
  4815 INLINE_HEADER_END
  4816 
  4817 #endif /* EMACS_LISP_H */
/* [<][>][^][v][top][bottom][index][help] */
root/test/manual/etags/c-src/emacs/src/lisp.h

INCLUDED FROM

DEFINITIONS
