Revert "Symbol-name, intern* with additional arg"

This reverts commit e66106378d954902ab34d190b5c7e6f49323a3c1.

diff --git a/.gitignore b/.gitignore
index b09a0c030b3486a29c5c95a886900147f8d228ee..e3a628eecb8534f788936528a54576cf5b28d02f 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -338,3 +338,4 @@ lib-src/seccomp-filter-exec.pfc
 # GDB history
 .gdb_history
 _gdb_history
+*.desktop

diff --git a/src/callint.c b/src/callint.c
index d6c5c55dbb9dd0dd0038ba59b5161ef32f60bd22..d8d2b27845815bd36ef76db1e33f710dd84f4dbe 100644 (file)
--- a/src/callint.c
+++ b/src/callint.c
@@ -462,7 +462,7 @@ invoke it (via an `interactive' spec that contains, for instance, an
          visargs[i] = Fcompleting_read (callint_message,
                                         Vobarray, Qfboundp, Qt,
                                         Qnil, Qnil, Qnil, Qnil);
-         args[i] = Fintern (visargs[i], Qnil, Qnil);
+         args[i] = Fintern (visargs[i], Qnil);
          break;
 
        case 'b':               /* Name of existing buffer.  */
@@ -496,7 +496,7 @@ invoke it (via an `interactive' spec that contains, for instance, an
          visargs[i] = Fcompleting_read (callint_message,
                                         Vobarray, Qcommandp,
                                         Qt, Qnil, Qnil, Qnil, Qnil);
-         args[i] = Fintern (visargs[i], Qnil, Qnil);
+         args[i] = Fintern (visargs[i], Qnil);
          break;
 
        case 'd':               /* Value of point.  Does not do I/O.  */
@@ -675,7 +675,7 @@ invoke it (via an `interactive' spec that contains, for instance, an
        case 'S':               /* Any symbol.  */
          visargs[i] = Fread_string (callint_message,
                                     Qnil, Qnil, Qnil, Qnil);
-         args[i] = Fintern (visargs[i], Qnil, Qnil);
+         args[i] = Fintern (visargs[i], Qnil);
          break;
 
        case 'v':               /* Variable name: symbol that is

diff --git a/src/coding.c b/src/coding.c
index 6a1c047fd37ce96dbb979440a653d39fec4cc607..899f8fc7b4d5601cf0f476d7f00999b0cb6e1d19 100644 (file)
--- a/src/coding.c
+++ b/src/coding.c
@@ -8567,7 +8567,7 @@ DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system,
                              Qt, Qnil, Qcoding_system_history, Qnil, Qnil);
     }
   while (SCHARS (val) == 0);
-  return Fintern (val, Qnil, Qnil);
+  return (Fintern (val, Qnil));
 }
 
 DEFUN ("read-coding-system", Fread_coding_system, Sread_coding_system, 1, 2, 0,
@@ -8587,7 +8587,7 @@ are lower-case).  */)
                          Qt, Qnil, Qcoding_system_history,
                          default_coding_system, Qnil);
   val = unbind_to (count, val);
-  return (SCHARS (val) == 0 ? Qnil : Fintern (val, Qnil, Qnil));
+  return (SCHARS (val) == 0 ? Qnil : Fintern (val, Qnil));
 }
 
 DEFUN ("check-coding-system", Fcheck_coding_system, Scheck_coding_system,
@@ -11417,10 +11417,10 @@ usage: (define-coding-system-internal ...)  */)
          ASET (this_spec, 2, this_eol_type);
          Fputhash (this_name, this_spec, Vcoding_system_hash_table);
          Vcoding_system_list = Fcons (this_name, Vcoding_system_list);
-         val = Fassoc (Fsymbol_name (this_name, Qnil), Vcoding_system_alist, Qnil);
+         val = Fassoc (Fsymbol_name (this_name), Vcoding_system_alist, Qnil);
          if (NILP (val))
            Vcoding_system_alist
-             = Fcons (Fcons (Fsymbol_name (this_name, Qnil), Qnil),
+             = Fcons (Fcons (Fsymbol_name (this_name), Qnil),
                       Vcoding_system_alist);
        }
     }
@@ -11432,9 +11432,9 @@ usage: (define-coding-system-internal ...)  */)
 
   Fputhash (name, spec_vec, Vcoding_system_hash_table);
   Vcoding_system_list = Fcons (name, Vcoding_system_list);
-  val = Fassoc (Fsymbol_name (name, Qnil), Vcoding_system_alist, Qnil);
+  val = Fassoc (Fsymbol_name (name), Vcoding_system_alist, Qnil);
   if (NILP (val))
-    Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (name, Qnil), Qnil),
+    Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (name), Qnil),
                                  Vcoding_system_alist);
 
   int id = coding_categories[category].id;
@@ -11551,9 +11551,9 @@ DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias,
 
   Fputhash (alias, spec, Vcoding_system_hash_table);
   Vcoding_system_list = Fcons (alias, Vcoding_system_list);
-  val = Fassoc (Fsymbol_name (alias, Qnil), Vcoding_system_alist, Qnil);
+  val = Fassoc (Fsymbol_name (alias), Vcoding_system_alist, Qnil);
   if (NILP (val))
-    Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (alias, Qnil), Qnil),
+    Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (alias), Qnil),
                                  Vcoding_system_alist);
 
   return Qnil;

diff --git a/src/data.c b/src/data.c
index 45be2aa3e2d47671943cb157a0974a832bd40c4f..72f570417d60da68ec8ff9f7ceb2731e922473ea 100644 (file)
--- a/src/data.c
+++ b/src/data.c
@@ -770,12 +770,12 @@ DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0,
   return XSYMBOL (symbol)->u.s.plist;
 }
 
-DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 2, 0,
+DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0,
        doc: /* Return SYMBOL's name, a string.  */)
-  (const Lisp_Object symbol, const Lisp_Object cl)
+  (register Lisp_Object symbol)
 {
   CHECK_SYMBOL (symbol);
-  if (SYMBOL_KEYWORD_P (symbol) && NILP (cl))
+  if (SYMBOL_KEYWORD_P (symbol))
     return concat2 (build_string (":"), SYMBOL_NAME (symbol));
   return SYMBOL_NAME (symbol);
 }

diff --git a/src/eval.c b/src/eval.c
index 443b71e90741f9ddafd536d63d2779e177bc249a..9e54d489a3b151e3ffe35e1471c8c9298f13d22c 100644 (file)
--- a/src/eval.c
+++ b/src/eval.c
@@ -546,7 +546,7 @@ usage: (function ARG)  */)
          if (SYMBOLP (docstring) && !NILP (docstring))
            /* Hack for OClosures: Allow the docstring to be a symbol
              * (the OClosure's type).  */
-           docstring = Fsymbol_name (docstring, Qnil);
+           docstring = Fsymbol_name (docstring);
          CHECK_STRING (docstring);
          cdr = Fcons (XCAR (cdr), Fcons (docstring, XCDR (XCDR (cdr))));
        }

diff --git a/src/fns.c b/src/fns.c
index c022867b25999033bb228f497e2a7448efecc834..25f16b58eeb6e9c67c7ea3fd89dcf8df6c7e1e67 100644 (file)
--- a/src/fns.c
+++ b/src/fns.c
@@ -3448,7 +3448,7 @@ FILENAME are suppressed.  */)
 
       /* Load the file.  */
       tem = load_with_autoload_queue
-       (NILP (filename) ? Fsymbol_name (feature, Qnil) : filename,
+       (NILP (filename) ? Fsymbol_name (feature) : filename,
         noerror, Qt, Qnil, (NILP (filename) ? Qt : Qnil));
 
       /* If load failed entirely, return nil.  */
@@ -5855,7 +5855,7 @@ secure_hash (Lisp_Object algorithm, Lisp_Object object, Lisp_Object start,
       hash_func          = sha512_buffer;
     }
   else
-    error ("Invalid algorithm arg: %s", SDATA (Fsymbol_name (algorithm, Qnil)));
+    error ("Invalid algorithm arg: %s", SDATA (Fsymbol_name (algorithm)));
 
   /* allocate 2 x digest_size so that it can be re-used to hold the
      hexified value */

diff --git a/src/font.c b/src/font.c
index cc465765745f3450dfb2943ebad27c5ee8bb79b2..832fc7358e23288cdd5756a13b04d583881dc071 100644 (file)
--- a/src/font.c
+++ b/src/font.c
@@ -532,11 +532,11 @@ static Lisp_Object
 font_prop_validate_symbol (Lisp_Object prop, Lisp_Object val)
 {
   if (STRINGP (val))
-    val = Fintern (val, Qnil, Qnil);
+    val = Fintern (val, Qnil);
   if (! SYMBOLP (val))
     val = Qerror;
   else if (EQ (prop, QCregistry))
-    val = Fintern (Fdowncase (SYMBOL_NAME (val)), Qnil, Qnil);
+    val = Fintern (Fdowncase (SYMBOL_NAME (val)), Qnil);
   return val;
 }
 
@@ -1009,7 +1009,7 @@ font_expand_wildcards (Lisp_Object *field, int n)
   memclear (field + j, (XLFD_LAST_INDEX - j) * word_size);
   if (FIXNUMP (field[XLFD_ENCODING_INDEX]))
     field[XLFD_ENCODING_INDEX]
-      = Fintern (Fnumber_to_string (field[XLFD_ENCODING_INDEX]), Qnil, Qnil);
+      = Fintern (Fnumber_to_string (field[XLFD_ENCODING_INDEX]), Qnil);
   return 0;
 }
 
@@ -1197,7 +1197,7 @@ font_parse_xlfd_1 (char *name, ptrdiff_t len, Lisp_Object font, int segments)
                         SYMBOL_NAME (prop[XLFD_ENCODING_INDEX]));
        }
       if (! NILP (val))
-       ASET (font, FONT_REGISTRY_INDEX, Fintern (val, Qnil, Qnil));
+       ASET (font, FONT_REGISTRY_INDEX, Fintern (val, Qnil));
 
       if (FIXNUMP (prop[XLFD_PIXEL_INDEX]))
        ASET (font, FONT_SIZE_INDEX, prop[XLFD_PIXEL_INDEX]);
@@ -1811,7 +1811,7 @@ font_parse_family_registry (Lisp_Object family, Lisp_Object registry, Lisp_Objec
          Ffont_put (font_spec, QCfamily, font_intern_prop (p1, len, 1));
        }
       else
-       ASET (font_spec, FONT_FAMILY_INDEX, Fintern (family, Qnil, Qnil));
+       ASET (font_spec, FONT_FAMILY_INDEX, Fintern (family, Qnil));
     }
   if (! NILP (registry))
     {
@@ -1827,7 +1827,7 @@ font_parse_family_registry (Lisp_Object family, Lisp_Object registry, Lisp_Objec
          registry = concat2 (registry, extra);
        }
       registry = Fdowncase (registry);
-      ASET (font_spec, FONT_REGISTRY_INDEX, Fintern (registry, Qnil, Qnil));
+      ASET (font_spec, FONT_REGISTRY_INDEX, Fintern (registry, Qnil));
     }
 }
 

diff --git a/src/frame.c b/src/frame.c
index 6224af8a36e5617d704e8832eaf8e7253c0facf3..83925d4742a22fc0c43cb3d1c7cf0818b46f4b9b 100644 (file)
--- a/src/frame.c
+++ b/src/frame.c
@@ -4816,7 +4816,7 @@ gui_set_font_backend (struct frame *f, Lisp_Object new_value, Lisp_Object old_va
        {
          while (*p1 && ! c_isspace (*p1) && *p1 != ',') p1++;
          if (p0 < p1)
-           new_value = Fcons (Fintern (make_string (p0, p1 - p0), Qnil, Qt),
+           new_value = Fcons (Fintern (make_string (p0, p1 - p0), Qnil),
                               new_value);
          if (*p1)
            {
@@ -5501,7 +5501,7 @@ gui_display_get_arg (Display_Info *dpyinfo, Lisp_Object alist, Lisp_Object param
                      || !strcmp (SSDATA (lower), "false"))
                  return Qnil;
                else
-                 return Fintern (tem, Qnil, Qnil);
+                 return Fintern (tem, Qnil);
              }
 
            default:

diff --git a/src/json.c b/src/json.c
index b875fbd58e7112d0a9862db37919805d676cdcbf..f7979fb446e537c6b9460647eb5c34ec87028d64 100644 (file)
--- a/src/json.c
+++ b/src/json.c
@@ -896,7 +896,7 @@ json_to_lisp (json_t *json, const struct json_configuration *conf)
               json_object_foreach (json, key_str, value)
                 {
                   Lisp_Object key
-                   = Fintern (build_string_from_utf8 (key_str), Qnil, Qnil);
+                   = Fintern (build_string_from_utf8 (key_str), Qnil);
                   result
                     = Fcons (Fcons (key, json_to_lisp (value, conf)),
                              result);

diff --git a/src/keyboard.c b/src/keyboard.c
index 461df47439c7ac494d9c16810231a6050e4cfc03..2e850b74b9b373ae2650334c99dd693f84b0190b 100644 (file)
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -6864,7 +6864,7 @@ apply_modifiers_uncached (int modifiers, char *base, int base_len, int base_len_
     memcpy (SDATA (new_name), new_mods, mod_len);
     memcpy (SDATA (new_name) + mod_len, base, base_len_byte);
 
-    return Fintern (new_name, Qnil, Qnil);
+    return Fintern (new_name, Qnil);
   }
 }
 
@@ -6927,7 +6927,7 @@ parse_modifiers (Lisp_Object symbol)
 
       unmodified = Fintern (make_string (SSDATA (SYMBOL_NAME (symbol)) + end,
                                         SBYTES (SYMBOL_NAME (symbol)) - end),
-                           Qnil, Qnil);
+                           Qnil);
 
       if (modifiers & ~INTMASK)
        emacs_abort ();

diff --git a/src/keymap.c b/src/keymap.c
index 78f173a62bfa7eb770ce3c313b51d1d2331d7d82..da2af98c2d6b06b5205c29dc833cc033185d49c3 100644 (file)
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1355,7 +1355,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
            ASET (new_key, i, item);
          else
            {
-             Lisp_Object key_item = Fsymbol_name (item, Qnil);
+             Lisp_Object key_item = Fsymbol_name (item);
              Lisp_Object new_item;
              if (!STRING_MULTIBYTE (key_item))
                new_item = Fdowncase (key_item);
@@ -1386,7 +1386,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
                                                    SBYTES (key_item));
                  SAFE_FREE ();
                }
-             ASET (new_key, i, Fintern (new_item, Qnil, Qnil));
+             ASET (new_key, i, Fintern (new_item, Qnil));
            }
        }
 
@@ -1403,7 +1403,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
          if (!SYMBOLP (AREF (new_key, i)))
            continue;
 
-         Lisp_Object lc_key = Fsymbol_name (AREF (new_key, i), Qnil);
+         Lisp_Object lc_key = Fsymbol_name (AREF (new_key, i));
 
          /* If there are no spaces in this symbol, just skip it.  */
          if (!strstr (SSDATA (lc_key), " "))
@@ -1428,7 +1428,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
          Lisp_Object new_it =
            make_multibyte_string ((char *) dst,
                                   SCHARS (lc_key), SBYTES (lc_key));
-         ASET (new_key, i, Fintern (new_it, Qnil, Qnil));
+         ASET (new_key, i, Fintern (new_it, Qnil));
          SAFE_FREE ();
        }
 
@@ -1472,7 +1472,7 @@ silly_event_symbol_error (Lisp_Object c)
   Lisp_Object parsed = parse_modifiers (c);
   int modifiers = XFIXNAT (XCAR (XCDR (parsed)));
   Lisp_Object base = XCAR (parsed);
-  Lisp_Object name = Fsymbol_name (base, Qnil);
+  Lisp_Object name = Fsymbol_name (base);
   /* This alist includes elements such as ("RET" . "\\r").  */
   Lisp_Object assoc = Fassoc (name, exclude_keys, Qnil);
 
@@ -2350,7 +2350,7 @@ See `text-char-description' for describing character codes.  */)
          return result;
        }
       else
-       return Fsymbol_name (key, Qnil);
+       return Fsymbol_name (key);
     }
   else if (STRINGP (key))      /* Buffer names in the menubar.  */
     return Fcopy_sequence (key);

