[Emacs-diffs] Changes to emacs/lisp/ielm.el,v

[Juanma Barranquero]

CVSROOT:        /cvsroot/emacs
Module name:    emacs
Changes by:     Juanma Barranquero <lektu>      08/11/16 04:54:09

Index: ielm.el
===================================================================
RCS file: /cvsroot/emacs/emacs/lisp/ielm.el,v
retrieving revision 1.62
retrieving revision 1.63
diff -u -b -r1.62 -r1.63
--- ielm.el     6 May 2008 07:57:39 -0000       1.62
+++ ielm.el     16 Nov 2008 04:54:09 -0000      1.63
@@ -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 @@
 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 @@
 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 @@
 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 @@
   :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 @@
   "*** 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
+(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 ielm-map "\e\C-q" 'indent-sexp)
-  (define-key ielm-map "\177" 'backward-delete-char-untabify)
+    (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 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))
+    (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
+  (when (or (eq (preceding-char) ?\n)
+           (eq (char-syntax (preceding-char)) ?\s))
        (ielm-indent-line)
-       t)))
+    t))
 
 (defun ielm-complete-symbol nil
   "Complete the Lisp symbol before point."
@@ -224,7 +220,7 @@
 
 (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)))
+  (when (nth 3 (parse-partial-sexp comint-last-input-start (point)))
       (comint-dynamic-complete-filename)))
 
 (defun ielm-indent-line nil
@@ -253,7 +249,10 @@
 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,10 +271,10 @@
                                   (point)))))
        (if (and (< (car state) 1) (not (nth 3 state)))
            (ielm-send-input)
-         (if (and ielm-dynamic-multiline-inputs
+         (when (and ielm-dynamic-multiline-inputs
                   (save-excursion
                     (beginning-of-line)
-                    (looking-at comint-prompt-regexp)))
+                      (looking-at-p comint-prompt-regexp)))
              (save-excursion
                (goto-char (ielm-pm))
                (newline 1)))
@@ -301,7 +300,7 @@
 (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)))
+      (string-match-p "\\`[ \t\n]*\\(?:;.*\\)*\\'" string)))
 
 ;;; Evaluation
 
@@ -326,23 +325,20 @@
        (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
+    (unless (ielm-is-whitespace-or-comment ielm-string)
          (condition-case err
-             (let (rout)
-               (setq rout (read-from-string ielm-string))
-               (setq ielm-form (car rout))
-               (setq ielm-pos (cdr rout)))
+         (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")))
-         (if ielm-error-type nil
+      (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))
+         (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
@@ -393,12 +389,12 @@
                (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
+      (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)
-         (if (not ielm-error-type)
+      (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
@@ -409,14 +405,14 @@
                       (setq ielm-result "Quit during pretty-printing"))))
          (if ielm-error-type
              (progn
-               (if ielm-noisy (ding))
+           (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 "\n")))
     (setq ielm-output (concat ielm-output ielm-prompt-internal))
     (comint-output-filter (ielm-process) ielm-output)))
 
@@ -436,9 +432,7 @@
 
 ;;; 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 @@
 * \\[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,48 +474,34 @@
 
 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
+  (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
@@ -548,15 +528,13 @@
          '(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)))))