Merge from trunk

diff --cc doc/lispref/ChangeLog.trunk
Simple merge

diff --cc lisp/ChangeLog.trunk
Simple merge

diff --cc lisp/custom.el
Simple merge

diff --cc lisp/dired.el
Simple merge

diff --cc lisp/emacs-lisp/bytecomp.el
Simple merge

diff --cc lisp/emacs-lisp/cl-loaddefs.el
index 3a6878e,0800117..8bcbd67
--- 1/lisp/emacs-lisp/cl-loaddefs.el
--- 2/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@@ -277,12 -277,12 +277,12 @@@ Not documente
  ;;;;;;  assert check-type typep deftype cl-struct-setf-expander defstruct
  ;;;;;;  define-modify-macro callf2 callf letf* letf rotatef shiftf
  ;;;;;;  remf cl-do-pop psetf setf get-setf-method defsetf define-setf-method
 -;;;;;;  declare locally multiple-value-setq multiple-value-bind lexical-let*
 -;;;;;;  lexical-let symbol-macrolet macrolet labels flet progv psetq
 -;;;;;;  do-all-symbols do-symbols dotimes dolist do* do loop return-from
 -;;;;;;  return block etypecase typecase ecase case load-time-value
 -;;;;;;  eval-when destructuring-bind function* defmacro* defun* gentemp
 -;;;;;;  gensym) "cl-macs" "cl-macs.el" "b3031039e82679e5b013ce1cbf174ee8")
 +;;;;;;  declare the locally multiple-value-setq multiple-value-bind
 +;;;;;;  lexical-let* lexical-let symbol-macrolet macrolet labels
 +;;;;;;  flet progv psetq do-all-symbols do-symbols dotimes dolist
 +;;;;;;  do* do loop return-from return block etypecase typecase ecase
 +;;;;;;  case load-time-value eval-when destructuring-bind function*
