Replace XSETSYMBOL with make_lisp_symbol

* src/lisp.h (XSETSYMBOL): Remove.  All callers changed to use
make_lisp_symbol.

(cherry picked from commit de6b1e1efb1a36c69e7a6e09297e1de5b1477121)

diff --git a/src/alloc.c b/src/alloc.c
index 2ffd24154476b265e9eb2859c2412b20afa6233e..16257469aa6992a9749f00a7f3c62b81cfced17e 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);
-      XSETSYMBOL (val, symbol_free_list);
+      val = make_lisp_symbol (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]);
-      XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index]);
+      val = make_lisp_symbol (&symbol_block->symbols[symbol_block_index]);
       symbol_block_index++;
     }
 
@@ -7398,12 +7398,8 @@ process_mark_stack (ptrdiff_t base_sp)
                mark_stack_push_value (SYMBOL_VAL (ptr));
                break;
              case SYMBOL_VARALIAS:
-               {
-                 Lisp_Object tem;
-                 XSETSYMBOL (tem, SYMBOL_ALIAS (ptr));
-                 mark_stack_push_value (tem);
-                 break;
-               }
+               mark_stack_push_value (make_lisp_symbol (SYMBOL_ALIAS (ptr)));
+               break;
              case SYMBOL_LOCALIZED:
                {
                  struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (ptr);

diff --git a/src/buffer.c b/src/buffer.c
index d67e1d67cd6c4a7fb55699ce968883f661b0bf1a..e235ff8f9f878c1354267aba28dcaec97f71d818 100644 (file)
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1334,7 +1334,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);
-       XSETSYMBOL (variable, sym); /* Update In case of aliasing.  */
+       variable = make_lisp_symbol (sym); /* Update In case of aliasing.  */
        result = assq_no_quit (variable, BVAR (buf, local_var_alist));
        if (!NILP (result))
          {
@@ -4971,7 +4971,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);
-  XSETSYMBOL (PER_BUFFER_SYMBOL (offset), sym);
+  PER_BUFFER_SYMBOL (offset) = make_lisp_symbol (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 bb4cdd62d66fc59ac019956dbd2b83ba74480ae6..da507901b76a4d63439bc118511ed7848a3f579c 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);
-      XSETSYMBOL (object, sym);
+      object = make_lisp_symbol (sym);
     }
   return object;
 }
@@ -1506,12 +1506,9 @@ 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.  */
-      {
-       Lisp_Object var;
-       XSETSYMBOL (var, symbol);
-       tem1 = assq_no_quit (var, BVAR (current_buffer, local_var_alist));
-       set_blv_where (blv, Fcurrent_buffer ());
-      }
+      tem1 = assq_no_quit (make_lisp_symbol (symbol),
+                          BVAR (current_buffer, local_var_alist));
+      set_blv_where (blv, Fcurrent_buffer ());
       if (!(blv->found = !NILP (tem1)))
        tem1 = blv->defcell;
 
@@ -1655,7 +1652,8 @@ set_internal (Lisp_Object symbol, Lisp_Object newval, Lisp_Object where,
              set_blv_value (blv, do_symval_forwarding (blv->fwd));
 
            /* Find the new binding.  */
-           XSETSYMBOL (symbol, sym); /* May have changed via aliasing.  */
+           /* May have changed via aliasing.  */
+           symbol = make_lisp_symbol (sym);
            Lisp_Object tem1
              = assq_no_quit (symbol,
                              BVAR (XBUFFER (where), local_var_alist));
@@ -2059,13 +2057,10 @@ make_blv (struct Lisp_Symbol *sym, bool forwarded,
          union Lisp_Val_Fwd valcontents)
 {
   struct Lisp_Buffer_Local_Value *blv = xmalloc (sizeof *blv);
-  Lisp_Object symbol;
-  Lisp_Object tem;
-
- XSETSYMBOL (symbol, sym);
- tem = Fcons (symbol, (forwarded
-                       ? do_symval_forwarding (valcontents.fwd)
-                       : valcontents.value));
+  Lisp_Object tem = Fcons (make_lisp_symbol (sym),
+                          forwarded
+                          ? do_symval_forwarding (valcontents.fwd)
+                          : valcontents.value);
 
   /* Buffer_Local_Values cannot have as realval a buffer-local
      or keyboard-local forwarding.  */
@@ -2221,7 +2216,7 @@ Instead, use `add-hook' and specify t for the LOCAL argument.  */)
     }
 
   /* Make sure this buffer has its own value of symbol.  */
-  XSETSYMBOL (variable, sym);  /* Update in case of aliasing.  */
+  variable = make_lisp_symbol (sym);   /* Update in case of aliasing.  */
   tem = assq_no_quit (variable, BVAR (current_buffer, local_var_alist));
   if (NILP (tem))
     {
@@ -2301,7 +2296,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.  */
-  XSETSYMBOL (variable, sym);  /* Propagate variable indirection.  */
+  variable = make_lisp_symbol (sym);   /* Propagate variable indirection.  */
   tem = assq_no_quit (variable, BVAR (current_buffer, local_var_alist));
   if (!NILP (tem))
     bset_local_var_alist
@@ -2346,7 +2341,7 @@ Also see `buffer-local-boundp'.*/)
        Lisp_Object tmp;
        struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
        XSETBUFFER (tmp, buf);
-       XSETSYMBOL (variable, sym); /* Update in case of aliasing.  */
+       variable = make_lisp_symbol (sym); /* Update in case of aliasing.  */
 
        if (EQ (blv->where, tmp)) /* The binding is already loaded.  */
          return blv_found (blv) ? Qt : Qnil;
@@ -2396,7 +2391,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;
-       XSETSYMBOL (variable, sym); /* Update in case of aliasing.  */
+       variable = make_lisp_symbol (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 95eb21909d24daee8f8821662fb359ef227af468..9d3b98eb359eed60ada3d9588d045d939aca2ee7 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); XSETSYMBOL (symbol, sym); goto start;
+      sym = SYMBOL_ALIAS (sym); symbol = make_lisp_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 f353e4956ebc5d6d137f98a7e1262cc1ed6dde11..4fc447452110e1ca6ad65e4314932c8c86d5acb5 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1380,7 +1380,6 @@ 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.