* ielm.el (ielm-noisy, ielm-dynamic-return, ielm-mode-hook)

  (ielm-dynamic-multiline-inputs): Remove * from defcustom docstrings.
  (ielm-prompt-read-only, ielm-font-lock-keywords): Fix docstring typos.
  (ielm-map): Define within defvar.  Add docstring.
  (ielm-tab, ielm-eval-input, ielm-get-old-input, ielm-return)
  (ielm-complete-filename): Use `when', `unless'.
  (ielm-is-whitespace-or-comment): Use `string-match-p'.
  (ielm-return, ielm-get-old-input): Use `looking-at-p'.
  (ielm-change-working-buffer): Check that the buffer is live.
  (inferior-emacs-lisp-mode): Define with `define-derived-mode'.
  Simplify.  Reflow docstring.
  (inferior-emacs-lisp-mode-hook, inferior-emacs-lisp-mode-map):
  New aliases, to satisfy `define-derived-mode' expectations.

2 files changed, 175 insertions, 182 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 923802156e7..f36bb2e761c 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,19 @@
+2008-11-16  Juanma Barranquero  <lekktu@gmail.com>
+
+        * ielm.el (ielm-noisy, ielm-dynamic-return, ielm-mode-hook)
+        (ielm-dynamic-multiline-inputs): Remove * from defcustom docstrings.
+        (ielm-prompt-read-only, ielm-font-lock-keywords): Fix docstring typos.
+        (ielm-map): Define within defvar.  Add docstring.
+        (ielm-tab, ielm-eval-input, ielm-get-old-input, ielm-return)
+        (ielm-complete-filename): Use `when', `unless'.
+        (ielm-is-whitespace-or-comment): Use `string-match-p'.
+        (ielm-return, ielm-get-old-input): Use `looking-at-p'.
+        (ielm-change-working-buffer): Check that the buffer is live.
+        (inferior-emacs-lisp-mode): Define with `define-derived-mode'.
+        Simplify.  Reflow docstring.
+        (inferior-emacs-lisp-mode-hook, inferior-emacs-lisp-mode-map):
+        New aliases, to satisfy `define-derived-mode' expectations.
+
 2008-11-15  Glenn Morris  <rgm@gnu.org>
             Martin Rudalics  <rudalics@gmx.at>
 
@@ -31,8 +47,7 @@
 
 2008-11-14  Karl Fogel  <kfogel@red-bean.com>
 
-        * files.el (file-precious-flag): Document that this flag is
-        advisory.
+        * files.el (file-precious-flag): Document that this flag is advisory.
 
 2008-11-14  Shigeru Fukaya  <shigeru.fukaya@gmail.com>
 
