/* 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 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 (__STDC__) || defined (WINDOWSNT)
+#define P_(proto) proto
+#else
+#define P_(proto) ()
+#endif
+
/* 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
/* Define the fundamental Lisp data structures. */
/* 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
#endif /* NO_UNION_TYPE */
-/* If union type is not wanted, define Lisp_Object as just a number
- and define the macros below to extract fields by shifting */
+/* If union type is not wanted, define Lisp_Object as just a number. */
#ifdef NO_UNION_TYPE
-
#define Lisp_Object EMACS_INT
+#endif /* NO_UNION_TYPE */
#ifndef VALMASK
#define VALMASK ((((EMACS_INT) 1)<<VALBITS) - 1)
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. */
#define PSEUDOVECTOR_SIZE_MASK 0x1ff
-
-#endif /* NO_UNION_TYPE */
\f
/* These macros extract various sorts of values from a Lisp_Object.
For example, if tem is a Lisp_Object whose type is Lisp_Cons,
/* 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) (((a) << (BITS_PER_EMACS_INT-VALBITS)) >> (BITS_PER_EMACS_INT-VALBITS))
#endif
/* Extract the value as an unsigned integer. This is a basis
#define XSET(var, vartype, ptr) \
(((var).s.type = ((char) (vartype))), ((var).s.val = ((int) (ptr))))
+extern Lisp_Object make_number ();
+
/* During garbage collection, XGCTYPE must be used for extracting types
so that the mark bit is ignored. XMARKBIT access the markbit.
Markbits are used only in particular slots of particular structure types.
#define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
#define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
\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. */
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) \
int bufpos;
};
+/* Nonzero if STR is a multibyte string. */
+#define STRING_MULTIBYTE(STR) \
+ (XSTRING (STR)->size_byte >= 0)
+
+/* Return the length in bytes of STR. */
+#define STRING_BYTES(STR) \
+ ((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte)
+
+/* 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;
+ EMACS_INT size_byte;
DECLARE_INTERVALS /* `data' field must be last. */
unsigned char data[1];
};
Lisp_Object contents[1];
};
-/* A char table is a kind of vectorlike, with contents are like a vector
- but with a few other slots. For some purposes, it makes sense
- to handle a chartable with type struct Lisp_Vector. */
-
-/* This is the number of slots that apply to characters
- or character sets. */
-#define CHAR_TABLE_ORDINARY_SLOTS 256
-
-/* This is the number of slots that every char table must have.
- This counts the ordinary slots and the parent and defalt slots. */
-#define CHAR_TABLE_STANDARD_SLOTS (256+3)
+/* A char table is a kind of vectorlike, with contents are like a
+ vector but with a few other slots. For some purposes, it makes
+ sense to handle a chartable with type struct Lisp_Vector. An
+ element of a char table can be any Lisp objects, but if it is a sub
+ char-table, we treat it a table that contains information of a
+ group of characters of the same charsets or a specific character of
+ a charset. A sub char-table has the same structure as a char table
+ except for that the former omits several slots at the tail. A sub
+ char table appears only in an element of a char table, and there's
+ no way to access it directly from Emacs Lisp program. */
+
+/* This is the number of slots that apply to characters or character
+ sets. The first 128 are for ASCII, the next 128 are for 8-bit
+ European characters, and the last 128 are for multibyte characters.
+ The first 256 are indexed by the code itself, but the last 128 are
+ indexed by (charset-id + 128). */
+#define CHAR_TABLE_ORDINARY_SLOTS 384
+
+/* This is the number of slots that apply to characters of ASCII and
+ 8-bit Europeans only. */
+#define CHAR_TABLE_SINGLE_BYTE_SLOTS 256
+
+/* This is the number of slots that every char table must have. This
+ counts the ordinary slots and the top, defalt, parent, and purpose
+ slots. */
+#define CHAR_TABLE_STANDARD_SLOTS (CHAR_TABLE_ORDINARY_SLOTS + 4)
+
+/* This is the number of slots that apply to position-code-1 and
+ position-code-2 of a multibyte character at the 2nd and 3rd level
+ sub char tables respectively. */
+#define SUB_CHAR_TABLE_ORDINARY_SLOTS 128
+
+/* This is the number of slots that every sub char table must have.
+ This counts the ordinary slots and the top and defalt slot. */
+#define SUB_CHAR_TABLE_STANDARD_SLOTS (SUB_CHAR_TABLE_ORDINARY_SLOTS + 2)
/* Return the number of "extra" slots in the char table CT. */
#define CHAR_TABLE_EXTRA_SLOTS(CT) \
(((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
+/* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
+ 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) >= 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) \
+ do { \
+ if (XFASTINT (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS) \
+ XCHAR_TABLE (CT)->contents[XFASTINT (IDX)] = VAL; \
+ else \
+ Faset (CT, IDX, VAL); \
+ } while (0)
+
struct Lisp_Char_Table
{
/* This is the vector's size field, which also holds the
pseudovector type information. It holds the size, too.
- The size counts the defalt and parent slots. */
+ The size counts the top, defalt, purpose, and parent slots.
+ The last three are not counted if this is a sub char table. */
EMACS_INT size;
struct Lisp_Vector *next;
- Lisp_Object contents[CHAR_TABLE_ORDINARY_SLOTS];
+ /* This holds a flag to tell if this is a top level char table (t)
+ or a sub char table (nil). */
+ Lisp_Object top;
/* This holds a default value,
which is used whenever the value for a specific character is nil. */
Lisp_Object defalt;
+ /* This holds an actual value of each element. A sub char table
+ has only SUB_CHAR_TABLE_ORDINARY_SLOTS number of elements. */
+ Lisp_Object contents[CHAR_TABLE_ORDINARY_SLOTS];
+
+ /* A sub char table doesn't has the following slots. */
+
/* This points to another char table, which we inherit from
when the value for a specific character is nil.
The `defalt' slot takes precedence over this. */
This type is treated in most respects as a pseudovector,
but since we never dynamically allocate or free them,
we don't need a next-vector field. */
-
+
struct Lisp_Subr
{
EMACS_INT size;
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.
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;
+ unsigned int check_frame : 1;
+ unsigned int found_for_buffer : 1;
+ unsigned int found_for_frame : 1;
+ Lisp_Object realvalue;
+ Lisp_Object buffer, frame;
+ Lisp_Object cdr;
};
/* In an overlay object, the mark bit of the plist is used as the GC mark.
/* Optional Lisp floating point type */
struct Lisp_Float
{
- Lisp_Object type; /* essentially used for mark-bit
+ Lisp_Object type; /* essentially used for mark-bit
and chaining when on free-list */
- double data;
+#ifdef HIDE_LISP_IMPLEMENTATION
+ double data_;
+#else
+ double data;
+#endif
};
+
+#ifdef HIDE_LISP_IMPLEMENTATION
+#define XFLOAT_DATA(f) (XFLOAT (f)->data_)
+#else
+#define XFLOAT_DATA(f) (XFLOAT (f)->data)
+#endif
#endif /* LISP_FLOAT_TYPE */
/* A character, declared with the following typedef, is a member
#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_CHAR 0x0007FFFF /* The lowest 19 bits */
+#define GLYPH_MASK_FACE 0x7FFFFF00
+ /* Mask bits for character code. */
+#define GLYPH_MASK_CHAR 0x000000FF /* The lowest 8 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. */
-#define FAST_MAKE_GLYPH(CHAR, FACE) ((unsigned char) (CHAR) | \
- ((FACE) << CHARACTERBITS))
+/* Set a character code and a face ID in a glyph G. */
+#define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << 8))
/* Return a glyph's character code. */
#define FAST_GLYPH_CHAR(glyph) ((glyph) & GLYPH_MASK_CHAR)
/* Return a glyph's face ID. */
-#define FAST_GLYPH_FACE(glyph) (((glyph) & GLYPH_MASK_FACE) >> CHARACTERBITS)
+#define FAST_GLYPH_FACE(glyph) (((glyph) & GLYPH_MASK_FACE) >> 8)
/* 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) \
+ ((GLYPH) (FAST_GLYPH_CHAR (glyph)) <= MAX_CHAR)
/* The ID of the mode line highlighting face. */
#define GLYPH_MODE_LINE_FACE 1
#define GC_BOOL_VECTOR_P(x) GC_PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
#define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
#define GC_FRAMEP(x) GC_PSEUDOVECTORP (x, PVEC_FRAME)
+
+#define SUB_CHAR_TABLE_P(x) (CHAR_TABLE_P (x) && NILP (XCHAR_TABLE (x)->top))
\f
#define EQ(x, y) (XFASTINT (x) == XFASTINT (y))
#define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y))
do { if (!WINDOWP ((x))) x = wrong_type_argument (Qwindowp, (x)); } while (0)
/* This macro rejects windows on the interior of the window tree as
- "dead", which is what we want; this is an argument-checking macro, and
+ "dead", which is what we want; this is an argument-checking macro, and
the user should never get access to interior windows.
A window of any sort, leaf or interior, is dead iff the buffer,
#ifdef LISP_FLOAT_TYPE
-#ifndef DBL_DIG
-#define DBL_DIG 20
-#endif
-
#define XFLOATINT(n) extract_float((n))
#define CHECK_FLOAT(x, i) \
/* 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.
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
/* 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. */
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 */
};
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.
-#define QUIT \
- if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
- { Vquit_flag = Qnil; Fsignal (Qquit, Qnil); }
+ 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 \
+ do { \
+ if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
+ { \
+ Vquit_flag = Qnil; \
+ Fsignal (Qquit, Qnil); \
+ } \
+ } while (0)
/* Nonzero if ought to quit now. */
#define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
\f
-/* 1 if CH is upper case. */
+/* Variables used locally in the following case handling macros. */
+extern int case_temp1;
+extern Lisp_Object case_temp2;
-#define UPPERCASEP(CH) \
- (XCHAR_TABLE (current_buffer->downcase_table)->contents[CH] != (CH))
+/* Current buffer's map from characters to lower-case characters. */
-/* 1 if CH is lower case. */
+#define DOWNCASE_TABLE current_buffer->downcase_table
-#define LOWERCASEP(CH) \
- (!UPPERCASEP (CH) \
- && XCHAR_TABLE (current_buffer->upcase_table)->contents[CH] != (CH))
+/* Current buffer's map from characters to upper-case characters. */
-/* 1 if CH is neither upper nor lower case. */
+#define UPCASE_TABLE current_buffer->upcase_table
-#define NOCASEP(CH) \
- (XCHAR_TABLE (current_buffer->upcase_table)->contents[CH] == (CH))
+/* Downcase a character, or make no change if that cannot be done. */
-/* Upcase a character, or make no change if that cannot be done. */
+#define DOWNCASE(CH) \
+ ((case_temp1 = (CH), \
+ case_temp2 = CHAR_TABLE_REF (DOWNCASE_TABLE, case_temp1), \
+ NATNUMP (case_temp2)) \
+ ? XFASTINT (case_temp2) : case_temp1)
-#define UPCASE(CH) \
- (XCHAR_TABLE (current_buffer->downcase_table)->contents[CH] == (CH) \
- ? UPCASE1 (CH) : (CH))
+/* 1 if CH is upper case. */
-/* Upcase a character known to be not upper case. */
+#define UPPERCASEP(CH) (DOWNCASE (CH) != (CH))
-#define UPCASE1(CH) (XCHAR_TABLE (current_buffer->upcase_table)->contents[CH])
+/* 1 if CH is neither upper nor lower case. */
-/* Downcase a character, or make no change if that cannot be done. */
+#define NOCASEP(CH) (UPCASE1 (CH) == (CH))
-#define DOWNCASE(CH) \
- (XCHAR_TABLE (current_buffer->downcase_table)->contents[CH])
+/* 1 if CH is lower case. */
-/* Current buffer's map from characters to lower-case characters. */
+#define LOWERCASEP(CH) (!UPPERCASEP (CH) && !NOCASEP(CH))
+
+/* Upcase a character, or make no change if that cannot be done. */
+
+#define UPCASE(CH) (!UPPERCASEP (CH) ? UPCASE1 (CH) : (CH))
-#define DOWNCASE_TABLE XCHAR_TABLE (current_buffer->downcase_table)->contents
+/* Upcase a character known to be not upper case. */
+
+#define UPCASE1(CH) \
+ ((case_temp1 = (CH), \
+ case_temp2 = CHAR_TABLE_REF (UPCASE_TABLE, case_temp1), \
+ NATNUMP (case_temp2)) \
+ ? XFASTINT (case_temp2) : case_temp1)
extern Lisp_Object Vascii_downcase_table;
\f
struct gcpro *next;
Lisp_Object *var; /* Address of first protected variable */
int nvars; /* Number of consecutive protected variables */
+#ifdef DEBUG_GCPRO
+ int level;
+#endif
};
+#ifndef DEBUG_GCPRO
+
#define GCPRO1(varname) \
{gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
gcprolist = &gcpro1; }
gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
gcprolist = &gcpro5; }
-/* Call staticpro (&var) to protect static variable `var'. */
-
-void staticpro();
-
#define UNGCPRO (gcprolist = gcpro1.next)
+#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 */
+
/* 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 (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 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 ();
+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);
#ifdef LISP_FLOAT_TYPE
-extern Lisp_Object Ffloatp(), Finteger_or_floatp();
-extern Lisp_Object Finteger_or_float_or_marker_p(), Ftruncate();
+EXFUN (Ffloatp, 1);
+EXFUN (Finteger_or_floatp, 1);
+EXFUN (Finteger_or_float_or_marker_p, 1);
#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 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 (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);
+
+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, int));
+extern void syms_of_data P_ ((void));
+extern void init_data P_ ((void));
/* 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 ();
+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));
+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);
+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 void sweep_weak_hash_tables P_ ((void));
extern Lisp_Object Qstring_lessp;
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 (), 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 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_ (());
+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 void syms_of_fns P_ ((void));
+
+/* Defined in floatfns.c */
+#ifdef LISP_FLOAT_TYPE
+extern double extract_float P_ ((Lisp_Object));
+EXFUN (Ffloat, 1);
+#endif /* LISP_FLOAT_TYPE */
+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_redisplay;
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 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_ ((void));
+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));
+
+/* Defined in vm-limit.c. */
+#ifdef __STDC__
+extern void memory_warnings P_ ((void *, void (*warnfun) ()));
+#else
+extern void memory_warnings P_ ((char *, void (*warnfun) ()));
+#endif
+
/* Defined in alloc.c */
+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 ();
+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;
+#ifdef LISP_FLOAT_TYPE
+extern Lisp_Object make_float P_ ((double));
+#endif /* LISP_FLOAT_TYPE */
+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));
/* 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;
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);
+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 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 *, ... */));
+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 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 ();
+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;
/* 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 P_ ((Lisp_Object));
extern struct buffer *all_buffers;
+EXFUN (Fprevious_overlay_change, 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 ();
+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));
/* 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);
+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 read_minibuf (), 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 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 Lisp_Object Vtty_erase_char, Vhelp_form, Vtop_level;
+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 ();
+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));
/* defined in keymap.c */
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, 1);
+EXFUN (Fwhere_is_internal, 4);
+extern Lisp_Object access_keymap P_ ((Lisp_Object, Lisp_Object, int, int));
+extern Lisp_Object store_in_keymap P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object get_keyelt P_ ((Lisp_Object, int));
+extern Lisp_Object get_keymap P_ ((Lisp_Object));
+extern Lisp_Object get_keymap_1 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 fix_submap_inheritance P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+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 ();
+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, 2);
+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 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 ();
+EXFUN (Fnext_property_change, 3);
+EXFUN (Fnext_single_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 intervals.c */
-extern Lisp_Object get_local_map ();
+extern Lisp_Object get_local_map P_ ((int, struct buffer *));
/* 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));
+
+/* 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 ();
+
+#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 x_set_tool_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
+extern void syms_of_xfns P_ ((void));
+EXFUN (Fx_hide_busy_cursor, 1);
+extern void init_xfns P_ ((void));
+#endif
+
+/* 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 char *getenv (), *ctime (), *getwd ();
extern long *xmalloc (), *xrealloc ();
extern void xfree ();
-extern char *egetenv ();
-
+extern char *egetenv P_ ((char *));
+
/* 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
HCoop / bpt / emacs.git / blobdiff