diff --git a/src/lisp.h b/src/lisp.h
index c1097d1894cff55d28cd299911822f9ac11f2272..90bbdde073e5a9cf4b9605bfc01038d7fb853082 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2289,8 +2289,8 @@ extern Lisp_Object pkg_unqualified_symbol (Lisp_Object name);
 extern bool pkg_keywordp (Lisp_Object obj);
 extern Lisp_Object pkg_define_symbol (Lisp_Object sym, Lisp_Object package);
 extern Lisp_Object pkg_intern_symbol (Lisp_Object sym, Lisp_Object package, Lisp_Object *status);
-extern Lisp_Object pkg_emacs_intern (Lisp_Object name, Lisp_Object package, Lisp_Object cl);
-extern Lisp_Object pkg_emacs_intern_soft (Lisp_Object name, Lisp_Object package, Lisp_Object cl);
+extern Lisp_Object pkg_emacs_intern (Lisp_Object name, Lisp_Object package);
+extern Lisp_Object pkg_emacs_intern_soft (Lisp_Object name, Lisp_Object package);
 extern Lisp_Object pkg_emacs_unintern (Lisp_Object name, Lisp_Object package);
 extern Lisp_Object pkg_emacs_mapatoms (Lisp_Object fn, Lisp_Object package);
 extern Lisp_Object pkg_lookup_non_keyword_c_string (const char *ptr, ptrdiff_t nchars, ptrdiff_t nbytes);
