merge trunk

1 files changed, 71 insertions, 67 deletions

diff --git a/src/eval.c b/src/eval.c
index f16fdc6dd4c..f3f14d60e1c 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -691,18 +691,6 @@ usage: (defvar SYMBOL &optional INITVALUE DOCSTRING)  */)
       /* Do it before evaluating the initial value, for self-references.  */
       XSYMBOL (sym)->declared_special = 1;
 
-      if (SYMBOL_CONSTANT_P (sym))
-        {
-          /* For upward compatibility, allow (defvar :foo (quote :foo)).  */
-          Lisp_Object tem1 = Fcar (tail);
-          if (! (CONSP (tem1)
-                 && EQ (XCAR (tem1), Qquote)
-                 && CONSP (XCDR (tem1))
-                 && EQ (XCAR (XCDR (tem1)), sym)))
-            error ("Constant symbol `%s' specified in defvar",
-                   SDATA (SYMBOL_NAME (sym)));
-        }
-
       if (NILP (tem))
         Fset_default (sym, eval_sub (Fcar (tail)));
       else
@@ -1000,26 +988,14 @@ definitions to shadow the loaded ones for use in file byte-compilation.  */)
         {
           /* SYM is not mentioned in ENVIRONMENT.
              Look at its function definition.  */
+          struct gcpro gcpro1;
+          GCPRO1 (form);
+          def = Fautoload_do_load (def, sym, Qmacro);
+          UNGCPRO;
           if (EQ (def, Qunbound) || !CONSP (def))
             /* Not defined or definition not suitable.  */
             break;
-          if (EQ (XCAR (def), Qautoload))
-            {
-              /* Autoloading function: will it be a macro when loaded?  */
-              tem = Fnth (make_number (4), def);
-              if (EQ (tem, Qt) || EQ (tem, Qmacro))
-                /* Yes, load it and try again.  */
-                {
-                  struct gcpro gcpro1;
-                  GCPRO1 (form);
-                  do_autoload (def, sym);
-                  UNGCPRO;
-                  continue;
-                }
-              else
-                break;
-            }
-          else if (!EQ (XCAR (def), Qmacro))
+          if (!EQ (XCAR (def), Qmacro))
             break;
           else expander = XCDR (def);
         }
