Tune interpretation of integer arglist descriptor

* src/bytecode.c (exec_byte_code):
Simplify and tune when INTEGERP (args_template).

diff --git a/src/bytecode.c b/src/bytecode.c
index ee1b79f182622706858fc7505bef146693fb9694..6ccad469efa0217c6c435d3d2de2da30080cb21b 100644 (file)
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -476,49 +476,26 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   stacke = stack.bottom - 1 + XFASTINT (maxdepth);
 #endif
 
-  if (INTEGERP (args_template))
+  if (!NILP (args_template))
     {
+      eassert (INTEGERP (args_template));
       ptrdiff_t at = XINT (args_template);
       bool rest = (at & 128) != 0;
       int mandatory = at & 127;
       ptrdiff_t nonrest = at >> 8;
-      eassert (mandatory <= nonrest);
-      if (nargs <= nonrest)
-       {
-         ptrdiff_t i;
-         for (i = 0 ; i < nargs; i++, args++)
-           PUSH (*args);
-         if (nargs < mandatory)
-           /* Too few arguments.  */
-           Fsignal (Qwrong_number_of_arguments,
-                    list2 (Fcons (make_number (mandatory),
-                                  rest ? Qand_rest : make_number (nonrest)),
-                           make_number (nargs)));
-         else
-           {
-             for (; i < nonrest; i++)
-               PUSH (Qnil);
-             if (rest)
-               PUSH (Qnil);
-           }
-       }
-      else if (rest)
-       {
-         ptrdiff_t i;
-         for (i = 0 ; i < nonrest; i++, args++)
-           PUSH (*args);
-         PUSH (Flist (nargs - nonrest, args));
-       }
-      else
-       /* Too many arguments.  */
+      ptrdiff_t maxargs = rest ? PTRDIFF_MAX : nonrest;
+      if (! (mandatory <= nargs && nargs <= maxargs))
        Fsignal (Qwrong_number_of_arguments,
                 list2 (Fcons (make_number (mandatory), make_number (nonrest)),
                        make_number (nargs)));
-    }
-  else if (! NILP (args_template))
-    /* We should push some arguments on the stack.  */
-    {
-      error ("Unknown args template!");
+      ptrdiff_t pushedargs = min (nonrest, nargs);
+      for (ptrdiff_t i = 0; i < pushedargs; i++, args++)
+       PUSH (*args);
+      if (nonrest < nargs)
+       PUSH (Flist (nargs - nonrest, args));
+      else
+       for (ptrdiff_t i = nargs - rest; i < nonrest; i++)
+         PUSH (Qnil);
     }
 
   while (1)

diff --git a/src/eval.c b/src/eval.c
index d182f7f693d792e4a546371f318209bbf51b6f30..7b7bdd8df7b1eef5e0d685ed57e1dbbc0895e73b 100644 (file)
--- a/src/eval.c
+++ b/src/eval.c
@@ -2863,14 +2863,14 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
        xsignal1 (Qinvalid_function, fun);
       syms_left = AREF (fun, COMPILED_ARGLIST);
       if (INTEGERP (syms_left))
-       /* A byte-code object with a non-nil `push args' slot means we
+       /* A byte-code object with an integer args template means we
           shouldn't bind any arguments, instead just call the byte-code
           interpreter directly; it will push arguments as necessary.
 
-          Byte-code objects with either a non-existent, or a nil value for
-          the `push args' slot (the default), have dynamically-bound
-          arguments, and use the argument-binding code below instead (as do
-          all interpreted functions, even lexically bound ones).  */
+          Byte-code objects with a nil args template (the default)
+          have dynamically-bound arguments, and use the
+          argument-binding code below instead (as do all interpreted
+          functions, even lexically bound ones).  */
        {
          /* If we have not actually read the bytecode string
             and constants vector yet, fetch them from the file.  */