(defcustom ielm-noisy t
- "*If non-nil, IELM will beep on error."
+ "If non-nil, IELM will beep on error."
:type 'boolean
:group 'ielm)
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
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
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
: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.")
"*** 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."
(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."
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
(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)))
(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
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)))
;;; 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).
* \\[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
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))
'(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)))))
projects / emacs.git / commitdiff