@@ -1423,7 +1399,9 @@ internal_condition_case_n (Lisp_Object (*bfun) (ptrdiff_t, Lisp_Object *),
                            ptrdiff_t nargs,
                            Lisp_Object *args,
                            Lisp_Object handlers,
-                           Lisp_Object (*hfun) (Lisp_Object))
+                           Lisp_Object (*hfun) (Lisp_Object err,
+                                                ptrdiff_t nargs,
+                                                Lisp_Object *args))
 {
   Lisp_Object val;
   struct catchtag c;
@@ -1441,7 +1419,7 @@ internal_condition_case_n (Lisp_Object (*bfun) (ptrdiff_t, Lisp_Object *),
   c.byte_stack = byte_stack_list;
   if (_setjmp (c.jmp))
     {
-      return (*hfun) (c.val);
+      return (*hfun) (c.val, nargs, args);
     }
   c.next = catchlist;
   catchlist = &c;
@@ -1964,22 +1942,35 @@ un_autoload (Lisp_Object oldqueue)
    FUNNAME is the symbol which is the function's name.
    FUNDEF is the autoload definition (a list).  */
 
-void
-do_autoload (Lisp_Object fundef, Lisp_Object funname)
+DEFUN ("autoload-do-load", Fautoload_do_load, Sautoload_do_load, 1, 3, 0,
+       doc: /* Load FUNDEF which should be an autoload.
+If non-nil, FUNNAME should be the symbol whose function value is FUNDEF,
+in which case the function returns the new autoloaded function value.
+If equal to `macro', MACRO-ONLY specifies that FUNDEF should only be loaded if
+it is defines a macro.  */)
+  (Lisp_Object fundef, Lisp_Object funname, Lisp_Object macro_only)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
-  Lisp_Object fun;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
+  if (!CONSP (fundef) || !EQ (Qautoload, XCAR (fundef)))
+    return fundef;
+
+  if (EQ (macro_only, Qmacro))
+    {
+      Lisp_Object kind = Fnth (make_number (4), fundef);
+      if (! (EQ (kind, Qt) || EQ (kind, Qmacro)))
+        return fundef;
+    }
+
   /* This is to make sure that loadup.el gives a clear picture
      of what files are preloaded and when.  */
   if (! NILP (Vpurify_flag))
     error ("Attempt to autoload %s while preparing to dump",
            SDATA (SYMBOL_NAME (funname)));
 
-  fun = funname;
   CHECK_SYMBOL (funname);
-  GCPRO3 (fun, funname, fundef);
+  GCPRO3 (funname, fundef, macro_only);
 
   /* Preserve the match data.  */
   record_unwind_save_match_data ();
@@ -1994,18 +1985,28 @@ do_autoload (Lisp_Object fundef, Lisp_Object funname)
      The value saved here is to be restored into Vautoload_queue.  */
   record_unwind_protect (un_autoload, Vautoload_queue);
   Vautoload_queue = Qt;
-  Fload (Fcar (Fcdr (fundef)), Qnil, Qt, Qnil, Qt);
+  /* If `macro_only', assume this autoload to be a "best-effort",
+     so don't signal an error if autoloading fails.  */
+  Fload (Fcar (Fcdr (fundef)), macro_only, Qt, Qnil, Qt);
 
   /* Once loading finishes, don't undo it.  */
   Vautoload_queue = Qt;
   unbind_to (count, Qnil);
 
-  fun = Findirect_function (fun, Qnil);
-
-  if (!NILP (Fequal (fun, fundef)))
-    error ("Autoloading failed to define function %s",
-           SDATA (SYMBOL_NAME (funname)));
   UNGCPRO;
+
+  if (NILP (funname))
+    return Qnil;
+  else
+    {
+      Lisp_Object fun = Findirect_function (funname, Qnil);
+
+      if (!NILP (Fequal (fun, fundef)))
+        error ("Autoloading failed to define function %s",
+               SDATA (SYMBOL_NAME (funname)));
+      else
+        return fun;
+    }
 }
 
 
@@ -2052,15 +2053,7 @@ eval_sub (Lisp_Object form)
     return form;
 
   QUIT;
-  if ((consing_since_gc > gc_cons_threshold
-       && consing_since_gc > gc_relative_threshold)
-      ||
-      (!NILP (Vmemory_full) && consing_since_gc > memory_full_cons_threshold))
-    {
-      GCPRO1 (form);
-      Fgarbage_collect ();
-      UNGCPRO;
-    }
+  maybe_gc ();
 
   if (++lisp_eval_depth > max_lisp_eval_depth)
     {
@@ -2103,7 +2096,7 @@ eval_sub (Lisp_Object form)
       args_left = original_args;
       numargs = Flength (args_left);
 
-      CHECK_CONS_LIST ();
+      check_cons_list ();
 
       if (XINT (numargs) < XSUBR (fun)->min_args
           || (XSUBR (fun)->max_args >= 0
@@ -2220,18 +2213,30 @@ eval_sub (Lisp_Object form)
         xsignal1 (Qinvalid_function, original_fun);
       if (EQ (funcar, Qautoload))
         {
-          do_autoload (fun, original_fun);
+          Fautoload_do_load (fun, original_fun, Qnil);
           goto retry;
         }
       if (EQ (funcar, Qmacro))
-        val = eval_sub (apply1 (Fcdr (fun), original_args));
+        {
+          ptrdiff_t count = SPECPDL_INDEX ();
+          extern Lisp_Object Qlexical_binding;
+          Lisp_Object exp;
+          /* Bind lexical-binding during expansion of the macro, so the
+             macro can know reliably if the code it outputs will be
+             interpreted using lexical-binding or not.  */
+          specbind (Qlexical_binding,
+                    NILP (Vinternal_interpreter_environment) ? Qnil : Qt);
+          exp = apply1 (Fcdr (fun), original_args);
+          unbind_to (count, Qnil);
+          val = eval_sub (exp);
+        }
       else if (EQ (funcar, Qlambda)
                || EQ (funcar, Qclosure))
         val = apply_lambda (fun, original_args);
       else
         xsignal1 (Qinvalid_function, original_fun);
     }
-  CHECK_CONS_LIST ();
+  check_cons_list ();
 
   lisp_eval_depth--;
   if (backtrace.debug_on_exit)
@@ -2310,7 +2315,7 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
       gcpro1.nvars = 1 + numargs;
     }
 
-  memcpy (funcall_args, args, nargs * sizeof (Lisp_Object));
+  memcpy (funcall_args, args, nargs * word_size);
   /* Spread the last arg we got.  Its first element goes in
      the slot that it used to occupy, hence this value of I.  */
   i = nargs - 1;
@@ -2749,11 +2754,6 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   ptrdiff_t i;
 
   QUIT;
-  if ((consing_since_gc > gc_cons_threshold
-       && consing_since_gc > gc_relative_threshold)
-      ||
-      (!NILP (Vmemory_full) && consing_since_gc > memory_full_cons_threshold))
-    Fgarbage_collect ();
 
   if (++lisp_eval_depth > max_lisp_eval_depth)
     {
@@ -2766,14 +2766,17 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   backtrace.next = backtrace_list;
   backtrace_list = &backtrace;
   backtrace.function = &args[0];
-  backtrace.args = &args[1];
+  backtrace.args = &args[1];    /* This also GCPROs them.  */
   backtrace.nargs = nargs - 1;
   backtrace.debug_on_exit = 0;
 
+  /* Call GC after setting up the backtrace, so the latter GCPROs the args.  */
+  maybe_gc ();
+
   if (debug_on_next_call)
     do_debug_on_call (Qlambda);
 
-  CHECK_CONS_LIST ();
+  check_cons_list ();
 
   original_fun = args[0];
 
@@ -2805,7 +2808,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
             {
               internal_args = alloca (XSUBR (fun)->max_args
                                       * sizeof *internal_args);
-              memcpy (internal_args, args + 1, numargs * sizeof (Lisp_Object));
+              memcpy (internal_args, args + 1, numargs * word_size);
               for (i = numargs; i < XSUBR (fun)->max_args; i++)
                 internal_args[i] = Qnil;
             }
@@ -2881,14 +2884,14 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
         val = funcall_lambda (fun, numargs, args + 1);
       else if (EQ (funcar, Qautoload))
         {
-          do_autoload (fun, original_fun);
-          CHECK_CONS_LIST ();
+          Fautoload_do_load (fun, original_fun, Qnil);
+          check_cons_list ();
           goto retry;
         }
       else
         xsignal1 (Qinvalid_function, original_fun);
     }
-  CHECK_CONS_LIST ();
+  check_cons_list ();
   lisp_eval_depth--;
   if (backtrace.debug_on_exit)
     val = call_debugger (Fcons (Qexit, Fcons (val, Qnil)));
@@ -3606,6 +3609,7 @@ alist of active lexical bindings.  */);
   defsubr (&Scalled_interactively_p);
   defsubr (&Scommandp);
   defsubr (&Sautoload);
+  defsubr (&Sautoload_do_load);
   defsubr (&Seval);
   defsubr (&Sapply);
   defsubr (&Sfuncall);