/* Fundamental definitions for GNU Emacs Lisp interpreter.
- Copyright (C) 1985,86,87,93,94,95 Free Software Foundation, Inc.
+ Copyright (C) 1985,86,87,93,94,95,97,98,1999,2000, 2001
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+/* Declare the prototype for a general external function. */
+#if defined (PROTOTYPES) || defined (WINDOWSNT)
+#define P_(proto) proto
+#else
+#define P_(proto) ()
+#endif
+
+/* 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
+
/* These are default choices for the types to use. */
+#ifdef _LP64
+#ifndef EMACS_INT
+#define EMACS_INT long
+#define BITS_PER_EMACS_INT BITS_PER_LONG
+#endif
+#ifndef EMACS_UINT
+#define EMACS_UINT unsigned long
+#endif
+#else /* not _LP64 */
#ifndef EMACS_INT
#define EMACS_INT int
#define BITS_PER_EMACS_INT BITS_PER_INT
#ifndef EMACS_UINT
#define EMACS_UINT unsigned int
#endif
+#endif
+
+/* Extra internal type checking? */
+extern int suppress_checking;
+extern void die P_((const char *, const char *, int));
+
+#ifdef ENABLE_CHECKING
+
+#define CHECK(check,msg) ((check || suppress_checking \
+ ? (void) 0 \
+ : die (msg, __FILE__, __LINE__)), \
+ 0)
+
+/* Let's get some compile-time checking too. */
+#undef NO_UNION_TYPE
+
+#else
+
+/* Produce same side effects and result, but don't complain. */
+#define CHECK(check,msg) ((check),0)
+
+#endif
+
+/* Used for making sure that Emacs is compilable in all
+ conigurations. */
+
+#ifdef USE_LISP_UNION_TYPE
+#undef NO_UNION_TYPE
+#endif
+
+/* Define an Emacs version of "assert", since some system ones are
+ flaky. */
+#ifndef ENABLE_CHECKING
+#define eassert(X) (void) 0
+#else /* ENABLE_CHECKING */
+#if defined (__GNUC__) && __GNUC__ >= 2 && defined (__STDC__)
+#define eassert(cond) CHECK(cond,"assertion failed: " #cond)
+#else
+#define eassert(cond) CHECK(cond,"assertion failed")
+#endif
+#endif /* ENABLE_CHECKING */
/* Define the fundamental Lisp data structures. */
/* Cons. XCONS (object) points to a struct Lisp_Cons. */
Lisp_Cons,
-#ifdef LISP_FLOAT_TYPE
Lisp_Float,
-#endif /* LISP_FLOAT_TYPE */
/* This is not a type code. It is for range checking. */
Lisp_Type_Limit
/* These values are overridden by the m- file on some machines. */
#ifndef VALBITS
-#define VALBITS 28
+#define VALBITS (BITS_PER_EMACS_INT - 4)
#endif
#ifndef GCTYPEBITS
#define GCTYPEBITS 3
#endif
+#if 0 /* This doesn't work on some systems that don't allow enumerators
+ > INT_MAX, and it won't work for long long EMACS_INT. These
+ values are now found in emacs.c as EMACS_INT variables. */
+
/* Make these values available in GDB, which sees enums but not macros. */
enum gdb_lisp_params
#endif
};
+#endif /* 0 */
+
#ifndef NO_UNION_TYPE
#ifndef WORDS_BIG_ENDIAN
{
/* Used for comparing two Lisp_Objects;
also, positive integers can be accessed fast this way. */
- int i;
+ EMACS_INT i;
struct
{
- int val: VALBITS;
- int type: GCTYPEBITS+1;
+ EMACS_INT val : VALBITS;
+ EMACS_INT type : GCTYPEBITS + 1;
} s;
struct
{
- unsigned int val: VALBITS;
- int type: GCTYPEBITS+1;
+ EMACS_UINT val : VALBITS;
+ EMACS_INT type : GCTYPEBITS + 1;
} u;
struct
{
- unsigned int val: VALBITS;
- enum Lisp_Type type: GCTYPEBITS;
+ EMACS_UINT val : VALBITS;
+ enum Lisp_Type type : GCTYPEBITS;
/* The markbit is not really part of the value of a Lisp_Object,
and is always zero except during garbage collection. */
- unsigned int markbit: 1;
+ EMACS_UINT markbit : 1;
} gu;
}
Lisp_Object;
{
/* Used for comparing two Lisp_Objects;
also, positive integers can be accessed fast this way. */
- int i;
+ EMACS_INT i;
struct
{
- int type: GCTYPEBITS+1;
- int val: VALBITS;
+ EMACS_INT type : GCTYPEBITS+1;
+ EMACS_INT val : VALBITS;
} s;
struct
{
- int type: GCTYPEBITS+1;
- unsigned int val: VALBITS;
+ EMACS_INT type : GCTYPEBITS+1;
+ EMACS_UINT val : VALBITS;
} u;
struct
{
/* The markbit is not really part of the value of a Lisp_Object,
and is always zero except during garbage collection. */
- unsigned int markbit: 1;
- enum Lisp_Type type: GCTYPEBITS;
- unsigned int val: VALBITS;
+ EMACS_UINT markbit : 1;
+ enum Lisp_Type type : GCTYPEBITS;
+ EMACS_UINT val : VALBITS;
} gu;
}
Lisp_Object;
rather than being part of a string block. */
#ifndef MARKBIT
-#define MARKBIT ((int) ((unsigned int) 1 << (VALBITS + GCTYPEBITS)))
+#define MARKBIT ((EMACS_INT) ((EMACS_UINT) 1 << (VALBITS + GCTYPEBITS)))
#endif /*MARKBIT */
/* In the size word of a vector, this bit means the vector has been marked.
PVEC_CHAR_TABLE = 0x8000,
PVEC_BOOL_VECTOR = 0x10000,
PVEC_BUFFER = 0x20000,
- PVEC_TYPE_MASK = 0x3fe00,
+ PVEC_HASH_TABLE = 0x40000,
+ PVEC_TYPE_MASK = 0x7fe00
+
+#if 0 /* This is used to make the value of PSEUDOVECTOR_FLAG available to
+ GDB. It doesn't work on OS Alpha. Moved to a variable in
+ emacs.c. */
PVEC_FLAG = PSEUDOVECTOR_FLAG
+#endif
};
/* For convenience, we also store the number of elements in these bits. */
/* Extract the value of a Lisp_Object as a signed integer. */
#ifndef XINT /* Some machines need to do this differently. */
-#define XINT(a) (((a) << (BITS_PER_INT-VALBITS)) >> (BITS_PER_INT-VALBITS))
+#define XINT(a) ((EMACS_INT) (((a) << (BITS_PER_EMACS_INT - VALBITS)) \
+ >> (BITS_PER_EMACS_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) ((a) & VALMASK)
+#define XUINT(a) ((EMACS_UINT) ((a) & VALMASK))
#endif
#ifndef XPNTR
#ifdef EXPLICIT_SIGN_EXTEND
/* Make sure we sign-extend; compilers have been known to fail to do so. */
-#define XINT(a) (((a).i << (BITS_PER_INT-VALBITS)) >> (BITS_PER_INT-VALBITS))
+#define XINT(a) (((a).i << (BITS_PER_EMACS_INT - VALBITS)) \
+ >> (BITS_PER_EMACS_INT - VALBITS))
#else
#define XINT(a) ((a).s.val)
#endif /* EXPLICIT_SIGN_EXTEND */
#define XPNTR(a) ((a).u.val)
#define XSET(var, vartype, ptr) \
- (((var).s.type = ((char) (vartype))), ((var).s.val = ((int) (ptr))))
+ (((var).s.val = ((EMACS_INT) (ptr))), ((var).s.type = ((char) (vartype))))
+#if __GNUC__ >= 2 && defined (__OPTIMIZE__)
+#define make_number(N) \
+ (__extension__ ({ Lisp_Object _l; _l.s.val = (N); _l.s.type = Lisp_Int; _l; }))
+#else
extern Lisp_Object make_number ();
+#endif
/* During garbage collection, XGCTYPE must be used for extracting types
so that the mark bit is ignored. XMARKBIT access the markbit.
/* Extract a value or address from a Lisp_Object. */
-#define XCONS(a) ((struct Lisp_Cons *) XPNTR(a))
+#define XCONS(a) (eassert (GC_CONSP(a)),(struct Lisp_Cons *) XPNTR(a))
#define XVECTOR(a) ((struct Lisp_Vector *) XPNTR(a))
-#define XSTRING(a) ((struct Lisp_String *) XPNTR(a))
-#define XSYMBOL(a) ((struct Lisp_Symbol *) XPNTR(a))
-#define XFLOAT(a) ((struct Lisp_Float *) XPNTR(a))
+#define XSTRING(a) (eassert (GC_STRINGP(a)),(struct Lisp_String *) XPNTR(a))
+#define XSYMBOL(a) (eassert (GC_SYMBOLP(a)),(struct Lisp_Symbol *) XPNTR(a))
+#define XFLOAT(a) (eassert (GC_FLOATP(a)),(struct Lisp_Float *) XPNTR(a))
/* Misc types. */
+
#define XMISC(a) ((union Lisp_Misc *) XPNTR(a))
#define XMISCTYPE(a) (XMARKER (a)->type)
#define XMARKER(a) (&(XMISC(a)->u_marker))
#define XKBOARD_OBJFWD(a) (&(XMISC(a)->u_kboard_objfwd))
/* Pseudovector types. */
-#define XPROCESS(a) ((struct Lisp_Process *) XPNTR(a))
-#define XWINDOW(a) ((struct window *) XPNTR(a))
-#define XSUBR(a) ((struct Lisp_Subr *) XPNTR(a))
-#define XBUFFER(a) ((struct buffer *) XPNTR(a))
+
+#define XPROCESS(a) (eassert (GC_PROCESSP(a)),(struct Lisp_Process *) XPNTR(a))
+#define XWINDOW(a) (eassert (GC_WINDOWP(a)),(struct window *) XPNTR(a))
+#define XSUBR(a) (eassert (GC_SUBRP(a)),(struct Lisp_Subr *) XPNTR(a))
+#define XBUFFER(a) (eassert (GC_BUFFERP(a)),(struct buffer *) XPNTR(a))
#define XCHAR_TABLE(a) ((struct Lisp_Char_Table *) XPNTR(a))
#define XBOOL_VECTOR(a) ((struct Lisp_Bool_Vector *) XPNTR(a))
-
/* Construct a Lisp_Object from a value or address. */
#define XSETINT(a, b) XSET (a, Lisp_Int, b)
#define XSETFLOAT(a, b) XSET (a, Lisp_Float, b)
/* Misc types. */
+
#define XSETMISC(a, b) XSET (a, Lisp_Misc, b)
#define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
/* Pseudovector types. */
+
#define XSETPSEUDOVECTOR(a, b, code) \
(XSETVECTOR (a, b), XVECTOR (a)->size |= PSEUDOVECTOR_FLAG | (code))
#define XSETWINDOW_CONFIGURATION(a, b) \
#define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
#define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
#define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
+
+/* Convenience macros for dealing with Lisp arrays. */
+
+#define AREF(ARRAY, IDX) XVECTOR ((ARRAY))->contents[IDX]
+#define ASET(ARRAY, IDX, VAL) (AREF ((ARRAY), (IDX)) = (VAL))
+#define ASIZE(ARRAY) XVECTOR ((ARRAY))->size
+
\f
-#ifdef USE_TEXT_PROPERTIES
/* Basic data type for use of intervals. See the macros in intervals.h. */
struct interval
unsigned int total_length; /* Length of myself and both children. */
unsigned int position; /* Cache of interval's character position. */
+ /* This field is usually updated
+ simultaneously with an interval
+ traversal, there is no guaranty
+ that it is valid for a random
+ interval. */
struct interval *left; /* Intervals which precede me. */
struct interval *right; /* Intervals which succeed me. */
You'd think we could store this information in the parent object
somewhere (after all, that should be visited once and then
ignored too, right?), but strings are GC'd strangely. */
- struct interval *parent;
+ union
+ {
+ struct interval *interval;
+ Lisp_Object obj;
+ } up;
+ unsigned int up_obj : 1;
/* The remaining components are `properties' of the interval.
The first four are duplicates for things which can be on the list,
for purposes of speed. */
- unsigned char write_protect; /* Non-zero means can't modify. */
- unsigned char visible; /* Zero means don't display. */
- unsigned char front_sticky; /* Non-zero means text inserted just
+ unsigned int write_protect : 1; /* Non-zero means can't modify. */
+ unsigned int visible : 1; /* Zero means don't display. */
+ unsigned int front_sticky : 1; /* Non-zero means text inserted just
before this interval goes into it. */
- unsigned char rear_sticky; /* Likewise for just after it. */
+ unsigned int rear_sticky : 1; /* Likewise for just after it. */
/* Properties of this interval.
The mark bit on this field says whether this particular interval
#define CHECK_STRING_OR_BUFFER(x, i) \
{ if (!STRINGP ((x)) && !BUFFERP ((x))) \
x = wrong_type_argument (Qbuffer_or_string_p, (x)); }
-
-/* Macro used to conditionally compile intervals into certain data
- structures. See, e.g., struct Lisp_String below. */
-#define DECLARE_INTERVALS INTERVAL intervals;
-
-/* Macro used to conditionally compile interval initialization into
- certain code. See, e.g., alloc.c. */
-#define INITIALIZE_INTERVAL(ptr,val) ptr->intervals = val
-
-#else /* No text properties */
-
-/* If no intervals are used, make the above definitions go away. */
-
-#define CHECK_STRING_OR_BUFFER(x, i)
-
-#define INTERVAL
-#define DECLARE_INTERVALS
-#define INITIALIZE_INTERVAL(ptr,val)
-
-#endif /* USE_TEXT_PROPERTIES */
\f
/* In a cons, the markbit of the car is the gc mark bit */
struct Lisp_Cons
{
+ /* Please do not use the names of these elements in code other
+ than the core lisp implementation. Use XCAR and XCDR below. */
+#ifdef HIDE_LISP_IMPLEMENTATION
+ Lisp_Object car_, cdr_;
+#else
Lisp_Object car, cdr;
+#endif
};
/* Take the car or cdr of something known to be a cons cell. */
+#ifdef HIDE_LISP_IMPLEMENTATION
+#define XCAR(c) (XCONS ((c))->car_)
+#define XCDR(c) (XCONS ((c))->cdr_)
+#else
#define XCAR(c) (XCONS ((c))->car)
#define XCDR(c) (XCONS ((c))->cdr)
+#endif
/* Take the car or cdr of something whose type is not known. */
#define CAR(c) \
: NILP ((c)) ? Qnil \
: wrong_type_argument (Qlistp, (c)))
-/* Like a cons, but records info on where the text lives that it was read from */
-/* This is not really in use now */
+/* Nonzero if STR is a multibyte string. */
+#define STRING_MULTIBYTE(STR) \
+ (XSTRING (STR)->size_byte >= 0)
-struct Lisp_Buffer_Cons
- {
- Lisp_Object car, cdr;
- struct buffer *buffer;
- int bufpos;
- };
+/* Return the length in bytes of STR. */
+
+#ifdef GC_CHECK_STRING_BYTES
+
+struct Lisp_String;
+extern int string_bytes P_ ((struct Lisp_String *));
+#define STRING_BYTES(S) string_bytes ((S))
+
+#else /* not GC_CHECK_STRING_BYTES */
+
+#define STRING_BYTES(STR) \
+ ((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte)
+
+#endif /* not GC_CHECK_STRING_BYTES */
+
+/* Set the length in bytes of STR. */
+#define SET_STRING_BYTES(STR, SIZE) ((STR)->size_byte = (SIZE))
/* In a string or vector, the sign bit of the `size' is the gc mark bit */
struct Lisp_String
{
EMACS_INT size;
- DECLARE_INTERVALS /* `data' field must be last. */
- unsigned char data[1];
+ EMACS_INT size_byte;
+ INTERVAL intervals; /* text properties in this string */
+ unsigned char *data;
};
/* If a struct is made to look like a vector, this macro returns the length
and 8-bit Europeans characters. For these characters, do not check
validity of CT. Do not follow parent. */
#define CHAR_TABLE_REF(CT, IDX) \
- ((IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
+ ((IDX) >= 0 && (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
? XCHAR_TABLE (CT)->contents[IDX] \
: XCHAR_TABLE (CT)->defalt) \
: Faref (CT, make_number (IDX)))
+/* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
+ and 8-bit Europeans characters. However, if the result is nil,
+ return IDX.
+
+ For these characters, do not check validity of CT
+ and do not follow parent. */
+#define CHAR_TABLE_TRANSLATE(CT, IDX) \
+ ((IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
+ ? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
+ ? XINT (XCHAR_TABLE (CT)->contents[IDX]) \
+ : IDX) \
+ : char_table_translate (CT, IDX))
+
/* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
8-bit Europeans characters. Do not check validity of CT. */
#define CHAR_TABLE_SET(CT, IDX, VAL) \
char *prompt;
char *doc;
};
+
+\f
+/***********************************************************************
+ Hash Tables
+ ***********************************************************************/
+
+/* The structure of a Lisp hash table. */
+
+struct Lisp_Hash_Table
+{
+ /* Vector fields. The hash table code doesn't refer to these. */
+ EMACS_INT size;
+ struct Lisp_Vector *vec_next;
+
+ /* Function used to compare keys. */
+ Lisp_Object test;
+
+ /* Nil if table is non-weak. Otherwise a symbol describing the
+ weakness of the table. */
+ Lisp_Object weak;
+
+ /* When the table is resized, and this is an integer, compute the
+ new size by adding this to the old size. If a float, compute the
+ new size by multiplying the old size with this factor. */
+ Lisp_Object rehash_size;
+
+ /* Resize hash table when number of entries/ table size is >= this
+ ratio, a float. */
+ Lisp_Object rehash_threshold;
+
+ /* Number of key/value entries in the table. */
+ Lisp_Object count;
+
+ /* Vector of keys and values. The key of item I is found at index
+ 2 * I, the value is found at index 2 * I + 1. */
+ Lisp_Object key_and_value;
+
+ /* Vector of hash codes.. If hash[I] is nil, this means that that
+ entry I is unused. */
+ Lisp_Object hash;
+
+ /* Vector used to chain entries. If entry I is free, next[I] is the
+ entry number of the next free item. If entry I is non-free,
+ next[I] is the index of the next entry in the collision chain. */
+ Lisp_Object next;
+
+ /* Index of first free entry in free list. */
+ Lisp_Object next_free;
+
+ /* Bucket vector. A non-nil entry is the index of the first item in
+ a collision chain. This vector's size can be larger than the
+ hash table size to reduce collisions. */
+ Lisp_Object index;
+
+ /* Next weak hash table if this is a weak hash table. The head
+ of the list is in Vweak_hash_tables. */
+ Lisp_Object next_weak;
+
+ /* User-supplied hash function, or nil. */
+ Lisp_Object user_hash_function;
+
+ /* User-supplied key comparison function, or nil. */
+ Lisp_Object user_cmp_function;
+
+ /* C function to compare two keys. */
+ int (* cmpfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object,
+ unsigned, Lisp_Object, unsigned));
+
+ /* C function to compute hash code. */
+ unsigned (* hashfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object));
+};
+
+
+#define XHASH_TABLE(OBJ) \
+ ((struct Lisp_Hash_Table *) XPNTR (OBJ))
+
+#define XSET_HASH_TABLE(VAR, PTR) \
+ (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
+
+#define HASH_TABLE_P(OBJ) PSEUDOVECTORP (OBJ, PVEC_HASH_TABLE)
+#define GC_HASH_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_HASH_TABLE)
+
+#define CHECK_HASH_TABLE(x, i) \
+ do \
+ { \
+ if (!HASH_TABLE_P ((x))) \
+ x = wrong_type_argument (Qhash_table_p, (x)); \
+ } \
+ while (0)
+
+/* Default size for hash tables if not specified. */
+
+#define DEFAULT_HASH_SIZE 65
+
+/* Default threshold specifying when to resize a hash table. The
+ value gives the ratio of current entries in the hash table and the
+ size of the hash table. */
+
+#define DEFAULT_REHASH_THRESHOLD 0.8
+
+/* Default factor by which to increase the size of a hash table. */
+
+#define DEFAULT_REHASH_SIZE 1.5
+
\f
/* These structures are used for various misc types. */
/* 1 means normal insertion at the marker's position
leaves the marker after the inserted text. */
unsigned int insertion_type : 1;
+ /* This is the buffer that the marker points into,
+ or 0 if it points nowhere. */
struct buffer *buffer;
+
+ /* The remaining fields are meaningless in a marker that
+ does not point anywhere. */
+
+ /* For markers that point somewhere,
+ this is used to chain of all the markers in a given buffer. */
Lisp_Object chain;
- int bufpos;
+ /* This is the char position where the marker points. */
+ int charpos;
+ /* This is the byte position. */
+ int bytepos;
};
/* Forwarding pointer to an int variable.
int offset;
};
-/* Used in a symbol value cell when the symbol's value is per-buffer.
- The actual contents resemble a cons cell which starts a list like this:
- (REALVALUE BUFFER CURRENT-ALIST-ELEMENT . DEFAULT-VALUE).
-
- The cons-like structure is for historical reasons; it might be better
- to just put these elements into the struct, now.
-
- BUFFER is the last buffer for which this symbol's value was
- made up to date.
-
- CURRENT-ALIST-ELEMENT is a pointer to an element of BUFFER's
- local_var_alist, that being the element whose car is this
- variable. Or it can be a pointer to the
- (CURRENT-ALIST-ELEMENT . DEFAULT-VALUE),
- if BUFFER does not have an element in its alist for this
- variable (that is, if BUFFER sees the default value of this
- variable).
-
- If we want to examine or set the value and BUFFER is current,
- we just examine or set REALVALUE. If BUFFER is not current, we
- store the current REALVALUE value into CURRENT-ALIST-ELEMENT,
- then find the appropriate alist element for the buffer now
- current and set up CURRENT-ALIST-ELEMENT. Then we set
- REALVALUE out of that element, and store into BUFFER.
-
- If we are setting the variable and the current buffer does not
- have an alist entry for this variable, an alist entry is
- created.
-
- Note that REALVALUE can be a forwarding pointer. Each time it
- is examined or set, forwarding must be done. Each time we
- switch buffers, buffer-local variables which forward into C
- variables are swapped immediately, so the C code can assume
- that they are always up to date.
+/* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
+ the symbol has buffer-local or frame-local bindings. (Exception:
+ some buffer-local variables are built-in, with their values stored
+ in the buffer structure itself. They are handled differently,
+ using struct Lisp_Buffer_Objfwd.)
+
+ The `realvalue' slot holds the variable's current value, or a
+ forwarding pointer to where that value is kept. This value is the
+ one that corresponds to the loaded binding. To read or set the
+ variable, you must first make sure the right binding is loaded;
+ then you can access the value in (or through) `realvalue'.
+
+ `buffer' and `frame' are the buffer and frame for which the loaded
+ binding was found. If those have changed, to make sure the right
+ binding is loaded it is necessary to find which binding goes with
+ the current buffer and selected frame, then load it. To load it,
+ first unload the previous binding, then copy the value of the new
+ binding into `realvalue' (or through it). Also update
+ LOADED-BINDING to point to the newly loaded binding.
Lisp_Misc_Buffer_Local_Value and Lisp_Misc_Some_Buffer_Local_Value
- use the same substructure. The difference is that with the latter,
- merely setting the variable while some buffer is current
- does not cause that buffer to have its own local value of this variable.
- Only make-local-variable does that. */
+ both use this kind of structure. With the former, merely setting
+ the variable creates a local binding for the current buffer. With
+ the latter, setting the variable does not do that; only
+ make-local-variable does that. */
+
struct Lisp_Buffer_Local_Value
{
- int type : 16; /* = Lisp_Misc_Buffer_Local_Value
- or Lisp_Misc_Some_Buffer_Local_Value */
- int spacer : 16;
- Lisp_Object car, cdr;
+ int type : 16; /* = Lisp_Misc_Buffer_Local_Value
+ or Lisp_Misc_Some_Buffer_Local_Value */
+ int spacer : 13;
+
+ /* 1 means this variable is allowed to have frame-local bindings,
+ so check for them when looking for the proper binding. */
+ unsigned int check_frame : 1;
+ /* 1 means that the binding now loaded was found
+ as a local binding for the buffer in the `buffer' slot. */
+ unsigned int found_for_buffer : 1;
+ /* 1 means that the binding now loaded was found
+ as a local binding for the frame in the `frame' slot. */
+ unsigned int found_for_frame : 1;
+ Lisp_Object realvalue;
+ /* The buffer and frame for which the loaded binding was found. */
+ Lisp_Object buffer, frame;
+
+ /* A cons cell, (LOADED-BINDING . DEFAULT-VALUE).
+
+ LOADED-BINDING is the binding now loaded. It is a cons cell
+ whose cdr is the binding's value. The cons cell may be an
+ element of a buffer's local-variable alist, or an element of a
+ frame's parameter alist, or it may be this cons cell.
+
+ DEFAULT-VALUE is the variable's default value, seen when the
+ current buffer and selected frame do not have their own
+ bindings for the variable. When the default binding is loaded,
+ LOADED-BINDING is actually this very cons cell; thus, its car
+ points to itself. */
+ Lisp_Object cdr;
};
/* In an overlay object, the mark bit of the plist is used as the GC mark.
struct Lisp_Kboard_Objfwd u_kboard_objfwd;
};
\f
-#ifdef LISP_FLOAT_TYPE
-/* Optional Lisp floating point type */
+/* Lisp floating point type */
struct Lisp_Float
{
Lisp_Object type; /* essentially used for mark-bit
and chaining when on free-list */
+#ifdef HIDE_LISP_IMPLEMENTATION
+ double data_;
+#else
double data;
+#endif
};
-#endif /* LISP_FLOAT_TYPE */
+
+#ifdef HIDE_LISP_IMPLEMENTATION
+#define XFLOAT_DATA(f) (XFLOAT (f)->data_)
+#else
+#define XFLOAT_DATA(f) (XFLOAT (f)->data)
+#endif
/* A character, declared with the following typedef, is a member
of some character set associated with the current buffer. */
#define CHAR_CTL (0x4000000)
#define CHAR_META (0x8000000)
+#define CHAR_MODIFIER_MASK \
+ (CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META)
+
+
/* Actually, the current Emacs uses 19 bits for the character value
itself. */
#define CHARACTERBITS 19
+/* The maximum byte size consumed by push_key_description.
+ All callers should assure that at least this size of memory is
+ allocated at the place pointed by the second argument.
+
+ Thers are 6 modifiers, each consumes 2 chars.
+ The octal form of a character code consumes
+ (1 + CHARACTERBITS / 3 + 1) chars (including backslash at the head).
+ We need one more byte for string terminator `\0'. */
+#define KEY_DESCRIPTION_SIZE ((2 * 6) + 1 + (CHARACTERBITS / 3) + 1 + 1)
+
#ifdef USE_X_TOOLKIT
#ifdef NO_UNION_TYPE
/* Use this for turning a (void *) into a Lisp_Object, as when the
\f
/* The glyph datatype, used to represent characters on the display. */
-/* The low 19 bits (CHARACTERBITS) are the character code, and the
- bits above them except for the topmost two bits are the numeric
- face ID. If FID is the face ID of a glyph on a frame F, then
- F->display.x->faces[FID] contains the description of that face.
- This is an int instead of a short, so we can support a good bunch
- of face ID's (i.e. 2^(32 - 19 - 2) = 2048 ID's) ; given that we
+/* Glyph code to use as an index to the glyph table. If it is out of
+ range for the glyph table, or the corresonding element in the table
+ is nil, the low 8 bits are the single byte character code, and the
+ bits above are the numeric face ID. If FID is the face ID of a
+ glyph on a frame F, then F->display.x->faces[FID] contains the
+ description of that face. This is an int instead of a short, so we
+ can support a good bunch of face ID's (2^(31 - 8)); given that we
have no mechanism for tossing unused frame face ID's yet, we'll
- probably run out of 255 pretty quickly. */
-#define GLYPH unsigned int
-
-/* Mask bit for a glyph of a character which should be written from
- right to left. */
-#define GLYPH_MASK_REV_DIR 0x80000000
-/* Mask bit for a padding glyph of a multi-column character. */
-#define GLYPH_MASK_PADDING 0x40000000
+ probably run out of 255 pretty quickly.
+ This is always -1 for a multibyte character. */
+#define GLYPH int
+
/* Mask bits for face. */
-#define GLYPH_MASK_FACE 0x3FF80000
-/* Mask bits for character code. */
+#define GLYPH_MASK_FACE 0x7FF80000
+ /* Mask bits for character code. */
#define GLYPH_MASK_CHAR 0x0007FFFF /* The lowest 19 bits */
-#ifdef HAVE_FACES
/* The FAST macros assume that we already know we're in an X window. */
-/* Given a character code and a face ID, return the appropriate glyph. */
+/* Set a character code and a face ID in a glyph G. */
#define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << CHARACTERBITS))
/* Return a glyph's character code. */
#define FAST_GLYPH_FACE(glyph) (((glyph) & GLYPH_MASK_FACE) >> CHARACTERBITS)
/* Slower versions that test the frame type first. */
-#define MAKE_GLYPH(f, char, face) (FRAME_TERMCAP_P (f) ? (char) \
- : FAST_MAKE_GLYPH (char, face))
-#define GLYPH_CHAR(f, g) (FRAME_TERMCAP_P (f) ? (g) : FAST_GLYPH_CHAR (g))
-#define GLYPH_FACE(f, g) (FRAME_TERMCAP_P (f) ? (0) : FAST_GLYPH_FACE (g))
-#else /* not HAVE_FACES */
-#define MAKE_GLYPH(f, char, face) (char)
-#define FAST_MAKE_GLYPH(char, face) (char)
-#define GLYPH_CHAR(f, g) ((g) & GLYPH_MASK_CHAR)
-#define FAST_GLYPH_CHAR(g) ((g) & GLYPH_MASK_CHAR)
-#define GLYPH_FACE(f, g) ((g) & GLYPH_MASK_FACE)
-#define FAST_GLYPH_FACE(g) ((g) & GLYPH_MASK_FACE)
-#endif /* not HAVE_FACES */
+#define MAKE_GLYPH(f, char, face) (FAST_MAKE_GLYPH (char, face))
+#define GLYPH_CHAR(f, g) (FAST_GLYPH_CHAR (g))
+#define GLYPH_FACE(f, g) (FAST_GLYPH_FACE (g))
/* Return 1 iff GLYPH contains valid character code. */
#define GLYPH_CHAR_VALID_P(glyph) \
#define NILP(x) (XFASTINT (x) == XFASTINT (Qnil))
#define GC_NILP(x) GC_EQ (x, Qnil)
-#ifdef LISP_FLOAT_TYPE
#define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
#define GC_NUMBERP(x) (GC_INTEGERP (x) || GC_FLOATP (x))
-#else
-#define NUMBERP(x) (INTEGERP (x))
-#define GC_NUMBERP(x) (GC_INTEGERP (x))
-#endif
#define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
#define GC_NATNUMP(x) (GC_INTEGERP (x) && XINT (x) >= 0)
#define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
#define GC_CONSP(x) (XGCTYPE ((x)) == Lisp_Cons)
-#ifdef LISP_FLOAT_TYPE
#define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
#define GC_FLOATP(x) (XGCTYPE ((x)) == Lisp_Float)
-#else
-#define FLOATP(x) (0)
-#define GC_FLOATP(x) (0)
-#endif
#define VECTORP(x) (VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
#define GC_VECTORP(x) (GC_VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
#define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
else if (!INTEGERP ((x))) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } while (0)
-#ifdef LISP_FLOAT_TYPE
-
-#ifndef DBL_DIG
-#define DBL_DIG 20
-#endif
-
#define XFLOATINT(n) extract_float((n))
#define CHECK_FLOAT(x, i) \
else if (!INTEGERP (x) && !FLOATP (x)) \
x = wrong_type_argument (Qnumber_or_marker_p, (x)); } while (0)
-#else /* Not LISP_FLOAT_TYPE */
-
-#define CHECK_NUMBER_OR_FLOAT CHECK_NUMBER
-
-#define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER CHECK_NUMBER_COERCE_MARKER
-
-#define XFLOATINT(n) XINT((n))
-#endif /* LISP_FLOAT_TYPE */
-
#define CHECK_OVERLAY(x, i) \
do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
/* Cast pointers to this type to compare them. Some machines want int. */
#ifndef PNTR_COMPARISON_TYPE
-#define PNTR_COMPARISON_TYPE unsigned int
+#define PNTR_COMPARISON_TYPE EMACS_UINT
#endif
\f
/* Define a built-in function for calling from Lisp.
A null string means call interactively with no arguments.
`doc' is documentation for the user. */
-#if !defined (__STDC__) || defined (USE_NONANSI_DEFUN)
+#if (!defined (__STDC__) && !defined (PROTOTYPES)) \
+ || defined (USE_NONANSI_DEFUN)
#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
Lisp_Object fnname (); \
struct Lisp_Subr sname = \
Lisp_Object, Lisp_Object)
#define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
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))) \
+ || COMPILEDP (OBJ) \
+ || SUBRP (OBJ))
+
/* defsubr (Sname);
is how we define the symbol for function `name' at start-up time. */
-extern void defsubr ();
+extern void defsubr P_ ((struct Lisp_Subr *));
#define MANY -2
#define UNEVALLED -1
-extern void defvar_lisp ();
-extern void defvar_bool ();
-extern void defvar_int ();
-extern void defvar_kboard ();
+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 *, int *));
+extern void defvar_per_buffer P_ ((char *, Lisp_Object *, Lisp_Object, char *));
+extern void defvar_kboard P_ ((char *, int));
/* Macros we use to define forwarded Lisp variables.
These are used in the syms_of_FILENAME functions. */
If func is zero and symbol is nil, undoing this binding evaluates
the list of forms in old_value; this implements Lisp's unwind-protect
form.
- Otherwise, undoing this binding stores old_value as symbol's value; this
- undoes the bindings made by a let form or function call. */
+
+ Otherwise, the element is a variable binding.
+ If the symbol field is a symbol, it is an ordinary variable binding.
+ Otherwise, it should be a structure (SYMBOL BUFFER . BUFFER),
+ which represents having bound BUFFER's local value,
+ or (SYMBOL nil . BUFFER), which represents having bound the default
+ value when BUFFER was current (buffer not having any local binding
+ for SYMBOL). */
+
struct specbinding
{
Lisp_Object symbol, old_value;
- Lisp_Object (*func) ();
+ Lisp_Object (*func) P_ ((Lisp_Object));
Lisp_Object unused; /* Dividing by 16 is faster than by 12 */
};
extern struct specbinding *specpdl_ptr;
extern int specpdl_size;
+#define BINDING_STACK_SIZE() (specpdl_ptr - specpdl)
+
/* Everything needed to describe an active condition case. */
struct handler
{
Tells GC how to save a copy of the stack. */
extern char *stack_bottom;
-/* Check quit-flag and quit if it is non-nil. */
+/* Check quit-flag and quit if it is non-nil.
+ Typing C-g does not directly cause a quit; it only sets Vquit_flag.
+ So the program needs to do QUIT at times when it is safe to quit.
+ Every loop that might run for a long time or might not exit
+ ought to do QUIT at least once, at a safe place.
+ Unless that is impossible, of course.
+ But it is very desirable to avoid creating loops where QUIT is impossible.
+
+ Exception: if you set immediate_quit to nonzero,
+ then the handler that responds to the C-g does the quit itself.
+ This is a good thing to do around a loop that has no side effects
+ and (in particular) cannot call arbitrary Lisp code. */
-#define QUIT \
- if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
- { Vquit_flag = Qnil; Fsignal (Qquit, Qnil); }
+#define QUIT \
+ do { \
+ if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
+ { \
+ Vquit_flag = Qnil; \
+ Fsignal (Qquit, Qnil); \
+ } \
+ } while (0)
/* Nonzero if ought to quit now. */
extern struct gcpro *gcprolist;
struct gcpro
- {
- struct gcpro *next;
- Lisp_Object *var; /* Address of first protected variable */
- int nvars; /* Number of consecutive protected variables */
- };
+{
+ struct gcpro *next;
+
+ /* Address of first protected variable. */
+ volatile Lisp_Object *var;
+
+ /* Number of consecutive protected variables. */
+ int nvars;
+
+#ifdef DEBUG_GCPRO
+ int level;
+#endif
+};
+
+/* Values of GC_MARK_STACK during compilation:
+
+ 0 Use GCPRO as before
+ 1 Do the real thing, make GCPROs and UNGCPRO no-ops.
+ 2 Mark the stack, and check that everything GCPRO'd is
+ marked.
+ 3 Mark using GCPRO's, mark stack last, and count how many
+ dead objects are kept alive. */
+
+
+#define GC_USE_GCPROS_AS_BEFORE 0
+#define GC_MAKE_GCPROS_NOOPS 1
+#define GC_MARK_STACK_CHECK_GCPROS 2
+#define GC_USE_GCPROS_CHECK_ZOMBIES 3
+
+#ifndef GC_MARK_STACK
+#define GC_MARK_STACK GC_USE_GCPROS_AS_BEFORE
+#endif
+
+#if GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS
+
+#define GCPRO1(varname) ((void) 0)
+#define GCPRO2(varname1, varname2)((void) 0)
+#define GCPRO3(varname1, varname2, varname3) ((void) 0)
+#define GCPRO4(varname1, varname2, varname3, varname4) ((void) 0)
+#define GCPRO5(varname1, varname2, varname3, varname4, varname5) ((void) 0)
+#define UNGCPRO ((void) 0)
+
+#else /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
+
+#ifndef DEBUG_GCPRO
#define GCPRO1(varname) \
{gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
gcprolist = &gcpro5; }
-/* Call staticpro (&var) to protect static variable `var'. */
+#define UNGCPRO (gcprolist = gcpro1.next)
-void staticpro();
+#else
+
+extern int gcpro_level;
+
+#define GCPRO1(varname) \
+ {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
+ gcpro1.level = gcpro_level++; \
+ gcprolist = &gcpro1; }
+
+#define GCPRO2(varname1, varname2) \
+ {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
+ gcpro1.level = gcpro_level; \
+ gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
+ gcpro2.level = gcpro_level++; \
+ gcprolist = &gcpro2; }
+
+#define GCPRO3(varname1, varname2, varname3) \
+ {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
+ gcpro1.level = gcpro_level; \
+ gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
+ gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
+ gcpro3.level = gcpro_level++; \
+ gcprolist = &gcpro3; }
+
+#define GCPRO4(varname1, varname2, varname3, varname4) \
+ {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
+ gcpro1.level = gcpro_level; \
+ gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
+ gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
+ gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
+ gcpro4.level = gcpro_level++; \
+ gcprolist = &gcpro4; }
+
+#define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
+ {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
+ gcpro1.level = gcpro_level; \
+ gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
+ gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
+ gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
+ gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
+ gcpro5.level = gcpro_level++; \
+ gcprolist = &gcpro5; }
+
+#define UNGCPRO \
+ ((--gcpro_level != gcpro1.level) \
+ ? (abort (), 0) \
+ : ((gcprolist = gcpro1.next), 0))
+
+#endif /* DEBUG_GCPRO */
+#endif /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
-#define UNGCPRO (gcprolist = gcpro1.next)
/* Evaluate expr, UNGCPRO, and then return the value of expr. */
#define RETURN_UNGCPRO(expr) \
-if (1) \
+do \
{ \
Lisp_Object ret_ungc_val; \
ret_ungc_val = (expr); \
UNGCPRO; \
return ret_ungc_val; \
} \
-else
+while (0)
+
+/* Call staticpro (&var) to protect static variable `var'. */
+
+void staticpro P_ ((Lisp_Object *));
\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)) \
+ || defined (USE_NONANSI_DEFUN)
+#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;
+struct frame;
+
/* Defined in data.c */
extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
extern Lisp_Object Qend_of_file, Qarith_error;
extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
-extern Lisp_Object Qmark_inactive;
+extern Lisp_Object Qmark_inactive, Qtext_read_only;
extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
extern Lisp_Object Qoverflow_error, Qunderflow_error;
extern Lisp_Object Qbuffer_or_string_p;
extern Lisp_Object Qcdr;
-#ifdef LISP_FLOAT_TYPE
extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
-#endif /* LISP_FLOAT_TYPE */
extern Lisp_Object Qframep;
-extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp ();
-extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp ();
-extern Lisp_Object Fvectorp (), Fstringp (), Farrayp (), Fsequencep ();
-extern Lisp_Object Fbufferp (), Fmarkerp (), Fsubrp (), Fchar_or_string_p ();
-extern Lisp_Object Finteger_or_marker_p ();
-#ifdef LISP_FLOAT_TYPE
-extern Lisp_Object Ffloatp(), Finteger_or_floatp();
-extern Lisp_Object Finteger_or_float_or_marker_p(), Ftruncate();
-#endif /* LISP_FLOAT_TYPE */
-
-extern Lisp_Object Fcar (), Fcar_safe(), Fcdr (), Fcdr_safe();
-extern Lisp_Object Fsetcar (), Fsetcdr ();
-extern Lisp_Object Fboundp (), Ffboundp (), Fmakunbound (), Ffmakunbound ();
-extern Lisp_Object Fsymbol_function (), Fsymbol_plist (), Fsymbol_name ();
-extern Lisp_Object indirect_function (), Findirect_function ();
-extern Lisp_Object Ffset (), Fsetplist ();
-extern Lisp_Object Fsymbol_value (), find_symbol_value (), Fset ();
-extern Lisp_Object Fdefault_value (), Fset_default (), Fdefault_boundp ();
-extern Lisp_Object Fmake_local_variable ();
-extern Lisp_Object Flocal_variable_if_set_p ();
-
-extern Lisp_Object Faref (), Faset ();
-
-extern Lisp_Object Fstring_to_number (), Fnumber_to_string ();
-extern Lisp_Object Feqlsign (), Fgtr (), Flss (), Fgeq (), Fleq ();
-extern Lisp_Object Fneq (), Fzerop ();
-extern Lisp_Object Fplus (), Fminus (), Ftimes (), Fquo (), Frem ();
-extern Lisp_Object Fmax (), Fmin ();
-extern Lisp_Object Flogand (), Flogior (), Flogxor (), Flognot ();
-extern Lisp_Object Flsh (), Fash ();
-
-extern Lisp_Object Fadd1 (), Fsub1 ();
-
-extern Lisp_Object long_to_cons ();
-extern unsigned long cons_to_long ();
-extern void args_out_of_range ();
-extern void args_out_of_range_3 ();
-extern Lisp_Object wrong_type_argument ();
-extern void store_symval_forwarding ();
-extern Lisp_Object do_symval_forwarding ();
-#ifdef LISP_FLOAT_TYPE
-extern Lisp_Object Ffloat_to_int(), Fint_to_float();
-extern double extract_float();
-extern Lisp_Object make_float ();
-extern Lisp_Object Ffloat ();
-#endif /* LISP_FLOAT_TYPE */
+EXFUN (Feq, 2);
+EXFUN (Fnull, 1);
+EXFUN (Flistp, 1);
+EXFUN (Fconsp, 1);
+EXFUN (Fatom, 1);
+EXFUN (Fnlistp, 1);
+EXFUN (Fintegerp, 1);
+EXFUN (Fnatnump, 1);
+EXFUN (Fsymbolp, 1);
+EXFUN (Fvectorp, 1);
+EXFUN (Fstringp, 1);
+EXFUN (Fmultibyte_string_p, 1);
+EXFUN (Farrayp, 1);
+EXFUN (Fsequencep, 1);
+EXFUN (Fbufferp, 1);
+EXFUN (Fmarkerp, 1);
+EXFUN (Fsubrp, 1);
+EXFUN (Fchar_or_string_p, 1);
+EXFUN (Finteger_or_marker_p, 1);
+EXFUN (Ffloatp, 1);
+EXFUN (Finteger_or_floatp, 1);
+EXFUN (Finteger_or_float_or_marker_p, 1);
+
+EXFUN (Fcar, 1);
+EXFUN (Fcar_safe, 1);
+EXFUN (Fcdr, 1);
+EXFUN (Fcdr_safe, 1);
+EXFUN (Fsetcar, 2);
+EXFUN (Fsetcdr, 2);
+EXFUN (Fboundp, 1);
+EXFUN (Ffboundp, 1);
+EXFUN (Fmakunbound, 1);
+EXFUN (Ffmakunbound, 1);
+EXFUN (Fsymbol_function, 1);
+EXFUN (Fsymbol_plist, 1);
+EXFUN (Fsymbol_name, 1);
+extern Lisp_Object indirect_function P_ ((Lisp_Object));
+EXFUN (Findirect_function, 1);
+EXFUN (Ffset, 2);
+EXFUN (Fsetplist, 2);
+EXFUN (Fsymbol_value, 1);
+extern Lisp_Object find_symbol_value P_ ((Lisp_Object));
+EXFUN (Fset, 2);
+EXFUN (Fdefault_value, 1);
+EXFUN (Fset_default, 2);
+EXFUN (Fdefault_boundp, 1);
+EXFUN (Fmake_local_variable, 1);
+EXFUN (Flocal_variable_p, 2);
+EXFUN (Flocal_variable_if_set_p, 2);
+
+EXFUN (Faref, 2);
+EXFUN (Faset, 3);
+
+EXFUN (Fstring_to_number, 2);
+EXFUN (Fnumber_to_string, 1);
+EXFUN (Feqlsign, 2);
+EXFUN (Fgtr, 2);
+EXFUN (Flss, 2);
+EXFUN (Fgeq, 2);
+EXFUN (Fleq, 2);
+EXFUN (Fneq, 2);
+EXFUN (Fzerop, 1);
+EXFUN (Fplus, MANY);
+EXFUN (Fminus, MANY);
+EXFUN (Ftimes, MANY);
+EXFUN (Fquo, MANY);
+EXFUN (Frem, 2);
+EXFUN (Fmax, MANY);
+EXFUN (Fmin, MANY);
+EXFUN (Flogand, MANY);
+EXFUN (Flogior, MANY);
+EXFUN (Flogxor, MANY);
+EXFUN (Flognot, 1);
+EXFUN (Flsh, 2);
+EXFUN (Fash, 2);
+
+EXFUN (Fadd1, 1);
+EXFUN (Fsub1, 1);
+EXFUN (Fmake_variable_buffer_local, 1);
+
+extern Lisp_Object long_to_cons P_ ((unsigned long));
+extern unsigned long cons_to_long P_ ((Lisp_Object));
+extern void args_out_of_range P_ ((Lisp_Object, Lisp_Object));
+extern void args_out_of_range_3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object wrong_type_argument P_ ((Lisp_Object, Lisp_Object));
+extern void store_symval_forwarding P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object do_symval_forwarding P_ ((Lisp_Object));
+extern Lisp_Object set_internal P_ ((Lisp_Object, Lisp_Object, struct buffer *, int));
+extern void syms_of_data P_ ((void));
+extern void init_data P_ ((void));
+extern void swap_in_global_binding P_ ((Lisp_Object));
/* Defined in cmds.c */
-extern Lisp_Object Fend_of_line (), Fforward_char (), Fforward_line ();
+EXFUN (Fend_of_line, 1);
+EXFUN (Fforward_char, 1);
+EXFUN (Fforward_line, 1);
+extern int forward_point P_ ((int));
+extern int internal_self_insert P_ ((int, int));
+extern void syms_of_cmds P_ ((void));
+extern void keys_of_cmds P_ ((void));
/* Defined in coding.c */
-extern Lisp_Object Fcoding_system_p (), Fcheck_coding_system ();
-extern Lisp_Object Fread_coding_system (), Fread_non_nil_coding_system ();
-extern Lisp_Object Ffind_coding_system ();
+EXFUN (Fcoding_system_p, 1);
+EXFUN (Fcheck_coding_system, 1);
+EXFUN (Fread_coding_system, 2);
+EXFUN (Fread_non_nil_coding_system, 1);
+EXFUN (Ffind_operation_coding_system, MANY);
+EXFUN (Fencode_coding_string, 3);
+EXFUN (Fdecode_coding_string, 3);
+extern Lisp_Object detect_coding_system P_ ((unsigned char *, int, int, int));
+Lisp_Object code_convert_string_norecord P_ ((Lisp_Object, Lisp_Object, int));
+extern void init_coding P_ ((void));
+extern void init_coding_once P_ ((void));
+extern void syms_of_coding P_ ((void));
+extern Lisp_Object code_convert_string_norecord P_ ((Lisp_Object, Lisp_Object,
+ int));
+
+/* Defined in charset.c */
+extern int nonascii_insert_offset;
+extern Lisp_Object Vnonascii_translation_table;
+EXFUN (Fchar_bytes, 1);
+EXFUN (Fchar_width, 1);
+EXFUN (Fstring, MANY);
+extern int chars_in_text P_ ((unsigned char *, int));
+extern int multibyte_chars_in_text P_ ((unsigned char *, int));
+extern int unibyte_char_to_multibyte P_ ((int));
+extern int multibyte_char_to_unibyte P_ ((int, Lisp_Object));
+extern Lisp_Object Qcharset;
+extern void init_charset_once P_ ((void));
+extern void syms_of_charset P_ ((void));
/* Defined in syntax.c */
-extern Lisp_Object Fforward_word ();
+EXFUN (Fforward_word, 1);
+EXFUN (Fskip_chars_forward, 2);
+EXFUN (Fskip_chars_backward, 2);
+EXFUN (Fsyntax_table_p, 1);
+EXFUN (Fsyntax_table, 0);
+EXFUN (Fset_syntax_table, 1);
+extern void init_syntax_once P_ ((void));
+extern void syms_of_syntax P_ ((void));
/* Defined in fns.c */
+extern int use_dialog_box;
+extern int next_almost_prime P_ ((int));
+extern Lisp_Object larger_vector P_ ((Lisp_Object, int, Lisp_Object));
+extern void sweep_weak_hash_tables P_ ((void));
extern Lisp_Object Qstring_lessp;
+EXFUN (Foptimize_char_table, 1);
extern Lisp_Object Vfeatures;
-extern Lisp_Object Fidentity (), Frandom ();
-extern Lisp_Object Flength (), Fsafe_length ();
-extern Lisp_Object Fappend (), Fconcat (), Fvconcat (), Fcopy_sequence ();
-extern Lisp_Object Fsubstring ();
-extern Lisp_Object Fnth (), Fnthcdr (), Fmemq (), Fassq (), Fassoc ();
-extern Lisp_Object Felt (), Fmember (), Frassq (), Fdelq (), Fsort ();
-extern Lisp_Object Freverse (), Fnreverse (), Fget (), Fput (), Fequal ();
-extern Lisp_Object Ffillarray (), Fnconc (), Fmapcar (), Fmapconcat ();
-extern Lisp_Object Fy_or_n_p (), do_yes_or_no_p ();
-extern Lisp_Object Ffeaturep (), Frequire () , Fprovide ();
-extern Lisp_Object concat2 (), concat3 (), nconc2 ();
-extern Lisp_Object assq_no_quit ();
-extern Lisp_Object Fcopy_alist ();
-extern Lisp_Object Fplist_get ();
-extern Lisp_Object Fset_char_table_parent ();
-extern Lisp_Object Fchar_table_extra_slot ();
-extern Lisp_Object Frassoc ();
+extern Lisp_Object QCtest, QCweakness, Qequal;
+unsigned sxhash P_ ((Lisp_Object, int));
+Lisp_Object make_hash_table P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
+ Lisp_Object, Lisp_Object, Lisp_Object,
+ Lisp_Object));
+Lisp_Object copy_hash_table P_ ((struct Lisp_Hash_Table *));
+int hash_lookup P_ ((struct Lisp_Hash_Table *, Lisp_Object, unsigned *));
+int hash_put P_ ((struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
+ unsigned));
+void hash_remove P_ ((struct Lisp_Hash_Table *, Lisp_Object));
+void hash_clear P_ ((struct Lisp_Hash_Table *));
+void remove_hash_entry P_ ((struct Lisp_Hash_Table *, int));
+extern void init_fns P_ ((void));
+EXFUN (Fsxhash, 1);
+EXFUN (Fmake_hash_table, MANY);
+EXFUN (Fcopy_hash_table, 1);
+EXFUN (Fhash_table_count, 1);
+EXFUN (Fhash_table_rehash_size, 1);
+EXFUN (Fhash_table_rehash_threshold, 1);
+EXFUN (Fhash_table_size, 1);
+EXFUN (Fhash_table_test, 1);
+EXFUN (Fhash_table_weak, 1);
+EXFUN (Fhash_table_p, 1);
+EXFUN (Fclrhash, 1);
+EXFUN (Fgethash, 3);
+EXFUN (Fputhash, 3);
+EXFUN (Fremhash, 2);
+EXFUN (Fmaphash, 2);
+EXFUN (Fdefine_hash_table_test, 3);
+
+EXFUN (Fidentity, 1);
+EXFUN (Frandom, 1);
+EXFUN (Flength, 1);
+EXFUN (Fsafe_length, 1);
+EXFUN (Fappend, MANY);
+EXFUN (Fconcat, MANY);
+EXFUN (Fvconcat, MANY);
+EXFUN (Fcopy_sequence, 1);
+EXFUN (Fstring_make_multibyte, 1);
+EXFUN (Fstring_make_unibyte, 1);
+EXFUN (Fstring_as_multibyte, 1);
+EXFUN (Fstring_as_unibyte, 1);
+EXFUN (Fsubstring, 3);
+extern Lisp_Object substring_both P_ ((Lisp_Object, int, int, int, int));
+EXFUN (Fnth, 2);
+EXFUN (Fnthcdr, 2);
+EXFUN (Fmemq, 2);
+EXFUN (Fassq, 2);
+EXFUN (Fassoc, 2);
+EXFUN (Felt, 2);
+EXFUN (Fmember, 2);
+EXFUN (Frassq, 2);
+EXFUN (Fdelq, 2);
+EXFUN (Fsort, 2);
+EXFUN (Freverse, 1);
+EXFUN (Fnreverse, 1);
+EXFUN (Fget, 2);
+EXFUN (Fput, 3);
+EXFUN (Fequal, 2);
+EXFUN (Ffillarray, 2);
+EXFUN (Fnconc, MANY);
+EXFUN (Fmapcar, 2);
+EXFUN (Fmapconcat, 3);
+EXFUN (Fy_or_n_p, 1);
+extern Lisp_Object do_yes_or_no_p P_ ((Lisp_Object));
+EXFUN (Ffeaturep, 1);
+EXFUN (Frequire, 3);
+EXFUN (Fprovide, 1);
+extern Lisp_Object concat2 P_ ((Lisp_Object, Lisp_Object));
+extern Lisp_Object concat3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object nconc2 P_ ((Lisp_Object, Lisp_Object));
+extern Lisp_Object assq_no_quit P_ ((Lisp_Object, Lisp_Object));
+extern void clear_string_char_byte_cache P_ ((void));
+extern int string_char_to_byte P_ ((Lisp_Object, int));
+extern int string_byte_to_char P_ ((Lisp_Object, int));
+extern Lisp_Object string_make_multibyte P_ ((Lisp_Object));
+extern Lisp_Object string_make_unibyte P_ ((Lisp_Object));
+EXFUN (Fcopy_alist, 1);
+EXFUN (Fplist_get, 2);
+EXFUN (Fplist_put, 3);
+EXFUN (Fset_char_table_parent, 2);
+EXFUN (Fchar_table_extra_slot, 2);
+EXFUN (Fset_char_table_extra_slot, 3);
+EXFUN (Frassoc, 2);
+EXFUN (Fstring_equal, 2);
+EXFUN (Fcompare_strings, 7);
+EXFUN (Fstring_lessp, 2);
+extern int char_table_translate P_ ((Lisp_Object, int));
+extern void map_char_table P_ ((void (*) (Lisp_Object, Lisp_Object, Lisp_Object),
+ Lisp_Object, Lisp_Object, Lisp_Object, int,
+ Lisp_Object *));
+extern Lisp_Object char_table_ref_and_index P_ ((Lisp_Object, int, int *));
+extern void syms_of_fns P_ ((void));
+
+/* Defined in floatfns.c */
+extern double extract_float P_ ((Lisp_Object));
+EXFUN (Ffloat, 1);
+EXFUN (Ftruncate, 2);
+extern void init_floatfns P_ ((void));
+extern void syms_of_floatfns P_ ((void));
/* Defined in insdel.c */
-extern void move_gap ();
-extern void make_gap ();
-extern void insert ();
-extern void insert_and_inherit ();
-extern void insert_1 ();
-extern void insert_from_string ();
-extern void insert_from_buffer ();
-extern void insert_char ();
-extern void insert_string ();
-extern void insert_before_markers ();
-extern void insert_before_markers_and_inherit ();
-extern void insert_from_string_before_markers ();
-extern void del_range ();
-extern void del_range_1 ();
-extern void modify_region ();
-extern void prepare_to_modify_buffer ();
-extern void signal_before_change ();
-extern void signal_after_change ();
+extern void move_gap P_ ((int));
+extern void move_gap_both P_ ((int, int));
+extern void make_gap P_ ((int));
+extern int copy_text P_ ((unsigned char *, unsigned char *, int, int, int));
+extern int count_size_as_multibyte P_ ((unsigned char *, int));
+extern int count_combining_before P_ ((unsigned char *, int, int, int));
+extern int count_combining_after P_ ((unsigned char *, int, int, int));
+extern void insert P_ ((unsigned char *, int));
+extern void insert_and_inherit P_ ((unsigned char *, int));
+extern void insert_1 P_ ((unsigned char *, int, int, int, int));
+extern void insert_1_both P_ ((unsigned char *, int, int, int, int, int));
+extern void insert_from_string P_ ((Lisp_Object, int, int, int, int, int));
+extern void insert_from_buffer P_ ((struct buffer *, int, int, int));
+extern void insert_char P_ ((int));
+extern void insert_string P_ ((char *));
+extern void insert_before_markers P_ ((unsigned char *, int));
+extern void insert_before_markers_and_inherit P_ ((unsigned char *, int));
+extern void insert_from_string_before_markers P_ ((Lisp_Object, int, int, int, int, int));
+extern void del_range P_ ((int, int));
+extern Lisp_Object del_range_1 P_ ((int, int, int, int));
+extern void del_range_byte P_ ((int, int, int));
+extern void del_range_both P_ ((int, int, int, int, int));
+extern Lisp_Object del_range_2 P_ ((int, int, int, int, int));
+extern void modify_region P_ ((struct buffer *, int, int));
+extern void prepare_to_modify_buffer P_ ((int, int, int *));
+extern void signal_before_change P_ ((int, int, int *));
+extern void signal_after_change P_ ((int, int, int));
+extern void adjust_after_replace P_ ((int, int, Lisp_Object, int, int));
+extern void adjust_after_insert P_ ((int, int, int, int, int));
+extern void replace_range P_ ((int, int, Lisp_Object, int, int, int));
+extern void syms_of_insdel P_ ((void));
/* Defined in dispnew.c */
-extern Lisp_Object Fding (), Fredraw_display ();
-extern Lisp_Object Fsleep_for ();
+extern Lisp_Object selected_frame;
+EXFUN (Fding, 1);
+EXFUN (Fredraw_frame, 1);
+EXFUN (Fredraw_display, 0);
+EXFUN (Fsleep_for, 2);
+EXFUN (Fsit_for, 3);
+extern Lisp_Object sit_for P_ ((int, int, int, int, int));
+extern void init_display P_ ((void));
+extern void syms_of_display P_ ((void));
+extern void safe_bcopy P_ ((char *, char *, int));
/* Defined in xdisp.c */
+extern Lisp_Object Qinhibit_point_motion_hooks;
+extern Lisp_Object Qinhibit_redisplay, Qdisplay;
+extern Lisp_Object Qmessage_truncate_lines;
extern Lisp_Object Vmessage_log_max;
-extern void message ();
-extern void message_nolog ();
-extern void message1 ();
-extern void message1_nolog ();
-extern void message2 ();
-extern void message2_nolog ();
-extern void message_dolog ();
-extern void message_log_maybe_newline ();
+extern int message_enable_multibyte;
+extern Lisp_Object echo_area_buffer[2];
+extern void check_message_stack P_ ((void));
+extern void setup_echo_area_for_printing P_ ((int));
+extern int push_message P_ ((void));
+extern Lisp_Object push_message_unwind P_ ((Lisp_Object));
+extern void pop_message P_ ((void));
+extern void restore_message P_ ((void));
+extern Lisp_Object current_message P_ ((void));
+extern void set_message P_ ((char *s, Lisp_Object, int, int));
+extern void clear_message P_ ((int, int));
+extern void message P_ ((/* char *, ... */));
+extern void message_nolog P_ ((/* char *, ... */));
+extern void message1 P_ ((char *));
+extern void message1_nolog P_ ((char *));
+extern void message2 P_ ((char *, int, int));
+extern void message2_nolog P_ ((char *, int, int));
+extern void message3 P_ ((Lisp_Object, int, int));
+extern void message3_nolog P_ ((Lisp_Object, int, int));
+extern void message_dolog P_ ((char *, int, int, int));
+extern void message_with_string P_ ((char *, Lisp_Object, int));
+extern void message_log_maybe_newline P_ ((void));
+extern void update_echo_area P_ ((void));
+extern void truncate_echo_area P_ ((int));
+extern void redisplay P_ ((void));
+extern int check_point_in_composition
+ P_ ((struct buffer *, int, struct buffer *, int));
+extern void redisplay_preserve_echo_area P_ ((int));
+extern void mark_window_display_accurate P_ ((Lisp_Object, int));
+extern int invisible_p P_ ((Lisp_Object, Lisp_Object));
+extern void prepare_menu_bars P_ ((void));
+extern void syms_of_xdisp P_ ((void));
+extern void init_xdisp P_ ((void));
+extern Lisp_Object safe_eval P_ ((Lisp_Object));
+extern int pos_visible_p P_ ((struct window *, int, int *, int));
+
+/* Defined in vm-limit.c. */
+extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
/* Defined in alloc.c */
+extern void allocate_string_data P_ ((struct Lisp_String *, int, int));
+extern void uninterrupt_malloc P_ ((void));
+extern void malloc_warning P_ ((char *));
+extern void memory_full P_ ((void));
+extern void buffer_memory_full P_ ((void));
+extern int survives_gc_p P_ ((Lisp_Object));
+extern void mark_object P_ ((Lisp_Object *));
extern Lisp_Object Vpurify_flag;
-extern Lisp_Object Fcons (), Flist(), Fmake_list (), allocate_misc ();
-extern Lisp_Object Fmake_vector (), Fvector (), Fmake_symbol (), Fmake_marker ();
-extern Lisp_Object Fmake_string (), build_string (), make_string ();
-extern Lisp_Object make_event_array (), make_uninit_string ();
-extern Lisp_Object Fpurecopy (), make_pure_string ();
-extern Lisp_Object pure_cons (), make_pure_vector ();
-extern Lisp_Object Fgarbage_collect ();
-extern Lisp_Object Fmake_byte_code ();
-extern Lisp_Object Fmake_bool_vector (), Fmake_char_table ();
-extern Lisp_Object make_sub_char_table ();
+EXFUN (Fcons, 2);
+EXFUN (list2, 2);
+EXFUN (list3, 3);
+EXFUN (list4, 4);
+EXFUN (list5, 5);
+EXFUN (Flist, MANY);
+EXFUN (Fmake_list, 2);
+extern Lisp_Object allocate_misc P_ ((void));
+EXFUN (Fmake_vector, 2);
+EXFUN (Fvector, MANY);
+EXFUN (Fmake_symbol, 1);
+EXFUN (Fmake_marker, 0);
+EXFUN (Fmake_string, 2);
+extern Lisp_Object build_string P_ ((char *));
+extern Lisp_Object make_string P_ ((char *, int));
+extern Lisp_Object make_unibyte_string P_ ((char *, int));
+extern Lisp_Object make_multibyte_string P_ ((char *, int, int));
+extern Lisp_Object make_event_array P_ ((int, Lisp_Object *));
+extern Lisp_Object make_uninit_string P_ ((int));
+extern Lisp_Object make_uninit_multibyte_string P_ ((int, int));
+extern Lisp_Object make_string_from_bytes P_ ((char *, int, int));
+extern Lisp_Object make_specified_string P_ ((char *, int, int, int));
+EXFUN (Fpurecopy, 1);
+extern Lisp_Object make_pure_string P_ ((char *, int, int, int));
+extern Lisp_Object pure_cons P_ ((Lisp_Object, Lisp_Object));
+extern Lisp_Object make_pure_vector P_ ((EMACS_INT));
+EXFUN (Fgarbage_collect, 0);
+EXFUN (Fmake_byte_code, MANY);
+EXFUN (Fmake_bool_vector, 2);
+EXFUN (Fmake_char_table, 2);
+extern Lisp_Object make_sub_char_table P_ ((Lisp_Object));
extern Lisp_Object Qchar_table_extra_slots;
-extern struct Lisp_Vector *allocate_vectorlike ();
+extern struct Lisp_Vector *allocate_vectorlike P_ ((EMACS_INT));
extern int gc_in_progress;
+extern Lisp_Object make_float P_ ((double));
+extern void display_malloc_warning P_ ((void));
+extern int inhibit_garbage_collection P_ ((void));
+extern void free_marker P_ ((Lisp_Object));
+extern void free_cons P_ ((struct Lisp_Cons *));
+extern void init_alloc_once P_ ((void));
+extern void init_alloc P_ ((void));
+extern void syms_of_alloc P_ ((void));
+extern struct buffer * allocate_buffer P_ ((void));
/* Defined in print.c */
extern Lisp_Object Vprin1_to_string_buffer;
-extern Lisp_Object Fprin1 (), Fprin1_to_string (), Fprinc ();
-extern Lisp_Object Fterpri (), Fprint ();
-extern Lisp_Object Ferror_message_string ();
+extern void debug_print P_ ((Lisp_Object));
+EXFUN (Fprin1, 2);
+EXFUN (Fprin1_to_string, 2);
+EXFUN (Fprinc, 2);
+EXFUN (Fterpri, 1);
+EXFUN (Fprint, 2);
+EXFUN (Ferror_message_string, 1);
extern Lisp_Object Vstandard_output, Qstandard_output;
extern Lisp_Object Qexternal_debugging_output;
-extern void temp_output_buffer_setup (), temp_output_buffer_show ();
+extern void temp_output_buffer_setup P_ ((char *));
extern int print_level, print_escape_newlines;
extern Lisp_Object Qprint_escape_newlines;
+extern void write_string P_ ((char *, int));
+extern void write_string_1 P_ ((char *, int, Lisp_Object));
+extern void print_error_message P_ ((Lisp_Object, Lisp_Object));
+extern Lisp_Object internal_with_output_to_temp_buffer
+ P_ ((char *, Lisp_Object (*) (Lisp_Object), Lisp_Object));
+extern void float_to_string P_ ((unsigned char *, double));
+extern void syms_of_print P_ ((void));
+
+/* 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;
-extern Lisp_Object Vobarray, Vstandard_input;
-extern Lisp_Object Fread (), Fread_from_string ();
-extern Lisp_Object Fintern (), Fintern_soft (), Fload ();
-extern Lisp_Object Fget_file_char (), Fread_char ();
-extern Lisp_Object read_filtered_event ();
-extern Lisp_Object Feval_current_buffer (), Feval_region ();
-extern Lisp_Object intern (), make_symbol (), oblookup ();
+extern Lisp_Object Vobarray, initial_obarray, Vstandard_input;
+EXFUN (Fread, 1);
+EXFUN (Fread_from_string, 3);
+EXFUN (Fintern, 2);
+EXFUN (Fintern_soft, 2);
+EXFUN (Fload, 5);
+EXFUN (Fget_file_char, 0);
+EXFUN (Fread_char, 2);
+EXFUN (Fread_event, 2);
+extern Lisp_Object read_filtered_event P_ ((int, int, int, int));
+EXFUN (Feval_region, 4);
+extern Lisp_Object intern P_ ((char *));
+extern Lisp_Object make_symbol P_ ((char *));
+extern Lisp_Object oblookup P_ ((Lisp_Object, char *, int, int));
#define LOADHIST_ATTACH(x) \
if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
extern Lisp_Object Vcurrent_load_list;
extern Lisp_Object Vload_history;
+extern int openp P_ ((Lisp_Object, Lisp_Object, char *, Lisp_Object *, int));
+extern int isfloat_string P_ ((char *));
+extern void map_obarray P_ ((Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
+ Lisp_Object));
+extern void dir_warning P_ ((char *, Lisp_Object));
+extern void close_load_descs P_ ((void));
+extern void init_obarray P_ ((void));
+extern void init_lread P_ ((void));
+extern void syms_of_lread P_ ((void));
/* Defined in eval.c */
extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments;
extern Lisp_Object Vautoload_queue;
extern Lisp_Object Vdebug_on_error;
+extern Lisp_Object Vsignaling_function;
+extern int handling_signal;
+
/* To run a normal hook, use the appropriate function from the list below.
The calling convention:
should no longer be used. */
extern Lisp_Object Vrun_hooks;
-extern Lisp_Object Frun_hooks (), Frun_hook_with_args ();
-extern Lisp_Object Frun_hook_with_args_until_success ();
-extern Lisp_Object Frun_hook_with_args_until_failure ();
-extern Lisp_Object Fand (), For (), Fif (), Fprogn (), Fprog1 (), Fprog2 ();
-extern Lisp_Object Fsetq (), Fquote ();
-extern Lisp_Object Fuser_variable_p (), Finteractive_p ();
-extern Lisp_Object Fdefun (), Flet (), FletX (), Fwhile ();
-extern Lisp_Object Fcatch (), Fthrow (), Funwind_protect ();
-extern Lisp_Object Fcondition_case (), Fsignal ();
-extern Lisp_Object Ffunction_type (), Fautoload (), Fcommandp ();
-extern Lisp_Object Feval (), Fapply (), Ffuncall ();
-extern Lisp_Object Fglobal_set (), Fglobal_value (), Fbacktrace ();
-extern Lisp_Object apply1 (), call0 (), call1 (), call2 (), call3 ();
-extern Lisp_Object call4 (), call5 (), call6 ();
-extern Lisp_Object Fkill_emacs (), Fkey_binding (), Fsit_for ();
-extern Lisp_Object Fdo_auto_save (), Fset_marker ();
-extern Lisp_Object apply_lambda ();
-extern Lisp_Object internal_catch ();
-extern Lisp_Object internal_condition_case ();
-extern Lisp_Object internal_condition_case_1 ();
-extern Lisp_Object unbind_to ();
-extern void error ();
-extern Lisp_Object un_autoload ();
-extern Lisp_Object Ffetch_bytecode ();
+EXFUN (Frun_hooks, MANY);
+EXFUN (Frun_hook_with_args, MANY);
+EXFUN (Frun_hook_with_args_until_success, MANY);
+EXFUN (Frun_hook_with_args_until_failure, MANY);
+extern Lisp_Object run_hook_list_with_args P_ ((Lisp_Object, int, Lisp_Object *));
+extern void run_hook_with_args_2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+EXFUN (Fand, UNEVALLED);
+EXFUN (For, UNEVALLED);
+EXFUN (Fif, UNEVALLED);
+EXFUN (Fprogn, UNEVALLED);
+EXFUN (Fprog1, UNEVALLED);
+EXFUN (Fprog2, UNEVALLED);
+EXFUN (Fsetq, UNEVALLED);
+EXFUN (Fquote, UNEVALLED);
+EXFUN (Fuser_variable_p, 1);
+EXFUN (Finteractive_p, 0);
+EXFUN (Fdefun, UNEVALLED);
+EXFUN (Flet, UNEVALLED);
+EXFUN (FletX, UNEVALLED);
+EXFUN (Fwhile, UNEVALLED);
+EXFUN (Fcatch, UNEVALLED);
+EXFUN (Fthrow, 2) NO_RETURN;
+EXFUN (Funwind_protect, UNEVALLED);
+EXFUN (Fcondition_case, UNEVALLED);
+EXFUN (Fsignal, 2);
+EXFUN (Fautoload, 5);
+EXFUN (Fcommandp, 1);
+EXFUN (Feval, 1);
+EXFUN (Fapply, MANY);
+EXFUN (Ffuncall, MANY);
+EXFUN (Fbacktrace, 0);
+extern Lisp_Object apply1 P_ ((Lisp_Object, Lisp_Object));
+extern Lisp_Object call0 P_ ((Lisp_Object));
+extern Lisp_Object call1 P_ ((Lisp_Object, Lisp_Object));
+extern Lisp_Object call2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object call3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object call4 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object call5 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object call6 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
+EXFUN (Fdo_auto_save, 2);
+extern Lisp_Object apply_lambda P_ ((Lisp_Object, Lisp_Object, int));
+extern Lisp_Object internal_catch P_ ((Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object));
+extern Lisp_Object internal_condition_case P_ ((Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object)));
+extern Lisp_Object internal_condition_case_1 P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
+extern Lisp_Object internal_condition_case_2 P_ ((Lisp_Object (*) (int, Lisp_Object *), int, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
+extern void specbind P_ ((Lisp_Object, Lisp_Object));
+extern void record_unwind_protect P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object));
+extern Lisp_Object unbind_to P_ ((int, Lisp_Object));
+extern void error P_ ((/* char *, ... */)) NO_RETURN;
+extern void do_autoload P_ ((Lisp_Object, Lisp_Object));
+extern Lisp_Object un_autoload P_ ((Lisp_Object));
+EXFUN (Ffetch_bytecode, 1);
+extern void init_eval_once P_ ((void));
+extern Lisp_Object safe_call P_ ((int, Lisp_Object *));
+extern Lisp_Object safe_call1 P_ ((Lisp_Object, Lisp_Object));
+extern void init_eval P_ ((void));
+extern void syms_of_eval P_ ((void));
/* Defined in editfns.c */
-extern Lisp_Object Fgoto_char ();
-extern Lisp_Object Fpoint_min_marker (), Fpoint_max_marker ();
-extern Lisp_Object Fpoint_min (), Fpoint_max ();
-extern Lisp_Object Fpoint (), Fpoint_marker (), Fmark_marker ();
-extern Lisp_Object Fline_beginning_position (), Fline_end_position ();
-extern Lisp_Object Ffollowing_char (), Fprevious_char (), Fchar_after ();
-extern Lisp_Object Finsert (), Finsert_and_inherit ();
-extern Lisp_Object Finsert_before_markers ();
-extern Lisp_Object Finsert_buffer_substring ();
-extern Lisp_Object Finsert_char ();
-extern Lisp_Object Feolp (), Feobp (), Fbolp (), Fbobp ();
-extern Lisp_Object Fformat (), format1 ();
-extern Lisp_Object make_buffer_string (), Fbuffer_substring ();
-extern Lisp_Object Fbuffer_string ();
-extern Lisp_Object Fstring_equal (), Fstring_lessp (), Fbuffer_substring_lessp ();
-extern Lisp_Object save_excursion_save (), save_restriction_save ();
-extern Lisp_Object save_excursion_restore (), save_restriction_restore ();
-extern Lisp_Object Fchar_to_string ();
-extern Lisp_Object Fdelete_region (), Fnarrow_to_region (), Fwiden ();
-extern Lisp_Object Fuser_login_name (), Fsystem_name ();
+EXFUN (Fcurrent_message, 0);
+EXFUN (Fgoto_char, 1);
+EXFUN (Fpoint_min_marker, 0);
+EXFUN (Fpoint_max_marker, 0);
+EXFUN (Fpoint_min, 0);
+EXFUN (Fpoint_max, 0);
+EXFUN (Fpoint, 0);
+EXFUN (Fpoint_marker, 0);
+EXFUN (Fmark_marker, 0);
+EXFUN (Fline_beginning_position, 1);
+EXFUN (Fline_end_position, 1);
+EXFUN (Ffollowing_char, 0);
+EXFUN (Fprevious_char, 0);
+EXFUN (Fchar_after, 1);
+EXFUN (Finsert, MANY);
+EXFUN (Finsert_and_inherit, MANY);
+EXFUN (Finsert_before_markers, MANY);
+EXFUN (Finsert_buffer_substring, 3);
+EXFUN (Finsert_char, 3);
+extern void insert1 P_ ((Lisp_Object));
+EXFUN (Feolp, 0);
+EXFUN (Feobp, 0);
+EXFUN (Fbolp, 0);
+EXFUN (Fbobp, 0);
+EXFUN (Fformat, MANY);
+EXFUN (Fmessage, MANY);
+extern Lisp_Object format1 P_ ((/* char *, ... */));
+extern Lisp_Object make_buffer_string P_ ((int, int, int));
+EXFUN (Fbuffer_substring, 2);
+EXFUN (Fbuffer_string, 0);
+extern Lisp_Object save_excursion_save P_ ((void));
+extern Lisp_Object save_restriction_save P_ ((void));
+extern Lisp_Object save_excursion_restore P_ ((Lisp_Object));
+extern Lisp_Object save_restriction_restore P_ ((Lisp_Object));
+EXFUN (Fchar_to_string, 1);
+EXFUN (Fdelete_region, 2);
+EXFUN (Fnarrow_to_region, 2);
+EXFUN (Fwiden, 0);
+EXFUN (Fuser_login_name, 1);
+EXFUN (Fsystem_name, 0);
+EXFUN (Fcurrent_time, 0);
+extern int clip_to_bounds P_ ((int, int, int));
+extern Lisp_Object make_buffer_string P_ ((int, int, int));
+extern Lisp_Object make_buffer_string_both P_ ((int, int, int, int, int));
+extern void init_editfns P_ ((void));
+extern void syms_of_editfns P_ ((void));
+EXFUN (Fcurrent_message, 0);
+extern Lisp_Object Vinhibit_field_text_motion;
+EXFUN (Fconstrain_to_field, 5);
+EXFUN (Ffield_string, 1);
+EXFUN (Fdelete_field, 1);
+EXFUN (Ffield_beginning, 2);
+EXFUN (Ffield_string_no_properties, 1);
+extern void set_time_zone_rule P_ ((char *));
/* defined in buffer.c */
-extern Lisp_Object Foverlay_start (), Foverlay_end ();
-extern void adjust_overlays_for_insert ();
-extern void adjust_overlays_for_delete ();
-extern void fix_overlays_in_range ();
-extern int overlay_touches_p ();
+extern void nsberror P_ ((Lisp_Object));
+extern char *no_switch_window P_ ((Lisp_Object window));
+EXFUN (Fset_buffer_multibyte, 1);
+EXFUN (Foverlay_start, 1);
+EXFUN (Foverlay_end, 1);
+extern void adjust_overlays_for_insert P_ ((int, int));
+extern void adjust_overlays_for_delete P_ ((int, int));
+extern void fix_overlays_in_range P_ ((int, int));
+extern void report_overlay_modification P_ ((Lisp_Object, Lisp_Object, int,
+ Lisp_Object, Lisp_Object, Lisp_Object));
+extern int overlay_touches_p P_ ((int));
extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
-extern Lisp_Object Fget_buffer (), Fget_buffer_create (), Fset_buffer ();
-extern Lisp_Object Fbarf_if_buffer_read_only ();
-extern Lisp_Object Fcurrent_buffer (), Fswitch_to_buffer (), Fpop_to_buffer ();
-extern Lisp_Object Fother_buffer ();
-extern Lisp_Object Foverlay_get ();
-extern Lisp_Object Fbuffer_modified_p (), Fset_buffer_modified_p ();
-extern Lisp_Object Fkill_buffer (), Fkill_all_local_variables ();
-extern Lisp_Object Fbuffer_disable_undo (), Fbuffer_enable_undo ();
-extern Lisp_Object Ferase_buffer ();
+EXFUN (Fget_buffer, 1);
+EXFUN (Fget_buffer_create, 1);
+EXFUN (Fset_buffer, 1);
+EXFUN (set_buffer_if_live, 1);
+EXFUN (Fbarf_if_buffer_read_only, 0);
+EXFUN (Fcurrent_buffer, 0);
+EXFUN (Fswitch_to_buffer, 2);
+EXFUN (Fpop_to_buffer, 3);
+EXFUN (Fother_buffer, 3);
+EXFUN (Foverlay_get, 2);
+EXFUN (Fbuffer_modified_p, 1);
+EXFUN (Fset_buffer_modified_p, 1);
+EXFUN (Fkill_buffer, 1);
+EXFUN (Fkill_all_local_variables, 0);
+EXFUN (Fbuffer_disable_undo, 1);
+EXFUN (Fbuffer_enable_undo, 1);
+EXFUN (Ferase_buffer, 0);
extern Lisp_Object Qoverlayp;
-extern Lisp_Object get_truename_buffer ();
+extern Lisp_Object get_truename_buffer P_ ((Lisp_Object));
extern struct buffer *all_buffers;
-extern Lisp_Object Fprevious_overlay_change ();
+EXFUN (Fprevious_overlay_change, 1);
+EXFUN (Fbuffer_file_name, 1);
+extern void init_buffer_once P_ ((void));
+extern void init_buffer P_ ((void));
+extern void syms_of_buffer P_ ((void));
+extern void keys_of_buffer P_ ((void));
/* defined in marker.c */
-extern Lisp_Object Fmarker_position (), Fmarker_buffer ();
-extern Lisp_Object Fcopy_marker ();
+EXFUN (Fmarker_position, 1);
+EXFUN (Fmarker_buffer, 1);
+EXFUN (Fcopy_marker, 2);
+EXFUN (Fset_marker, 3);
+extern int marker_position P_ ((Lisp_Object));
+extern int marker_byte_position P_ ((Lisp_Object));
+extern void clear_charpos_cache P_ ((struct buffer *));
+extern int charpos_to_bytepos P_ ((int));
+extern int buf_charpos_to_bytepos P_ ((struct buffer *, int));
+extern int buf_bytepos_to_charpos P_ ((struct buffer *, int));
+extern void unchain_marker P_ ((Lisp_Object));
+extern Lisp_Object set_marker_restricted P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object set_marker_both P_ ((Lisp_Object, Lisp_Object, int, int));
+extern Lisp_Object set_marker_restricted_both P_ ((Lisp_Object, Lisp_Object,
+ int, int));
+extern void syms_of_marker P_ ((void));
/* Defined in fileio.c */
extern Lisp_Object Qfile_error;
-extern Lisp_Object Ffind_file_name_handler ();
-extern Lisp_Object Ffile_name_as_directory ();
-extern Lisp_Object Fexpand_file_name (), Ffile_name_nondirectory ();
-extern Lisp_Object Fsubstitute_in_file_name ();
-extern Lisp_Object Ffile_symlink_p ();
-extern Lisp_Object Fverify_visited_file_modtime ();
-extern Lisp_Object Ffile_exists_p ();
-extern Lisp_Object Ffile_name_absolute_p ();
-extern Lisp_Object Fdirectory_file_name ();
-extern Lisp_Object Ffile_name_directory ();
-extern Lisp_Object expand_and_dir_to_file ();
-extern Lisp_Object Ffile_accessible_directory_p ();
-extern Lisp_Object Funhandled_file_name_directory ();
-extern Lisp_Object Ffile_directory_p ();
-extern Lisp_Object Fwrite_region ();
-extern Lisp_Object Ffile_readable_p (), Ffile_executable_p ();
+EXFUN (Ffind_file_name_handler, 2);
+EXFUN (Ffile_name_as_directory, 1);
+EXFUN (Fmake_temp_name, 1);
+EXFUN (Fexpand_file_name, 2);
+EXFUN (Ffile_name_nondirectory, 1);
+EXFUN (Fsubstitute_in_file_name, 1);
+EXFUN (Ffile_symlink_p, 1);
+EXFUN (Fverify_visited_file_modtime, 1);
+EXFUN (Ffile_exists_p, 1);
+EXFUN (Ffile_name_absolute_p, 1);
+EXFUN (Fdirectory_file_name, 1);
+EXFUN (Ffile_name_directory, 1);
+extern Lisp_Object expand_and_dir_to_file P_ ((Lisp_Object, Lisp_Object));
+EXFUN (Ffile_accessible_directory_p, 1);
+EXFUN (Funhandled_file_name_directory, 1);
+EXFUN (Ffile_directory_p, 1);
+EXFUN (Fwrite_region, 7);
+EXFUN (Ffile_readable_p, 1);
+EXFUN (Ffile_executable_p, 1);
+EXFUN (Fread_file_name, 5);
+extern Lisp_Object close_file_unwind P_ ((Lisp_Object));
+extern void report_file_error P_ ((char *, Lisp_Object));
+extern int internal_delete_file P_ ((Lisp_Object));
+extern void syms_of_fileio P_ ((void));
+EXFUN (Fmake_temp_name, 1);
+extern void init_fileio_once P_ ((void));
+extern Lisp_Object make_temp_name P_ ((Lisp_Object, int));
/* Defined in abbrev.c */
extern Lisp_Object Vfundamental_mode_abbrev_table;
+extern void syms_of_abbrev P_ ((void));
/* defined in search.c */
-extern Lisp_Object Fstring_match ();
-extern Lisp_Object Fscan_buffer ();
-extern void restore_match_data ();
-extern Lisp_Object Fmatch_data (), Fstore_match_data ();
-extern Lisp_Object Fmatch_beginning (), Fmatch_end ();
-extern Lisp_Object Fskip_chars_forward (), Fskip_chars_backward ();
+extern void shrink_regexp_cache P_ ((void));
+EXFUN (Fstring_match, 3);
+extern void restore_match_data P_ ((void));
+EXFUN (Fmatch_data, 2);
+EXFUN (Fset_match_data, 1);
+EXFUN (Fmatch_beginning, 1);
+EXFUN (Fmatch_end, 1);
+EXFUN (Flooking_at, 1);
+extern int fast_string_match P_ ((Lisp_Object, Lisp_Object));
+extern int fast_c_string_match_ignore_case P_ ((Lisp_Object, char *));
+extern int scan_buffer P_ ((int, int, int, int, int *, int));
+extern int scan_newline P_ ((int, int, int, int, int, int));
+extern int find_next_newline P_ ((int, int));
+extern int find_next_newline_no_quit P_ ((int, int));
+extern int find_before_next_newline P_ ((int, int, int));
+extern void syms_of_search P_ ((void));
/* defined in minibuf.c */
extern Lisp_Object last_minibuf_string;
-extern Lisp_Object Fcompleting_read ();
-extern Lisp_Object Fread_from_minibuffer ();
-extern Lisp_Object Fread_variable (), Fread_buffer (), Fread_key_sequence ();
-extern Lisp_Object Fread_minibuffer (), Feval_minibuffer ();
-extern Lisp_Object Fread_string (), Fread_file_name ();
-extern Lisp_Object Fread_no_blanks_input ();
-extern Lisp_Object get_minibuffer ();
+extern void choose_minibuf_frame P_ ((void));
+extern int scmp P_ ((unsigned char *, unsigned char *, int));
+EXFUN (Fcompleting_read, 8);
+EXFUN (Fread_from_minibuffer, 7);
+EXFUN (Fread_variable, 2);
+EXFUN (Fread_buffer, 3);
+EXFUN (Fread_minibuffer, 2);
+EXFUN (Feval_minibuffer, 2);
+EXFUN (Fread_string, 5);
+EXFUN (Fread_no_blanks_input, 3);
+extern Lisp_Object get_minibuffer P_ ((int));
+extern void temp_echo_area_glyphs P_ ((char *));
+extern void init_minibuf_once P_ ((void));
+extern void syms_of_minibuf P_ ((void));
+extern void keys_of_minibuf P_ ((void));
/* Defined in callint.c */
extern Lisp_Object Qminus, Qplus, Vcurrent_prefix_arg;
extern Lisp_Object Vcommand_history;
extern Lisp_Object Qcall_interactively, Qmouse_leave_buffer_hook;
-extern Lisp_Object Fcall_interactively ();
-extern Lisp_Object Fprefix_numeric_value ();
+EXFUN (Fcall_interactively, 3);
+EXFUN (Fprefix_numeric_value, 1);
+extern void syms_of_callint P_ ((void));
/* defined in casefiddle.c */
-extern Lisp_Object Fdowncase (), Fupcase (), Fcapitalize ();
-extern Lisp_Object Fupcase_region ();
-extern Lisp_Object Fupcase_initials (), Fupcase_initials_region ();
+EXFUN (Fdowncase, 1);
+EXFUN (Fupcase, 1);
+EXFUN (Fcapitalize, 1);
+EXFUN (Fupcase_region, 2);
+EXFUN (Fupcase_initials, 1);
+EXFUN (Fupcase_initials_region, 2);
+extern void syms_of_casefiddle P_ ((void));
+extern void keys_of_casefiddle P_ ((void));
/* defined in casetab.c */
-extern Lisp_Object Fset_case_table ();
-extern Lisp_Object Fset_standard_case_table ();
+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 */
-extern Lisp_Object Qdisabled;
+extern Lisp_Object Qdisabled, QCfilter;
extern Lisp_Object Vtty_erase_char, Vhelp_form, Vtop_level;
-extern Lisp_Object Fdiscard_input (), Frecursive_edit ();
-extern Lisp_Object Fcommand_execute (), Finput_pending_p ();
-extern Lisp_Object menu_bar_items ();
+extern int input_pending;
+EXFUN (Fdiscard_input, 0);
+EXFUN (Frecursive_edit, 0);
+EXFUN (Fcommand_execute, 4);
+EXFUN (Finput_pending_p, 0);
+extern Lisp_Object menu_bar_items P_ ((Lisp_Object));
+extern Lisp_Object tool_bar_items P_ ((Lisp_Object, int *));
extern Lisp_Object Qvertical_scroll_bar;
-extern Lisp_Object Fevent_convert_list ();
-#ifdef MULTI_KBOARD
-extern void delete_kboard ();
-#endif
+extern void discard_mouse_events P_ ((void));
+EXFUN (Fevent_convert_list, 1);
+EXFUN (Fread_key_sequence, 5);
+EXFUN (Fset_input_mode, 4);
+extern int detect_input_pending P_ ((void));
+extern int detect_input_pending_run_timers P_ ((int));
+extern void safe_run_hooks P_ ((Lisp_Object));
+extern void cmd_error_internal P_ ((Lisp_Object, char *));
+extern Lisp_Object command_loop_1 P_ ((void));
+extern Lisp_Object recursive_edit_1 P_ ((void));
+extern void record_auto_save P_ ((void));
+extern void init_keyboard P_ ((void));
+extern void syms_of_keyboard P_ ((void));
+extern void keys_of_keyboard P_ ((void));
+extern char *push_key_description P_ ((unsigned int, char *, int));
/* defined in keymap.c */
+#define KEYMAPP(m) (!NILP (get_keymap (m, 0, 0)))
extern Lisp_Object Qkeymap, Qmenu_bar;
extern Lisp_Object current_global_map;
-extern Lisp_Object Fdefine_key ();
-extern Lisp_Object Fkey_description (), Fsingle_key_description ();
-extern Lisp_Object Fwhere_is_internal ();
-extern Lisp_Object access_keymap (), store_in_keymap ();
-extern Lisp_Object get_keyelt (), get_keymap (), get_keymap_1 ();
-extern void describe_map_tree ();
+EXFUN (Fmake_sparse_keymap, 1);
+EXFUN (Fcopy_keymap, 1);
+EXFUN (Fdefine_key, 3);
+EXFUN (Flookup_key, 3);
+EXFUN (Fkey_binding, 2);
+EXFUN (Fkey_description, 1);
+EXFUN (Fsingle_key_description, 2);
+EXFUN (Fwhere_is_internal, 4);
+extern Lisp_Object access_keymap P_ ((Lisp_Object, Lisp_Object, int, int, int));
+extern Lisp_Object get_keyelt P_ ((Lisp_Object, int));
+extern Lisp_Object get_keymap P_ ((Lisp_Object, int, int));
+extern void describe_vector P_ ((Lisp_Object, Lisp_Object,
+ void (*) (Lisp_Object), int,
+ Lisp_Object, Lisp_Object, int *, int));
+extern void describe_map_tree P_ ((Lisp_Object, int, Lisp_Object, Lisp_Object,
+ char *, int, int, int));
+extern int current_minor_maps P_ ((Lisp_Object **, Lisp_Object **));
+extern void initial_define_key P_ ((Lisp_Object, int, char *));
+extern void initial_define_lispy_key P_ ((Lisp_Object, char *, char *));
+extern void syms_of_keymap P_ ((void));
+extern void keys_of_keymap P_ ((void));
/* defined in indent.c */
-extern Lisp_Object Fvertical_motion (), Findent_to (), Fcurrent_column ();
-extern Lisp_Object Fmove_to_column ();
+EXFUN (Fvertical_motion, 2);
+EXFUN (Findent_to, 2);
+EXFUN (Fcurrent_column, 0);
+EXFUN (Fmove_to_column, 2);
+extern int current_column P_ ((void));
+extern void invalidate_current_column P_ ((void));
+extern int indented_beyond_p P_ ((int, int, int));
+extern void syms_of_indent P_ ((void));
/* defined in window.c */
extern Lisp_Object Qwindowp, Qwindow_live_p;
-extern Lisp_Object Fselected_window ();
-extern Lisp_Object Fget_buffer_window ();
-extern Lisp_Object Fsave_window_excursion ();
-extern Lisp_Object Fset_window_configuration (), Fcurrent_window_configuration ();
-extern Lisp_Object Fcoordinates_in_window_p ();
-extern Lisp_Object Fwindow_at ();
-extern Lisp_Object Fpos_visible_in_window_p ();
-extern int window_internal_height (), window_internal_width ();
-extern Lisp_Object Frecenter ();
-extern Lisp_Object Fscroll_other_window ();
-extern Lisp_Object Fset_window_start ();
+EXFUN (Fwindow_end, 2);
+EXFUN (Fselected_window, 0);
+EXFUN (Fnext_window, 3);
+EXFUN (Fdelete_window, 1);
+EXFUN (Fselect_window, 1);
+EXFUN (Fset_window_buffer, 2);
+EXFUN (Fget_buffer_window, 2);
+EXFUN (Fsave_window_excursion, UNEVALLED);
+EXFUN (Fsplit_window, 3);
+EXFUN (Fset_window_configuration, 1);
+EXFUN (Fcurrent_window_configuration, 1);
+extern int compare_window_configurations P_ ((Lisp_Object, Lisp_Object, int));
+EXFUN (Fcoordinates_in_window_p, 2);
+EXFUN (Fwindow_at, 3);
+EXFUN (Fpos_visible_in_window_p, 3);
+extern void mark_window_cursors_off P_ ((struct window *));
+extern int window_internal_height P_ ((struct window *));
+extern int window_internal_width P_ ((struct window *));
+EXFUN (Frecenter, 1);
+EXFUN (Fscroll_other_window, 1);
+EXFUN (Fset_window_start, 3);
+extern void temp_output_buffer_show P_ ((Lisp_Object));
+extern void replace_buffer_in_all_windows P_ ((Lisp_Object));
+extern void init_window_once P_ ((void));
+extern void syms_of_window P_ ((void));
+extern void keys_of_window P_ ((void));
/* defined in frame.c */
extern Lisp_Object Qvisible;
-extern void store_frame_param (), store_in_alist ();
-extern Lisp_Object do_switch_frame ();
-extern Lisp_Object get_frame_param();
-extern Lisp_Object frame_buffer_predicate ();
-extern Lisp_Object Fframep ();
-extern Lisp_Object Fselect_frame ();
-extern Lisp_Object Fselected_frame ();
-extern Lisp_Object Fwindow_frame ();
-extern Lisp_Object Fframe_root_window ();
-extern Lisp_Object Fframe_first_window ();
-extern Lisp_Object Fframe_selected_window ();
-extern Lisp_Object Fframe_list ();
-extern Lisp_Object Fnext_frame ();
-extern Lisp_Object Fdelete_frame ();
-extern Lisp_Object Fread_mouse_position ();
-extern Lisp_Object Fset_mouse_position ();
-extern Lisp_Object Fmake_frame_visible ();
-extern Lisp_Object Fmake_frame_invisible ();
-extern Lisp_Object Ficonify_frame ();
-extern Lisp_Object Fdeiconify_frame ();
-extern Lisp_Object Fframe_visible_p ();
-extern Lisp_Object Fvisible_frame_list ();
-extern Lisp_Object Fframe_parameters ();
-extern Lisp_Object Fmodify_frame_parameters ();
-extern Lisp_Object Fframe_pixel_size ();
-extern Lisp_Object Fframe_height ();
-extern Lisp_Object Fframe_width ();
-extern Lisp_Object Fset_frame_height ();
-extern Lisp_Object Fset_frame_width ();
-extern Lisp_Object Fset_frame_size ();
-extern Lisp_Object Fset_frame_position ();
-extern Lisp_Object Fraise_frame ();
-extern Lisp_Object Fredirect_frame_focus ();
-extern Lisp_Object frame_buffer_list ();
+extern void store_frame_param P_ ((struct frame *, Lisp_Object, Lisp_Object));
+extern void store_in_alist P_ ((Lisp_Object *, Lisp_Object, Lisp_Object));
+extern Lisp_Object do_switch_frame P_ ((Lisp_Object, Lisp_Object, int));
+extern Lisp_Object get_frame_param P_ ((struct frame *, Lisp_Object));
+extern Lisp_Object frame_buffer_predicate P_ ((Lisp_Object));
+EXFUN (Fframep, 1);
+EXFUN (Fselect_frame, 2);
+EXFUN (Fselected_frame, 0);
+EXFUN (Fwindow_frame, 1);
+EXFUN (Fframe_root_window, 1);
+EXFUN (Fframe_first_window, 1);
+EXFUN (Fframe_selected_window, 1);
+EXFUN (Fframe_list, 0);
+EXFUN (Fnext_frame, 2);
+EXFUN (Fdelete_frame, 2);
+EXFUN (Fset_mouse_position, 3);
+EXFUN (Fmake_frame_visible, 1);
+EXFUN (Fmake_frame_invisible, 2);
+EXFUN (Ficonify_frame, 1);
+EXFUN (Fframe_visible_p, 1);
+EXFUN (Fvisible_frame_list, 0);
+EXFUN (Fframe_parameters, 1);
+EXFUN (Fmodify_frame_parameters, 2);
+EXFUN (Fset_frame_height, 3);
+EXFUN (Fset_frame_width, 3);
+EXFUN (Fset_frame_size, 3);
+EXFUN (Fset_frame_position, 3);
+EXFUN (Fraise_frame, 1);
+EXFUN (Fredirect_frame_focus, 2);
+EXFUN (Fset_frame_selected_window, 2);
+extern Lisp_Object frame_buffer_list P_ ((Lisp_Object));
+extern void frames_discard_buffer P_ ((Lisp_Object));
+extern void set_frame_buffer_list P_ ((Lisp_Object, Lisp_Object));
+extern void frames_bury_buffer P_ ((Lisp_Object));
+extern void syms_of_frame P_ ((void));
+extern void keys_of_frame P_ ((void));
/* defined in emacs.c */
-extern Lisp_Object decode_env_path ();
+extern Lisp_Object decode_env_path P_ ((char *, char *));
extern Lisp_Object Vinvocation_name, Vinvocation_directory;
extern Lisp_Object Vinstallation_directory;
-void shut_down_emacs ( /* int signal, int no_x, Lisp_Object stuff */ );
+EXFUN (Fkill_emacs, 1);
+#if HAVE_SETLOCALE
+void fixup_locale P_ ((void));
+void synchronize_system_messages_locale P_ ((void));
+void synchronize_system_time_locale P_ ((void));
+#else
+#define setlocale(category, locale)
+#define fixup_locale()
+#define synchronize_system_messages_locale()
+#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 */
extern int noninteractive;
/* Nonzero means don't do use window-system-specific display code */
extern int running_asynch_code;
/* defined in process.c */
-extern Lisp_Object Fget_process (), Fget_buffer_process (), Fprocessp ();
-extern Lisp_Object Fprocess_status (), Fkill_process ();
-extern Lisp_Object Fprocess_send_eof ();
-extern Lisp_Object Fwaiting_for_user_input_p ();
+EXFUN (Fget_process, 1);
+EXFUN (Fget_buffer_process, 1);
+EXFUN (Fprocessp, 1);
+EXFUN (Fprocess_status, 1);
+EXFUN (Fkill_process, 2);
+EXFUN (Fprocess_send_eof, 1);
+EXFUN (Fwaiting_for_user_input_p, 0);
extern Lisp_Object Qprocessp;
+extern void kill_buffer_processes P_ ((Lisp_Object));
+extern int wait_reading_process_input P_ ((int, int, Lisp_Object, int));
+extern void deactivate_process P_ ((Lisp_Object));
+extern void add_keyboard_wait_descriptor P_ ((int));
+extern void delete_keyboard_wait_descriptor P_ ((int));
+extern void close_process_descs P_ ((void));
+extern void status_notify P_ ((void));
+extern int read_process_output P_ ((Lisp_Object, int));
+extern void init_process P_ ((void));
+extern void syms_of_process P_ ((void));
/* defined in callproc.c */
extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
extern Lisp_Object Vdoc_directory;
+EXFUN (Fcall_process, MANY);
+extern int child_setup P_ ((int, int, int, char **, int, Lisp_Object));
+extern void init_callproc_1 P_ ((void));
+extern void init_callproc P_ ((void));
+extern void set_process_environment P_ ((void));
+extern void syms_of_callproc P_ ((void));
/* defined in doc.c */
extern Lisp_Object Vdoc_file_name;
-extern Lisp_Object Fsubstitute_command_keys ();
-extern Lisp_Object Fdocumentation (), Fdocumentation_property ();
-extern Lisp_Object read_doc_string ();
+EXFUN (Fsubstitute_command_keys, 1);
+EXFUN (Fdocumentation, 2);
+EXFUN (Fdocumentation_property, 3);
+extern Lisp_Object read_doc_string P_ ((Lisp_Object));
+extern Lisp_Object get_doc_string P_ ((Lisp_Object, int, int));
+extern void syms_of_doc P_ ((void));
+extern int read_bytecode_char P_ ((int));
/* defined in bytecode.c */
extern Lisp_Object Qbytecode;
-extern Lisp_Object Fbyte_code ();
+EXFUN (Fbyte_code, 3);
+extern void syms_of_bytecode P_ ((void));
+extern struct byte_stack *byte_stack_list;
+extern void mark_byte_stack P_ ((void));
+extern void unmark_byte_stack P_ ((void));
/* defined in macros.c */
extern Lisp_Object Qexecute_kbd_macro;
-extern Lisp_Object Fexecute_kbd_macro ();
+EXFUN (Fexecute_kbd_macro, 2);
+extern void init_macros P_ ((void));
+extern void syms_of_macros P_ ((void));
+extern void keys_of_macros P_ ((void));
/* defined in undo.c */
extern Lisp_Object Qinhibit_read_only;
-extern Lisp_Object Fundo_boundary ();
-extern Lisp_Object truncate_undo_list ();
+EXFUN (Fundo_boundary, 0);
+extern Lisp_Object truncate_undo_list P_ ((Lisp_Object, int, int));
+extern void record_marker_adjustment P_ ((Lisp_Object, int));
+extern void record_insert P_ ((int, int));
+extern void record_delete P_ ((int, Lisp_Object));
+extern void record_first_change P_ ((void));
+extern void record_change P_ ((int, int));
+extern void record_property_change P_ ((int, int, Lisp_Object, Lisp_Object,
+ Lisp_Object));
+extern void syms_of_undo P_ ((void));
/* defined in textprop.c */
extern Lisp_Object Qmodification_hooks;
extern Lisp_Object Qrear_nonsticky, Qfont;
extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
-extern Lisp_Object Fnext_property_change ();
-extern Lisp_Object Fnext_single_property_change ();
-extern Lisp_Object Fprevious_single_property_change ();
-extern Lisp_Object Fget_text_property (), Fput_text_property ();
-extern Lisp_Object Fset_text_properties ();
-extern Lisp_Object Ftext_property_not_all ();
-extern Lisp_Object Fprevious_char_property_change ();
-extern Lisp_Object Fnext_char_property_change ();
-
-/* defined in intervals.c */
-extern Lisp_Object get_local_map ();
+EXFUN (Fnext_property_change, 3);
+EXFUN (Fnext_single_property_change, 4);
+EXFUN (Fnext_single_char_property_change, 4);
+EXFUN (Fprevious_single_property_change, 4);
+EXFUN (Fget_text_property, 3);
+EXFUN (Fput_text_property, 5);
+EXFUN (Fset_text_properties, 4);
+EXFUN (Ftext_property_not_all, 5);
+EXFUN (Fprevious_char_property_change, 2);
+EXFUN (Fnext_char_property_change, 2);
+extern void report_interval_modification P_ ((Lisp_Object, Lisp_Object));
+extern void syms_of_textprop P_ ((void));
+extern Lisp_Object next_single_char_property_change P_ ((Lisp_Object,
+ Lisp_Object,
+ Lisp_Object,
+ Lisp_Object));
+extern Lisp_Object set_text_properties P_ ((Lisp_Object, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ Lisp_Object));
/* defined in xmenu.c */
-extern Lisp_Object Fx_popup_menu (), Fx_popup_dialog ();
+EXFUN (Fx_popup_menu, 2);
+EXFUN (Fx_popup_dialog, 2);
+extern void syms_of_xmenu P_ ((void));
+extern int popup_activated_flag;
+
+/* defined in sysdep.c */
+extern void stuff_char P_ ((char c));
+extern void init_sigio P_ ((int));
+extern void request_sigio P_ ((void));
+extern void unrequest_sigio P_ ((void));
+extern void reset_sys_modes P_ ((void));
+extern void sys_subshell P_ ((void));
+extern void sys_suspend P_ ((void));
+extern void discard_tty_input P_ ((void));
+extern void init_sys_modes P_ ((void));
+extern void reset_sys_modes P_ ((void));
+extern void get_frame_size P_ ((int *, int *));
+extern void wait_for_termination P_ ((int));
+extern void flush_pending_output P_ ((int));
+extern void child_setup_tty P_ ((int));
+extern void setup_pty P_ ((int));
+extern int set_window_size P_ ((int, int, int));
+extern void create_process P_ ((Lisp_Object, char **, Lisp_Object));
+extern int tabs_safe_p P_ ((void));
+extern void init_baud_rate P_ ((void));
+extern int emacs_open P_ ((char *, int, int));
+extern int emacs_close P_ ((int));
+extern int emacs_read P_ ((int, char *, unsigned int));
+extern int emacs_write P_ ((int, char *, unsigned int));
+
+/* defined in filelock.c */
+EXFUN (Funlock_buffer, 0);
+EXFUN (Ffile_locked_p, 1);
+extern void unlock_all_files P_ ((void));
+extern void lock_file P_ ((Lisp_Object));
+extern void unlock_file P_ ((Lisp_Object));
+extern void unlock_buffer P_ ((struct buffer *));
+extern void syms_of_filelock P_ ((void));
+extern void init_filelock P_ ((void));
+
+/* Defined in sound.c */
+extern void syms_of_sound P_ ((void));
+extern void init_sound P_ ((void));
+
+/* Defined in category.c */
+extern void init_category_once P_ ((void));
+extern void syms_of_category P_ ((void));
+
+/* Defined in ccl.c */
+extern void syms_of_ccl P_ ((void));
+
+/* Defined in dired.c */
+EXFUN (Ffile_attributes, 1);
+extern void syms_of_dired P_ ((void));
+
+/* Defined in mocklisp.c */
+extern void syms_of_mocklisp P_ ((void));
+
+/* Defined in term.c */
+extern void syms_of_term P_ ((void));
+extern void fatal () NO_RETURN;
+
+#ifdef HAVE_X_WINDOWS
+/* Defined in fontset.c */
+extern void syms_of_fontset P_ ((void));
+EXFUN (Fset_fontset_font, 4);
+#endif
+
+/* Defined in xfaces.c */
+extern void syms_of_xfaces P_ ((void));
+
+/* Defined in getloadavg.c */
+extern int getloadavg P_ ((double *, int));
+
+#ifdef HAVE_X_WINDOWS
+/* Defined in xfns.c */
+extern void syms_of_xfns P_ ((void));
+extern void init_xfns P_ ((void));
+EXFUN (Fxw_display_color_p, 1);
+#endif /* HAVE_X_WINDOWS */
+
+/* Defined in xselect.c */
+extern void syms_of_xselect P_ ((void));
+
+/* Defined in xterm.c */
+extern void syms_of_xterm P_ ((void));
+
+/* Defined in getloadavg.c */
+extern int getloadavg P_ ((double [], int));
\f
/* Nonzero means Emacs has already been initialized.
Used during startup to detect startup of dumped Emacs. */
extern int immediate_quit; /* Nonzero means ^G can quit instantly */
-extern void debugger ();
+extern POINTER_TYPE *xmalloc P_ ((size_t));
+extern POINTER_TYPE *xrealloc P_ ((POINTER_TYPE *, size_t));
+extern void xfree P_ ((POINTER_TYPE *));
-extern char *getenv (), *ctime (), *getwd ();
-extern long *xmalloc (), *xrealloc ();
-extern void xfree ();
+extern char *xstrdup P_ ((char *));
-extern char *egetenv ();
+#ifndef USE_CRT_DLL
+extern char *egetenv P_ ((char *));
+#endif
/* Set up the name of the machine we're running on. */
-extern void init_system_name ();
+extern void init_system_name P_ ((void));
/* Some systems (e.g., NT) use a different path separator than Unix,
in addition to a device separator. Default the path separator