From 8271d59040b3d83fb3fc8cb23723538183b12ad4 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Wed, 1 Aug 2012 11:57:09 +0400 Subject: [PATCH] Use INTERNAL_FIELD for symbols. * src/lisp.h (SVAR): New macro. Adjust users. * src/alloc.c, src/bytecode.c, src/cmds.c, src/data.c, src/doc.c, src/eval.c: * src/fns.c, src/keyboard.c, src/lread.c, src/xterm.c: Users changed. * admin/coccinelle/symbol.cocci: Semantic patch to replace direct access to Lisp_Object members of struct Lisp_Symbol to SVAR. --- admin/ChangeLog | 5 +++++ src/ChangeLog | 7 +++++++ src/alloc.c | 32 ++++++++++++++++---------------- src/bytecode.c | 2 +- src/cmds.c | 8 +++++--- src/data.c | 34 +++++++++++++++++----------------- src/doc.c | 2 +- src/eval.c | 14 +++++++------- src/fns.c | 6 +++--- src/keyboard.c | 9 +++++---- src/lisp.h | 19 ++++++++++++------- src/lread.c | 8 ++++---- src/xterm.c | 2 +- 13 files changed, 84 insertions(+), 64 deletions(-) diff --git a/admin/ChangeLog b/admin/ChangeLog index 656c1a0faf..8ca17e58b3 100644 --- a/admin/ChangeLog +++ b/admin/ChangeLog @@ -1,3 +1,8 @@ +2012-08-01 Dmitry Antipov + + * coccinelle/symbol.cocci: Semantic patch to replace direct + access to Lisp_Object members of struct Lisp_Symbol to SVAR. + 2012-08-01 Dmitry Antipov * coccinelle/process.cocci: Semantic patch to replace direct diff --git a/src/ChangeLog b/src/ChangeLog index e6b8051458..3bb9c2b4ee 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,10 @@ +2012-08-01 Dmitry Antipov + + Use INTERNAL_FIELD for symbols. + * lisp.h (SVAR): New macro. Adjust users. + * alloc.c, bytecode.c, cmds.c, data.c, doc.c, eval.c: + * fns.c, keyboard.c, lread.c, xterm.c: Users changed. + 2012-08-01 Dmitry Antipov Use INTERNAL_FIELD for processes. diff --git a/src/alloc.c b/src/alloc.c index d824a6a491..8207f022a1 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -3518,11 +3518,11 @@ Its value and function definition are void, and its property list is nil. */) MALLOC_UNBLOCK_INPUT; p = XSYMBOL (val); - p->xname = name; - p->plist = Qnil; + SVAR (p, xname) = name; + SVAR (p, plist) = Qnil; p->redirect = SYMBOL_PLAINVAL; SET_SYMBOL_VAL (p, Qunbound); - p->function = Qunbound; + SVAR (p, function) = Qunbound; p->next = NULL; p->gcmarkbit = 0; p->interned = SYMBOL_UNINTERNED; @@ -4321,7 +4321,7 @@ live_symbol_p (struct mem_node *m, void *p) && offset < (SYMBOL_BLOCK_SIZE * sizeof b->symbols[0]) && (b != symbol_block || offset / sizeof b->symbols[0] < symbol_block_index) - && !EQ (((struct Lisp_Symbol *) p)->function, Vdead)); + && !EQ (SVAR (((struct Lisp_Symbol *)p), function), Vdead)); } else return 0; @@ -6073,8 +6073,8 @@ mark_object (Lisp_Object arg) break; CHECK_ALLOCATED_AND_LIVE (live_symbol_p); ptr->gcmarkbit = 1; - mark_object (ptr->function); - mark_object (ptr->plist); + mark_object (SVAR (ptr, function)); + mark_object (SVAR (ptr, plist)); switch (ptr->redirect) { case SYMBOL_PLAINVAL: mark_object (SYMBOL_VAL (ptr)); break; @@ -6105,9 +6105,9 @@ mark_object (Lisp_Object arg) break; default: abort (); } - if (!PURE_POINTER_P (XSTRING (ptr->xname))) - MARK_STRING (XSTRING (ptr->xname)); - MARK_INTERVAL_TREE (STRING_INTERVALS (ptr->xname)); + if (!PURE_POINTER_P (XSTRING (SVAR (ptr, xname)))) + MARK_STRING (XSTRING (SVAR (ptr, xname))); + MARK_INTERVAL_TREE (STRING_INTERVALS (SVAR (ptr, xname))); ptr = ptr->next; if (ptr) @@ -6473,7 +6473,7 @@ gc_sweep (void) /* Check if the symbol was created during loadup. In such a case it might be pointed to by pure bytecode which we don't trace, so we conservatively assume that it is live. */ - int pure_p = PURE_POINTER_P (XSTRING (sym->s.xname)); + int pure_p = PURE_POINTER_P (XSTRING (sym->s.INTERNAL_FIELD (xname))); if (!sym->s.gcmarkbit && !pure_p) { @@ -6482,7 +6482,7 @@ gc_sweep (void) sym->s.next = symbol_free_list; symbol_free_list = &sym->s; #if GC_MARK_STACK - symbol_free_list->function = Vdead; + SVAR (symbol_free_list, function) = Vdead; #endif ++this_free; } @@ -6490,7 +6490,7 @@ gc_sweep (void) { ++num_used; if (!pure_p) - UNMARK_STRING (XSTRING (sym->s.xname)); + UNMARK_STRING (XSTRING (sym->s.INTERNAL_FIELD (xname))); sym->s.gcmarkbit = 0; } } @@ -6675,10 +6675,10 @@ which_symbols (Lisp_Object obj, EMACS_INT find_max) XSETSYMBOL (tem, sym); val = find_symbol_value (tem); if (EQ (val, obj) - || EQ (sym->function, obj) - || (!NILP (sym->function) - && COMPILEDP (sym->function) - && EQ (AREF (sym->function, COMPILED_BYTECODE), obj)) + || EQ (SVAR (sym, function), obj) + || (!NILP (SVAR (sym, function)) + && COMPILEDP (SVAR (sym, function)) + && EQ (AREF (SVAR (sym, function), COMPILED_BYTECODE), obj)) || (!NILP (val) && COMPILEDP (val) && EQ (AREF (val, COMPILED_BYTECODE), obj))) diff --git a/src/bytecode.c b/src/bytecode.c index dca1e552dd..523d56bc97 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -818,7 +818,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, && !EQ (val, Qunbound) && !XSYMBOL (sym)->redirect && !SYMBOL_CONSTANT_P (sym)) - XSYMBOL (sym)->val.value = val; + SVAR (XSYMBOL (sym), val.value) = val; else { BEFORE_POTENTIAL_GC (); diff --git a/src/cmds.c b/src/cmds.c index a7a2eb6f52..4512f56206 100644 --- a/src/cmds.c +++ b/src/cmds.c @@ -446,11 +446,13 @@ internal_self_insert (int c, EMACS_INT n) /* If we expanded an abbrev which has a hook, and the hook has a non-nil `no-self-insert' property, return right away--don't really self-insert. */ - if (SYMBOLP (sym) && ! NILP (sym) && ! NILP (XSYMBOL (sym)->function) - && SYMBOLP (XSYMBOL (sym)->function)) + if (SYMBOLP (sym) && ! NILP (sym) + && ! NILP (SVAR (XSYMBOL (sym), function)) + && SYMBOLP (SVAR (XSYMBOL (sym), function))) { Lisp_Object prop; - prop = Fget (XSYMBOL (sym)->function, intern ("no-self-insert")); + prop = Fget (SVAR (XSYMBOL (sym), function), + intern ("no-self-insert")); if (! NILP (prop)) return 1; } diff --git a/src/data.c b/src/data.c index 59228adb28..4c6f7fe3ea 100644 --- a/src/data.c +++ b/src/data.c @@ -562,7 +562,7 @@ DEFUN ("fboundp", Ffboundp, Sfboundp, 1, 1, 0, (register Lisp_Object symbol) { CHECK_SYMBOL (symbol); - return (EQ (XSYMBOL (symbol)->function, Qunbound) ? Qnil : Qt); + return (EQ (SVAR (XSYMBOL (symbol), function), Qunbound) ? Qnil : Qt); } DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0, @@ -585,7 +585,7 @@ Return SYMBOL. */) CHECK_SYMBOL (symbol); if (NILP (symbol) || EQ (symbol, Qt)) xsignal1 (Qsetting_constant, symbol); - XSYMBOL (symbol)->function = Qunbound; + SVAR (XSYMBOL (symbol), function) = Qunbound; return symbol; } @@ -594,8 +594,8 @@ DEFUN ("symbol-function", Fsymbol_function, Ssymbol_function, 1, 1, 0, (register Lisp_Object symbol) { CHECK_SYMBOL (symbol); - if (!EQ (XSYMBOL (symbol)->function, Qunbound)) - return XSYMBOL (symbol)->function; + if (!EQ (SVAR (XSYMBOL (symbol), function), Qunbound)) + return SVAR (XSYMBOL (symbol), function); xsignal1 (Qvoid_function, symbol); } @@ -604,7 +604,7 @@ DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0, (register Lisp_Object symbol) { CHECK_SYMBOL (symbol); - return XSYMBOL (symbol)->plist; + return SVAR (XSYMBOL (symbol), plist); } DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0, @@ -628,7 +628,7 @@ DEFUN ("fset", Ffset, Sfset, 2, 2, 0, if (NILP (symbol) || EQ (symbol, Qt)) xsignal1 (Qsetting_constant, symbol); - function = XSYMBOL (symbol)->function; + function = SVAR (XSYMBOL (symbol), function); if (!NILP (Vautoload_queue) && !EQ (function, Qunbound)) Vautoload_queue = Fcons (Fcons (symbol, function), Vautoload_queue); @@ -636,13 +636,13 @@ DEFUN ("fset", Ffset, Sfset, 2, 2, 0, if (CONSP (function) && EQ (XCAR (function), Qautoload)) Fput (symbol, Qautoload, XCDR (function)); - XSYMBOL (symbol)->function = definition; + SVAR (XSYMBOL (symbol), function) = definition; /* Handle automatic advice activation. */ - if (CONSP (XSYMBOL (symbol)->plist) + if (CONSP (SVAR (XSYMBOL (symbol), plist)) && !NILP (Fget (symbol, Qad_advice_info))) { call2 (Qad_activate_internal, symbol, Qnil); - definition = XSYMBOL (symbol)->function; + definition = SVAR (XSYMBOL (symbol), function); } return definition; } @@ -657,8 +657,8 @@ The return value is undefined. */) (register Lisp_Object symbol, Lisp_Object definition, Lisp_Object docstring) { CHECK_SYMBOL (symbol); - if (CONSP (XSYMBOL (symbol)->function) - && EQ (XCAR (XSYMBOL (symbol)->function), Qautoload)) + if (CONSP (SVAR (XSYMBOL (symbol), function)) + && EQ (XCAR (SVAR (XSYMBOL (symbol), function)), Qautoload)) LOADHIST_ATTACH (Fcons (Qt, symbol)); if (!NILP (Vpurify_flag) /* If `definition' is a keymap, immutable (and copying) is wrong. */ @@ -679,7 +679,7 @@ DEFUN ("setplist", Fsetplist, Ssetplist, 2, 2, 0, (register Lisp_Object symbol, Lisp_Object newplist) { CHECK_SYMBOL (symbol); - XSYMBOL (symbol)->plist = newplist; + SVAR (XSYMBOL (symbol), plist) = newplist; return newplist; } @@ -2019,12 +2019,12 @@ indirect_function (register Lisp_Object object) { if (!SYMBOLP (hare) || EQ (hare, Qunbound)) break; - hare = XSYMBOL (hare)->function; + hare = SVAR (XSYMBOL (hare), function); if (!SYMBOLP (hare) || EQ (hare, Qunbound)) break; - hare = XSYMBOL (hare)->function; + hare = SVAR (XSYMBOL (hare), function); - tortoise = XSYMBOL (tortoise)->function; + tortoise = SVAR (XSYMBOL (tortoise), function); if (EQ (hare, tortoise)) xsignal1 (Qcyclic_function_indirection, object); @@ -2048,7 +2048,7 @@ function chain of symbols. */) /* Optimize for no indirection. */ result = object; if (SYMBOLP (result) && !EQ (result, Qunbound) - && (result = XSYMBOL (result)->function, SYMBOLP (result))) + && (result = SVAR (XSYMBOL (result), function), SYMBOLP (result))) result = indirect_function (result); if (!EQ (result, Qunbound)) return result; @@ -3197,7 +3197,7 @@ syms_of_data (void) defsubr (&Ssubr_arity); defsubr (&Ssubr_name); - XSYMBOL (Qwholenump)->function = XSYMBOL (Qnatnump)->function; + SVAR (XSYMBOL (Qwholenump), function) = SVAR (XSYMBOL (Qnatnump), function); DEFVAR_LISP ("most-positive-fixnum", Vmost_positive_fixnum, doc: /* The largest value that is representable in a Lisp integer. */); diff --git a/src/doc.c b/src/doc.c index 44363e30e8..e57b26525e 100644 --- a/src/doc.c +++ b/src/doc.c @@ -508,7 +508,7 @@ store_function_docstring (Lisp_Object obj, ptrdiff_t offset) { /* Don't use indirect_function here, or defaliases will apply their docstrings to the base functions (Bug#2603). */ - Lisp_Object fun = SYMBOLP (obj) ? XSYMBOL (obj)->function : obj; + Lisp_Object fun = SYMBOLP (obj) ? SVAR (XSYMBOL (obj), function) : obj; /* The type determines where the docstring is stored. */ diff --git a/src/eval.c b/src/eval.c index 391058d12c..64f384f2ca 100644 --- a/src/eval.c +++ b/src/eval.c @@ -976,7 +976,7 @@ definitions to shadow the loaded ones for use in file byte-compilation. */) tem = Fassq (sym, environment); if (NILP (tem)) { - def = XSYMBOL (sym)->function; + def = SVAR (XSYMBOL (sym), function); if (!EQ (def, Qunbound)) continue; } @@ -1893,9 +1893,9 @@ this does nothing and returns nil. */) CHECK_STRING (file); /* If function is defined and not as an autoload, don't override. */ - if (!EQ (XSYMBOL (function)->function, Qunbound) - && !(CONSP (XSYMBOL (function)->function) - && EQ (XCAR (XSYMBOL (function)->function), Qautoload))) + if (!EQ (SVAR (XSYMBOL (function), function), Qunbound) + && !(CONSP (SVAR (XSYMBOL (function), function)) + && EQ (XCAR (SVAR (XSYMBOL (function), function)), Qautoload))) return Qnil; if (NILP (Vpurify_flag)) @@ -2081,7 +2081,7 @@ eval_sub (Lisp_Object form) /* Optimize for no indirection. */ fun = original_fun; if (SYMBOLP (fun) && !EQ (fun, Qunbound) - && (fun = XSYMBOL (fun)->function, SYMBOLP (fun))) + && (fun = SVAR (XSYMBOL (fun), function), SYMBOLP (fun))) fun = indirect_function (fun); if (SUBRP (fun)) @@ -2266,7 +2266,7 @@ usage: (apply FUNCTION &rest ARGUMENTS) */) /* Optimize for no indirection. */ if (SYMBOLP (fun) && !EQ (fun, Qunbound) - && (fun = XSYMBOL (fun)->function, SYMBOLP (fun))) + && (fun = SVAR (XSYMBOL (fun), function), SYMBOLP (fun))) fun = indirect_function (fun); if (EQ (fun, Qunbound)) { @@ -2771,7 +2771,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS) */) /* Optimize for no indirection. */ fun = original_fun; if (SYMBOLP (fun) && !EQ (fun, Qunbound) - && (fun = XSYMBOL (fun)->function, SYMBOLP (fun))) + && (fun = SVAR (XSYMBOL (fun), function), SYMBOLP (fun))) fun = indirect_function (fun); if (SUBRP (fun)) diff --git a/src/fns.c b/src/fns.c index 6e6b933294..0ff2877ea5 100644 --- a/src/fns.c +++ b/src/fns.c @@ -1868,7 +1868,7 @@ This is the last value stored with `(put SYMBOL PROPNAME VALUE)'. */) (Lisp_Object symbol, Lisp_Object propname) { CHECK_SYMBOL (symbol); - return Fplist_get (XSYMBOL (symbol)->plist, propname); + return Fplist_get (SVAR (XSYMBOL (symbol), plist), propname); } DEFUN ("plist-put", Fplist_put, Splist_put, 3, 3, 0, @@ -1910,8 +1910,8 @@ It can be retrieved with `(get SYMBOL PROPNAME)'. */) (Lisp_Object symbol, Lisp_Object propname, Lisp_Object value) { CHECK_SYMBOL (symbol); - XSYMBOL (symbol)->plist - = Fplist_put (XSYMBOL (symbol)->plist, propname, value); + SVAR (XSYMBOL (symbol), plist) + = Fplist_put (SVAR (XSYMBOL (symbol), plist), propname, value); return value; } diff --git a/src/keyboard.c b/src/keyboard.c index a8e7beddbc..d14d510630 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -7894,7 +7894,8 @@ parse_menu_item (Lisp_Object item, int inmenubar) /* If the command is an alias for another (such as lmenu.el set it up), check if the original command matches the cached command. */ - && !(SYMBOLP (def) && EQ (tem, XSYMBOL (def)->function)))) + && !(SYMBOLP (def) + && EQ (tem, SVAR (XSYMBOL (def), function))))) keys = Qnil; } @@ -8823,9 +8824,9 @@ access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt, /* Handle a symbol whose function definition is a keymap or an array. */ if (SYMBOLP (next) && !NILP (Ffboundp (next)) - && (ARRAYP (XSYMBOL (next)->function) - || KEYMAPP (XSYMBOL (next)->function))) - next = Fautoload_do_load (XSYMBOL (next)->function, next, Qnil); + && (ARRAYP (SVAR (XSYMBOL (next), function)) + || KEYMAPP (SVAR (XSYMBOL (next), function)))) + next = Fautoload_do_load (SVAR (XSYMBOL (next), function), next, Qnil); /* If the keymap gives a function, not an array, then call the function with one arg and use diff --git a/src/lisp.h b/src/lisp.h index e1c0cc18d6..5e2195ce01 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -1039,6 +1039,11 @@ enum symbol_redirect SYMBOL_FORWARDED = 3 }; +/* Most code should use this macro to access + Lisp fields in struct Lisp_Symbol. */ + +#define SVAR(sym, field) ((sym)->INTERNAL_FIELD (field)) + struct Lisp_Symbol { unsigned gcmarkbit : 1; @@ -1066,22 +1071,22 @@ struct Lisp_Symbol /* The symbol's name, as a Lisp string. The name "xname" is used to intentionally break code referring to the old field "name" of type pointer to struct Lisp_String. */ - Lisp_Object xname; + Lisp_Object INTERNAL_FIELD (xname); /* Value of the symbol or Qunbound if unbound. Which alternative of the union is used depends on the `redirect' field above. */ union { - Lisp_Object value; + Lisp_Object INTERNAL_FIELD (value); struct Lisp_Symbol *alias; struct Lisp_Buffer_Local_Value *blv; union Lisp_Fwd *fwd; } val; /* Function value of the symbol or Qunbound if not fboundp. */ - Lisp_Object function; + Lisp_Object INTERNAL_FIELD (function); /* The symbol's property list. */ - Lisp_Object plist; + Lisp_Object INTERNAL_FIELD (plist); /* Next symbol in obarray bucket, if the symbol is interned. */ struct Lisp_Symbol *next; @@ -1090,7 +1095,7 @@ struct Lisp_Symbol /* Value is name of symbol. */ #define SYMBOL_VAL(sym) \ - (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value) + (eassert ((sym)->redirect == SYMBOL_PLAINVAL), SVAR (sym, val.value)) #define SYMBOL_ALIAS(sym) \ (eassert ((sym)->redirect == SYMBOL_VARALIAS), (sym)->val.alias) #define SYMBOL_BLV(sym) \ @@ -1098,7 +1103,7 @@ struct Lisp_Symbol #define SYMBOL_FWD(sym) \ (eassert ((sym)->redirect == SYMBOL_FORWARDED), (sym)->val.fwd) #define SET_SYMBOL_VAL(sym, v) \ - (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v)) + (eassert ((sym)->redirect == SYMBOL_PLAINVAL), SVAR (sym, val.value) = (v)) #define SET_SYMBOL_ALIAS(sym, v) \ (eassert ((sym)->redirect == SYMBOL_VARALIAS), (sym)->val.alias = (v)) #define SET_SYMBOL_BLV(sym, v) \ @@ -1107,7 +1112,7 @@ struct Lisp_Symbol (eassert ((sym)->redirect == SYMBOL_FORWARDED), (sym)->val.fwd = (v)) #define SYMBOL_NAME(sym) \ - LISP_MAKE_RVALUE (XSYMBOL (sym)->xname) + LISP_MAKE_RVALUE (SVAR (XSYMBOL (sym), xname)) /* Value is non-zero if SYM is an interned symbol. */ diff --git a/src/lread.c b/src/lread.c index 0db37d7492..8a9547ee57 100644 --- a/src/lread.c +++ b/src/lread.c @@ -3922,13 +3922,13 @@ init_obarray (void) /* Fmake_symbol inits fields of new symbols with Qunbound and Qnil, so those two need to be fixed manually. */ SET_SYMBOL_VAL (XSYMBOL (Qunbound), Qunbound); - XSYMBOL (Qunbound)->function = Qunbound; - XSYMBOL (Qunbound)->plist = Qnil; + SVAR (XSYMBOL (Qunbound), function) = Qunbound; + SVAR (XSYMBOL (Qunbound), plist) = Qnil; /* XSYMBOL (Qnil)->function = Qunbound; */ SET_SYMBOL_VAL (XSYMBOL (Qnil), Qnil); XSYMBOL (Qnil)->constant = 1; XSYMBOL (Qnil)->declared_special = 1; - XSYMBOL (Qnil)->plist = Qnil; + SVAR (XSYMBOL (Qnil), plist) = Qnil; Qt = intern_c_string ("t"); SET_SYMBOL_VAL (XSYMBOL (Qt), Qt); @@ -3950,7 +3950,7 @@ defsubr (struct Lisp_Subr *sname) Lisp_Object sym; sym = intern_c_string (sname->symbol_name); XSETTYPED_PVECTYPE (sname, size, PVEC_SUBR); - XSETSUBR (XSYMBOL (sym)->function, sname); + XSETSUBR (SVAR (XSYMBOL (sym), function), sname); } #ifdef NOTDEF /* Use fset in subr.el now! */ diff --git a/src/xterm.c b/src/xterm.c index e4023f9de7..6831ef6971 100644 --- a/src/xterm.c +++ b/src/xterm.c @@ -10117,7 +10117,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name) terminal->kboard->next_kboard = all_kboards; all_kboards = terminal->kboard; - if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound)) + if (!EQ (SVAR (XSYMBOL (Qvendor_specific_keysyms), function), Qunbound)) { char *vendor = ServerVendor (dpy); -- 2.20.1