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.

diff --git a/admin/ChangeLog b/admin/ChangeLog
index 656c1a0fafaaae80be046b43a0faed7d83f5921d..8ca17e58b30f9917808bde2a3de56aad68a6acc4 100644 (file)
--- a/admin/ChangeLog
+++ b/admin/ChangeLog
@@ -1,3 +1,8 @@
+2012-08-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+       * coccinelle/symbol.cocci: Semantic patch to replace direct
+       access to Lisp_Object members of struct Lisp_Symbol to SVAR.
+
 2012-08-01  Dmitry Antipov  <dmantipov@yandex.ru>
 
        * coccinelle/process.cocci: Semantic patch to replace direct

diff --git a/src/ChangeLog b/src/ChangeLog
index e6b8051458f66ddda00be18de8d152c8adff06fe..3bb9c2b4eefb36704606e46eb748d56d4935dbf6 100644 (file)
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,10 @@
+2012-08-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+       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  <dmantipov@yandex.ru>
 
        Use INTERNAL_FIELD for processes.

diff --git a/src/alloc.c b/src/alloc.c
index d824a6a491e80b63e61df87b6a573be0f08410c9..8207f022a1290028bbdbd181cd7bb155e2dedc38 100644 (file)
--- 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 dca1e552dd00d763cefb5e0f630a37e73c4bfbf7..523d56bc97b19fd7e6d2c2a3ce2b2f92b90fbee2 100644 (file)
--- 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 a7a2eb6f52879dcccc726ec6f8a71ad11c519894..4512f562064df2a1d3f3d1c75909bc7006c8276d 100644 (file)
--- 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 59228adb28f74b17012444010c46505cb1912bcb..4c6f7fe3eae7fa311057774e2ee6c4c28035888b 100644 (file)
--- 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 44363e30e820a0b8485448352da764b5bccf59a3..e57b26525e1290e6b2fe90f8440d1eeaa52b29b8 100644 (file)
--- 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 391058d12c6db39896e4dfe178419163bc3979b4..64f384f2ca9bb4b11045fb6efcb7e1b92a06db5a 100644 (file)
--- 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 6e6b9332942fe004ddfd10a673b5564b5a63d2c1..0ff2877ea5edda6323abe3ba80bb789715fc42f3 100644 (file)
--- 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;
 }
 \f

diff --git a/src/keyboard.c b/src/keyboard.c
index a8e7beddbc11cf32b99a71fdc95cf134f4b1c080..d14d510630687adb6ea04455e58d932a77d3ab2d 100644 (file)
--- 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 e1c0cc18d6dcd238bf587c9b3ce4dca9f940b900..5e2195ce01d20f67aab2c8d4fc3af27485de1124 100644 (file)
--- 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 0db37d7492f6827bc0d1edad183383b6cd0ab6d1..8a9547ee579455c3cfc9c3ced8d34fed219311ac 100644 (file)
--- 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 e4023f9de767f904d297e4f7bd7cbafb1f32ab43..6831ef6971e28b72f252dce459ba6623914d4ddc 100644 (file)
--- 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);