- ;;;;;;  defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "80cb83265399ce021c8c0c7d1a8562f2")
++;;;;;;  defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "c4734fbda33043d967624d39d80c3304")
  ;;; Generated autoloads from cl-macs.el
  
  (autoload 'gensym "cl-macs" "\
@@@ -500,16 -500,16 +500,16 @@@ Like `let', but lexically scoped
  The main visible difference is that lambdas inside BODY will create
  lexical closures as in Common Lisp.
  
--\(fn VARLIST BODY)" nil (quote macro))
++\(fn BINDINGS BODY)" nil (quote macro))
  
  (autoload 'lexical-let* "cl-macs" "\
  Like `let*', but lexically scoped.
  The main visible difference is that lambdas inside BODY, and in
--successive bindings within VARLIST, will create lexical closures
++successive bindings within BINDINGS, will create lexical closures
  as in Common Lisp.  This is similar to the behavior of `let*' in
  Common Lisp.
  
--\(fn VARLIST BODY)" nil (quote macro))
++\(fn BINDINGS BODY)" nil (quote macro))
  
  (autoload 'multiple-value-bind "cl-macs" "\
  Collect multiple return values.

diff --cc lisp/files.el
Simple merge

diff --cc lisp/help-fns.el
Simple merge

diff --cc lisp/minibuffer.el
Simple merge

diff --cc lisp/server.el
Simple merge

diff --cc lisp/simple.el
Simple merge

diff --cc lisp/startup.el
Simple merge

diff --cc lisp/subr.el
Simple merge

diff --cc lisp/vc/diff-mode.el
Simple merge

diff --cc src/ChangeLog.trunk
Simple merge

diff --cc src/alloc.c
Simple merge

diff --cc src/buffer.c
Simple merge

diff --cc src/bytecode.c
index ba3c012,ce2f06d..d887668
--- 1/src/bytecode.c
--- 2/src/bytecode.c
+++ b/src/bytecode.c
@@@ -156,9 -152,13 +154,13 @@@ extern Lisp_Object Qand_optional, Qand_
  #define Bcurrent_buffer 0160
  #define Bset_buffer 0161
  #define Bsave_current_buffer_1 0162 /* Replacing Bsave_current_buffer.  */
+ #if 0
  #define Bread_char 0162 /* No longer generated as of v19 */
+ #endif
+ #ifdef BYTE_CODE_SAFE
  #define Bset_mark 0163 /* this loser is no longer generated as of v18 */
 -#define Binteractive_p 0164 /* Needed since interactive-p takes unevalled args */
+ #endif
 +#define Binteractive_p 0164 /* Obsolete.  */
  
  #define Bforward_char 0165
  #define Bforward_word 0166
@@@ -228,13 -228,7 +230,12 @@@
  #define BconcatN 0260
  #define BinsertN 0261
  
 +/* Bstack_ref is code 0.  */
 +#define Bstack_set  0262
 +#define Bstack_set2 0263
 +#define BdiscardN   0266
 +
  #define Bconstant 0300
- #define CONSTANTLIM 0100
  
  /* Whether to maintain a `top' and `bottom' field in the stack frame.  */
  #define BYTE_MAINTAIN_TOP (BYTE_CODE_SAFE || BYTE_MARK_STACK)

diff --cc src/callint.c
index a0efc4b,282d8a8..3c52074
--- 1/src/callint.c
--- 2/src/callint.c
+++ b/src/callint.c
@@@ -118,12 -118,11 +118,12 @@@ usage: (interactive &optional ARGS)  */
  
  /* Quotify EXP: if EXP is constant, return it.
     If EXP is not constant, return (quote EXP).  */
- Lisp_Object
+ static Lisp_Object
  quotify_arg (register Lisp_Object exp)
  {
 -  if (!INTEGERP (exp) && !STRINGP (exp)
 -      && !NILP (exp) && !EQ (exp, Qt))
 +  if (CONSP (exp)
 +      || (SYMBOLP (exp)
 +        && !NILP (exp) && !EQ (exp, Qt)))
      return Fcons (Qquote, Fcons (exp, Qnil));
  
    return exp;

diff --cc src/data.c
Simple merge

diff --cc src/doc.c
index b56464e,1ed9949..158b097
--- 1/src/doc.c
--- 2/src/doc.c
+++ b/src/doc.c
@@@ -369,12 -374,10 +375,11 @@@ string is passed through `substitute-co
        else if (EQ (funcar, Qkeymap))
        return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
        else if (EQ (funcar, Qlambda)
 +             || (EQ (funcar, Qclosure) && (fun = XCDR (fun), 1))
               || EQ (funcar, Qautoload))
        {
-         Lisp_Object tem1;
-         tem1 = Fcdr (Fcdr (fun));
-         tem = Fcar (tem1);
+         Lisp_Object tem1 = Fcdr (Fcdr (fun));
+         Lisp_Object tem = Fcar (tem1);
          if (STRINGP (tem))
            doc = tem;
          /* Handle a doc reference--but these never come last

diff --cc src/eval.c
index 2fb89ce,f68274e..c22e7d3
--- 1/src/eval.c
--- 2/src/eval.c
+++ b/src/eval.c
@@@ -832,19 -800,13 +832,20 @@@ usage: (defvar SYMBOL &optional INITVAL
        }
        LOADHIST_ATTACH (sym);
      }
 +  else if (!NILP (Vinternal_interpreter_environment)
 +         && !XSYMBOL (sym)->declared_special)
 +    /* A simple (defvar foo) with lexical scoping does "nothing" except
 +       declare that var to be dynamically scoped *locally* (i.e. within
 +       the current file or let-block).  */
 +    Vinternal_interpreter_environment =
 +      Fcons (sym, Vinternal_interpreter_environment);
    else
-     /* Simple (defvar <var>) should not count as a definition at all.
-        It could get in the way of other definitions, and unloading this
-        package could try to make the variable unbound.  */
-     ;
-       
+     {
+       /* Simple (defvar <var>) should not count as a definition at all.
+        It could get in the way of other definitions, and unloading this
+        package could try to make the variable unbound.  */
+     }
+ 
    return sym;
  }
  
@@@ -3820,7 -3592,4 +3824,6 @@@ alist of active lexical bindings.  */)
    defsubr (&Sbacktrace_debug);
    defsubr (&Sbacktrace);
    defsubr (&Sbacktrace_frame);
 +  defsubr (&Sspecial_variable_p);
 +  defsubr (&Sfunctionp);
  }
- 

diff --cc src/fns.c
Simple merge

diff --cc src/image.c
Simple merge

diff --cc src/keyboard.c
index 78aa1cf,fc8622d..63e7573
--- 1/src/keyboard.c
--- 2/src/keyboard.c
+++ b/src/keyboard.c
@@@ -1132,10 -1132,10 +1132,10 @@@ command_loop_2 (Lisp_Object ignore
    return Qnil;
  }
  
- Lisp_Object
+ static Lisp_Object
  top_level_2 (void)
  {
 -  return Feval (Vtop_level);
 +  return Feval (Vtop_level, Qnil);
  }
  
  Lisp_Object

diff --cc src/lisp.h
Simple merge

diff --cc src/lread.c
Simple merge

diff --cc src/minibuf.c
Simple merge

diff --cc src/print.c
Simple merge

diff --cc src/window.c
Simple merge

diff --cc src/window.h
Simple merge