X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/60d1b18734fff144f1608da6228d60e4bda7b24c..551562513e304a38a0caa1b94d87cc39a1af7c18:/src/lisp.h?ds=sidebyside diff --git a/src/lisp.h b/src/lisp.h index d2d385605c..a1409d1af8 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -1,4 +1,4 @@ -/* Fundamental definitions for GNU Emacs Lisp interpreter. +/* Fundamental definitions for GNU Emacs Lisp interpreter. -*- coding: utf-8 -*- Copyright (C) 1985-1987, 1993-1995, 1997-2015 Free Software Foundation, Inc. @@ -258,7 +258,7 @@ enum Lisp_Bits /* The maximum value that can be stored in a EMACS_INT, assuming all bits other than the type bits contribute to a nonnegative signed value. - This can be used in #if, e.g., '#if USB_TAG' below expands to an + This can be used in #if, e.g., '#if USE_LSB_TAG' below expands to an expression involving VAL_MAX. */ #define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1)) @@ -301,10 +301,6 @@ error !; and/or via a function definition like this: - LISP_MACRO_DEFUN (OP, Lisp_Object, (Lisp_Object x), (x)) - - which macro-expands to this: - Lisp_Object (OP) (Lisp_Object x) { return lisp_h_OP (x); } without worrying about the implementations diverging, since @@ -351,8 +347,6 @@ error !; #define lisp_h_XCONS(a) \ (eassert (CONSP (a)), (struct Lisp_Cons *) XUNTAG (a, Lisp_Cons)) #define lisp_h_XHASH(a) XUINT (a) -#define lisp_h_XPNTR(a) \ - (SYMBOLP (a) ? XSYMBOL (a) : (void *) ((intptr_t) (XLI (a) & VALMASK))) #ifndef GC_CHECK_CONS_LIST # define lisp_h_check_cons_list() ((void) 0) #endif @@ -397,7 +391,6 @@ error !; # define XCDR(c) lisp_h_XCDR (c) # define XCONS(a) lisp_h_XCONS (a) # define XHASH(a) lisp_h_XHASH (a) -# define XPNTR(a) lisp_h_XPNTR (a) # ifndef GC_CHECK_CONS_LIST # define check_cons_list() lisp_h_check_cons_list () # endif @@ -411,17 +404,6 @@ error !; # endif #endif -/* Define NAME as a lisp.h inline function that returns TYPE and has - arguments declared as ARGDECLS and passed as ARGS. ARGDECLS and - ARGS should be parenthesized. Implement the function by calling - lisp_h_NAME ARGS. */ -#define LISP_MACRO_DEFUN(name, type, argdecls, args) \ - INLINE type (name) argdecls { return lisp_h_##name args; } - -/* like LISP_MACRO_DEFUN, except NAME returns void. */ -#define LISP_MACRO_DEFUN_VOID(name, argdecls, args) \ - INLINE void (name) argdecls { lisp_h_##name args; } - /* Define the fundamental Lisp data structures. */ @@ -754,8 +736,18 @@ struct Lisp_Symbol /* Convert a Lisp_Object to the corresponding EMACS_INT and vice versa. At the machine level, these operations are no-ops. */ -LISP_MACRO_DEFUN (XLI, EMACS_INT, (Lisp_Object o), (o)) -LISP_MACRO_DEFUN (XIL, Lisp_Object, (EMACS_INT i), (i)) + +INLINE EMACS_INT +(XLI) (Lisp_Object o) +{ + return lisp_h_XLI (o); +} + +INLINE Lisp_Object +(XIL) (EMACS_INT i) +{ + return lisp_h_XIL (i); +} /* In the size word of a vector, this bit means the vector has been marked. */ @@ -831,12 +823,41 @@ DEFINE_GDB_SYMBOL_END (VALMASK) #if USE_LSB_TAG -LISP_MACRO_DEFUN (make_number, Lisp_Object, (EMACS_INT n), (n)) -LISP_MACRO_DEFUN (XINT, EMACS_INT, (Lisp_Object a), (a)) -LISP_MACRO_DEFUN (XFASTINT, EMACS_INT, (Lisp_Object a), (a)) -LISP_MACRO_DEFUN (XSYMBOL, struct Lisp_Symbol *, (Lisp_Object a), (a)) -LISP_MACRO_DEFUN (XTYPE, enum Lisp_Type, (Lisp_Object a), (a)) -LISP_MACRO_DEFUN (XUNTAG, void *, (Lisp_Object a, int type), (a, type)) +INLINE Lisp_Object +(make_number) (EMACS_INT n) +{ + return lisp_h_make_number (n); +} + +INLINE EMACS_INT +(XINT) (Lisp_Object a) +{ + return lisp_h_XINT (a); +} + +INLINE EMACS_INT +(XFASTINT) (Lisp_Object a) +{ + return lisp_h_XFASTINT (a); +} + +INLINE struct Lisp_Symbol * +(XSYMBOL) (Lisp_Object a) +{ + return lisp_h_XSYMBOL (a); +} + +INLINE enum Lisp_Type +(XTYPE) (Lisp_Object a) +{ + return lisp_h_XTYPE (a); +} + +INLINE void * +(XUNTAG) (Lisp_Object a, int type) +{ + return lisp_h_XUNTAG (a, type); +} #else /* ! USE_LSB_TAG */ @@ -916,9 +937,6 @@ XUNTAG (Lisp_Object a, int type) #endif /* ! USE_LSB_TAG */ -/* Extract the pointer hidden within A. */ -LISP_MACRO_DEFUN (XPNTR, void *, (Lisp_Object a), (a)) - /* Extract A's value as an unsigned integer. */ INLINE EMACS_UINT XUINT (Lisp_Object a) @@ -930,7 +948,12 @@ XUINT (Lisp_Object a) /* Return A's (Lisp-integer sized) hash. Happens to be like XUINT right now, but XUINT should only be applied to objects we know are integers. */ -LISP_MACRO_DEFUN (XHASH, EMACS_INT, (Lisp_Object a), (a)) + +INLINE EMACS_INT +(XHASH) (Lisp_Object a) +{ + return lisp_h_XHASH (a); +} /* Like make_number (N), but may be faster. N must be in nonnegative range. */ INLINE Lisp_Object @@ -942,7 +965,12 @@ make_natnum (EMACS_INT n) } /* Return true if X and Y are the same object. */ -LISP_MACRO_DEFUN (EQ, bool, (Lisp_Object x, Lisp_Object y), (x, y)) + +INLINE bool +(EQ) (Lisp_Object x, Lisp_Object y) +{ + return lisp_h_EQ (x, y); +} /* Value is true if I doesn't fit into a Lisp fixnum. It is written this way so that it also works if I is of unsigned @@ -960,7 +988,11 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper) /* Extract a value or address from a Lisp_Object. */ -LISP_MACRO_DEFUN (XCONS, struct Lisp_Cons *, (Lisp_Object a), (a)) +INLINE struct Lisp_Cons * +(XCONS) (Lisp_Object a) +{ + return lisp_h_XCONS (a); +} INLINE struct Lisp_Vector * XVECTOR (Lisp_Object a) @@ -1133,9 +1165,11 @@ make_pointer_integer (void *p) /* Type checking. */ -LISP_MACRO_DEFUN_VOID (CHECK_TYPE, - (int ok, Lisp_Object predicate, Lisp_Object x), - (ok, predicate, x)) +INLINE void +(CHECK_TYPE) (int ok, Lisp_Object predicate, Lisp_Object x) +{ + lisp_h_CHECK_TYPE (ok, predicate, x); +} /* See the macros in intervals.h. */ @@ -1175,8 +1209,18 @@ xcdr_addr (Lisp_Object c) } /* Use these from normal code. */ -LISP_MACRO_DEFUN (XCAR, Lisp_Object, (Lisp_Object c), (c)) -LISP_MACRO_DEFUN (XCDR, Lisp_Object, (Lisp_Object c), (c)) + +INLINE Lisp_Object +(XCAR) (Lisp_Object c) +{ + return lisp_h_XCAR (c); +} + +INLINE Lisp_Object +(XCDR) (Lisp_Object c) +{ + return lisp_h_XCDR (c); +} /* Use these to set the fields of a cons cell. @@ -1713,7 +1757,11 @@ verify (offsetof (struct Lisp_Sub_Char_Table, contents) /* Value is name of symbol. */ -LISP_MACRO_DEFUN (SYMBOL_VAL, Lisp_Object, (struct Lisp_Symbol *sym), (sym)) +INLINE Lisp_Object +(SYMBOL_VAL) (struct Lisp_Symbol *sym) +{ + return lisp_h_SYMBOL_VAL (sym); +} INLINE struct Lisp_Symbol * SYMBOL_ALIAS (struct Lisp_Symbol *sym) @@ -1734,8 +1782,11 @@ SYMBOL_FWD (struct Lisp_Symbol *sym) return sym->val.fwd; } -LISP_MACRO_DEFUN_VOID (SET_SYMBOL_VAL, - (struct Lisp_Symbol *sym, Lisp_Object v), (sym, v)) +INLINE void +(SET_SYMBOL_VAL) (struct Lisp_Symbol *sym, Lisp_Object v) +{ + lisp_h_SET_SYMBOL_VAL (sym, v); +} INLINE void SET_SYMBOL_ALIAS (struct Lisp_Symbol *sym, struct Lisp_Symbol *v) @@ -1782,7 +1833,11 @@ SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P (Lisp_Object sym) value cannot be changed (there is an exception for keyword symbols, whose value can be set to the keyword symbol itself). */ -LISP_MACRO_DEFUN (SYMBOL_CONSTANT_P, int, (Lisp_Object sym), (sym)) +INLINE int +(SYMBOL_CONSTANT_P) (Lisp_Object sym) +{ + return lisp_h_SYMBOL_CONSTANT_P (sym); +} /* Placeholder for make-docfile to process. The actual symbol definition is done by lread.c's defsym. */ @@ -2452,7 +2507,11 @@ enum char_bits /* Data type checking. */ -LISP_MACRO_DEFUN (NILP, bool, (Lisp_Object x), (x)) +INLINE bool +(NILP) (Lisp_Object x) +{ + return lisp_h_NILP (x); +} INLINE bool NUMBERP (Lisp_Object x) @@ -2476,13 +2535,41 @@ RANGED_INTEGERP (intmax_t lo, Lisp_Object x, intmax_t hi) && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \ && XINT (x) <= TYPE_MAXIMUM (type)) -LISP_MACRO_DEFUN (CONSP, bool, (Lisp_Object x), (x)) -LISP_MACRO_DEFUN (FLOATP, bool, (Lisp_Object x), (x)) -LISP_MACRO_DEFUN (MISCP, bool, (Lisp_Object x), (x)) -LISP_MACRO_DEFUN (SYMBOLP, bool, (Lisp_Object x), (x)) -LISP_MACRO_DEFUN (INTEGERP, bool, (Lisp_Object x), (x)) -LISP_MACRO_DEFUN (VECTORLIKEP, bool, (Lisp_Object x), (x)) -LISP_MACRO_DEFUN (MARKERP, bool, (Lisp_Object x), (x)) +INLINE bool +(CONSP) (Lisp_Object x) +{ + return lisp_h_CONSP (x); +} +INLINE bool +(FLOATP) (Lisp_Object x) +{ + return lisp_h_FLOATP (x); +} +INLINE bool +(MISCP) (Lisp_Object x) +{ + return lisp_h_MISCP (x); +} +INLINE bool +(SYMBOLP) (Lisp_Object x) +{ + return lisp_h_SYMBOLP (x); +} +INLINE bool +(INTEGERP) (Lisp_Object x) +{ + return lisp_h_INTEGERP (x); +} +INLINE bool +(VECTORLIKEP) (Lisp_Object x) +{ + return lisp_h_VECTORLIKEP (x); +} +INLINE bool +(MARKERP) (Lisp_Object x) +{ + return lisp_h_MARKERP (x); +} INLINE bool STRINGP (Lisp_Object x) @@ -2633,9 +2720,23 @@ CHECK_LIST (Lisp_Object x) CHECK_TYPE (CONSP (x) || NILP (x), Qlistp, x); } -LISP_MACRO_DEFUN_VOID (CHECK_LIST_CONS, (Lisp_Object x, Lisp_Object y), (x, y)) -LISP_MACRO_DEFUN_VOID (CHECK_SYMBOL, (Lisp_Object x), (x)) -LISP_MACRO_DEFUN_VOID (CHECK_NUMBER, (Lisp_Object x), (x)) +INLINE void +(CHECK_LIST_CONS) (Lisp_Object x, Lisp_Object y) +{ + lisp_h_CHECK_LIST_CONS (x, y); +} + +INLINE void +(CHECK_SYMBOL) (Lisp_Object x) +{ + lisp_h_CHECK_SYMBOL (x); +} + +INLINE void +(CHECK_NUMBER) (Lisp_Object x) +{ + lisp_h_CHECK_NUMBER (x); +} INLINE void CHECK_STRING (Lisp_Object x) @@ -2736,7 +2837,7 @@ XFLOATINT (Lisp_Object n) INLINE void CHECK_NUMBER_OR_FLOAT (Lisp_Object x) { - CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x); + CHECK_TYPE (NUMBERP (x), Qnumberp, x); } #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \ @@ -2744,7 +2845,7 @@ CHECK_NUMBER_OR_FLOAT (Lisp_Object x) if (MARKERP (x)) \ XSETFASTINT (x, marker_position (x)); \ else \ - CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x); \ + CHECK_TYPE (NUMBERP (x), Qnumber_or_marker_p, x); \ } while (false) /* Since we can't assign directly to the CAR or CDR fields of a cons @@ -3840,6 +3941,7 @@ extern void fclose_unwind (void *); extern void restore_point_unwind (Lisp_Object); extern _Noreturn void report_file_errno (const char *, Lisp_Object, int); extern _Noreturn void report_file_error (const char *, Lisp_Object); +extern _Noreturn void report_file_notify_error (const char *, Lisp_Object); extern bool internal_delete_file (Lisp_Object); extern Lisp_Object emacs_readlinkat (int, const char *); extern bool file_directory_p (const char *); @@ -4352,12 +4454,13 @@ INLINE ptrdiff_t lisp_word_count (ptrdiff_t nbytes) { if (-1 >> 1 == -1) - switch (word_size) + switch (word_size + 0) { case 2: return nbytes >> 1; case 4: return nbytes >> 2; case 8: return nbytes >> 3; case 16: return nbytes >> 4; + default: break; } return nbytes / word_size - (nbytes % word_size < 0); }