Mercurial > emacs

--- a/lisp/ChangeLog	Sun Nov 16 04:44:42 2008 +0000
+++ b/lisp/ChangeLog	Sun Nov 16 04:54:05 2008 +0000
@@ -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>
--- a/lisp/ielm.el	Sun Nov 16 04:44:42 2008 +0000
+++ b/lisp/ielm.el	Sun Nov 16 04:54:05 2008 +0000
@@ -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
-  ;; 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 @@

 (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 @@
 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 @@
 				   (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 @@

 (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 @@
 	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"))))
+    (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
-	  (if (eq ielm-wbuf ielm-working-buffer) nil
-	    (message "current buffer is now: %s" ielm-wbuf)
-	    (setq ielm-working-buffer ielm-wbuf))
+      ;; 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)
-	  (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"))))
+      (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 @@

 ;;; 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,49 +474,35 @@

 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 @@
          '(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)))))