X-Git-Url: https://git.hcoop.net/bpt/emacs.git/blobdiff_plain/92a2515a65646d08ae30a4334553c5797938b798..26228404554a2c330f6e757fa9c22b744c296d44:/src/lisp.h diff --git a/src/lisp.h b/src/lisp.h index a524d86db4..d5e4aadc9e 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -1,5 +1,5 @@ /* 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,1998 Free Software Foundation, Inc. This file is part of GNU Emacs. @@ -18,6 +18,13 @@ along with GNU Emacs; see the file COPYING. If not, write to 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. */ #ifndef EMACS_INT @@ -181,12 +188,11 @@ Lisp_Object; #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)<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]; }; @@ -564,34 +588,100 @@ struct Lisp_Vector 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. */ @@ -636,7 +726,7 @@ struct Lisp_Symbol 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; @@ -646,6 +736,110 @@ struct Lisp_Subr char *prompt; char *doc; }; + + +/*********************************************************************** + 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 + /* These structures are used for various misc types. */ @@ -657,7 +851,7 @@ struct Lisp_Free union Lisp_Misc *chain; }; -/* In a marker, the markbit of the chain field is used as the gc mark bit */ +/* In a marker, the markbit of the chain field is used as the gc mark bit. */ struct Lisp_Marker { int type : 16; /* = Lisp_Misc_Marker */ @@ -665,9 +859,20 @@ struct Lisp_Marker /* 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. @@ -754,10 +959,15 @@ struct Lisp_Buffer_Objfwd 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. @@ -800,9 +1010,9 @@ union Lisp_Misc /* 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; + double data; }; #endif /* LISP_FLOAT_TYPE */ @@ -833,6 +1043,14 @@ typedef unsigned char UCHAR; #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 + #ifdef USE_X_TOOLKIT #ifdef NO_UNION_TYPE /* Use this for turning a (void *) into a Lisp_Object, as when the @@ -864,37 +1082,45 @@ typedef unsigned char UCHAR; /* The glyph datatype, used to represent characters on the display. */ -/* The low eight bits are the character code, and the bits above them - 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; given that we have no mechanism for - tossing unused frame face ID's yet, we'll probably run out of 255 - pretty quickly. */ +/* 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 + have no mechanism for tossing unused frame face ID's yet, we'll + probably run out of 255 pretty quickly. */ #define GLYPH unsigned int -#ifdef HAVE_FACES +/* 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 +/* Mask bits for face. */ +#define GLYPH_MASK_FACE 0x3FF80000 +/* Mask bits for character code. */ +#define GLYPH_MASK_CHAR 0x0007FFFF /* The lowest 19 bits */ + /* 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) ((char) | ((face) << 8)) +#define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << CHARACTERBITS)) /* Return a glyph's character code. */ -#define FAST_GLYPH_CHAR(glyph) ((glyph) & 0xff) +#define FAST_GLYPH_CHAR(glyph) ((glyph) & GLYPH_MASK_CHAR) /* Return a glyph's face ID. */ -#define FAST_GLYPH_FACE(glyph) (((glyph) >> 8) & ((1 << 24) - 1)) +#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 GLYPH_CHAR(f, g) (g) -#define GLYPH_FACE(f, g) (g) -#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 @@ -988,6 +1214,8 @@ typedef unsigned char UCHAR; #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)) #define EQ(x, y) (XFASTINT (x) == XFASTINT (y)) #define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y)) @@ -1023,7 +1251,7 @@ typedef unsigned char UCHAR; 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, @@ -1054,10 +1282,6 @@ typedef unsigned char UCHAR; #ifdef LISP_FLOAT_TYPE -#ifndef DBL_DIG -#define DBL_DIG 20 -#endif - #define XFLOATINT(n) extract_float((n)) #define CHECK_FLOAT(x, i) \ @@ -1146,19 +1370,23 @@ typedef unsigned char UCHAR; 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. */ @@ -1191,7 +1419,7 @@ extern void defvar_kboard (); 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 */ }; @@ -1237,40 +1465,49 @@ extern char *stack_bottom; #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) -/* 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)) + +/* Upcase a character known to be not upper case. */ -#define DOWNCASE_TABLE XCHAR_TABLE (current_buffer->downcase_table)->contents +#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; @@ -1336,8 +1573,8 @@ struct gcpro /* Call staticpro (&var) to protect static variable `var'. */ -void staticpro(); - +void staticpro P_ ((Lisp_Object *)); + #define UNGCPRO (gcprolist = gcpro1.next) /* Evaluate expr, UNGCPRO, and then return the value of expr. */ @@ -1351,6 +1588,22 @@ if (1) \ } \ else +/* 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; @@ -1381,151 +1634,430 @@ extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p; 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 */ +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)); +extern void init_coding P_ ((void)); +extern void init_coding_once P_ ((void)); +extern void syms_of_coding P_ ((void)); + +/* 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 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 (); +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 *)); +void 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)); +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 void del_range_1 P_ ((int, int, int)); +extern void del_range_byte P_ ((int, int, int)); +extern void del_range_both P_ ((int, int, int, int, int)); +extern void del_range_2 P_ ((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 (); +EXFUN (Fding, 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)); /* Defined in xdisp.c */ +extern Lisp_Object Vresize_mini_config; +extern struct frame *resize_mini_frame; +extern int resize_mini_initial_height; +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 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 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 alloc.c */ +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 (); +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 (), 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; @@ -1541,218 +2073,396 @@ extern Lisp_Object Vdebug_on_error; 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 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); +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)); /* 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)); +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 (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 void report_file_error P_ ((char *, Lisp_Object)); +extern int internal_delete_file P_ ((Lisp_Object)); +extern void syms_of_fileio 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 (); +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 toolbar_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 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); +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 */ @@ -1761,51 +2471,156 @@ extern int inhibit_window_system; 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; +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)); /* defined in bytecode.c */ extern Lisp_Object Qbytecode; -extern Lisp_Object Fbyte_code (); +EXFUN (Fbyte_code, 3); +extern void syms_of_bytecode 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)); /* 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 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)); + +/* 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)); + +/* 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 */ +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)); + +#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)); + +#ifdef HAVE_X_WINDOWS +/* Defined in xfns.c */ +extern void syms_of_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)); /* Nonzero means Emacs has already been initialized. Used during startup to detect startup of dumped Emacs. */ @@ -1813,16 +2628,14 @@ extern int initialized; 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