@@ -2443,7 +2443,7 @@ INLINE Lisp_Object
 LISP_SYMBOL_NAME (Lisp_Object sym)
 {
   if (SYMBOL_KEYWORD_P (sym))
-    return Fsymbol_name (sym, Qnil);
+    return Fsymbol_name (sym);
   return SYMBOL_NAME (sym);
 }
 

diff --git a/src/lread.c b/src/lread.c
index 8ada6c11ac845ecfffdb6957f7b92b28e9a43fc3..c1bbb5a7a159d1135aab1edae6b76c838b3b6950 100644 (file)
--- a/src/lread.c
+++ b/src/lread.c
@@ -3873,7 +3873,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
 
          case '#':
            /* ## -- the empty symbol */
-           obj = Fintern (empty_unibyte_string, Qnil, Qnil);
+           obj = Fintern (empty_unibyte_string, Qnil);
            break;
 
          case 's':
@@ -4023,7 +4023,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
              {
                /* No symbol character follows: this is the empty symbol.  */
                UNREAD (c);
-               obj = Fintern (empty_unibyte_string, Qnil, Qnil);
+               obj = Fintern (empty_unibyte_string, Qnil);
                break;
              }
            uninterned_symbol = false;
@@ -4811,25 +4811,25 @@ pkg_define_builtin_symbols (void)
     define_symbol (builtin_lisp_symbol (i), defsym_name[i]);
 }
 
