Revert "Replace XSETSYMBOL with make_lisp_symbol"

This reverts commit de6b1e1efb1a36c69e7a6e09297e1de5b1477121.

While it did simplify code, there aren't much in the way of technical
benefits the change at this time, and there were protest against the
unwarranted style change.

(cherry picked from commit 11ffb4656d768b09e1f7dfacc091d85eef4a403a)

diff --git a/src/alloc.c b/src/alloc.c
index 16257469aa6992a9749f00a7f3c62b81cfced17e..2ffd24154476b265e9eb2859c2412b20afa6233e 100644 (file)
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3960,7 +3960,7 @@ Its value is void, and its function definition and property list are nil.  */)
   if (symbol_free_list)
     {
       ASAN_UNPOISON_SYMBOL (symbol_free_list);
-      val = make_lisp_symbol (symbol_free_list);
+      XSETSYMBOL (val, symbol_free_list);
       symbol_free_list = symbol_free_list->u.s.next;
     }
   else
@@ -3976,7 +3976,7 @@ Its value is void, and its function definition and property list are nil.  */)
        }
 
       ASAN_UNPOISON_SYMBOL (&symbol_block->symbols[symbol_block_index]);
-      val = make_lisp_symbol (&symbol_block->symbols[symbol_block_index]);
+      XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index]);
       symbol_block_index++;
     }
 
@@ -7398,8 +7398,12 @@ process_mark_stack (ptrdiff_t base_sp)
                mark_stack_push_value (SYMBOL_VAL (ptr));
                break;
              case SYMBOL_VARALIAS:
-               mark_stack_push_value (make_lisp_symbol (SYMBOL_ALIAS (ptr)));
-               break;
+               {
+                 Lisp_Object tem;
+                 XSETSYMBOL (tem, SYMBOL_ALIAS (ptr));
+                 mark_stack_push_value (tem);
+                 break;
+               }
              case SYMBOL_LOCALIZED:
                {
                  struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (ptr);

diff --git a/src/buffer.c b/src/buffer.c
index 9f55a8813fac0d340ca7633ffd3c0de8564765ff..43a9249528c606453c50dc279236faf3ab98160d 100644 (file)
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1340,7 +1340,7 @@ buffer_local_value (Lisp_Object variable, Lisp_Object buffer)
     case SYMBOL_LOCALIZED:
       { /* Look in local_var_alist.  */
        struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
-       variable = make_lisp_symbol (sym); /* Update In case of aliasing.  */
+       XSETSYMBOL (variable, sym); /* Update In case of aliasing.  */
        result = assq_no_quit (variable, BVAR (buf, local_var_alist));
        if (!NILP (result))
          {
@@ -4985,7 +4985,7 @@ defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
   sym->u.s.declared_special = true;
   sym->u.s.redirect = SYMBOL_FORWARDED;
   SET_SYMBOL_FWD (sym, bo_fwd);
-  PER_BUFFER_SYMBOL (offset) = make_lisp_symbol (sym);
+  XSETSYMBOL (PER_BUFFER_SYMBOL (offset), sym);
 
   if (PER_BUFFER_IDX (offset) == 0)
     /* Did a DEFVAR_PER_BUFFER without initializing the corresponding

diff --git a/src/data.c b/src/data.c
index c87b53176182fb73a8f87c964126b4a07a330371..df08eaf810214460213a9d77870d545a79d42fbb 100644 (file)
--- a/src/data.c
+++ b/src/data.c
@@ -1256,7 +1256,7 @@ If OBJECT is not a symbol, just return it.  */)
       struct Lisp_Symbol *sym = XSYMBOL (object);
       while (sym->u.s.redirect == SYMBOL_VARALIAS)
        sym = SYMBOL_ALIAS (sym);
-      object = make_lisp_symbol (sym);
+      XSETSYMBOL (object, sym);
     }
   return object;
 }
