/* Fundamental definitions for GNU Emacs Lisp interpreter.
- Copyright (C) 1985, 1986, 1987, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc.
This file is part of GNU Emacs.
Lisp_Window,
/* Used by save,set,restore-window-configuration */
- Lisp_Window_Configuration
+ Lisp_Window_Configuration,
#ifdef LISP_FLOAT_TYPE
- ,
- Lisp_Float
+ Lisp_Float,
#endif /* LISP_FLOAT_TYPE */
+
+ /* The overlay type.
+ An overlay values is actually a retagged cons, the first in a
+ list of the form
+ ((START . END) nil . PLIST)
+ where START and END are markers in the overlay's buffer, and
+ PLIST is the overlay's property list. */
+ Lisp_Overlay
};
#ifndef NO_UNION_TYPE
-#ifndef BIG_ENDIAN
+#ifndef WORDS_BIG_ENDIAN
/* Definition of Lisp_Object for little-endian machines. */
}
Lisp_Object;
-#else /* If BIG_ENDIAN */
+#else /* If WORDS_BIG_ENDIAN */
typedef
union Lisp_Object
}
Lisp_Object;
-#endif /* BIG_ENDIAN */
+#endif /* WORDS_BIG_ENDIAN */
#endif /* NO_UNION_TYPE */
#define VALMASK ((1<<VALBITS) - 1)
#endif
#define GCTYPEMASK ((1<<GCTYPEBITS) - 1)
+
+/* Two flags that are set during GC. On some machines, these flags
+ are defined differently by the m- file. */
+
+/* This is set in the car of a cons and in the plist slot of a symbol
+ to indicate it is marked. Likewise in the plist slot of an interval,
+ the chain slot of a marker, the type slot of a float, and the name
+ slot of a buffer.
+
+ In strings, this bit in the size field indicates that the string
+ is a "large" one, one which was separately malloc'd
+ rather than being part of a string block. */
+
#define MARKBIT (1 << (VALBITS + GCTYPEBITS))
+/* In the size word of a vector, this bit means the vector has been marked.
+ In the size word of a large string, likewise. */
+
+#ifndef ARRAY_MARK_FLAG
+#define ARRAY_MARK_FLAG ((MARKBIT >> 1) & ~MARKBIT)
+#endif /* no ARRAY_MARK_FLAG */
+
+#if ARRAY_MARK_FLAG == MARKBIT
+you lose
+#endif
+
#endif /* NO_UNION_TYPE */
\f
/* These macros extract various sorts of values from a Lisp_Object.
unsigned int position; /* Cache of interval's character position */
struct interval *left; /* Intervals which precede me. */
struct interval *right; /* Intervals which succeed me. */
- struct interval *parent; /* Parent in the tree, or the Lisp_Object
- containing this interval tree. */
+
+ /* Parent in the tree, or the Lisp_Object containing this interval tree.
+
+ The mark bit on the root interval of an interval tree says
+ whether we have started (and possibly finished) marking the
+ tree. If GC comes across an interval tree whose root's parent
+ field has its markbit set, it leaves the tree alone.
+
+ You'd think we could store this information in the parent object
+ somewhere (after all, that should be visited once and then
+ ignored too, right?), but strings are GC'd strangely. */
+ struct interval *parent;
/* The remaining components are `properties' of the interval.
The first four are duplicates for things which can be on the list,
before this interval goes into it. */
unsigned char rear_sticky; /* Likewise for just after it. */
- Lisp_Object plist; /* Properties of this interval. */
+ /* Properties of this interval.
+ The mark bit on this field says whether this particular interval
+ tree node has been visited. Since intervals should never be
+ shared, GC aborts if it seems to have visited an interval twice. */
+ Lisp_Object plist;
};
typedef struct interval *INTERVAL;
structures. See, e.g., struct Lisp_String below. */
#define DECLARE_INTERVALS INTERVAL intervals;
-/* Macro used to condionally compile interval initialization into
+/* Macro used to conditionally compile interval initialization into
certain code. See, e.g., alloc.c. */
#define INITIALIZE_INTERVAL(ptr,val) ptr->intervals = val
/* A character, declared with the following typedef, is a member
of some character set associated with the current buffer. */
+#ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
+#define _UCHAR_T
typedef unsigned char UCHAR;
+#endif
/* Meanings of slots in a Lisp_Compiled: */
#define COMPILED_DOC_STRING 4
#define COMPILED_INTERACTIVE 5
-/* Flag bits in a character. */
+/* Flag bits in a character. These also get used in termhooks.h.
+ Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
+ (MUlti-Lingual Emacs) might need 18 bits for the character value
+ itself, so we probably shouldn't use any bits lower than 0x040000. */
+#define CHAR_ALT (0x040000)
+#define CHAR_SUPER (0x080000)
+#define CHAR_HYPER (0x100000)
+#define CHAR_SHIFT (0x200000)
+#define CHAR_CTL (0x400000)
+#define CHAR_META (0x800000)
+
+#ifdef USE_X_TOOLKIT
+#ifdef NO_UNION_TYPE
+/* Use this for turning a (void *) into a Lisp_Object, as when the
+ Lisp_Object is passed into a toolkit callback function. */
+#define VOID_TO_LISP(larg,varg) \
+ do { ((larg) = ((Lisp_Object) (varg))); } while (0)
+#define CVOID_TO_LISP VOID_TO_LISP
+
+/* Use this for turning a Lisp_Object into a (void *), as when the
+ Lisp_Object is passed into a toolkit callback function. */
+#define LISP_TO_VOID(larg) ((void *) (larg))
+#define LISP_TO_CVOID(varg) ((const void *) (larg))
+
+#else /* not NO_UNION_TYPE */
+/* Use this for turning a (void *) into a Lisp_Object, as when the
+ Lisp_Object is passed into a toolkit callback function. */
+#define VOID_TO_LISP(larg,varg) \
+ do { ((larg).v = (void *) (varg)); } while (0)
+#define CVOID_TO_LISP(larg,varg) \
+ do { ((larg).cv = (const void *) (varg)); } while (0)
+
+/* Use this for turning a Lisp_Object into a (void *), as when the
+ Lisp_Object is passed into a toolkit callback function. */
+#define LISP_TO_VOID(larg) ((larg).v)
+#define LISP_TO_CVOID(larg) ((larg).cv)
+#endif /* not NO_UNION_TYPE */
+#endif /* USE_X_TOOLKIT */
-#define CHAR_META 0x800000
-#define CHAR_CTL 0x400000
-#define CHAR_SHIFT 0x200000
+\f
+/* 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. */
+#define GLYPH unsigned int
+
+#ifdef HAVE_X_WINDOWS
+/* 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))
+
+/* Return a glyph's character code. */
+#define FAST_GLYPH_CHAR(glyph) ((glyph) & 0xff)
+
+/* Return a glyph's face ID. */
+#define FAST_GLYPH_FACE(glyph) (((glyph) >> 8) & ((1 << 24) - 1))
+
+/* 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
+#define MAKE_GLYPH(f, char, face) (char)
+#define GLYPH_CHAR(f, g) (g)
+#define GLYPH_FACE(f, g) (g)
+#endif
+
+/* The ID of the mode line highlighting face. */
+#define GLYPH_MODE_LINE_FACE 1
\f
/* Data type checking */
#define FRAMEP(x) (XTYPE ((x)) == Lisp_Frame)
#define WINDOWP(x) (XTYPE ((x)) == Lisp_Window)
#define WINDOW_CONFIGURATIONP(x) (XTYPE ((x)) == Lisp_Window_Configuration)
+#ifdef LISP_FLOAT_TYPE
#define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
+#else
+#define FLOATP(x) (0)
+#endif
+#define OVERLAYP(x) (XTYPE ((x)) == Lisp_Overlay)
#define EQ(x, y) (XFASTINT (x) == XFASTINT (y))
#define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y))
#define CHECK_LIST(x, i) \
- { if ((XTYPE ((x)) != Lisp_Cons) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); }
+ do { if ((XTYPE ((x)) != Lisp_Cons) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); } while (0)
#define CHECK_STRING(x, i) \
- { if (XTYPE ((x)) != Lisp_String) x = wrong_type_argument (Qstringp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_String) x = wrong_type_argument (Qstringp, (x)); } while (0)
#define CHECK_CONS(x, i) \
- { if (XTYPE ((x)) != Lisp_Cons) x = wrong_type_argument (Qconsp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Cons) x = wrong_type_argument (Qconsp, (x)); } while (0)
#define CHECK_SYMBOL(x, i) \
- { if (XTYPE ((x)) != Lisp_Symbol) x = wrong_type_argument (Qsymbolp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Symbol) x = wrong_type_argument (Qsymbolp, (x)); } while (0)
#define CHECK_VECTOR(x, i) \
- { if (XTYPE ((x)) != Lisp_Vector) x = wrong_type_argument (Qvectorp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Vector) x = wrong_type_argument (Qvectorp, (x)); } while (0)
#define CHECK_BUFFER(x, i) \
- { if (XTYPE ((x)) != Lisp_Buffer) x = wrong_type_argument (Qbufferp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Buffer) x = wrong_type_argument (Qbufferp, (x)); } while (0)
#define CHECK_WINDOW(x, i) \
- { if (XTYPE ((x)) != Lisp_Window) x = wrong_type_argument (Qwindowp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Window) 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
vchild, and hchild members are all nil. */
#define CHECK_LIVE_WINDOW(x, i) \
- { \
+ do { \
if (XTYPE ((x)) != Lisp_Window \
|| NILP (XWINDOW ((x))->buffer)) \
x = wrong_type_argument (Qwindow_live_p, (x)); \
- }
+ } while (0)
#define CHECK_PROCESS(x, i) \
- { if (XTYPE ((x)) != Lisp_Process) x = wrong_type_argument (Qprocessp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Process) x = wrong_type_argument (Qprocessp, (x)); } while (0)
#define CHECK_NUMBER(x, i) \
- { if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qintegerp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qintegerp, (x)); } while (0)
#define CHECK_NATNUM(x, i) \
- { if (XTYPE ((x)) != Lisp_Int || XINT ((x)) < 0) \
- x = wrong_type_argument (Qnatnump, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Int || XINT ((x)) < 0) \
+ x = wrong_type_argument (Qwholenump, (x)); } while (0)
#define CHECK_MARKER(x, i) \
- { if (XTYPE ((x)) != Lisp_Marker) x = wrong_type_argument (Qmarkerp, (x)); }
+ do { if (XTYPE ((x)) != Lisp_Marker) x = wrong_type_argument (Qmarkerp, (x)); } while (0)
#define CHECK_NUMBER_COERCE_MARKER(x, i) \
- { if (XTYPE ((x)) == Lisp_Marker) XFASTINT (x) = marker_position (x); \
- else if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qinteger_or_marker_p, (x)); }
+ do { if (XTYPE ((x)) == Lisp_Marker) XFASTINT (x) = marker_position (x); \
+ else if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } while (0)
#ifdef LISP_FLOAT_TYPE
#define XFLOATINT(n) extract_float((n))
#define CHECK_FLOAT(x, i) \
-{ if (XTYPE (x) != Lisp_Float) \
- x = wrong_type_argument (Qfloatp, (x)); }
+ do { if (XTYPE (x) != Lisp_Float) \
+ x = wrong_type_argument (Qfloatp, (x)); } while (0)
#define CHECK_NUMBER_OR_FLOAT(x, i) \
-{ if (XTYPE (x) != Lisp_Float && XTYPE (x) != Lisp_Int) \
- x = wrong_type_argument (Qnumberp, (x)); }
+ do { if (XTYPE (x) != Lisp_Float && XTYPE (x) != Lisp_Int) \
+ x = wrong_type_argument (Qnumberp, (x)); } while (0)
#define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x, i) \
-{ if (XTYPE (x) == Lisp_Marker) XFASTINT (x) = marker_position (x); \
+ do { if (XTYPE (x) == Lisp_Marker) XFASTINT (x) = marker_position (x); \
else if (XTYPE (x) != Lisp_Int && XTYPE (x) != Lisp_Float) \
- x = wrong_type_argument (Qnumber_or_marker_p, (x)); }
+ x = wrong_type_argument (Qnumber_or_marker_p, (x)); } while (0)
#else /* Not LISP_FLOAT_TYPE */
#define XFLOATINT(n) XINT((n))
#endif /* LISP_FLOAT_TYPE */
+#define CHECK_OVERLAY(x, i) \
+ do { if (XTYPE ((x)) != Lisp_Overlay) x = wrong_type_argument (Qoverlayp, (x));} while (0)
+
/* Cast pointers to this type to compare them. Some machines want int. */
#ifndef PNTR_COMPARISON_TYPE
#define PNTR_COMPARISON_TYPE unsigned int
`doc' is documentation for the user.
*/
+#ifndef __STDC__
#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
Lisp_Object fnname (); \
struct Lisp_Subr sname = {fnname, minargs, maxargs, lname, prompt, 0}; \
Lisp_Object fnname
+#else
+
+/* This version of DEFUN declares a function prototype with the right
+ arguments, so we can catch errors with maxargs at compile-time. */
+#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
+ Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
+ struct Lisp_Subr sname = {fnname, minargs, maxargs, lname, prompt, 0}; \
+ Lisp_Object fnname
+
+/* Note that the weird token-substitution semantics of ANSI C makes
+ this work for MANY and UNEVALLED. */
+#define DEFUN_ARGS_MANY (int, Lisp_Object *)
+#define DEFUN_ARGS_UNEVALLED (Lisp_Object)
+#define DEFUN_ARGS_0 (void)
+#define DEFUN_ARGS_1 (Lisp_Object)
+#define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
+#define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
+#define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
+#define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
+ Lisp_Object)
+#define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
+ Lisp_Object, Lisp_Object)
+#define DEFUN_ARGS_7 (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 ();
/* The handler clauses and variable from the condition-case form. */
Lisp_Object handler;
Lisp_Object var;
+ /* Fsignal stores here the condition-case clause that applies,
+ and Fcondition_case thus knows which clause to run. */
+ Lisp_Object chosen_clause;
/* Used to effect the longjump out to the handler. */
struct catchtag *tag;
extern struct catchtag *catchlist;
extern struct backtrace *backtrace_list;
+extern Lisp_Object memory_signal_data;
+
/* An address near the bottom of the stack.
Tells GC how to save a copy of the stack. */
extern char *stack_bottom;
#define UPCASE_TABLE XSTRING (current_buffer->upcase_table)->data
extern Lisp_Object Vascii_downcase_table, Vascii_upcase_table;
+extern Lisp_Object Vascii_canon_table, Vascii_eqv_table;
\f
/* number of bytes of structure consed since last GC */
Normally every link of the chain is an automatic variable of a function,
and its `val' points to some argument or local variable of the function.
On exit to the function, the chain is set back to the value it had on entry.
- This way, no link remains in the chain when the stack frame containing the link disappears.
+ This way, no link remains in the chain when the stack frame containing the
+ link disappears.
Every function that can call Feval must protect in this fashion all
Lisp_Object variables whose contents will be used again. */
ret_ungc_val = (expr); \
UNGCPRO; \
return ret_ungc_val; \
- } \
+ }
\f
/* Defined in data.c */
extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
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;
-Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
-Lisp_Object Qoverflow_error, Qunderflow_error;
+extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
+extern Lisp_Object Qoverflow_error, Qunderflow_error;
-extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qsymbolp, Qlistp, Qconsp;
+extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qwholenump;
+extern Lisp_Object Qsymbolp, Qlistp, Qconsp;
extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp;
extern Lisp_Object Qinteger_or_marker_p, Qnumber_or_marker_p;
extern Lisp_Object Fadd1 (), Fsub1 ();
extern Lisp_Object make_number ();
+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 Lisp_Object pure_cons (), make_pure_vector ();
extern Lisp_Object Fgarbage_collect ();
extern Lisp_Object Fmake_byte_code ();
+extern int gc_in_progress;
/* Defined in print.c */
extern Lisp_Object Vprin1_to_string_buffer;
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 ();
+#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;
/* Defined in eval.c */
extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments;
extern Lisp_Object Vautoload_queue;
+/* To run a normal hook, do
+ if (!NILP (Vrun_hooks))
+ call1 (Vrun_hooks, Qmy_funny_hook); */
extern Lisp_Object Vrun_hooks;
extern Lisp_Object Fand (), For (), Fif (), Fprogn (), Fprog1 (), Fprog2 ();
extern Lisp_Object Fsetq (), Fquote ();
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 Fchar_to_string ();
/* defined in buffer.c */
-extern Lisp_Object Vbuffer_alist;
+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 Qoverlayp;
extern struct buffer *all_buffers;
/* defined in marker.c */
/* defined in keymap.c */
-extern Lisp_Object Qkeymap;
+extern Lisp_Object Qkeymap, Qmenu_bar;
extern Lisp_Object current_global_map;
extern Lisp_Object Fkey_description (), Fsingle_key_description ();
extern Lisp_Object Fwhere_is_internal ();
extern int window_internal_height (), window_internal_width ();
/* defined in frame.c */
+extern Lisp_Object Qvisible;
extern Lisp_Object Fframep ();
extern Lisp_Object Fselect_frame ();
extern Lisp_Object Ffocus_frame ();
/* defined in emacs.c */
extern Lisp_Object decode_env_path ();
-extern Lisp_Object Vinvocation_name;
-void shut_down_emacs ( /* int signal */ );
+extern Lisp_Object Vinvocation_name, Vinvocation_directory;
+extern Lisp_Object Vinstallation_directory;
+void shut_down_emacs ( /* int signal, int no_x, Lisp_Object stuff */ );
/* 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 */
/* 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 ();
/* defined in callproc.c */
extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
+extern Lisp_Object Vdoc_directory;
/* defined in doc.c */
extern Lisp_Object Vdoc_file_name;
extern Lisp_Object Fundo_boundary ();
extern Lisp_Object truncate_undo_list ();
+/* defined in textprop.c */
+extern Lisp_Object Qmodification_hooks;
+extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
+extern Lisp_Object Fnext_property_change ();
+extern Lisp_Object Fnext_single_property_change ();
+
/* Nonzero means Emacs has already been initialized.
Used during startup to detect startup of dumped Emacs. */
extern int initialized;
extern void debugger ();
-extern char *malloc (), *realloc (), *getenv (), *ctime (), *getwd ();
+extern char *getenv (), *ctime (), *getwd ();
extern long *xmalloc (), *xrealloc ();
extern void xfree ();
extern char *egetenv ();
+
+/* Set up the name of the machine we're running on. */
+extern void init_system_name ();
HCoop / bpt / emacs.git / blobdiff