Merge remote-tracking branch 'origin/master' into 'feature/type-hierarchy'

1 files changed, 3 insertions, 58 deletions

diff --git a/src/eval.c b/src/eval.c
index 6f1c39ffb0e..9d3b98eb359 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -3122,19 +3122,6 @@ funcall_subr (struct Lisp_Subr *subr, ptrdiff_t numargs, Lisp_Object *args)
     xsignal2 (Qwrong_number_of_arguments, fun, make_fixnum (numargs));
 }
 
-/* Call the compiled Lisp function FUN.  If we have not yet read FUN's
-   bytecode string and constants vector, fetch them from the file first.  */
-
-static Lisp_Object
-fetch_and_exec_byte_code (Lisp_Object fun, ptrdiff_t args_template,
-                          ptrdiff_t nargs, Lisp_Object *args)
-{
-  if (CONSP (AREF (fun, COMPILED_BYTECODE)))
-    Ffetch_bytecode (fun);
-
-  return exec_byte_code (fun, args_template, nargs, args);
-}
-
 static Lisp_Object
 apply_lambda (Lisp_Object fun, Lisp_Object args, specpdl_ref count)
 {
@@ -3204,8 +3191,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
          ARGLIST slot value: pass the arguments to the byte-code
          engine directly.  */
       if (FIXNUMP (syms_left))
-        return fetch_and_exec_byte_code (fun, XFIXNUM (syms_left),
-                                         nargs, arg_vector);
+        return exec_byte_code (fun, XFIXNUM (syms_left), nargs, arg_vector);
       /* Otherwise the bytecode object uses dynamic binding and the
          ARGLIST slot contains a standard formal argument list whose
          variables are bound dynamically below.  */
@@ -3293,7 +3279,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
       val = XSUBR (fun)->function.a0 ();
     }
   else
-    val = fetch_and_exec_byte_code (fun, 0, 0, NULL);
+    val = exec_byte_code (fun, 0, 0, NULL);
 
   return unbind_to (count, val);
 }
@@ -3411,46 +3397,6 @@ lambda_arity (Lisp_Object fun)
   return Fcons (make_fixnum (minargs), make_fixnum (maxargs));
 }
 
-DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
-       1, 1, 0,
-       doc: /* If byte-compiled OBJECT is lazy-loaded, fetch it now.  */)
-  (Lisp_Object object)
-{
-  Lisp_Object tem;
-
-  if (COMPILEDP (object))
-    {
-      if (CONSP (AREF (object, COMPILED_BYTECODE)))
-        {
-          tem = read_doc_string (AREF (object, COMPILED_BYTECODE));
-          if (! (CONSP (tem) && STRINGP (XCAR (tem))
-                 && VECTORP (XCDR (tem))))
-            {
-              tem = AREF (object, COMPILED_BYTECODE);
-              if (CONSP (tem) && STRINGP (XCAR (tem)))
-                error ("Invalid byte code in %s", SDATA (XCAR (tem)));
-              else
-                error ("Invalid byte code");
-            }
-
-          Lisp_Object bytecode = XCAR (tem);
-          if (STRING_MULTIBYTE (bytecode))
-            {
-              /* BYTECODE must have been produced by Emacs 20.2 or earlier
-                 because it produced a raw 8-bit string for byte-code and now
-                 such a byte-code string is loaded as multibyte with raw 8-bit
-                 characters converted to multibyte form.  Convert them back to
-                 the original unibyte form.  */
-              bytecode = Fstring_as_unibyte (bytecode);
-            }
-
-          pin_string (bytecode);
-          ASET (object, COMPILED_BYTECODE, bytecode);
-          ASET (object, COMPILED_CONSTANTS, XCDR (tem));
-        }
-    }
-  return object;
-}
 
 /* Return true if SYMBOL's default currently has a let-binding
    which was made in the buffer that is now current.  */
@@ -3529,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.  */
@@ -4512,7 +4458,6 @@ alist of active lexical bindings.  */);
   defsubr (&Srun_hook_with_args_until_success);
   defsubr (&Srun_hook_with_args_until_failure);
   defsubr (&Srun_hook_wrapped);
-  defsubr (&Sfetch_bytecode);
   defsubr (&Sbacktrace_debug);
   DEFSYM (QCdebug_on_exit, ":debug-on-exit");
   defsubr (&Smapbacktrace);