diff --git a/lisp/ielm.el b/lisp/ielm.el
index d577b888147..e22b6eda8b2 100644
--- a/lisp/ielm.el
+++ b/lisp/ielm.el
@@ -44,7 +44,7 @@
 
 
 (defcustom ielm-noisy t
-  "*If non-nil, IELM will beep on error."
+  "If non-nil, IELM will beep on error."
   :type 'boolean
   :group 'ielm)
 
@@ -56,7 +56,7 @@ This works by setting the buffer-local value of `comint-prompt-read-only'.
 Setting that value directly affects new prompts in the current buffer.
 
 If this option is enabled, then the safe way to temporarily
-override the read-only-ness of ielm prompts is to call
+override the read-only-ness of IELM prompts is to call
 `comint-kill-whole-line' or `comint-kill-region' with no
 narrowing in effect.  This way you will be certain that none of
 the remaining prompts will be accidentally messed up.  You may
@@ -71,7 +71,7 @@ wish to put something like the following in your `.emacs' file:
 If you set `comint-prompt-read-only' to t, you might wish to use
 `comint-mode-hook' and `comint-mode-map' instead of
 `ielm-mode-hook' and `ielm-map'.  That will affect all comint
-buffers, including ielm buffers.  If you sometimes use ielm on
+buffers, including IELM buffers.  If you sometimes use IELM on
 text-only terminals or with `emacs -nw', you might wish to use
 another binding for `comint-kill-whole-line'."
   :type 'boolean
@@ -101,14 +101,14 @@ prevent a running IELM process from being messed up when the user
 customizes `ielm-prompt'.")
 
 (defcustom ielm-dynamic-return t
-  "*Controls whether \\<ielm-map>\\[ielm-return] has intelligent behavior in IELM.
+  "Controls whether \\<ielm-map>\\[ielm-return] has intelligent behavior in IELM.
 If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
 and indents for incomplete sexps.  If nil, always inserts newlines."
   :type 'boolean
   :group 'ielm)
 
 (defcustom ielm-dynamic-multiline-inputs t
-  "*Force multiline inputs to start from column zero?
+  "Force multiline inputs to start from column zero?
 If non-nil, after entering the first line of an incomplete sexp, a newline
 will be inserted after the prompt, moving the input to the next line.
 This gives more frame width for large indented sexps, and allows functions
@@ -117,10 +117,11 @@ such as `edebug-defun' to work with such inputs."
   :group 'ielm)
 
 (defcustom ielm-mode-hook nil
-  "*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
+  "Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
   :options '(turn-on-eldoc-mode)
   :type 'hook
   :group 'ielm)
+(defvaralias 'inferior-emacs-lisp-mode-hook 'ielm-mode-hook)
 
 (defvar * nil
   "Most recent value evaluated in IELM.")
@@ -165,45 +166,40 @@ This variable is buffer-local.")
   "*** Welcome to IELM ***  Type (describe-mode) for help.\n"
   "Message to display when IELM is started.")
 
-(defvar ielm-map nil)
-(if ielm-map nil
-  (if (featurep 'xemacs)
-      ;; Lemacs
-      (progn
-        (setq ielm-map (make-sparse-keymap))
-        (set-keymap-parent ielm-map comint-mode-map))
-    ;; FSF
-    (setq ielm-map (cons 'keymap comint-mode-map)))
-  (define-key ielm-map "\t" 'comint-dynamic-complete)
-  (define-key ielm-map "\C-m" 'ielm-return)
-  (define-key ielm-map "\C-j" 'ielm-send-input)
-  (define-key ielm-map "\e\C-x" 'eval-defun)         ; for consistency with
-  (define-key ielm-map "\e\t" 'lisp-complete-symbol) ; lisp-interaction-mode
-  ;; These bindings are from `lisp-mode-shared-map' -- can you inherit
-  ;; from more than one keymap??
-  (define-key ielm-map "\e\C-q" 'indent-sexp)
-  (define-key ielm-map "\177" 'backward-delete-char-untabify)
-  ;; Some convenience bindings for setting the working buffer
-  (define-key ielm-map "\C-c\C-b" 'ielm-change-working-buffer)
-  (define-key ielm-map "\C-c\C-f" 'ielm-display-working-buffer)
-  (define-key ielm-map "\C-c\C-v" 'ielm-print-working-buffer))
+(defvar ielm-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\t" 'comint-dynamic-complete)
+    (define-key map "\C-m" 'ielm-return)
+    (define-key map "\C-j" 'ielm-send-input)
+    (define-key map "\e\C-x" 'eval-defun)         ; for consistency with
+    (define-key map "\e\t" 'lisp-complete-symbol) ; lisp-interaction-mode
+    ;; These bindings are from `lisp-mode-shared-map' -- can you inherit
+    ;; from more than one keymap??
+    (define-key map "\e\C-q" 'indent-sexp)
+    (define-key map "\177" 'backward-delete-char-untabify)
+    ;; Some convenience bindings for setting the working buffer
+    (define-key map "\C-c\C-b" 'ielm-change-working-buffer)
+    (define-key map "\C-c\C-f" 'ielm-display-working-buffer)
+    (define-key map "\C-c\C-v" 'ielm-print-working-buffer)
+    map)
+  "Keymap for IELM mode.")
+(defvaralias 'inferior-emacs-lisp-mode-map 'ielm-map)
 
 (defvar ielm-font-lock-keywords
   '(("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)"
      (1 font-lock-comment-face)
      (2 font-lock-constant-face)))
-  "Additional expressions to highlight in ielm buffers.")
+  "Additional expressions to highlight in IELM buffers.")
 
 ;;; Completion stuff
 
 (defun ielm-tab nil
   "Possibly indent the current line as Lisp code."
   (interactive)
-  (if (or (eq (preceding-char) ?\n)
-          (eq (char-syntax (preceding-char)) ? ))
-      (progn
-        (ielm-indent-line)
-        t)))
+  (when (or (eq (preceding-char) ?\n)
+            (eq (char-syntax (preceding-char)) ?\s))
+    (ielm-indent-line)
+    t))
 
 (defun ielm-complete-symbol nil
   "Complete the Lisp symbol before point."
@@ -224,8 +220,8 @@ This variable is buffer-local.")
 
 (defun ielm-complete-filename nil
   "Dynamically complete filename before point, if in a string."
-  (if (nth 3 (parse-partial-sexp comint-last-input-start (point)))
-      (comint-dynamic-complete-filename)))
+  (when (nth 3 (parse-partial-sexp comint-last-input-start (point)))
+    (comint-dynamic-complete-filename)))
 
 (defun ielm-indent-line nil
   "Indent the current line as Lisp code if it is not a prompt line."
@@ -253,7 +249,10 @@ This is the buffer in which all sexps entered at the IELM prompt are
 evaluated.  You can achieve the same effect with a call to
 `set-buffer' at the IELM prompt."
   (interactive "bSet working buffer to: ")
-  (setq ielm-working-buffer (or (get-buffer buf) (error "No such buffer")))
+  (let ((buffer (get-buffer buf)))
+    (if (and buffer (buffer-live-p buffer))
+        (setq ielm-working-buffer buffer)
+      (error "No such buffer: %S" buf)))
   (ielm-print-working-buffer))
 
 ;;; Other bindings
@@ -272,13 +271,13 @@ simply inserts a newline."
                                    (point)))))
         (if (and (< (car state) 1) (not (nth 3 state)))
             (ielm-send-input)
-          (if (and ielm-dynamic-multiline-inputs
-                   (save-excursion
-                     (beginning-of-line)
-                     (looking-at comint-prompt-regexp)))
-              (save-excursion
-                (goto-char (ielm-pm))
-                (newline 1)))
+          (when (and ielm-dynamic-multiline-inputs
+                     (save-excursion
+                       (beginning-of-line)
+                       (looking-at-p comint-prompt-regexp)))
+            (save-excursion
+              (goto-char (ielm-pm))
+              (newline 1)))
           (newline-and-indent)))
     (newline)))
 
@@ -300,8 +299,8 @@ simply inserts a newline."
 
 (defun ielm-is-whitespace-or-comment (string)
   "Return non-nil if STRING is all whitespace or a comment."
-  (or (string= string "") 
-      (string-match "\\`[ \t\n]*\\(?:;.*\\)*\\'" string)))
+  (or (string= string "")
+      (string-match-p "\\`[ \t\n]*\\(?:;.*\\)*\\'" string)))
 
 ;;; Evaluation
 
@@ -323,100 +322,97 @@ simply inserts a newline."
         ielm-pos                        ; End posn of parse in string
         ielm-result                     ; Result, or error message
         ielm-error-type                 ; string, nil if no error
-        (ielm-output    "")             ; result to display
+        (ielm-output "")                ; result to display
         (ielm-wbuf ielm-working-buffer) ; current buffer after evaluation
         (ielm-pmark (ielm-pm)))
-    (if (not (ielm-is-whitespace-or-comment ielm-string))
-        (progn
-          (condition-case err
-              (let (rout)
-                (setq rout (read-from-string ielm-string))
-                (setq ielm-form (car rout))
-                (setq ielm-pos (cdr rout)))
-            (error (setq ielm-result (error-message-string err))
-                   (setq ielm-error-type "Read error")))
-          (if ielm-error-type nil
-            ;; Make sure working buffer has not been killed
-            (if (not (buffer-name ielm-working-buffer))
-                (setq ielm-result "Working buffer has been killed"
-                      ielm-error-type "IELM Error"
-                      ielm-wbuf (current-buffer))
-              (if (ielm-is-whitespace-or-comment
-                   (substring ielm-string ielm-pos))
-                  ;; To correctly handle the ielm-local variables *,
-                  ;; ** and ***, we need a temporary buffer to be
-                  ;; current at entry to the inner of the next two let
-                  ;; forms.  We need another temporary buffer to exit
-                  ;; that same let.  To avoid problems, neither of
-                  ;; these buffers should be alive during the
-                  ;; evaluation of ielm-form.
-                  (let ((*1 *)
-                        (*2 **)
-                        (*3 ***)
-                        ielm-temp-buffer)
-                    (set-match-data ielm-match-data)
-                    (save-excursion
-                      (with-temp-buffer
-                        (condition-case err
-                            (unwind-protect
-                                ;; The next let form creates default
-                                ;; bindings for *, ** and ***.  But
-                                ;; these default bindings are
-                                ;; identical to the ielm-local
-                                ;; bindings.  Hence, during the
-                                ;; evaluation of ielm-form, the
-                                ;; ielm-local values are going to be
-                                ;; used in all buffers except for
-                                ;; other ielm buffers, which override
-                                ;; them.  Normally, the variables *1,
-                                ;; *2 and *3 also have default
-                                ;; bindings, which are not overridden.
-                                (let ((* *1)
-                                      (** *2)
-                                      (*** *3))
-                                  (kill-buffer (current-buffer))
-                                  (set-buffer ielm-wbuf)
-                                  (setq ielm-result (eval ielm-form))
-                                  (setq ielm-wbuf (current-buffer))
-                                  (setq
-                                   ielm-temp-buffer
-                                   (generate-new-buffer " *ielm-temp*"))
-                                  (set-buffer ielm-temp-buffer))
-                              (when ielm-temp-buffer
-                                (kill-buffer ielm-temp-buffer)))
-                          (error (setq ielm-result (error-message-string err))
-                                 (setq ielm-error-type "Eval error"))
-                          (quit (setq ielm-result "Quit during evaluation")
-                                (setq ielm-error-type "Eval error")))))
-                    (setq ielm-match-data (match-data)))
-                (setq ielm-error-type "IELM error")
-                (setq ielm-result "More than one sexp in input"))))
-
-          ;; If the eval changed the current buffer, mention it here
-          (if (eq ielm-wbuf ielm-working-buffer) nil
-            (message "current buffer is now: %s" ielm-wbuf)
-            (setq ielm-working-buffer ielm-wbuf))
-
-          (goto-char ielm-pmark)
-          (if (not ielm-error-type)
-              (condition-case err
-                  ;; Self-referential objects cause loops in the printer, so
-                  ;; trap quits here. May as well do errors, too
-                  (setq ielm-output (concat ielm-output (pp-to-string ielm-result)))
-                (error (setq ielm-error-type "IELM Error")
-                       (setq ielm-result  "Error during pretty-printing (bug in pp)"))
-                (quit  (setq ielm-error-type "IELM Error")
-                       (setq ielm-result "Quit during pretty-printing"))))
-          (if ielm-error-type
-              (progn
-                (if ielm-noisy (ding))
-                (setq ielm-output (concat ielm-output "*** " ielm-error-type " ***  "))
-                (setq ielm-output (concat ielm-output ielm-result)))
-            ;; There was no error, so shift the *** values
-            (setq *** **)
-            (setq ** *)
-            (setq * ielm-result))
-          (setq ielm-output (concat ielm-output "\n"))))
+    (unless (ielm-is-whitespace-or-comment ielm-string)
+      (condition-case err
+          (let ((rout (read-from-string ielm-string)))
+            (setq ielm-form (car rout)
+                  ielm-pos (cdr rout)))
+        (error (setq ielm-result (error-message-string err))
+               (setq ielm-error-type "Read error")))
+      (unless ielm-error-type
+        ;; Make sure working buffer has not been killed
+        (if (not (buffer-name ielm-working-buffer))
+            (setq ielm-result "Working buffer has been killed"
+                  ielm-error-type "IELM Error"
+                  ielm-wbuf (current-buffer))
+          (if (ielm-is-whitespace-or-comment (substring ielm-string ielm-pos))
+              ;; To correctly handle the ielm-local variables *,
+              ;; ** and ***, we need a temporary buffer to be
+              ;; current at entry to the inner of the next two let
+              ;; forms.  We need another temporary buffer to exit
+              ;; that same let.  To avoid problems, neither of
+              ;; these buffers should be alive during the
+              ;; evaluation of ielm-form.
+              (let ((*1 *)
+                    (*2 **)
+                    (*3 ***)
+                    ielm-temp-buffer)
+                (set-match-data ielm-match-data)
+                (save-excursion
+                  (with-temp-buffer
+                    (condition-case err
+                        (unwind-protect
+                             ;; The next let form creates default
+                             ;; bindings for *, ** and ***.  But
+                             ;; these default bindings are
+                             ;; identical to the ielm-local
+                             ;; bindings.  Hence, during the
+                             ;; evaluation of ielm-form, the
+                             ;; ielm-local values are going to be
+                             ;; used in all buffers except for
+                             ;; other ielm buffers, which override
+                             ;; them.  Normally, the variables *1,
+                             ;; *2 and *3 also have default
+                             ;; bindings, which are not overridden.
+                             (let ((* *1)
+                                   (** *2)
+                                   (*** *3))
+                               (kill-buffer (current-buffer))
+                               (set-buffer ielm-wbuf)
+                               (setq ielm-result (eval ielm-form))
+                               (setq ielm-wbuf (current-buffer))
+                               (setq
+                                ielm-temp-buffer
+                                (generate-new-buffer " *ielm-temp*"))
+                               (set-buffer ielm-temp-buffer))
+                          (when ielm-temp-buffer
+                            (kill-buffer ielm-temp-buffer)))
+                      (error (setq ielm-result (error-message-string err))
+                             (setq ielm-error-type "Eval error"))
+                      (quit (setq ielm-result "Quit during evaluation")
+                            (setq ielm-error-type "Eval error")))))
+                (setq ielm-match-data (match-data)))
+            (setq ielm-error-type "IELM error")
+            (setq ielm-result "More than one sexp in input"))))
+
+      ;; If the eval changed the current buffer, mention it here
+      (when (eq ielm-wbuf ielm-working-buffer)
+        (message "current buffer is now: %s" ielm-wbuf)
+        (setq ielm-working-buffer ielm-wbuf))
+
+      (goto-char ielm-pmark)
+      (unless ielm-error-type
+        (condition-case err
+            ;; Self-referential objects cause loops in the printer, so
+            ;; trap quits here. May as well do errors, too
+            (setq ielm-output (concat ielm-output (pp-to-string ielm-result)))
+          (error (setq ielm-error-type "IELM Error")
+                 (setq ielm-result "Error during pretty-printing (bug in pp)"))
+          (quit  (setq ielm-error-type "IELM Error")
+                 (setq ielm-result "Quit during pretty-printing"))))
+      (if ielm-error-type
+          (progn
+            (when ielm-noisy (ding))
+            (setq ielm-output (concat ielm-output "*** " ielm-error-type " ***  "))
+            (setq ielm-output (concat ielm-output ielm-result)))
+        ;; There was no error, so shift the *** values
+        (setq *** **)
+        (setq ** *)
+        (setq * ielm-result))
+      (setq ielm-output (concat ielm-output "\n")))
     (setq ielm-output (concat ielm-output ielm-prompt-internal))
     (comint-output-filter (ielm-process) ielm-output)))
 
@@ -436,9 +432,7 @@ simply inserts a newline."
 
 ;;; Major mode
 
-(put 'inferior-emacs-lisp-mode 'mode-class 'special)
-
-(defun inferior-emacs-lisp-mode nil
+(define-derived-mode inferior-emacs-lisp-mode comint-mode "IELM"
   "Major mode for interactively evaluating Emacs Lisp expressions.
 Uses the interface provided by `comint-mode' (which see).
 
@@ -453,12 +447,12 @@ Uses the interface provided by `comint-mode' (which see).
 * \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
   or indents the line if there is nothing to complete.
 
-The current working buffer may be changed (with a call to
-`set-buffer', or with \\[ielm-change-working-buffer]), and its value
-is preserved between successive evaluations.  In this way, expressions
-may be evaluated in a different buffer than the *ielm* buffer.
-By default, its name is shown on the mode line; you can always display
-it with \\[ielm-print-working-buffer], or the buffer itself with \\[ielm-display-working-buffer].
+The current working buffer may be changed (with a call to `set-buffer',
+or with \\[ielm-change-working-buffer]), and its value is preserved between successive
+evaluations.  In this way, expressions may be evaluated in a different
+buffer than the *ielm* buffer.  By default, its name is shown on the
+mode line; you can always display it with \\[ielm-print-working-buffer], or the buffer itself
+with \\[ielm-display-working-buffer].
 
 During evaluations, the values of the variables `*', `**', and `***'
 are the results of the previous, second previous and third previous
@@ -480,49 +474,35 @@ The behavior of IELM may be customized with the following variables:
 
 Customized bindings may be defined in `ielm-map', which currently contains:
 \\{ielm-map}"
-  (interactive)
-  (delay-mode-hooks
-   (comint-mode))
+  :syntax-table emacs-lisp-mode-syntax-table
+
   (setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
   (set (make-local-variable 'paragraph-separate) "\\'")
-  (make-local-variable 'paragraph-start)
-  (setq paragraph-start comint-prompt-regexp)
+  (set (make-local-variable 'paragraph-start) comint-prompt-regexp)
   (setq comint-input-sender 'ielm-input-sender)
   (setq comint-process-echoes nil)
-  (make-local-variable 'comint-dynamic-complete-functions)
+  (set (make-local-variable 'comint-dynamic-complete-functions)
+       '(ielm-tab comint-replace-by-expanded-history
+         ielm-complete-filename ielm-complete-symbol))
   (set (make-local-variable 'ielm-prompt-internal) ielm-prompt)
   (set (make-local-variable 'comint-prompt-read-only) ielm-prompt-read-only)
-  (setq comint-dynamic-complete-functions
-        '(ielm-tab comint-replace-by-expanded-history ielm-complete-filename ielm-complete-symbol))
   (setq comint-get-old-input 'ielm-get-old-input)
-  (make-local-variable 'comint-completion-addsuffix)
-  (setq comint-completion-addsuffix '("/" . ""))
-  (setq major-mode 'inferior-emacs-lisp-mode)
-  (setq mode-name "IELM")
+  (set (make-local-variable 'comint-completion-addsuffix) '("/" . ""))
   (setq mode-line-process '(":%s on " (:eval (buffer-name ielm-working-buffer))))
-  (use-local-map ielm-map)
-  (set-syntax-table emacs-lisp-mode-syntax-table)
 
-  (make-local-variable 'indent-line-function)
-  (make-local-variable 'ielm-working-buffer)
-  (setq ielm-working-buffer (current-buffer))
-  (setq indent-line-function 'ielm-indent-line)
-  (make-local-variable 'fill-paragraph-function)
-  (setq fill-paragraph-function 'lisp-fill-paragraph)
+  (set (make-local-variable 'indent-line-function) 'ielm-indent-line)
+  (set (make-local-variable 'ielm-working-buffer) (current-buffer))
+  (set (make-local-variable 'fill-paragraph-function) 'lisp-fill-paragraph)
 
   ;; Value holders
-  (make-local-variable '*)
-  (setq * nil)
-  (make-local-variable '**)
-  (setq ** nil)
-  (make-local-variable '***)
-  (setq *** nil)
+  (set (make-local-variable '*) nil)
+  (set (make-local-variable '**) nil)
+  (set (make-local-variable '***) nil)
   (set (make-local-variable 'ielm-match-data) nil)
 
   ;; font-lock support
-  (make-local-variable 'font-lock-defaults)
-  (setq font-lock-defaults
-        '(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
+  (set (make-local-variable 'font-lock-defaults)
+       '(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
 
   ;; A dummy process to keep comint happy. It will never get any input
   (unless (comint-check-proc (current-buffer))
@@ -548,15 +528,13 @@ Customized bindings may be defined in `ielm-map', which currently contains:
          '(rear-nonsticky t field output inhibit-line-move-field-capture t))))
     (comint-output-filter (ielm-process) ielm-prompt-internal)
     (set-marker comint-last-input-start (ielm-pm))
-    (set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter))
-
-  (run-mode-hooks 'ielm-mode-hook))
+    (set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter)))
 
 (defun ielm-get-old-input nil
   ;; Return the previous input surrounding point
   (save-excursion
     (beginning-of-line)
-    (if (looking-at comint-prompt-regexp) nil
+    (unless (looking-at-p comint-prompt-regexp)
       (re-search-backward comint-prompt-regexp))
     (comint-skip-prompt)
     (buffer-substring (point) (progn (forward-sexp 1) (point)))))