-DEFUN ("intern", Fintern, Sintern, 1, 3, 0,
+DEFUN ("intern", Fintern, Sintern, 1, 2, 0,
        doc: /* Return the canonical symbol whose name is STRING.
 If there is none, one is created by this function and returned.
 A second optional argument specifies the obarray to use;
 it defaults to the value of `obarray'.  */)
-  (Lisp_Object string, Lisp_Object package, Lisp_Object cl)
+  (Lisp_Object string, Lisp_Object package)
 {
-  return pkg_emacs_intern (string, package, cl);
+  return pkg_emacs_intern (string, package);
 }
 
-DEFUN ("intern-soft", Fintern_soft, Sintern_soft, 1, 3, 0,
+DEFUN ("intern-soft", Fintern_soft, Sintern_soft, 1, 2, 0,
        doc: /* Return the canonical symbol named NAME, or nil if none exists.
 NAME may be a string or a symbol.  If it is a symbol, that exact
 symbol is searched for.
 A second optional argument specifies the obarray to use;
 it defaults to the value of `obarray'.  */)
-  (Lisp_Object name, Lisp_Object obarray, Lisp_Object cl)
+  (Lisp_Object name, Lisp_Object obarray)
 {
-  return pkg_emacs_intern_soft (name, obarray, cl);
+  return pkg_emacs_intern_soft (name, obarray);
 }
 
 DEFUN ("unintern", Funintern, Sunintern, 1, 2, 0,

diff --git a/src/minibuf.c b/src/minibuf.c
index 452b9acfe465ed4fd1b66368a728f261260b8ce1..9b0bcb0870acea5a02693ccffb4fcf622154c007 100644 (file)
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1431,7 +1431,7 @@ null input, return a symbol whose name is an empty string.  */)
                           Qnil, Qnil, default_string, Qnil);
   if (NILP (name))
     return name;
-  return Fintern (name, Qnil, Qnil);
+  return Fintern (name, Qnil);
 }
 
 #ifdef NOTDEF
