/* Fundamental definitions for GNU Emacs Lisp interpreter.
Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#define EMACS_LISP_H
/* Declare the prototype for a general external function. */
-#if defined (PROTOTYPES) || defined (WINDOWSNT)
#define P_(proto) proto
-#else
-#define P_(proto) ()
-#endif
-
-#if 0
-/* Define this temporarily to hunt a bug. If defined, the size of
- strings is redundantly recorded in sdata structures so that it can
- be compared to the sizes recorded in Lisp strings. */
-
-#define GC_CHECK_STRING_BYTES 1
-
-/* Define this to check for short string overrun. */
-
-#define GC_CHECK_STRING_OVERRUN 1
-
-/* Define this to check the string free list. */
-#define GC_CHECK_STRING_FREE_LIST 1
-
-/* Define this to check for malloc buffer overrun. */
-
-#define XMALLOC_OVERRUN_CHECK 1
-
-/* Define this to check for errors in cons list. */
-/* #define GC_CHECK_CONS_LIST 1 */
-
-#endif /* 0 */
+/* Use the configure flag --enable-checking[=LIST] to enable various
+ types of run time checks for Lisp objects. */
#ifdef GC_CHECK_CONS_LIST
#define CHECK_CONS_LIST() check_cons_list()
#if defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ || defined DARWIN_OS
/* We also need to be able to specify mult-of-8 alignment on static vars. */
# if defined DECL_ALIGN
-/* We currently do not support USE_LSB_TAG with a union Lisp_Object. */
-# ifndef USE_LISP_UNION_TYPE
-# define USE_LSB_TAG
-# endif
+# define USE_LSB_TAG
# endif
#endif
/* Define the fundamental Lisp data structures. */
+/* If USE_2_TAGBITS_FOR_INTS is defined, then Lisp integers use
+ 2 tags, to give them one extra bit, thus extending their range from
+ e.g -2^28..2^28-1 to -2^29..2^29-1. */
+#define USE_2_TAGS_FOR_INTS
+
+/* Making it work for the union case is too much trouble. */
+#ifdef USE_LISP_UNION_TYPE
+# undef USE_2_TAGS_FOR_INTS
+#endif
+
/* This is the set of Lisp data types. */
+#if !defined USE_2_TAGS_FOR_INTS
+# define LISP_INT_TAG Lisp_Int
+# define case_Lisp_Int case Lisp_Int
+# define LISP_STRING_TAG 4
+# define LISP_INT_TAG_P(x) ((x) == Lisp_Int)
+#else
+# define LISP_INT_TAG Lisp_Int0
+# define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
+# ifdef USE_LSB_TAG
+# define LISP_INT1_TAG 4
+# define LISP_STRING_TAG 1
+# define LISP_INT_TAG_P(x) (((x) & 3) == 0)
+# else
+# define LISP_INT1_TAG 1
+# define LISP_STRING_TAG 4
+# define LISP_INT_TAG_P(x) (((x) & 6) == 0)
+# endif
+#endif
+
enum Lisp_Type
{
/* Integer. XINT (obj) is the integer value. */
- Lisp_Int,
+#ifdef USE_2_TAGS_FOR_INTS
+ Lisp_Int0 = 0,
+ Lisp_Int1 = LISP_INT1_TAG,
+#else
+ Lisp_Int = 0,
+#endif
/* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
- Lisp_Symbol,
+ Lisp_Symbol = 2,
/* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
whose first member indicates the subtype. */
- Lisp_Misc,
+ Lisp_Misc = 3,
/* String. XSTRING (object) points to a struct Lisp_String.
The length of the string, and its contents, are stored therein. */
- Lisp_String,
+ Lisp_String = LISP_STRING_TAG,
/* Vector of Lisp objects, or something resembling it.
XVECTOR (object) points to a struct Lisp_Vector, which contains
the size and contents. The size field also contains the type
information, if it's not a real vector object. */
- Lisp_Vectorlike,
+ Lisp_Vectorlike = 5,
/* Cons. XCONS (object) points to a struct Lisp_Cons. */
- Lisp_Cons,
+ Lisp_Cons = 6,
- Lisp_Float,
-
- /* This is not a type code. It is for range checking. */
- Lisp_Type_Limit
+ Lisp_Float = 7,
};
/* This is the set of data types that share a common structure.
#define TYPEMASK ((((EMACS_INT) 1) << GCTYPEBITS) - 1)
#define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) & TYPEMASK))
-#define XINT(a) (((EMACS_INT) (a)) >> GCTYPEBITS)
-#define XUINT(a) (((EMACS_UINT) (a)) >> GCTYPEBITS)
+#ifdef USE_2_TAGS_FOR_INTS
+# define XINT(a) (((EMACS_INT) (a)) >> (GCTYPEBITS - 1))
+# define XUINT(a) (((EMACS_UINT) (a)) >> (GCTYPEBITS - 1))
+# define make_number(N) (((EMACS_INT) (N)) << (GCTYPEBITS - 1))
+#else
+# define XINT(a) (((EMACS_INT) (a)) >> GCTYPEBITS)
+# define XUINT(a) (((EMACS_UINT) (a)) >> GCTYPEBITS)
+# define make_number(N) (((EMACS_INT) (N)) << GCTYPEBITS)
+#endif
#define XSET(var, type, ptr) \
(eassert (XTYPE (ptr) == 0), /* Check alignment. */ \
(var) = ((EMACS_INT) (type)) | ((EMACS_INT) (ptr)))
-#define make_number(N) (((EMACS_INT) (N)) << GCTYPEBITS)
-
-/* XFASTINT and XSETFASTINT are for use when the integer is known to be
- positive, in which case the implementation can sometimes be faster
- depending on the tagging scheme. With USE_LSB_TAG, there's no benefit. */
-#define XFASTINT(a) XINT (a)
-#define XSETFASTINT(a, b) ((a) = make_number (b))
#define XPNTR(a) ((EMACS_INT) ((a) & ~TYPEMASK))
#define XFASTINT(a) ((a) + 0)
#define XSETFASTINT(a, b) ((a) = (b))
-/* Extract the value of a Lisp_Object as a signed integer. */
+/* Extract the value of a Lisp_Object as a (un)signed integer. */
-#ifndef XINT /* Some machines need to do this differently. */
-#define XINT(a) ((((EMACS_INT) (a)) << (BITS_PER_EMACS_INT - VALBITS)) \
+#ifdef USE_2_TAGS_FOR_INTS
+# define XINT(a) ((((EMACS_INT) (a)) << (GCTYPEBITS - 1)) >> (GCTYPEBITS - 1))
+# define XUINT(a) ((EMACS_UINT) ((a) & (1 + (VALMASK << 1))))
+# define make_number(N) ((((EMACS_INT) (N)) & (1 + (VALMASK << 1))))
+#else
+# define XINT(a) ((((EMACS_INT) (a)) << (BITS_PER_EMACS_INT - VALBITS)) \
>> (BITS_PER_EMACS_INT - VALBITS))
+# define XUINT(a) ((EMACS_UINT) ((a) & VALMASK))
+# define make_number(N) \
+ ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
#endif
-/* Extract the value as an unsigned integer. This is a basis
- for extracting it as a pointer to a structure in storage. */
-
-#ifndef XUINT
-#define XUINT(a) ((EMACS_UINT) ((a) & VALMASK))
-#endif
-
-#ifndef XSET
#define XSET(var, type, ptr) \
((var) = ((EMACS_INT)(type) << VALBITS) + ((EMACS_INT) (ptr) & VALMASK))
-#endif
-
-/* Convert a C integer into a Lisp_Object integer. */
-#define make_number(N) \
- ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
+#define XPNTR(a) ((EMACS_UINT) ((a) & VALMASK))
#endif /* not USE_LSB_TAG */
#else /* USE_LISP_UNION_TYPE */
+#ifdef USE_2_TAGS_FOR_INTS
+# error "USE_2_TAGS_FOR_INTS is not supported with USE_LISP_UNION_TYPE"
+#endif
+
#define XHASH(a) ((a).i)
#define XTYPE(a) ((enum Lisp_Type) (a).u.type)
-/* For integers known to be positive, XFASTINT provides fast retrieval
- and XSETFASTINT provides fast storage. This takes advantage of the
- fact that Lisp_Int is 0. */
-#define XFASTINT(a) ((a).i + 0)
-#define XSETFASTINT(a, b) ((a).i = (b))
-
#ifdef EXPLICIT_SIGN_EXTEND
-/* Make sure we sign-extend; compilers have been known to fail to do so. */
-#define XINT(a) (((a).s.val << (BITS_PER_EMACS_INT - VALBITS)) \
+/* Make sure we sign-extend; compilers have been known to fail to do so.
+ We additionally cast to EMACS_INT since it seems that some compilers
+ have been known to fail to do so, even though the bitfield is declared
+ as EMACS_INT already. */
+#define XINT(a) ((((EMACS_INT) (a).s.val) << (BITS_PER_EMACS_INT - VALBITS)) \
>> (BITS_PER_EMACS_INT - VALBITS))
#else
#define XINT(a) ((a).s.val)
#define XUINT(a) ((a).u.val)
-#define XSET(var, vartype, ptr) \
+#ifdef USE_LSB_TAG
+
+# define XSET(var, vartype, ptr) \
+ (eassert ((((EMACS_UINT) (ptr)) & ((1 << GCTYPEBITS) - 1)) == 0), \
+ (var).u.val = ((EMACS_UINT) (ptr)) >> GCTYPEBITS, \
+ (var).u.type = ((char) (vartype)))
+
+/* Some versions of gcc seem to consider the bitfield width when issuing
+ the "cast to pointer from integer of different size" warning, so the
+ cast is here to widen the value back to its natural size. */
+# define XPNTR(v) ((EMACS_INT)((v).s.val) << GCTYPEBITS)
+
+#else /* !USE_LSB_TAG */
+
+/* For integers known to be positive, XFASTINT provides fast retrieval
+ and XSETFASTINT provides fast storage. This takes advantage of the
+ fact that Lisp_Int is 0. */
+# define XFASTINT(a) ((a).i + 0)
+# define XSETFASTINT(a, b) ((a).i = (b))
+
+# define XSET(var, vartype, ptr) \
(((var).s.val = ((EMACS_INT) (ptr))), ((var).s.type = ((char) (vartype))))
+#endif /* !USE_LSB_TAG */
+
#if __GNUC__ >= 2 && defined (__OPTIMIZE__)
#define make_number(N) \
(__extension__ ({ Lisp_Object _l; _l.s.val = (N); _l.s.type = Lisp_Int; _l; }))
#endif /* USE_LISP_UNION_TYPE */
+/* For integers known to be positive, XFASTINT sometimes provides
+ faster retrieval and XSETFASTINT provides faster storage.
+ If not, fallback on the non-accelerated path. */
+#ifndef XFASTINT
+# define XFASTINT(a) (XINT (a))
+# define XSETFASTINT(a, b) (XSETINT (a, b))
+#endif
+
#define EQ(x, y) (XHASH (x) == XHASH (y))
#ifndef XPNTR
/* Largest and smallest representable fixnum values. These are the C
values. */
-#define MOST_NEGATIVE_FIXNUM - ((EMACS_INT) 1 << (VALBITS - 1))
-#define MOST_POSITIVE_FIXNUM (((EMACS_INT) 1 << (VALBITS - 1)) - 1)
+#ifdef USE_2_TAGS_FOR_INTS
+# define MOST_NEGATIVE_FIXNUM - ((EMACS_INT) 1 << VALBITS)
+# define MOST_POSITIVE_FIXNUM (((EMACS_INT) 1 << VALBITS) - 1)
/* Mask indicating the significant bits of a Lisp_Int.
I.e. (x & INTMASK) == XUINT (make_number (x)). */
-#define INTMASK ((((EMACS_INT) 1) << VALBITS) - 1)
+# define INTMASK ((((EMACS_INT) 1) << (VALBITS + 1)) - 1)
+#else
+# define MOST_NEGATIVE_FIXNUM - ((EMACS_INT) 1 << (VALBITS - 1))
+# define MOST_POSITIVE_FIXNUM (((EMACS_INT) 1 << (VALBITS - 1)) - 1)
+/* Mask indicating the significant bits of a Lisp_Int.
+ I.e. (x & INTMASK) == XUINT (make_number (x)). */
+# define INTMASK ((((EMACS_INT) 1) << VALBITS) - 1)
+#endif
-/* Value is non-zero if C integer I doesn't fit into a Lisp fixnum. */
+/* Value is non-zero if I doesn't fit into a Lisp fixnum. It is
+ written this way so that it also works if I is of unsigned
+ type. */
#define FIXNUM_OVERFLOW_P(i) \
- ((EMACS_INT)(i) > MOST_POSITIVE_FIXNUM \
- || (EMACS_INT) (i) < MOST_NEGATIVE_FIXNUM)
+ ((i) > MOST_POSITIVE_FIXNUM \
+ || ((i) < 0 && (i) < MOST_NEGATIVE_FIXNUM))
/* Extract a value or address from a Lisp_Object. */
#define CHAR_TABLE_EXTRA_SLOTS(CT) \
(((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
+#ifdef __GNUC__
+
+#define CHAR_TABLE_REF_ASCII(CT, IDX) \
+ ({struct Lisp_Char_Table *_tbl = NULL; \
+ Lisp_Object _val; \
+ do { \
+ _tbl = _tbl ? XCHAR_TABLE (_tbl->parent) : XCHAR_TABLE (CT); \
+ _val = (! SUB_CHAR_TABLE_P (_tbl->ascii) ? _tbl->ascii \
+ : XSUB_CHAR_TABLE (_tbl->ascii)->contents[IDX]); \
+ if (NILP (_val)) \
+ _val = _tbl->defalt; \
+ } while (NILP (_val) && ! NILP (_tbl->parent)); \
+ _val; })
+
+#else /* not __GNUC__ */
+
+#define CHAR_TABLE_REF_ASCII(CT, IDX) \
+ (! NILP (XCHAR_TABLE (CT)->ascii) \
+ ? (! SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii) \
+ ? XCHAR_TABLE (CT)->ascii \
+ : ! NILP (XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX]) \
+ ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] \
+ : char_table_ref ((CT), (IDX))) \
+ : char_table_ref ((CT), (IDX)))
+
+#endif /* not __GNUC__ */
+
/* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
characters. Do not check validity of CT. */
-#define CHAR_TABLE_REF(CT, IDX) \
- ((ASCII_CHAR_P (IDX) \
- && SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii) \
- && !NILP (XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX])) \
- ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] \
+#define CHAR_TABLE_REF(CT, IDX) \
+ (ASCII_CHAR_P (IDX) ? CHAR_TABLE_REF_ASCII ((CT), (IDX)) \
: char_table_ref ((CT), (IDX)))
/* Almost equivalent to Faref (CT, IDX). However, if the result is
struct Lisp_Vector *next;
/* Depth of this sub char-table. It should be 1, 2, or 3. A sub
- char-table of depth 1 contains 16 elments, and each element
+ char-table of depth 1 contains 16 elements, and each element
covers 4096 (128*32) characters. A sub char-table of depth 2
contains 32 elements, and each element covers 128 characters. A
sub char-table of depth 3 contains 128 elements, and each element
EMACS_UINT size;
Lisp_Object (*function) ();
short min_args, max_args;
- char *symbol_name;
+ const char *symbol_name;
char *intspec;
char *doc;
};
Lisp_Object user_cmp_function;
/* Only the fields above are traced normally by the GC. The ones below
- `count'. are special and are either ignored by the GC or traced in
+ `count' are special and are either ignored by the GC or traced in
a special way (e.g. because of weakness). */
/* Number of key/value entries in the table. */
binding into `realvalue' (or through it). Also update
LOADED-BINDING to point to the newly loaded binding.
- `local_if_set' indicates that merely setting the variable creates a local
- binding for the current buffer. Otherwise the latter, setting the
- variable does not do that; only make-local-variable does that. */
+ `local_if_set' indicates that merely setting the variable creates a
+ local binding for the current buffer. Otherwise the latter, setting
+ the variable does not do that; only make-local-variable does that. */
struct Lisp_Buffer_Local_Value
{
};
#ifdef HIDE_LISP_IMPLEMENTATION
-#define XFLOAT_DATA(f) (XFLOAT (f)->u.data_)
+#define XFLOAT_DATA(f) (XFLOAT (f)->u.data_ + 0)
#else
-#define XFLOAT_DATA(f) (XFLOAT (f)->u.data)
+#define XFLOAT_DATA(f) (XFLOAT (f)->u.data + 0)
+/* This should be used only in alloc.c, which always disables
+ HIDE_LISP_IMPLEMENTATION. */
+#define XFLOAT_INIT(f,n) (XFLOAT (f)->u.data = (n))
#endif
/* A character, declared with the following typedef, is a member
#define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
#define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
-#define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
+#define INTEGERP(x) (LISP_INT_TAG_P (XTYPE ((x))))
#define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
#define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
#define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
#define CHECK_VECTOR_OR_STRING(x) \
CHECK_TYPE (VECTORP (x) || STRINGP (x), Qarrayp, x)
-#define CHECK_ARRAY(x, Qxxxp) \
+#define CHECK_ARRAY(x, Qxxxp) \
CHECK_TYPE (ARRAYP (x), Qxxxp, x)
#define CHECK_VECTOR_OR_CHAR_TABLE(x) \
#define XFLOATINT(n) extract_float((n))
-#define CHECK_FLOAT(x) \
+#define CHECK_FLOAT(x) \
CHECK_TYPE (FLOATP (x), Qfloatp, x)
-#define CHECK_NUMBER_OR_FLOAT(x) \
+#define CHECK_NUMBER_OR_FLOAT(x) \
CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x)
#define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
- do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \
+ do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \
else CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x); } while (0)
#define CHECK_OVERLAY(x) \
A null string means call interactively with no arguments.
`doc' is documentation for the user. */
-#if (!defined (__STDC__) && !defined (PROTOTYPES))
-
-#define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
- Lisp_Object fnname (); \
- DECL_ALIGN (struct Lisp_Subr, sname) = \
- { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
- fnname, minargs, maxargs, lname, intspec, 0}; \
- Lisp_Object fnname
-
-#else
-
/* This version of DEFUN declares a function prototype with the right
arguments, so we can catch errors with maxargs at compile-time. */
#define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
Lisp_Object, Lisp_Object, Lisp_Object)
#define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
-#endif
/* Non-zero if OBJ is a Lisp function. */
-
#define FUNCTIONP(OBJ) \
((CONSP (OBJ) && EQ (XCAR (OBJ), Qlambda)) \
|| (SYMBOLP (OBJ) && !NILP (Ffboundp (OBJ))) \
#define MANY -2
#define UNEVALLED -1
-extern void defvar_lisp P_ ((char *, Lisp_Object *));
-extern void defvar_lisp_nopro P_ ((char *, Lisp_Object *));
-extern void defvar_bool P_ ((char *, int *));
-extern void defvar_int P_ ((char *, EMACS_INT *));
-extern void defvar_kboard P_ ((char *, int));
+extern void defvar_lisp (const char *, Lisp_Object *);
+extern void defvar_lisp_nopro (const char *, Lisp_Object *);
+extern void defvar_bool (const char *, int *);
+extern void defvar_int (const char *, EMACS_INT *);
+extern void defvar_kboard (const char *, int);
/* Macros we use to define forwarded Lisp variables.
These are used in the syms_of_FILENAME functions. */
If the symbol field is a symbol, it is an ordinary variable binding.
- Otherwise, it should be a structure (SYMBOL WHERE
- . CURRENT-BUFFER), which means having bound a local value while
- CURRENT-BUFFER was active. If WHERE is nil this means we saw the
- default value when binding SYMBOL. WHERE being a buffer or frame
- means we saw a buffer-local or frame-local value. Other values of
- WHERE mean an internal error. */
+ Otherwise, it should be a structure (SYMBOL WHERE . CURRENT-BUFFER),
+ which means having bound a local value while CURRENT-BUFFER was active.
+ If WHERE is nil this means we saw the default value when binding SYMBOL.
+ WHERE being a buffer or frame means we saw a buffer-local or frame-local
+ value. Other values of WHERE mean an internal error. */
typedef Lisp_Object (*specbinding_func) P_ ((Lisp_Object));
extern struct handler *handlerlist;
+/* This structure helps implement the `catch' and `throw' control
+ structure. A struct catchtag contains all the information needed
+ to restore the state of the interpreter after a non-local jump.
+
+ Handlers for error conditions (represented by `struct handler'
+ structures) just point to a catch tag to do the cleanup required
+ for their jumps.
+
+ catchtag structures are chained together in the C calling stack;
+ the `next' member points to the next outer catchtag.
+
+ A call like (throw TAG VAL) searches for a catchtag whose `tag'
+ member is TAG, and then unbinds to it. The `val' member is used to
+ hold VAL while the stack is unwound; `val' is returned as the value
+ of the catch form.
+
+ All the other members are concerned with restoring the interpreter
+ state. */
+
+struct catchtag
+{
+ Lisp_Object tag;
+ Lisp_Object val;
+ struct catchtag *next;
+ struct gcpro *gcpro;
+ jmp_buf jmp;
+ struct backtrace *backlist;
+ struct handler *handlerlist;
+ int lisp_eval_depth;
+ int pdlcount;
+ int poll_suppress_count;
+ int interrupt_input_blocked;
+ struct byte_stack *byte_stack;
+};
+
extern struct catchtag *catchlist;
extern struct backtrace *backtrace_list;
#ifdef SYNC_INPUT
extern void process_pending_signals P_ ((void));
extern int pending_signals;
-
-#define QUIT \
- do { \
- if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
- { \
- Lisp_Object flag = Vquit_flag; \
- Vquit_flag = Qnil; \
- if (EQ (Vthrow_on_input, flag)) \
- Fthrow (Vthrow_on_input, Qt); \
- Fsignal (Qquit, Qnil); \
- } \
- else if (pending_signals) \
- process_pending_signals (); \
- } while (0)
-
+#define ELSE_PENDING_SIGNALS \
+ else if (pending_signals) \
+ process_pending_signals ();
#else /* not SYNC_INPUT */
+#define ELSE_PENDING_SIGNALS
+#endif /* not SYNC_INPUT */
#define QUIT \
do { \
Fthrow (Vthrow_on_input, Qt); \
Fsignal (Qquit, Qnil); \
} \
+ ELSE_PENDING_SIGNALS \
} while (0)
-#endif /* not SYNC_INPUT */
-
/* Nonzero if ought to quit now. */
/* Structure for recording stack slots that need marking. */
-/* This is a chain of structures, each of which points at a Lisp_Object variable
- whose value should be marked in garbage collection.
- Normally every link of the chain is an automatic variable of a function,
- and its `val' points to some argument or local variable of the function.
- On exit to the function, the chain is set back to the value it had on entry.
- This way, no link remains in the chain when the stack frame containing the
- link disappears.
+/* This is a chain of structures, each of which points at a Lisp_Object
+ variable whose value should be marked in garbage collection.
+ Normally every link of the chain is an automatic variable of a function,
+ and its `val' points to some argument or local variable of the function.
+ On exit to the function, the chain is set back to the value it had on entry.
+ This way, no link remains in the chain when the stack frame containing the
+ link disappears.
- Every function that can call Feval must protect in this fashion all
- Lisp_Object variables whose contents will be used again. */
+ Every function that can call Feval must protect in this fashion all
+ Lisp_Object variables whose contents will be used again. */
extern struct gcpro *gcprolist;
\f
/* Declare a Lisp-callable function. The MAXARGS parameter has the same
meaning as in the DEFUN macro, and is used to construct a prototype. */
-#if (!defined (__STDC__) && !defined (PROTOTYPES))
-#define EXFUN(fnname, maxargs) \
- extern Lisp_Object fnname ()
-#else
/* We can use the same trick as in the DEFUN macro to generate the
appropriate prototype. */
#define EXFUN(fnname, maxargs) \
extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
-#endif
/* Forward declarations for prototypes. */
struct window;
extern void circular_list_error P_ ((Lisp_Object)) NO_RETURN;
EXFUN (Finteractive_form, 1);
+EXFUN (Fbyteorder, 0);
/* Defined in frame.c */
extern Lisp_Object Qframep;
extern int pos_visible_p P_ ((struct window *, int, int *,
int *, int *, int *, int *, int *));
+/* Defined in xsettings.c */
+extern void syms_of_xsettings P_ ((void));
+
/* Defined in vm-limit.c. */
extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
extern Lisp_Object make_string_from_bytes P_ ((const char *, int, int));
extern Lisp_Object make_specified_string P_ ((const char *, int, int, int));
EXFUN (Fpurecopy, 1);
-extern Lisp_Object make_pure_string P_ ((char *, int, int, int));
+extern Lisp_Object make_pure_string P_ ((const char *, int, int, int));
+extern Lisp_Object make_pure_c_string (const char *data);
extern Lisp_Object pure_cons P_ ((Lisp_Object, Lisp_Object));
extern Lisp_Object make_pure_vector P_ ((EMACS_INT));
EXFUN (Fgarbage_collect, 0);
/* Defined in doprnt.c */
extern int doprnt P_ ((char *, int, char *, char *, int, char **));
-extern int doprnt_lisp P_ ((char *, int, char *, char *, int, char **));
/* Defined in lread.c */
extern Lisp_Object Qvariable_documentation, Qstandard_input;
EXFUN (Feval_region, 4);
extern Lisp_Object check_obarray P_ ((Lisp_Object));
extern Lisp_Object intern P_ ((const char *));
+extern Lisp_Object intern_c_string (const char *);
extern Lisp_Object make_symbol P_ ((char *));
extern Lisp_Object oblookup P_ ((Lisp_Object, const char *, int, int));
#define LOADHIST_ATTACH(x) \
extern Lisp_Object Vload_history, Vload_suffixes, Vload_file_rep_suffixes;
extern int openp P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object *, Lisp_Object));
-extern int isfloat_string P_ ((char *));
+extern int isfloat_string P_ ((char *, int));
extern void map_obarray P_ ((Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
Lisp_Object));
extern void dir_warning P_ ((char *, Lisp_Object));
EXFUN (Ffield_string_no_properties, 1);
extern void set_time_zone_rule P_ ((char *));
-/* defined in buffer.c */
+/* Defined in buffer.c */
extern int mouse_face_overlay_overlaps P_ ((Lisp_Object));
extern void nsberror P_ ((Lisp_Object)) NO_RETURN;
EXFUN (Fset_buffer_multibyte, 1);
extern void syms_of_buffer P_ ((void));
extern void keys_of_buffer P_ ((void));
-/* defined in marker.c */
+/* Defined in marker.c */
EXFUN (Fmarker_position, 1);
EXFUN (Fmarker_buffer, 1);
EXFUN (Ffile_executable_p, 1);
EXFUN (Fread_file_name, 6);
extern Lisp_Object close_file_unwind P_ ((Lisp_Object));
+extern Lisp_Object restore_point_unwind P_ ((Lisp_Object));
extern void report_file_error P_ ((const char *, Lisp_Object)) NO_RETURN;
extern int internal_delete_file P_ ((Lisp_Object));
extern void syms_of_fileio P_ ((void));
-extern void init_fileio_once P_ ((void));
extern Lisp_Object make_temp_name P_ ((Lisp_Object, int));
EXFUN (Fmake_symbolic_link, 3);
-extern Lisp_Object Qdelete_directory;
extern Lisp_Object Qdelete_file;
/* Defined in abbrev.c */
extern void syms_of_abbrev P_ ((void));
-/* defined in search.c */
+/* Defined in search.c */
extern void shrink_regexp_cache P_ ((void));
EXFUN (Fstring_match, 3);
extern void restore_search_regs P_ ((void));
extern void syms_of_search P_ ((void));
extern void clear_regexp_cache P_ ((void));
-/* defined in minibuf.c */
+/* Defined in minibuf.c */
extern Lisp_Object last_minibuf_string;
extern void choose_minibuf_frame P_ ((void));
EXFUN (Fprefix_numeric_value, 1);
extern void syms_of_callint P_ ((void));
-/* defined in casefiddle.c */
+/* Defined in casefiddle.c */
EXFUN (Fdowncase, 1);
EXFUN (Fupcase, 1);
extern void syms_of_casefiddle P_ ((void));
extern void keys_of_casefiddle P_ ((void));
-/* defined in casetab.c */
+/* Defined in casetab.c */
EXFUN (Fset_case_table, 1);
EXFUN (Fset_standard_case_table, 1);
extern void init_casetab_once P_ ((void));
extern void syms_of_casetab P_ ((void));
-/* defined in keyboard.c */
+/* Defined in keyboard.c */
extern int echoing;
extern Lisp_Object echo_message_buffer;
extern void syms_of_keyboard P_ ((void));
extern void keys_of_keyboard P_ ((void));
extern char *push_key_description P_ ((unsigned int, char *, int));
-extern void add_user_signal P_ ((int sig, const char *name));
-/* defined in indent.c */
+/* Defined in indent.c */
EXFUN (Fvertical_motion, 2);
EXFUN (Findent_to, 2);
EXFUN (Fcurrent_column, 0);
extern int indented_beyond_p P_ ((int, int, double));
extern void syms_of_indent P_ ((void));
-/* defined in frame.c */
+/* Defined in frame.c */
#ifdef HAVE_WINDOW_SYSTEM
extern Lisp_Object Vx_resource_name;
extern Lisp_Object Vx_resource_class;
extern void frames_bury_buffer P_ ((Lisp_Object));
extern void syms_of_frame P_ ((void));
-/* defined in emacs.c */
+/* Defined in emacs.c */
extern Lisp_Object decode_env_path P_ ((char *, char *));
extern Lisp_Object Vinvocation_name, Vinvocation_directory;
extern Lisp_Object Vbefore_init_time, Vafter_init_time;
#define synchronize_system_time_locale()
#endif
void shut_down_emacs P_ ((int, int, Lisp_Object));
-/* Nonzero means don't do interactive redisplay and don't change tty modes */
+/* Nonzero means don't do interactive redisplay and don't change tty modes. */
extern int noninteractive;
+/* Nonzero means don't load X resources or Windows Registry settings. */
+extern int inhibit_x_resources;
+
/* Pipe used to send exit notification to the daemon parent at
startup. */
extern int daemon_pipe[2];
#define IS_DAEMON (daemon_pipe[1] != 0)
-/* Nonzero means don't do use window-system-specific display code */
+/* Nonzero means don't do use window-system-specific display code. */
extern int inhibit_window_system;
/* Nonzero means that a filter or a sentinel is running. */
extern int running_asynch_code;
-/* defined in process.c */
+/* Defined in process.c */
EXFUN (Fget_process, 1);
EXFUN (Fget_buffer_process, 1);
EXFUN (Fprocessp, 1);
extern void syms_of_process P_ ((void));
extern void setup_process_coding_systems P_ ((Lisp_Object));
-/* defined in callproc.c */
+/* Defined in callproc.c */
extern Lisp_Object Vexec_path, Vexec_suffixes,
Vexec_directory, Vdata_directory;
extern Lisp_Object Vdoc_directory;
extern void set_initial_environment P_ ((void));
extern void syms_of_callproc P_ ((void));
-/* defined in doc.c */
+/* Defined in doc.c */
extern Lisp_Object Vdoc_file_name;
EXFUN (Fsubstitute_command_keys, 1);
EXFUN (Fdocumentation, 2);
extern void syms_of_doc P_ ((void));
extern int read_bytecode_char P_ ((int));
-/* defined in bytecode.c */
+/* Defined in bytecode.c */
extern Lisp_Object Qbytecode;
EXFUN (Fbyte_code, 3);
extern void syms_of_bytecode P_ ((void));
extern void mark_byte_stack P_ ((void));
extern void unmark_byte_stack P_ ((void));
-/* defined in macros.c */
+/* Defined in macros.c */
extern Lisp_Object Qexecute_kbd_macro;
EXFUN (Fexecute_kbd_macro, 3);
EXFUN (Fcancel_kbd_macro_events, 0);
extern void init_macros P_ ((void));
extern void syms_of_macros P_ ((void));
-/* defined in undo.c */
+/* Defined in undo.c */
extern Lisp_Object Qinhibit_read_only;
EXFUN (Fundo_boundary, 0);
extern void truncate_undo_list P_ ((struct buffer *));
extern void syms_of_undo P_ ((void));
extern Lisp_Object Vundo_outer_limit;
-/* defined in textprop.c */
+/* Defined in textprop.c */
extern Lisp_Object Qfont, Qmouse_face;
extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
EXFUN (Fnext_single_property_change, 4);
Lisp_Object,
Lisp_Object));
-/* defined in menu.c */
+/* Defined in menu.c */
extern void syms_of_menu P_ ((void));
-/* defined in xmenu.c */
+/* Defined in xmenu.c */
EXFUN (Fx_popup_menu, 2);
EXFUN (Fx_popup_dialog, 3);
extern void syms_of_xmenu P_ ((void));
-/* defined in termchar.h */
+/* Defined in termchar.h */
struct tty_display_info;
-/* defined in termhooks.h */
+/* Defined in termhooks.h */
struct terminal;
-/* defined in sysdep.c */
+/* Defined in sysdep.c */
#ifndef HAVE_GET_CURRENT_DIR_NAME
extern char *get_current_dir_name P_ ((void));
#endif
extern int emacs_read P_ ((int, char *, unsigned int));
extern int emacs_write P_ ((int, const char *, unsigned int));
-/* defined in filelock.c */
+/* Defined in filelock.c */
EXFUN (Funlock_buffer, 0);
EXFUN (Ffile_locked_p, 1);
extern void unlock_all_files P_ ((void));
/* Defined in font.c */
extern void syms_of_font P_ ((void));
+extern void init_font P_ ((void));
#ifdef HAVE_WINDOW_SYSTEM
/* Defined in fontset.c */
#ifdef HAVE_DBUS
/* Defined in dbusbind.c */
+int xd_pending_messages P_ ((void));
void xd_read_queued_messages P_ ((void));
void syms_of_dbusbind P_ ((void));
#endif