/* Fundamental definitions for GNU Emacs Lisp interpreter.
- Copyright (C) 1985,86,87,93,94,95,97,98,1999,2000
+ Copyright (C) 1985,86,87,93,94,95,97,98,1999,2000, 2001
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#define P_(proto) ()
#endif
+#if 0
+/* Define this temporarily to hunt a bug. If defined, the size of
+ strings is redundantly recorded in sdata structures so that it can
+ be compared to the sizes recorded in Lisp strings. */
+
+#define GC_CHECK_STRING_BYTES 1
+#endif /* 0*/
+
/* These are default choices for the types to use. */
#ifdef _LP64
#endif
/* Used for making sure that Emacs is compilable in all
- conigurations. */
+ configurations. */
#ifdef USE_LISP_UNION_TYPE
#undef NO_UNION_TYPE
Lisp_Type_Limit
};
-/* This is the set of datatypes that share a common structure.
+/* This is the set of data types that share a common structure.
The first member of the structure is a type code from this set.
The enum values are arbitrary, but we'll use large numbers to make it
more likely that we'll spot the error if a random word in memory is
#endif /* WORDS_BIG_ENDIAN */
+#ifdef __GNUC__
+static __inline__ Lisp_Object
+LISP_MAKE_RVALUE (Lisp_Object o)
+{
+ return o;
+}
+#else
+#define LISP_MAKE_RVALUE(o) (o) /* XXX - keeps arg as rvalue. */
+#endif
+
#endif /* NO_UNION_TYPE */
#ifdef NO_UNION_TYPE
#define Lisp_Object EMACS_INT
+#define LISP_MAKE_RVALUE(o) (0+(o))
#endif /* NO_UNION_TYPE */
#ifndef VALMASK
/* One need to override this if there must be high bits set in data space
(doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
- on all machines, but would penalise machines which don't need it)
+ on all machines, but would penalize machines which don't need it)
*/
#ifndef XTYPE
#define XTYPE(a) ((enum Lisp_Type) ((a) >> VALBITS))
#ifndef XPNTR
#ifdef HAVE_SHM
/* In this representation, data is found in two widely separated segments. */
-extern int pure_size;
+extern size_t pure_size;
#define XPNTR(a) \
(XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
#else /* not HAVE_SHM */
#endif /* NO_UNION_TYPE */
+/* Largest and smallest representable fixnum values. These are the C
+ values. */
+
+#define MOST_NEGATIVE_FIXNUM - ((EMACS_INT) 1 << (VALBITS - 1))
+#define MOST_POSITIVE_FIXNUM (((EMACS_INT) 1 << (VALBITS - 1)) - 1)
+
+/* Value is non-zero if C integer I doesn't fit into a Lisp fixnum. */
+
+#define FIXNUM_OVERFLOW_P(i) \
+ ((EMACS_INT)(i) > MOST_POSITIVE_FIXNUM \
+ || (EMACS_INT) (i) < MOST_NEGATIVE_FIXNUM)
+
/* Extract a value or address from a Lisp_Object. */
#define XCONS(a) (eassert (GC_CONSP(a)),(struct Lisp_Cons *) XPNTR(a))
-#define XVECTOR(a) ((struct Lisp_Vector *) XPNTR(a))
+#define XVECTOR(a) (eassert (GC_VECTORLIKEP(a)),(struct Lisp_Vector *) XPNTR(a))
#define XSTRING(a) (eassert (GC_STRINGP(a)),(struct Lisp_String *) XPNTR(a))
#define XSYMBOL(a) (eassert (GC_SYMBOLP(a)),(struct Lisp_Symbol *) XPNTR(a))
#define XFLOAT(a) (eassert (GC_FLOATP(a)),(struct Lisp_Float *) XPNTR(a))
unsigned int position; /* Cache of interval's character position. */
/* This field is usually updated
simultaneously with an interval
- traversal, there is no guaranty
+ traversal, there is no guarantee
that it is valid for a random
interval. */
struct interval *left; /* Intervals which precede me. */
};
/* Take the car or cdr of something known to be a cons cell. */
+/* The _AS_LVALUE macros shouldn't be used outside of the minimal set
+ of code that has to know what a cons cell looks like. Other code not
+ part of the basic lisp implementation should assume that the car and cdr
+ fields are not accessible as lvalues. (What if we want to switch to
+ a copying collector someday? Cached cons cell field addresses may be
+ invalidated at arbitrary points.) */
#ifdef HIDE_LISP_IMPLEMENTATION
-#define XCAR(c) (XCONS ((c))->car_)
-#define XCDR(c) (XCONS ((c))->cdr_)
+#define XCAR_AS_LVALUE(c) (XCONS ((c))->car_)
+#define XCDR_AS_LVALUE(c) (XCONS ((c))->cdr_)
#else
-#define XCAR(c) (XCONS ((c))->car)
-#define XCDR(c) (XCONS ((c))->cdr)
+#define XCAR_AS_LVALUE(c) (XCONS ((c))->car)
+#define XCDR_AS_LVALUE(c) (XCONS ((c))->cdr)
#endif
+/* Okay, we're not quite ready to turn this on yet. A few files still
+ need to be updated and tested. */
+#undef LISP_MAKE_RVALUE
+#define LISP_MAKE_RVALUE(x) (x)
+
+/* Use these from normal code. */
+#define XCAR(c) LISP_MAKE_RVALUE(XCAR_AS_LVALUE(c))
+#define XCDR(c) LISP_MAKE_RVALUE(XCDR_AS_LVALUE(c))
+
+/* Use these to set the fields of a cons cell.
+
+ Note that both arguments may refer to the same object, so 'n'
+ should not be read after 'c' is first modified. Also, neither
+ argument should be evaluated more than once; side effects are
+ especially common in the second argument. */
+#define XSETCAR(c,n) (XCAR_AS_LVALUE(c) = (n))
+#define XSETCDR(c,n) (XCDR_AS_LVALUE(c) = (n))
+
+/* For performance: Fast storage of positive integers into the
+ fields of a cons cell. See above caveats. */
+#define XSETCARFASTINT(c,n) XSETFASTINT(XCAR_AS_LVALUE(c),(n))
+#define XSETCDRFASTINT(c,n) XSETFASTINT(XCDR_AS_LVALUE(c),(n))
+
/* Take the car or cdr of something whose type is not known. */
#define CAR(c) \
(CONSP ((c)) ? XCAR ((c)) \
(XSTRING (STR)->size_byte >= 0)
/* Return the length in bytes of STR. */
+
+#ifdef GC_CHECK_STRING_BYTES
+
+struct Lisp_String;
+extern int string_bytes P_ ((struct Lisp_String *));
+#define STRING_BYTES(S) string_bytes ((S))
+
+#else /* not GC_CHECK_STRING_BYTES */
+
#define STRING_BYTES(STR) \
((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte)
+#endif /* not GC_CHECK_STRING_BYTES */
+
/* Set the length in bytes of STR. */
#define SET_STRING_BYTES(STR, SIZE) ((STR)->size_byte = (SIZE))
unsigned char data[1];
};
-/* In a symbol, the markbit of the plist is used as the gc mark bit */
-
-struct Lisp_Symbol
- {
- struct Lisp_String *name;
- Lisp_Object value;
- Lisp_Object function;
- Lisp_Object plist;
- Lisp_Object obarray;
- struct Lisp_Symbol *next; /* -> next symbol in this obarray bucket */
- };
-
/* This structure describes a built-in function.
It is generated by the DEFUN macro only.
defsubr makes it into a Lisp object.
char *doc;
};
+\f
+/***********************************************************************
+ Symbols
+ ***********************************************************************/
+
+/* Interned state of a symbol. */
+
+enum symbol_interned
+{
+ SYMBOL_UNINTERNED = 0,
+ SYMBOL_INTERNED = 1,
+ SYMBOL_INTERNED_IN_INITIAL_OBARRAY = 2
+};
+
+/* In a symbol, the markbit of the plist is used as the gc mark bit */
+
+struct Lisp_Symbol
+{
+ /* Non-zero means symbol serves as a variable alias. The symbol
+ holding the real value is found in the value slot. */
+ unsigned indirect_variable : 1;
+
+ /* Non-zero means symbol is constant, i.e. changing its value
+ should signal an error. */
+ unsigned constant : 1;
+
+ /* Interned state of the symbol. This is an enumerator from
+ enum symbol_interned. */
+ unsigned interned : 2;
+
+ /* The symbol's name. This should become a Lisp_Object
+ some day; there's no need for the Lisp_String pointer nowadays. */
+ struct Lisp_String *name;
+
+ /* Value of the symbol or Qunbound if unbound. If this symbol is a
+ defvaralias, `value' contains the symbol for which it is an
+ alias. Use the SYMBOL_VALUE and SET_SYMBOL_VALUE macros to get
+ and set a symbol's value, to take defvaralias into account. */
+ Lisp_Object value;
+
+ /* Function value of the symbol or Qunbound if not fcoundp. */
+ Lisp_Object function;
+
+ /* The symbol's property list. */
+ Lisp_Object plist;
+
+ /* Next symbol in obarray bucket, if the symbol is interned. */
+ struct Lisp_Symbol *next;
+};
+
+/* Value is non-zero if SYM is an interned symbol. */
+
+#define SYMBOL_INTERNED_P(sym) \
+ (XSYMBOL (sym)->interned != SYMBOL_UNINTERNED)
+
+/* Value is non-zero if SYM is interned in initial_obarray. */
+
+#define SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P(sym) \
+ (XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY)
+
+/* Value is non-zero if symbol is considered a constant, i.e. its
+ value cannot be changed (there is an exception for keyword symbols,
+ whose value can be set to the keyword symbol itself). */
+
+#define SYMBOL_CONSTANT_P(sym) XSYMBOL (sym)->constant
+
+/* Value is the value of SYM, with defvaralias taken into
+ account. */
+
+#define SYMBOL_VALUE(sym) \
+ (XSYMBOL (sym)->indirect_variable \
+ ? XSYMBOL (indirect_variable (sym))->value \
+ : XSYMBOL (sym)->value)
+
+/* Set SYM's value to VAL, taking defvaralias into account. */
+
+#define SET_SYMBOL_VALUE(sym, val) \
+ do { \
+ if (XSYMBOL (sym)->indirect_variable) \
+ XSYMBOL (indirect_variable ((sym)))->value = (val); \
+ else \
+ XSYMBOL (sym)->value = (val); \
+ } while (0)
+
\f
/***********************************************************************
Hash Tables
#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)
+#define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (FAST_GLYPH_CHAR (glyph), 1)
/* The ID of the mode line highlighting face. */
#define GLYPH_MODE_LINE_FACE 1
#define CHECK_OVERLAY(x, i) \
do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
+/* Since we can't assign directly to the CAR or CDR fields of a cons
+ cell, use these when checking that those fields contain numbers. */
+#define CHECK_NUMBER_CAR(x, i) \
+ do { \
+ Lisp_Object tmp = XCAR (x); \
+ CHECK_NUMBER (tmp, (i)); \
+ XSETCAR ((x), tmp); \
+ } while (0)
+
+#define CHECK_NUMBER_CDR(x, i) \
+ do { \
+ Lisp_Object tmp = XCDR (x); \
+ CHECK_NUMBER (tmp, (i)); \
+ XSETCDR ((x), tmp); \
+ } while (0)
+
/* Cast pointers to this type to compare them. Some machines want int. */
#ifndef PNTR_COMPARISON_TYPE
#define PNTR_COMPARISON_TYPE EMACS_UINT
#if (!defined (__STDC__) && !defined (PROTOTYPES)) \
|| defined (USE_NONANSI_DEFUN)
-#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
+
+#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, args) \
Lisp_Object fnname (); \
struct Lisp_Subr sname = \
{ PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
fnname, minargs, maxargs, lname, prompt, 0}; \
- Lisp_Object fnname
+ Lisp_Object fnname args
#else
/* Macros we use to define forwarded Lisp variables.
These are used in the syms_of_FILENAME functions. */
+#ifdef DOC_STRINGS_IN_COMMENTS
+
+#define DEFVAR_LISP(lname, vname) defvar_lisp (lname, vname)
+#define DEFVAR_LISP_NOPRO(lname, vname) defvar_lisp_nopro (lname, vname)
+#define DEFVAR_BOOL(lname, vname) defvar_bool (lname, vname)
+#define DEFVAR_INT(lname, vname) defvar_int (lname, vname)
+#define DEFVAR_PER_BUFFER(lname, vname, type) \
+ defvar_per_buffer (lname, vname, type, 0)
+#define DEFVAR_KBOARD(lname, vname) \
+ defvar_kboard (lname, \
+ (int)((char *)(¤t_kboard->vname) \
+ - (char *)current_kboard))
+
+#else /* not DOC_STRINGS_IN_COMMENTS */
+
#define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
#define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
#define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
defvar_kboard (lname, \
(int)((char *)(¤t_kboard->vname) \
- (char *)current_kboard))
+
+#endif /* not DOC_STRINGS_IN_COMMENTS */
+
+
\f
/* Structure for recording Lisp call stack for backtrace purposes. */
form.
Otherwise, the element is a variable binding.
+
If the symbol field is a symbol, it is an ordinary variable binding.
- Otherwise, it should be a structure (SYMBOL BUFFER . BUFFER),
- which represents having bound BUFFER's local value,
- or (SYMBOL nil . BUFFER), which represents having bound the default
- value when BUFFER was current (buffer not having any local binding
- for SYMBOL). */
+
+ Otherwise, it should be a structure (SYMBOL WHERE
+ . CURRENT-BUFFER), which means having bound a local value while
+ CURRENT-BUFFER was active. If WHERE is nil this means we saw the
+ default value when binding SYMBOL. WHERE being a buffer or frame
+ means we saw a buffer-local or frame-local value. Other values of
+ WHERE mean an internal error. */
struct specbinding
{
extern Lisp_Object Qframep;
+extern void circular_list_error P_ ((Lisp_Object));
+
EXFUN (Feq, 2);
EXFUN (Fnull, 1);
EXFUN (Flistp, 1);
EXFUN (Fsub1, 1);
EXFUN (Fmake_variable_buffer_local, 1);
+extern Lisp_Object indirect_variable P_ ((Lisp_Object));
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 void store_symval_forwarding P_ ((Lisp_Object, Lisp_Object,
+ Lisp_Object, struct buffer *));
extern Lisp_Object do_symval_forwarding P_ ((Lisp_Object));
extern Lisp_Object set_internal P_ ((Lisp_Object, Lisp_Object, struct buffer *, int));
extern void syms_of_data P_ ((void));
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);
+EXFUN (Fprovide, 2);
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 void syms_of_floatfns P_ ((void));
/* Defined in insdel.c */
+extern Lisp_Object Qinhibit_modification_hooks;
extern void move_gap P_ ((int));
extern void move_gap_both P_ ((int, int));
extern void make_gap P_ ((int));
extern void safe_bcopy P_ ((char *, char *, int));
/* Defined in xdisp.c */
+extern Lisp_Object Qinhibit_point_motion_hooks;
extern Lisp_Object Qinhibit_redisplay, Qdisplay;
+extern Lisp_Object Qinhibit_eval_during_redisplay;
extern Lisp_Object Qmessage_truncate_lines;
extern Lisp_Object Vmessage_log_max;
extern int message_enable_multibyte;
extern void check_message_stack P_ ((void));
extern void setup_echo_area_for_printing P_ ((int));
extern int push_message P_ ((void));
+extern Lisp_Object push_message_unwind P_ ((Lisp_Object));
extern void pop_message P_ ((void));
extern void restore_message P_ ((void));
extern Lisp_Object current_message P_ ((void));
extern void 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 redisplay_preserve_echo_area P_ ((int));
extern void mark_window_display_accurate P_ ((Lisp_Object, int));
-extern int invisible_p P_ ((Lisp_Object, Lisp_Object));
extern void prepare_menu_bars P_ ((void));
extern void syms_of_xdisp P_ ((void));
extern void init_xdisp P_ ((void));
extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
/* Defined in alloc.c */
+extern void check_pure_size P_ ((void));
extern void allocate_string_data P_ ((struct Lisp_String *, int, int));
extern void uninterrupt_malloc P_ ((void));
extern void malloc_warning P_ ((char *));
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 P_ ((EMACS_INT));
+extern struct Lisp_Vector *allocate_vector P_ ((EMACS_INT));
+extern struct Lisp_Vector *allocate_other_vector P_ ((EMACS_INT));
+extern struct Lisp_Hash_Table *allocate_hash_table P_ ((void));
+extern struct window *allocate_window P_ ((void));
+extern struct frame *allocate_frame P_ ((void));
+extern struct Lisp_Process *allocate_process P_ ((void));
extern int gc_in_progress;
extern Lisp_Object make_float P_ ((double));
extern void display_malloc_warning P_ ((void));
#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 Lisp_Object Vload_history, Vload_suffixes;
+extern int openp P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
+ Lisp_Object *, int));
extern int isfloat_string P_ ((char *));
extern void map_obarray P_ ((Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
Lisp_Object));
extern Lisp_Object Vdebug_on_error;
extern Lisp_Object Vsignaling_function;
extern int handling_signal;
+extern int interactive_p P_ ((int));
/* To run a normal hook, use the appropriate function from the list below.
The calling convention:
EXFUN (Ffield_string, 1);
EXFUN (Fdelete_field, 1);
EXFUN (Ffield_beginning, 2);
+EXFUN (Ffield_end, 2);
EXFUN (Ffield_string_no_properties, 1);
extern void set_time_zone_rule P_ ((char *));
/* defined in buffer.c */
+extern int mouse_face_overlay_overlaps P_ ((Lisp_Object));
extern void nsberror P_ ((Lisp_Object));
extern char *no_switch_window P_ ((Lisp_Object window));
EXFUN (Fset_buffer_multibyte, 1);
/* defined in keyboard.c */
+extern int echoing;
+extern Lisp_Object echo_message_buffer;
+extern struct kboard *echo_kboard;
+extern void cancel_echoing P_ ((void));
extern Lisp_Object Qdisabled, QCfilter;
extern Lisp_Object Vtty_erase_char, Vhelp_form, Vtop_level;
extern int input_pending;
EXFUN (Fdiscard_input, 0);
EXFUN (Frecursive_edit, 0);
+EXFUN (Ftop_level, 0);
EXFUN (Fcommand_execute, 4);
EXFUN (Finput_pending_p, 0);
extern Lisp_Object menu_bar_items P_ ((Lisp_Object));
extern void init_keyboard P_ ((void));
extern void syms_of_keyboard P_ ((void));
extern void keys_of_keyboard P_ ((void));
+extern char *push_key_description P_ ((unsigned int, char *, int));
-/* defined in keymap.c */
-
-#define KEYMAPP(m) (!NILP (get_keymap (m, 0, 0)))
-extern Lisp_Object Qkeymap, Qmenu_bar;
-extern Lisp_Object current_global_map;
-EXFUN (Fmake_sparse_keymap, 1);
-EXFUN (Fcopy_keymap, 1);
-EXFUN (Fdefine_key, 3);
-EXFUN (Flookup_key, 3);
-EXFUN (Fkey_binding, 2);
-EXFUN (Fkey_description, 1);
-EXFUN (Fsingle_key_description, 2);
-EXFUN (Fwhere_is_internal, 4);
-extern Lisp_Object access_keymap P_ ((Lisp_Object, Lisp_Object, int, int, int));
-extern Lisp_Object get_keyelt P_ ((Lisp_Object, int));
-extern Lisp_Object get_keymap P_ ((Lisp_Object, int, int));
-extern void describe_vector P_ ((Lisp_Object, Lisp_Object,
- void (*) (Lisp_Object), int,
- Lisp_Object, Lisp_Object, int *, int));
-extern void describe_map_tree P_ ((Lisp_Object, int, Lisp_Object, Lisp_Object,
- char *, int, int, int));
-extern int current_minor_maps P_ ((Lisp_Object **, Lisp_Object **));
-extern void initial_define_key P_ ((Lisp_Object, int, char *));
-extern void initial_define_lispy_key P_ ((Lisp_Object, char *, char *));
-extern void syms_of_keymap P_ ((void));
-extern void keys_of_keymap P_ ((void));
/* defined in indent.c */
EXFUN (Fvertical_motion, 2);
/* defined in window.c */
extern Lisp_Object Qwindowp, Qwindow_live_p;
+extern Lisp_Object Vwindow_list;
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 (Fwindow_buffer, 1);
EXFUN (Fget_buffer_window, 2);
EXFUN (Fsave_window_excursion, UNEVALLED);
EXFUN (Fsplit_window, 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 init_window P_ ((void));
extern void syms_of_window P_ ((void));
extern void keys_of_window P_ ((void));
extern Lisp_Object Qvisible;
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 do_switch_frame P_ ((Lisp_Object, int, 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 (Ficonify_frame, 1);
EXFUN (Fframe_visible_p, 1);
EXFUN (Fvisible_frame_list, 0);
+EXFUN (Fframe_parameter, 2);
EXFUN (Fframe_parameters, 1);
EXFUN (Fmodify_frame_parameters, 2);
EXFUN (Fset_frame_height, 3);
/* defined in emacs.c */
extern Lisp_Object decode_env_path P_ ((char *, char *));
extern Lisp_Object Vinvocation_name, Vinvocation_directory;
-extern Lisp_Object Vinstallation_directory;
+extern Lisp_Object Vinstallation_directory, empty_string;
EXFUN (Fkill_emacs, 1);
#if HAVE_SETLOCALE
void fixup_locale 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 Vexec_path, Vexec_suffixes,
+ 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));
/* defined in textprop.c */
extern Lisp_Object Qmodification_hooks;
-extern Lisp_Object Qrear_nonsticky, Qfont;
+extern Lisp_Object Qrear_nonsticky, Qfont, Qmouse_face;
extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
EXFUN (Fnext_property_change, 3);
EXFUN (Fnext_single_property_change, 4);
/* Defined in xfns.c */
extern void syms_of_xfns P_ ((void));
extern void init_xfns P_ ((void));
+extern Lisp_Object Vx_resource_name;
EXFUN (Fxw_display_color_p, 1);
#endif /* HAVE_X_WINDOWS */
#else
#define SWITCH_ENUM_CAST(x) (x)
#endif
+
+/* Loop over Lisp list LIST. Signal an error if LIST is not a proper
+ list, or if it contains circles.
+
+ HARE and TORTOISE should be the names of Lisp_Object variables, and
+ N should be the name of an EMACS_INT variable declared in the
+ function where the macro is used. Each nested loop should use
+ its own variables.
+
+ In the loop body, HARE is set to each cons of LIST, and N is the
+ length of the list processed so far. */
+
+#define LIST_END_P(list, obj) \
+ (NILP (obj) \
+ ? 1 \
+ : (CONSP (obj) \
+ ? 0 \
+ : (wrong_type_argument (Qlistp, (list), 0)), 1))
+
+#define FOREACH(hare, list, tortoise, n) \
+ for (tortoise = hare = (list), n = 0; \
+ !LIST_END_P (list, hare); \
+ (hare = XCDR (hare), ++n, \
+ ((n & 1) != 0 \
+ ? (tortoise = XCDR (tortoise), \
+ (EQ (hare, tortoise) \
+ && (circular_list_error ((list)), 1))) \
+ : 0)))
+
+/* The ubiquitous min and max macros. */
+
+#ifdef max
+#undef max
+#undef min
+#endif
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+/* Return a fixnum or float, depending on whether VAL fits in a Lisp
+ fixnum. */
+
+#define make_fixnum_or_float(val) \
+ (FIXNUM_OVERFLOW_P (val) ? make_float (val) : make_number (val))