@@ -1468,7 +1468,7 @@ A user option, or customizable variable, is one for which
                           default_string, Qnil);
   if (NILP (name))
     return name;
-  return Fintern (name, Qnil, Qnil);
+  return Fintern (name, Qnil);
 }
 
 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 4, 0,
@@ -1682,7 +1682,7 @@ or from one of the possible completions.  */)
       /* Is this element a possible completion?  */
 
       if (SYMBOLP (eltstring))
-       eltstring = Fsymbol_name (eltstring, Qnil);
+       eltstring = Fsymbol_name (eltstring);
 
       if (STRINGP (eltstring)
          && SCHARS (string) <= SCHARS (eltstring)
@@ -1921,7 +1921,7 @@ with a space are ignored unless STRING itself starts with a space.  */)
       /* Is this element a possible completion?  */
 
       if (SYMBOLP (eltstring))
-       eltstring = Fsymbol_name (eltstring, Qnil);
+       eltstring = Fsymbol_name (eltstring);
 
       if (STRINGP (eltstring)
          && SCHARS (string) <= SCHARS (eltstring)
@@ -2090,7 +2090,7 @@ the values STRING, PREDICATE and `lambda'.  */)
           {
             tem = HASH_KEY (h, i);
             if (BASE_EQ (tem, Qunbound)) continue;
-            Lisp_Object strkey = (SYMBOLP (tem) ? Fsymbol_name (tem, Qnil) : tem);
+            Lisp_Object strkey = (SYMBOLP (tem) ? Fsymbol_name (tem) : tem);
             if (!STRINGP (strkey)) continue;
             if (BASE_EQ (Fcompare_strings (string, Qnil, Qnil,
                                           strkey, Qnil, Qnil,
@@ -2190,7 +2190,7 @@ single string, rather than a cons cell whose car is a string.  */)
   register Lisp_Object tail;
 
   if (SYMBOLP (key))
-    key = Fsymbol_name (key, Qnil);
+    key = Fsymbol_name (key);
 
   for (tail = list; CONSP (tail); tail = XCDR (tail))
     {
@@ -2198,7 +2198,7 @@ single string, rather than a cons cell whose car is a string.  */)
       elt = XCAR (tail);
       thiscar = CONSP (elt) ? XCAR (elt) : elt;
       if (SYMBOLP (thiscar))
-       thiscar = Fsymbol_name (thiscar, Qnil);
+       thiscar = Fsymbol_name (thiscar);
       else if (!STRINGP (thiscar))
        continue;
       tem = Fcompare_strings (thiscar, make_fixnum (0), Qnil,

diff --git a/src/pkg.c b/src/pkg.c
index 52d05a69e26f882fd9588576a9b087dcc0188fdc..7f78c61cf322bc4380d9b6f43dce26f3482983fa 100644 (file)
--- a/src/pkg.c
+++ b/src/pkg.c
@@ -521,7 +521,7 @@ pkg_fake_me_an_obarray (Lisp_Object vector)
 /* Implements Emacs' traditional Fintern function.  */
 
 Lisp_Object
-pkg_emacs_intern (Lisp_Object name, Lisp_Object package, Lisp_Object cl)
+pkg_emacs_intern (Lisp_Object name, Lisp_Object package)
 {
   CHECK_STRING (name);
 
@@ -547,7 +547,7 @@ pkg_emacs_intern (Lisp_Object name, Lisp_Object package, Lisp_Object cl)
 /* Implements Emacs' traditional Fintern_soft function.  */
 
 Lisp_Object
-pkg_emacs_intern_soft (Lisp_Object name, Lisp_Object package, Lisp_Object cl)
+pkg_emacs_intern_soft (Lisp_Object name, Lisp_Object package)
 {
   /* intern-soft allows symbols.  */
   Lisp_Object orig = name;

diff --git a/src/print.c b/src/print.c
index faa70f746b98cc60670e47470864381d44d9b499..e9ce2fa485631e206440ce67d2f2c7eb99d36fcf 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -1904,7 +1904,7 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
            /* A frame could be too young and have no name yet;
               don't crash.  */
            if (SYMBOLP (frame_name))
-             frame_name = Fsymbol_name (frame_name, Qnil);
+             frame_name = Fsymbol_name (frame_name);
            else        /* can't happen: name should be either nil or string */
              frame_name = build_string ("*INVALID*FRAME*NAME*");
          }
@@ -2029,7 +2029,7 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
       Lisp_Object language = XTS_PARSER (obj)->language_symbol;
       /* No need to print the buffer because it's not that useful: we
         usually know which buffer a parser belongs to.  */
-      print_string (Fsymbol_name (language, Qnil), printcharfun);
+      print_string (Fsymbol_name (language), printcharfun);
       printchar ('>', printcharfun);
       break;
     case PVEC_TS_NODE:

diff --git a/src/process.c b/src/process.c
index 510be5e6f2e6dc1399104d1459754d3f1aaf47fc..a5f0cf9de4a530f648fa9a152913a8223b6598fa 100644 (file)
--- a/src/process.c
+++ b/src/process.c
@@ -821,7 +821,7 @@ status_message (struct Lisp_Process *p)
       return CALLN (Fformat, format, code);
     }
   else
-    return Fcopy_sequence (Fsymbol_name (symbol, Qnil));
+    return Fcopy_sequence (Fsymbol_name (symbol));
 }
 \f
 enum { PTY_NAME_SIZE = 24 };

diff --git a/src/term.c b/src/term.c
index eba928540b8845d736f78173152ff0f3bdda2d00..4df3de8f4a5cab2526e874f3852ec05743c726ba 100644 (file)
--- a/src/term.c
+++ b/src/term.c
@@ -2160,7 +2160,7 @@ set_tty_color_mode (struct tty_display_info *tty, struct frame *f)
   Lisp_Object color_mode;
   int mode;
   Lisp_Object tty_color_mode_alist
-    = Fintern_soft (build_string ("tty-color-mode-alist"), Qnil, Qnil);
+    = Fintern_soft (build_string ("tty-color-mode-alist"), Qnil);
 
   tem = assq_no_quit (Qtty_color_mode, f->param_alist);
   val = CONSP (tem) ? XCDR (tem) : Qnil;

diff --git a/src/treesit.c b/src/treesit.c
index 26a8ccc7abc061b88cb75441c22726813308f6c8..b48ad47991e8673b3087e828542fd421fb46bd50 100644 (file)
--- a/src/treesit.c
+++ b/src/treesit.c
@@ -572,7 +572,7 @@ static TSLanguage *
 treesit_load_language (Lisp_Object language_symbol,
                       Lisp_Object *signal_symbol, Lisp_Object *signal_data)
 {
-  Lisp_Object symbol_name = Fsymbol_name (language_symbol, Qnil);
+  Lisp_Object symbol_name = Fsymbol_name (language_symbol);
 
   CHECK_LIST (Vtreesit_extra_load_path);
 
@@ -2655,7 +2655,7 @@ treesit_predicate_pred (Lisp_Object args, struct capture_range captures,
       return false;
     }
 
-  Lisp_Object fn = Fintern (XCAR (args), Qnil, Qnil);
+  Lisp_Object fn = Fintern (XCAR (args), Qnil);
   Lisp_Object nodes = Qnil;
   Lisp_Object tail = XCDR (args);
   FOR_EACH_TAIL (tail)

diff --git a/src/xdisp.c b/src/xdisp.c
index 6e1bb169ee9c075175bf8937ed75568d309af19b..aa49749edf93081d769ca6cdc7b138bfe6f10caa 100644 (file)
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -28431,7 +28431,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
       if (NILP (obj))
        return "no process";
 #ifndef MSDOS
-      obj = Fsymbol_name (Fprocess_status (obj), Qnil);
+      obj = Fsymbol_name (Fprocess_status (obj));
 #endif
       break;
 

diff --git a/src/xfaces.c b/src/xfaces.c
index f6931b5c624c5cf8d92f2c84a892e3e95d46f922..4c64fb9f37769c9af164162c9f4ba1ac4b7828db 100644 (file)
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -1944,7 +1944,7 @@ resolve_face_name (Lisp_Object face_name, bool signal_p)
   Lisp_Object tortoise, hare;
 
   if (STRINGP (face_name))
-    face_name = Fintern (face_name, Qnil, Qnil);
+    face_name = Fintern (face_name, Qnil);
 
   if (NILP (face_name) || !SYMBOLP (face_name))
     return face_name;
@@ -5657,7 +5657,7 @@ be found.  Value is ALIST.  */)
       entry = Fcopy_sequence (entry);
       XSETCAR (tail, entry);
       for (tail2 = entry; CONSP (tail2); tail2 = XCDR (tail2))
-       XSETCAR (tail2, Fintern (XCAR (tail2), Qnil, Qnil));
+       XSETCAR (tail2, Fintern (XCAR (tail2), Qnil));
     }
 
   Vface_alternative_font_family_alist = alist;