(completion-setup-function):

[gnu-emacs] / lisp / ielm.el

diff --git a/lisp/ielm.el b/lisp/ielm.el
index d577b888147dee92f35453bb048c48ac88bd0fd7..ad7565f22635e26e858a37ff117dda69499350e0 100644 (file)
--- a/lisp/ielm.el
+++ b/lisp/ielm.el
@@ -1,7 +1,7 @@
 ;;; ielm.el --- interaction mode for Emacs Lisp
 
 ;; Copyright (C) 1994, 2001, 2002, 2003, 2004, 2005,
 ;;; ielm.el --- interaction mode for Emacs Lisp
 
 ;; Copyright (C) 1994, 2001, 2002, 2003, 2004, 2005,

-;;   2006, 2007, 2008 Free Software Foundation, Inc.
+;;   2006, 2007, 2008, 2009 Free Software Foundation, Inc.

 
 ;; Author: David Smith <maa036@lancaster.ac.uk>
 ;; Maintainer: FSF
 
 ;; Author: David Smith <maa036@lancaster.ac.uk>
 ;; Maintainer: FSF


@@ -44,7 +44,7 @@
 
 
 (defcustom ielm-noisy t
 
 
 (defcustom ielm-noisy t

-  "*If non-nil, IELM will beep on error."
+  "If non-nil, IELM will beep on error."

   :type 'boolean
   :group 'ielm)
 
   :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
 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
 `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
 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
 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
 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
 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
 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
   :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)
   :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.")
 
 (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.")
 
   "*** 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)))
 
 (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)
 
 ;;; 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."
 
 (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."
 
 (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."
 
 (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: ")
 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
   (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)
                                   (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)))
 
          (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."
 
 (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
 
 
 ;;; 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-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)))
        (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
+      (unless (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)))
 
     (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
 
 
 ;;; 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).
 
   "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.
 
 * \\[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
 
 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}"
 
 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) "\\'")
   (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)
   (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)
   (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)
   (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))))
   (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
 
   ;; 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
   (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))
 
   ;; 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))
          '(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)
 
 (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)))))
       (re-search-backward comint-prompt-regexp))
     (comint-skip-prompt)
     (buffer-substring (point) (progn (forward-sexp 1) (point)))))