merge trunk

13 files changed, 228 insertions, 255 deletions

diff --git a/lisp/eshell/em-alias.el b/lisp/eshell/em-alias.el
index a46b48c01b3..9a9cc4cd567 100644
--- a/lisp/eshell/em-alias.el
+++ b/lisp/eshell/em-alias.el
@@ -221,18 +221,11 @@ file named by `eshell-aliases-file'.")
     (let ((alias (eshell-lookup-alias command)))
       (if alias
           (throw 'eshell-replace-command
-                 (list
-                  'let
-                  (list
-                   (list 'eshell-command-name
-                         (list 'quote eshell-last-command-name))
-                   (list 'eshell-command-arguments
-                         (list 'quote eshell-last-arguments))
-                   (list 'eshell-prevent-alias-expansion
-                         (list 'quote
-                               (cons command
-                                     eshell-prevent-alias-expansion))))
-                  (eshell-parse-command (nth 1 alias))))))))
+                 `(let ((eshell-command-name ',eshell-last-command-name)
+                        (eshell-command-arguments ',eshell-last-arguments)
+                        (eshell-prevent-alias-expansion
+                         ',(cons command eshell-prevent-alias-expansion)))
+                    ,(eshell-parse-command (nth 1 alias))))))))
 
 (defun eshell-alias-completions (name)
   "Find all possible completions for NAME.
diff --git a/lisp/eshell/em-glob.el b/lisp/eshell/em-glob.el
index a58c7730ded..b5ca8119470 100644
--- a/lisp/eshell/em-glob.el
+++ b/lisp/eshell/em-glob.el
@@ -180,6 +180,8 @@ interpretation."
                 (goto-char (1+ end))))))))))
 
 (defvar eshell-glob-chars-regexp nil)
+(defvar eshell-glob-matches)
+(defvar message-shown)
 
 (defun eshell-glob-regexp (pattern)
   "Convert glob-pattern PATTERN to a regular expression.
@@ -262,9 +264,6 @@ the form:
             (error "No matches found: %s" glob)
           glob))))
 