@@ -1506,9 +1506,12 @@ swap_in_symval_forwarding (struct Lisp_Symbol *symbol, struct Lisp_Buffer_Local_
       if (blv->fwd.fwdptr)
        set_blv_value (blv, do_symval_forwarding (blv->fwd));
       /* Choose the new binding.  */
-      tem1 = assq_no_quit (make_lisp_symbol (symbol),
-                          BVAR (current_buffer, local_var_alist));
-      set_blv_where (blv, Fcurrent_buffer ());
+      {
+       Lisp_Object var;
+       XSETSYMBOL (var, symbol);
+       tem1 = assq_no_quit (var, BVAR (current_buffer, local_var_alist));
+       set_blv_where (blv, Fcurrent_buffer ());
+      }
       if (!(blv->found = !NILP (tem1)))
        tem1 = blv->defcell;
 
@@ -1652,8 +1655,7 @@ set_internal (Lisp_Object symbol, Lisp_Object newval, Lisp_Object where,
              set_blv_value (blv, do_symval_forwarding (blv->fwd));
 
            /* Find the new binding.  */
-           /* May have changed via aliasing.  */
-           symbol = make_lisp_symbol (sym);
+           XSETSYMBOL (symbol, sym); /* May have changed via aliasing.  */
            Lisp_Object tem1
              = assq_no_quit (symbol,
                              BVAR (XBUFFER (where), local_var_alist));
@@ -2057,10 +2059,13 @@ make_blv (struct Lisp_Symbol *sym, bool forwarded,
          union Lisp_Val_Fwd valcontents)
 {
   struct Lisp_Buffer_Local_Value *blv = xmalloc (sizeof *blv);
-  Lisp_Object tem = Fcons (make_lisp_symbol (sym),
-                          forwarded
-                          ? do_symval_forwarding (valcontents.fwd)
-                          : valcontents.value);
+  Lisp_Object symbol;
+  Lisp_Object tem;
+
+ XSETSYMBOL (symbol, sym);
+ tem = Fcons (symbol, (forwarded
+                       ? do_symval_forwarding (valcontents.fwd)
+                       : valcontents.value));
 
   /* Buffer_Local_Values cannot have as realval a buffer-local
      or keyboard-local forwarding.  */
@@ -2216,7 +2221,7 @@ Instead, use `add-hook' and specify t for the LOCAL argument.  */)
     }
 
   /* Make sure this buffer has its own value of symbol.  */
-  variable = make_lisp_symbol (sym);   /* Update in case of aliasing.  */
+  XSETSYMBOL (variable, sym);  /* Update in case of aliasing.  */
   tem = assq_no_quit (variable, BVAR (current_buffer, local_var_alist));
   if (NILP (tem))
     {
@@ -2296,7 +2301,7 @@ From now on the default value will apply in this buffer.  Return VARIABLE.  */)
     notify_variable_watchers (variable, Qnil, Qmakunbound, Fcurrent_buffer ());
 
   /* Get rid of this buffer's alist element, if any.  */
-  variable = make_lisp_symbol (sym);   /* Propagate variable indirection.  */
+  XSETSYMBOL (variable, sym);  /* Propagate variable indirection.  */
   tem = assq_no_quit (variable, BVAR (current_buffer, local_var_alist));
   if (!NILP (tem))
     bset_local_var_alist
@@ -2341,7 +2346,7 @@ Also see `buffer-local-boundp'.*/)
        Lisp_Object tmp;
        struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
        XSETBUFFER (tmp, buf);
-       variable = make_lisp_symbol (sym); /* Update in case of aliasing.  */
+       XSETSYMBOL (variable, sym); /* Update in case of aliasing.  */
 
        if (EQ (blv->where, tmp)) /* The binding is already loaded.  */
          return blv_found (blv) ? Qt : Qnil;
@@ -2391,7 +2396,7 @@ value in BUFFER, or if VARIABLE is automatically buffer-local (see
        struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
        if (blv->local_if_set)
          return Qt;
-       variable = make_lisp_symbol (sym); /* Update in case of aliasing.  */
+       XSETSYMBOL (variable, sym); /* Update in case of aliasing.  */
        return Flocal_variable_p (variable, buffer);
       }
     case SYMBOL_FORWARDED:

diff --git a/src/eval.c b/src/eval.c
index 9d3b98eb359eed60ada3d9588d045d939aca2ee7..95eb21909d24daee8f8821662fb359ef227af468 100644 (file)
--- a/src/eval.c
+++ b/src/eval.c
@@ -3475,7 +3475,7 @@ specbind (Lisp_Object symbol, Lisp_Object value)
   switch (sym->u.s.redirect)
     {
     case SYMBOL_VARALIAS:
-      sym = SYMBOL_ALIAS (sym); symbol = make_lisp_symbol (sym); goto start;
+      sym = SYMBOL_ALIAS (sym); XSETSYMBOL (symbol, sym); goto start;
     case SYMBOL_PLAINVAL:
       /* The most common case is that of a non-constant symbol with a
         trivial value.  Make that as fast as we can.  */

diff --git a/src/lisp.h b/src/lisp.h
index 4fc447452110e1ca6ad65e4314932c8c86d5acb5..f353e4956ebc5d6d137f98a7e1262cc1ed6dde11 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1380,6 +1380,7 @@ make_lisp_ptr (void *ptr, enum Lisp_Type type)
 #define XSETCONS(a, b) ((a) = make_lisp_ptr (b, Lisp_Cons))
 #define XSETVECTOR(a, b) ((a) = make_lisp_ptr (b, Lisp_Vectorlike))
 #define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
+#define XSETSYMBOL(a, b) ((a) = make_lisp_symbol (b))
 #define XSETFLOAT(a, b) ((a) = make_lisp_ptr (b, Lisp_Float))
 
 /* Return a Lisp_Object value that does not correspond to any object.