-(defvar eshell-glob-matches)
-(defvar message-shown)
-
 ;; FIXME does this really need to abuse eshell-glob-matches, message-shown?
 (defun eshell-glob-entries (path globs &optional recurse-p)
   "Glob the entries in PATHS, possibly recursing if RECURSE-P is non-nil."
diff --git a/lisp/eshell/em-ls.el b/lisp/eshell/em-ls.el
index 41db4cd03d1..3dee1adb58a 100644
--- a/lisp/eshell/em-ls.el
+++ b/lisp/eshell/em-ls.el
@@ -268,6 +268,25 @@ scope during the evaluation of TEST-SEXP."
   :type '(repeat (cons function face))
   :group 'eshell-ls)
 
+(defvar block-size)
+(defvar dereference-links)
+(defvar dir-literal)
+(defvar error-func)
+(defvar flush-func)
+(defvar human-readable)
+(defvar ignore-pattern)
+(defvar insert-func)
+(defvar listing-style)
+(defvar numeric-uid-gid)
+(defvar reverse-list)
+(defvar show-all)
+(defvar show-almost-all)
+(defvar show-recursive)
+(defvar show-size)
+(defvar sort-method)
+(defvar ange-cache)
+(defvar dired-flag)
+
 ;;; Functions:
 
 (defun eshell-ls-insert-directory
@@ -315,25 +334,6 @@ instead."
 
 (put 'eshell/ls 'eshell-no-numeric-conversions t)
 
-(defvar block-size)
-(defvar dereference-links)
-(defvar dir-literal)
-(defvar error-func)
-(defvar flush-func)
-(defvar human-readable)
-(defvar ignore-pattern)
-(defvar insert-func)
-(defvar listing-style)
-(defvar numeric-uid-gid)
-(defvar reverse-list)
-(defvar show-all)
-(defvar show-almost-all)
-(defvar show-recursive)
-(defvar show-size)
-(defvar sort-method)
-(defvar ange-cache)
-(defvar dired-flag)
-
 (declare-function eshell-glob-regexp "em-glob" (pattern))
 
 (defun eshell-do-ls (&rest args)
diff --git a/lisp/eshell/em-pred.el b/lisp/eshell/em-pred.el
index 3a7f46ebe83..14d3020530f 100644
--- a/lisp/eshell/em-pred.el
+++ b/lisp/eshell/em-pred.el
@@ -307,7 +307,7 @@ functions.  PRED-FUNCS take a filename and return t if the test
 succeeds; MOD-FUNCS take any string and preform a modification,
 returning the resultant string."
   (let (result negate follow preds mods)
-    (condition-case err
+    (condition-case nil
         (while (not (eobp))
           (let ((char (char-after)))
             (cond
diff --git a/lisp/eshell/em-rebind.el b/lisp/eshell/em-rebind.el
index 341191fc62f..a526d590307 100644
--- a/lisp/eshell/em-rebind.el
+++ b/lisp/eshell/em-rebind.el
@@ -218,7 +218,7 @@ lock it at that."
         (cdar bindings))
       (setq bindings (cdr bindings)))))
 
-(defun eshell-delete-backward-char (n &optional killflag)
+(defun eshell-delete-backward-char (n)
   "Delete the last character, unless it's part of the output."
   (interactive "P")
   (let ((count (prefix-numeric-value n)))
diff --git a/lisp/eshell/em-unix.el b/lisp/eshell/em-unix.el
index af54d875cb0..b9b1c1635a5 100644
--- a/lisp/eshell/em-unix.el
+++ b/lisp/eshell/em-unix.el
@@ -714,6 +714,8 @@ available..."
           (goto-char (point-min))
           (resize-temp-buffer-window))))))
 
+(defvar compilation-scroll-output)
+
 (defun eshell-grep (command args &optional maybe-use-occur)
   "Generic service function for the various grep aliases.
 It calls Emacs's grep utility if the command is not redirecting output,
@@ -989,7 +991,7 @@ Show wall-clock time elapsed during execution of COMMAND.")
             (setq args nil)
           (setcdr (last args 3) nil))
         (with-current-buffer
-            (condition-case err
+            (condition-case nil
                 (diff-no-select
                  old new
                  (nil-blank-string (eshell-flatten-and-stringify args)))
@@ -1014,6 +1016,8 @@ Show wall-clock time elapsed during execution of COMMAND.")
 
 (put 'eshell/diff 'eshell-no-numeric-conversions t)
 
+(defvar locate-history-list)
+
 (defun eshell/locate (&rest args)
   "Alias \"locate\" to call Emacs `locate' function."
   (if (or eshell-plain-locate-behavior
diff --git a/lisp/eshell/esh-arg.el b/lisp/eshell/esh-arg.el
index d7dfd27d8d3..e3a12d5ece5 100644
--- a/lisp/eshell/esh-arg.el
+++ b/lisp/eshell/esh-arg.el
@@ -278,7 +278,7 @@ Point is left at the end of the arguments."
     (eshell-resolve-current-argument)
     eshell-current-argument))
 
-(defsubst eshell-operator (&rest args)
+(defsubst eshell-operator (&rest _args)
   "A stub function that generates an error if a floating operator is found."
   (error "Unhandled operator in input text"))
 
diff --git a/lisp/eshell/esh-cmd.el b/lisp/eshell/esh-cmd.el
index ef8a53f3c0b..c2922983ae2 100644
--- a/lisp/eshell/esh-cmd.el
+++ b/lisp/eshell/esh-cmd.el
@@ -650,7 +650,7 @@ For an external command, it means an exit code of 0."
            (looking-at eshell-lisp-regexp))
       (let* ((here (point))
              (obj
-              (condition-case err
+              (condition-case nil
                   (read (current-buffer))
                 (end-of-file
                  (throw 'eshell-incomplete ?\()))))
diff --git a/lisp/eshell/esh-mode.el b/lisp/eshell/esh-mode.el
index ed5fecf09ff..54a36428d58 100644
--- a/lisp/eshell/esh-mode.el
+++ b/lisp/eshell/esh-mode.el
@@ -220,74 +220,67 @@ This is used by `eshell-watch-for-password-prompt'."
 (defvar eshell-last-output-end nil)
 
 (defvar eshell-currently-handling-window nil)
-(defvar eshell-mode-syntax-table nil)
-(defvar eshell-mode-abbrev-table nil)
 
 (define-abbrev-table 'eshell-mode-abbrev-table ())
 
-(if (not eshell-mode-syntax-table)
-    (let ((i 0))
-      (setq eshell-mode-syntax-table (make-syntax-table))
-      (while (< i ?0)
-        (modify-syntax-entry i "_   " eshell-mode-syntax-table)
-        (setq i (1+ i)))
-      (setq i (1+ ?9))
-      (while (< i ?A)
-        (modify-syntax-entry i "_   " eshell-mode-syntax-table)
-        (setq i (1+ i)))
-      (setq i (1+ ?Z))
-      (while (< i ?a)
-        (modify-syntax-entry i "_   " eshell-mode-syntax-table)
-        (setq i (1+ i)))
-      (setq i (1+ ?z))
-      (while (< i 128)
-        (modify-syntax-entry i "_   " eshell-mode-syntax-table)
-        (setq i (1+ i)))
-      (modify-syntax-entry ?  "    " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\t "    " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\f "    " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\n ">   " eshell-mode-syntax-table)
-      ;; Give CR the same syntax as newline, for selective-display.
-      (modify-syntax-entry ?\^m ">   " eshell-mode-syntax-table)
-;;;   (modify-syntax-entry ?\; "<   " eshell-mode-syntax-table)
-      (modify-syntax-entry ?` "'   " eshell-mode-syntax-table)
-      (modify-syntax-entry ?' "'   " eshell-mode-syntax-table)
-      (modify-syntax-entry ?, "'   " eshell-mode-syntax-table)
-      ;; Used to be singlequote; changed for flonums.
-      (modify-syntax-entry ?. "_   " eshell-mode-syntax-table)
-      (modify-syntax-entry ?- "_   " eshell-mode-syntax-table)
-      (modify-syntax-entry ?| ".   " eshell-mode-syntax-table)
-      (modify-syntax-entry ?# "'   " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\" "\"    " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\\ "/   " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\( "()  " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\) ")(  " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\{ "(}  " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\} "){  " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\[ "(]  " eshell-mode-syntax-table)
-      (modify-syntax-entry ?\] ")[  " eshell-mode-syntax-table)
-      ;; All non-word multibyte characters should be `symbol'.
-      (if (featurep 'xemacs)
-          (map-char-table
-           (function
-            (lambda (key val)
-              (and (characterp key)
-                   (>= (char-int key) 256)
-                   (/= (char-syntax key) ?w)
-                   (modify-syntax-entry key "_   "
-                                        eshell-mode-syntax-table))))
-           (standard-syntax-table))
-        (map-char-table
-         (function
-          (lambda (key val)
-            (and (if (consp key)
-                     (and (>= (car key) 128)
-                          (/= (char-syntax (car key)) ?w))
-                   (and (>= key 256)
-                        (/= (char-syntax key) ?w)))
-                 (modify-syntax-entry key "_   "
-                                      eshell-mode-syntax-table))))
-         (standard-syntax-table)))))
+(defvar eshell-mode-syntax-table
+  (let ((st (make-syntax-table))
+        (i 0))
+    (while (< i ?0)
+      (modify-syntax-entry i "_   " st)
+      (setq i (1+ i)))
+    (setq i (1+ ?9))
+    (while (< i ?A)
+      (modify-syntax-entry i "_   " st)
+      (setq i (1+ i)))
+    (setq i (1+ ?Z))
+    (while (< i ?a)
+      (modify-syntax-entry i "_   " st)
+      (setq i (1+ i)))
+    (setq i (1+ ?z))
+    (while (< i 128)
+      (modify-syntax-entry i "_   " st)
+      (setq i (1+ i)))
+    (modify-syntax-entry ?  "    " st)
+    (modify-syntax-entry ?\t "    " st)
+    (modify-syntax-entry ?\f "    " st)
+    (modify-syntax-entry ?\n ">   " st)
+    ;; Give CR the same syntax as newline, for selective-display.
+    (modify-syntax-entry ?\^m ">   " st)
+    ;; (modify-syntax-entry ?\; "<   " st)
+    (modify-syntax-entry ?` "'   " st)
+    (modify-syntax-entry ?' "'   " st)
+    (modify-syntax-entry ?, "'   " st)
+    ;; Used to be singlequote; changed for flonums.
+    (modify-syntax-entry ?. "_   " st)
+    (modify-syntax-entry ?- "_   " st)
+    (modify-syntax-entry ?| ".   " st)
+    (modify-syntax-entry ?# "'   " st)
+    (modify-syntax-entry ?\" "\"    " st)
+    (modify-syntax-entry ?\\ "/   " st)
+    (modify-syntax-entry ?\( "()  " st)
+    (modify-syntax-entry ?\) ")(  " st)
+    (modify-syntax-entry ?\{ "(}  " st)
+    (modify-syntax-entry ?\} "){  " st)
+    (modify-syntax-entry ?\[ "(]  " st)
+    (modify-syntax-entry ?\] ")[  " st)
+    ;; All non-word multibyte characters should be `symbol'.
+    (map-char-table
+     (if (featurep 'xemacs)
+         (lambda (key _val)
+           (and (characterp key)
+                (>= (char-int key) 256)
+                (/= (char-syntax key) ?w)
+                (modify-syntax-entry key "_   " st)))
+       (lambda (key _val)
+         (and (if (consp key)
+                  (and (>= (car key) 128)
+                       (/= (char-syntax (car key)) ?w))
+                (and (>= key 256)
+                     (/= (char-syntax key) ?w)))
+              (modify-syntax-entry key "_   " st))))
+     (standard-syntax-table))
+    st))
 
 ;;; User Functions:
 
@@ -303,25 +296,18 @@ and the hook `eshell-exit-hook'."
   (run-hooks 'eshell-exit-hook))
 
 ;;;###autoload
-(defun eshell-mode ()
-  "Emacs shell interactive mode.
-
-\\{eshell-mode-map}"
-  (kill-all-local-variables)
-
-  (setq major-mode 'eshell-mode)
-  (setq mode-name "EShell")
-  (set (make-local-variable 'eshell-mode) t)
+(define-derived-mode eshell-mode fundamental-mode "EShell"
+  "Emacs shell interactive mode."
+  (setq-local eshell-mode t)
 
-  (make-local-variable 'eshell-mode-map)
-  (setq eshell-mode-map (make-sparse-keymap))
+  ;; FIXME: What the hell!?
+  (setq-local eshell-mode-map (make-sparse-keymap))
   (use-local-map eshell-mode-map)
 
   (when eshell-status-in-mode-line
     (make-local-variable 'eshell-command-running-string)
     (let ((fmt (copy-sequence mode-line-format)))
-      (make-local-variable 'mode-line-format)
-      (setq mode-line-format fmt))
+      (setq-local mode-line-format fmt))
     (let ((mode-line-elt (memq 'mode-line-modified mode-line-format)))
       (if mode-line-elt
           (setcar mode-line-elt 'eshell-command-running-string))))
@@ -331,11 +317,9 @@ and the hook `eshell-exit-hook'."
   (define-key eshell-mode-map [(meta control ?l)] 'eshell-show-output)
   (define-key eshell-mode-map [(control ?a)] 'eshell-bol)
 
-  (set (make-local-variable 'eshell-command-prefix)
-       (make-symbol "eshell-command-prefix"))
+  (setq-local eshell-command-prefix (make-symbol "eshell-command-prefix"))
   (fset eshell-command-prefix (make-sparse-keymap))
-  (set (make-local-variable 'eshell-command-map)
-       (symbol-function eshell-command-prefix))
+  (setq-local eshell-command-map (symbol-function eshell-command-prefix))
   (define-key eshell-mode-map [(control ?c)] eshell-command-prefix)
 
   ;; without this, find-tag complains about read-only text being
@@ -359,7 +343,6 @@ and the hook `eshell-exit-hook'."
   (define-key eshell-command-map [(control ?y)] 'eshell-repeat-argument)
 
   (setq local-abbrev-table eshell-mode-abbrev-table)
-  (set-syntax-table eshell-mode-syntax-table)
 
   (set (make-local-variable 'dired-directory) default-directory)
   (set (make-local-variable 'list-buffers-directory)
@@ -442,7 +425,6 @@ and the hook `eshell-exit-hook'."
 
   (if eshell-first-time-p
       (run-hooks 'eshell-first-time-mode-hook))
-  (run-mode-hooks 'eshell-mode-hook)
   (run-hooks 'eshell-post-command-hook))
 
 (put 'eshell-mode 'mode-class 'special)
@@ -470,8 +452,8 @@ and the hook `eshell-exit-hook'."
     (add-hook 'pre-command-hook 'eshell-intercept-commands t t)
     (message "Sending subprocess input directly")))
 
-(defun eshell-self-insert-command (N)
-  (interactive "i")
+(defun eshell-self-insert-command ()
+  (interactive)
   (process-send-string
    (eshell-interactive-process)
    (char-to-string (if (symbolp last-command-event)
@@ -944,10 +926,10 @@ a key."
 (custom-add-option 'eshell-output-filter-functions
                    'eshell-truncate-buffer)
 
-(defun eshell-send-invisible (str)
+(defun eshell-send-invisible ()
   "Read a string without echoing.
 Then send it to the process running in the current buffer."
-  (interactive "P")                     ; Defeat snooping via C-x ESC ESC
+  (interactive) ; Don't pass str as argument, to avoid snooping via C-x ESC ESC
   (let ((str (read-passwd
               (format "%s Password: "
                       (process-name (eshell-interactive-process))))))
@@ -969,7 +951,7 @@ This function could be in the list `eshell-output-filter-functions'."
       (beginning-of-line)
       (if (re-search-forward eshell-password-prompt-regexp
                              eshell-last-output-end t)
-          (eshell-send-invisible nil)))))
+          (eshell-send-invisible)))))
 
 (custom-add-option 'eshell-output-filter-functions
                    'eshell-watch-for-password-prompt)
@@ -977,32 +959,30 @@ This function could be in the list `eshell-output-filter-functions'."
 (defun eshell-handle-control-codes ()
   "Act properly when certain control codes are seen."
   (save-excursion
-    (let ((orig (point)))
-      (goto-char eshell-last-output-block-begin)
-      (unless (eolp)
-        (beginning-of-line))
-      (while (< (point) eshell-last-output-end)
-        (let ((char (char-after)))
-          (cond
-           ((eq char ?\r)
-            (if (< (1+ (point)) eshell-last-output-end)
-                (if (memq (char-after (1+ (point)))
-                          '(?\n ?\r))
-                    (delete-char 1)
-                  (let ((end (1+ (point))))
-                    (beginning-of-line)
-                    (delete-region (point) end)))
-              (add-text-properties (point) (1+ (point))
-                                   '(invisible t))
-              (forward-char)))
-           ((eq char ?\a)
-            (delete-char 1)
-            (beep))
-           ((eq char ?\C-h)
-            (delete-backward-char 1)
-            (delete-char 1))
-           (t
-            (forward-char))))))))
+    (goto-char eshell-last-output-block-begin)
+    (unless (eolp)
+      (beginning-of-line))
+    (while (< (point) eshell-last-output-end)
+      (let ((char (char-after)))
+        (cond
+         ((eq char ?\r)
+          (if (< (1+ (point)) eshell-last-output-end)
+              (if (memq (char-after (1+ (point)))
+                        '(?\n ?\r))
+                  (delete-char 1)
+                (let ((end (1+ (point))))
+                  (beginning-of-line)
+                  (delete-region (point) end)))
+            (add-text-properties (point) (1+ (point))
+                                 '(invisible t))
+            (forward-char)))
+         ((eq char ?\a)
+          (delete-char 1)
+          (beep))
+         ((eq char ?\C-h)
+          (delete-region (1- (point)) (1+ (point))))
+         (t
+          (forward-char)))))))
 
 (custom-add-option 'eshell-output-filter-functions
                    'eshell-handle-control-codes)
diff --git a/lisp/eshell/esh-opt.el b/lisp/eshell/esh-opt.el
index 33625433022..c62cbc7e1dc 100644
--- a/lisp/eshell/esh-opt.el
+++ b/lisp/eshell/esh-opt.el
@@ -28,11 +28,11 @@
 (require 'esh-ext)
 
 ;; Unused.
-;;; (defgroup eshell-opt nil
-;;;   "The options processing code handles command argument parsing for
-;;; Eshell commands implemented in Lisp."
-;;;   :tag "Command options processing"
-;;;   :group 'eshell)
+;; (defgroup eshell-opt nil
+;;   "The options processing code handles command argument parsing for
+;; Eshell commands implemented in Lisp."
+;;   :tag "Command options processing"
+;;   :group 'eshell)
 
 ;;; User Functions:
 
@@ -103,32 +103,25 @@ interned variable `args' (created using a `let' form)."
                macro-args
              (list 'eshell-stringify-list
                    (list 'eshell-flatten-list macro-args)))))
-     (let ,(append (delq nil (mapcar (lambda (opt)
+     (let ,(delq nil (mapcar (lambda (opt)
                                        (and (listp opt) (nth 3 opt)))
                                      (cadr options)))
-                   '(usage-msg last-value ext-command args))
        ;; FIXME: `options' ends up hiding some variable names under `quote',
        ;; which is incompatible with lexical scoping!!
-       (eshell-do-opt ,name ,options (lambda () ,@body-forms)))))
+       (eshell-do-opt ,name ,options (lambda (args) ,@body-forms) temp-args))))
 
 ;;; Internal Functions:
 
-(defvar temp-args)
-(defvar last-value)
-(defvar usage-msg)
-(defvar ext-command)
 ;; Documented part of the interface; see eshell-eval-using-options.
-(defvar args)
+(defvar eshell--args)
 
-(defun eshell-do-opt (name options body-fun)
+(defun eshell-do-opt (name options body-fun args)
   "Helper function for `eshell-eval-using-options'.
 This code doesn't really need to be macro expanded everywhere."
-  (setq args temp-args)
-  (if (setq
-       ext-command
+  (let* (last-value
+         (ext-command
        (catch 'eshell-ext-command
-         (when (setq
-                usage-msg
+            (let ((usage-msg
                 (catch 'eshell-usage
                   (setq last-value nil)
                   (if (and (= (length args) 0)
@@ -136,12 +129,14 @@ This code doesn't really need to be macro expanded everywhere."
                       (throw 'eshell-usage
                              (eshell-show-usage name options)))
                   (setq args (eshell-process-args name args options)
-                        last-value (funcall body-fun))
-                  nil))
-           (error "%s" usage-msg))))
+                        last-value (funcall body-fun args))
+                     nil)))
+              (when usage-msg
+                (error "%s" usage-msg))))))
+    (if ext-command
       (throw 'eshell-external
              (eshell-external-command ext-command args))
-    last-value))
+      last-value)))
 
 (defun eshell-show-usage (name options)
   "Display the usage message for NAME, using OPTIONS."
@@ -197,12 +192,13 @@ will be modified."
   (if (not (nth 3 opt))
       (eshell-show-usage name options)
     (if (eq (nth 2 opt) t)
-        (if (> ai (length args))
+        (if (> ai (length eshell--args))
             (error "%s: missing option argument" name)
-          (set (nth 3 opt) (nth ai args))
+          (set (nth 3 opt) (nth ai eshell--args))
           (if (> ai 0)
-              (setcdr (nthcdr (1- ai) args) (nthcdr (1+ ai) args))
-            (setq args (cdr args))))
+              (setcdr (nthcdr (1- ai) eshell--args)
+                      (nthcdr (1+ ai) eshell--args))
+            (setq eshell--args (cdr eshell--args))))
       (set (nth 3 opt) (or (nth 2 opt) t)))))
 
 (defun eshell-process-option (name switch kind ai options)
@@ -232,14 +228,15 @@ switch is unrecognized."
           (setq extcmd (eshell-search-path (cadr extcmd)))
           (if extcmd
               (throw 'eshell-ext-command extcmd)
-            (if (characterp switch)
-                (error "%s: unrecognized option -%c" name switch)
-              (error "%s: unrecognized option --%s" name switch))))))))
+            (error (if (characterp switch) "%s: unrecognized option -%c"
+                     "%s: unrecognized option --%s")
+                   name switch)))))))
 
 (defun eshell-process-args (name args options)
   "Process the given ARGS using OPTIONS.
 This assumes that symbols have been intern'd by `eshell-eval-using-options'."
-  (let ((ai 0) arg)
+  (let ((ai 0) arg
+        (eshell--args args))
     (while (< ai (length args))
       (setq arg (nth ai args))
       (if (not (and (stringp arg)
diff --git a/lisp/eshell/esh-util.el b/lisp/eshell/esh-util.el
index dd344eb50a2..968d1ebad79 100644
--- a/lisp/eshell/esh-util.el
+++ b/lisp/eshell/esh-util.el
@@ -23,6 +23,8 @@
 
 ;;; Code:
 
+(eval-when-compile (require 'cl-lib))
+
 (defgroup eshell-util nil
   "This is general utility code, meant for use by Eshell itself."
   :tag "General utilities"
@@ -484,12 +486,12 @@ list."
       (while (re-search-forward
               "^\\([^#[:space:]]+\\)\\s-+\\(\\S-+\\)\\(\\s-*\\(\\S-+\\)\\)?" nil t)
         (if (match-string 1)
-            (add-to-list 'hosts (match-string 1)))
+            (cl-pushnew (match-string 1) hosts :test #'equal))
         (if (match-string 2)
-            (add-to-list 'hosts (match-string 2)))
+            (cl-pushnew (match-string 2) hosts :test #'equal))
         (if (match-string 4)
-            (add-to-list 'hosts (match-string 4)))))
-    (sort hosts 'string-lessp)))
+            (cl-pushnew (match-string 4) hosts :test #'equal))))
+    (sort hosts #'string-lessp)))
 
 (defun eshell-read-hosts (file result-var timestamp-var)
   "Read the contents of /etc/passwd for user names."
diff --git a/lisp/eshell/esh-var.el b/lisp/eshell/esh-var.el
index 188b8165248..75c36a68544 100644
--- a/lisp/eshell/esh-var.el
+++ b/lisp/eshell/esh-var.el
@@ -395,12 +395,9 @@ process any indices that come after the variable reference."
           indices (and (not (eobp))
                        (eq (char-after) ?\[)
                        (eshell-parse-indices))
-          value (list 'let
-                      (list (list 'indices
-                                  (list 'quote indices)))
-                      value))
+          value `(let ((indices ',indices)) ,value))
     (if get-len
-        (list 'length value)
+        `(length ,value)
       value)))
 
 (defun eshell-parse-variable-ref ()
@@ -414,67 +411,68 @@ Possible options are:
   <LONG-NAME>   disambiguates the length of the name
   {COMMAND}     result of command is variable's value
   (LISP-FORM)   result of Lisp form is variable's value"
-  (let (end)
-    (cond
-     ((eq (char-after) ?{)
-      (let ((end (eshell-find-delimiter ?\{ ?\})))
-        (if (not end)
-            (throw 'eshell-incomplete ?\{)
-          (prog1
-              (list 'eshell-convert
-                    (list 'eshell-command-to-value
-                          (list 'eshell-as-subcommand
-                                (eshell-parse-command
-                                 (cons (1+ (point)) end)))))
-            (goto-char (1+ end))))))
-     ((memq (char-after) '(?\' ?\"))
-      (let ((name (if (eq (char-after) ?\')
-                      (eshell-parse-literal-quote)
-                    (eshell-parse-double-quote))))
-        (if name
+  (cond
+   ((eq (char-after) ?{)
+    (let ((end (eshell-find-delimiter ?\{ ?\})))
+      (if (not end)
+          (throw 'eshell-incomplete ?\{)
+        (prog1
+            (list 'eshell-convert
+                  (list 'eshell-command-to-value
+                        (list 'eshell-as-subcommand
+                              (eshell-parse-command
+                               (cons (1+ (point)) end)))))
+          (goto-char (1+ end))))))
+   ((memq (char-after) '(?\' ?\"))
+    (let ((name (if (eq (char-after) ?\')
+                    (eshell-parse-literal-quote)
+                  (eshell-parse-double-quote))))
+      (if name
           (list 'eshell-get-variable (eval name) 'indices))))
-     ((eq (char-after) ?\<)
-      (let ((end (eshell-find-delimiter ?\< ?\>)))
-        (if (not end)
-            (throw 'eshell-incomplete ?\<)
-          (let* ((temp (make-temp-file temporary-file-directory))
-                 (cmd (concat (buffer-substring (1+ (point)) end)
-                              " > " temp)))
-            (prog1
-                (list
-                 'let (list (list 'eshell-current-handles
-                                  (list 'eshell-create-handles temp
-                                        (list 'quote 'overwrite))))
-                 (list
-                  'progn
-                  (list 'eshell-as-subcommand
-                        (eshell-parse-command cmd))
-                  (list 'ignore
-                        (list 'nconc 'eshell-this-command-hook
-                              (list 'list
-                                    (list 'function
-                                          (list 'lambda nil
-                                                (list 'delete-file temp))))))
-                  (list 'quote temp)))
-              (goto-char (1+ end)))))))
-     ((eq (char-after) ?\()
-      (condition-case err
-          (list 'eshell-command-to-value
-                (list 'eshell-lisp-command
-                      (list 'quote (read (current-buffer)))))
-        (end-of-file
-         (throw 'eshell-incomplete ?\())))
-     ((assoc (char-to-string (char-after))
-             eshell-variable-aliases-list)
-      (forward-char)
-      (list 'eshell-get-variable
-            (char-to-string (char-before)) 'indices))
-     ((looking-at eshell-variable-name-regexp)
-      (prog1
-          (list 'eshell-get-variable (match-string 0) 'indices)
-        (goto-char (match-end 0))))
-     (t
-      (error "Invalid variable reference")))))
+   ((eq (char-after) ?\<)
+    (let ((end (eshell-find-delimiter ?\< ?\>)))
+      (if (not end)
+          (throw 'eshell-incomplete ?\<)
+        (let* ((temp (make-temp-file temporary-file-directory))
+               (cmd (concat (buffer-substring (1+ (point)) end)
+                            " > " temp)))
+          (prog1
+              (list
+               'let (list (list 'eshell-current-handles
+                                (list 'eshell-create-handles temp
+                                      (list 'quote 'overwrite))))
+               (list
+                'progn
+                (list 'eshell-as-subcommand
+                      (eshell-parse-command cmd))
+                (list 'ignore
+                      (list 'nconc 'eshell-this-command-hook
+                            (list 'list
+                                  (list 'function
+                                        (list 'lambda nil
+                                              (list 'delete-file temp))))))
+                (list 'quote temp)))
+            (goto-char (1+ end)))))))
+   ((eq (char-after) ?\()
+    (condition-case nil
+        (list 'eshell-command-to-value
+              (list 'eshell-lisp-command
+                    (list 'quote (read (current-buffer)))))
+      (end-of-file
+       (throw 'eshell-incomplete ?\())))
+   ((assoc (char-to-string (char-after))
+           eshell-variable-aliases-list)
+    (forward-char)
+    (list 'eshell-get-variable
+          (char-to-string (char-before)) 'indices))
+   ((looking-at eshell-variable-name-regexp)
+    (prog1
+        (list 'eshell-get-variable (match-string 0) 'indices)
+      (goto-char (match-end 0))))
+   (t
+    (error "Invalid variable reference"))))
+
+(defvar eshell-glob-function)
 
 (defun eshell-parse-indices ()
   "Parse and return a list of list of indices."
diff --git a/lisp/eshell/eshell.el b/lisp/eshell/eshell.el
index 9bdf8b3eb68..e3f8f0d11bc 100644
--- a/lisp/eshell/eshell.el
+++ b/lisp/eshell/eshell.el
@@ -300,7 +300,7 @@ buffer selected (or created)."
                     (get-buffer-create eshell-buffer-name)))))
     (cl-assert (and buf (buffer-live-p buf)))
     (pop-to-buffer-same-window buf)
-    (unless (eq major-mode 'eshell-mode)
+    (unless (derived-mode-p 'eshell-mode)
       (eshell-mode))
     buf))