;;; lisp-mode.el --- Lisp mode, and its idiosyncratic commands.
-;; Copyright (C) 1985 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1986, 1999 Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: lisp, languages
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
(setq i (1+ i)))
(modify-syntax-entry ? " " emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?\t " " emacs-lisp-mode-syntax-table)
+ (modify-syntax-entry ?\f " " emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?\n "> " emacs-lisp-mode-syntax-table)
;; Give CR the same syntax as newline, for selective-display.
(modify-syntax-entry ?\^m "> " emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?\( "() " emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?\) ")( " emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?\[ "(] " emacs-lisp-mode-syntax-table)
- (modify-syntax-entry ?\] ")[ " emacs-lisp-mode-syntax-table)))
+ (modify-syntax-entry ?\] ")[ " emacs-lisp-mode-syntax-table)
+ ;; All non-word multibyte characters should be `symbol'.
+ (map-char-table
+ (function (lambda (key val)
+ (and (>= key 256)
+ (/= (char-syntax key) ?w)
+ (modify-syntax-entry key "_ "
+ emacs-lisp-mode-syntax-table))))
+ (standard-syntax-table))))
(if (not lisp-mode-syntax-table)
(progn (setq lisp-mode-syntax-table
(define-abbrev-table 'lisp-mode-abbrev-table ())
+(defvar lisp-imenu-generic-expression
+ '(
+ (nil
+ "^\\s-*(def\\(un\\|subst\\|macro\\|advice\\|ine-skeleton\\)\
+\\s-+\\([-A-Za-z0-9+*|:/]+\\)" 2)
+ ("Variables"
+ "^\\s-*(def\\(var\\|const\\|custom\\)\\s-+\\([-A-Za-z0-9+*|:/]+\\)" 2)
+ ("Types"
+ "^\\s-*(def\\(group\\|type\\|struct\\|class\\|ine-condition\
+\\|ine-widget\\)\\s-+'?\\([-A-Za-z0-9+*|:/]+\\)"
+ 2))
+
+ "Imenu generic expression for Lisp mode. See `imenu-generic-expression'.")
+
(defun lisp-mode-variables (lisp-syntax)
(cond (lisp-syntax
(set-syntax-table lisp-mode-syntax-table)))
(setq local-abbrev-table lisp-mode-abbrev-table)
(make-local-variable 'paragraph-start)
- (setq paragraph-start (concat "^$\\|" page-delimiter))
+ (setq paragraph-start (concat page-delimiter "\\|$" ))
(make-local-variable 'paragraph-separate)
(setq paragraph-separate paragraph-start)
(make-local-variable 'paragraph-ignore-fill-prefix)
(setq paragraph-ignore-fill-prefix t)
(make-local-variable 'fill-paragraph-function)
(setq fill-paragraph-function 'lisp-fill-paragraph)
+ ;; Adaptive fill mode gets in the way of auto-fill,
+ ;; and should make no difference for explicit fill
+ ;; because lisp-fill-paragraph should do the job.
+ (make-local-variable 'adaptive-fill-mode)
+ (setq adaptive-fill-mode nil)
+ (make-local-variable 'normal-auto-fill-function)
+ (setq normal-auto-fill-function 'lisp-mode-auto-fill)
(make-local-variable 'indent-line-function)
(setq indent-line-function 'lisp-indent-line)
(make-local-variable 'indent-region-function)
(make-local-variable 'comment-start)
(setq comment-start ";")
(make-local-variable 'comment-start-skip)
- (setq comment-start-skip ";+ *")
+ ;; Look within the line for a ; following an even number of backslashes
+ ;; after either a non-backslash or the line beginning.
+ (setq comment-start-skip "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\);+ *")
(make-local-variable 'comment-column)
(setq comment-column 40)
(make-local-variable 'comment-indent-function)
- (setq comment-indent-function 'lisp-comment-indent))
+ (setq comment-indent-function 'lisp-comment-indent)
+ (make-local-variable 'imenu-generic-expression)
+ (setq imenu-generic-expression lisp-imenu-generic-expression))
\f
(defvar shared-lisp-mode-map ()
"Keymap for commands shared by all sorts of Lisp modes.")
()
(setq shared-lisp-mode-map (make-sparse-keymap))
(define-key shared-lisp-mode-map "\e\C-q" 'indent-sexp)
- (define-key shared-lisp-mode-map "\177" 'backward-delete-char-untabify)
- (define-key shared-lisp-mode-map "\t" 'lisp-indent-line))
+ (define-key shared-lisp-mode-map "\177" 'backward-delete-char-untabify))
(defvar emacs-lisp-mode-map ()
"Keymap for Emacs Lisp mode.
-All commands in shared-lisp-mode-map are inherited by this map.")
+All commands in `shared-lisp-mode-map' are inherited by this map.")
(if emacs-lisp-mode-map
()
(let ((map (make-sparse-keymap "Emacs-Lisp")))
- (setq emacs-lisp-mode-map
- (nconc (make-sparse-keymap) shared-lisp-mode-map))
+ (setq emacs-lisp-mode-map (make-sparse-keymap))
+ (set-keymap-parent emacs-lisp-mode-map shared-lisp-mode-map)
(define-key emacs-lisp-mode-map "\e\t" 'lisp-complete-symbol)
(define-key emacs-lisp-mode-map "\e\C-x" 'eval-defun)
(define-key emacs-lisp-mode-map [menu-bar] (make-sparse-keymap))
'("Instrument Function for Debugging" . edebug-defun))
(define-key map [byte-recompile]
'("Byte-recompile Directory..." . byte-recompile-directory))
+ (define-key map [emacs-byte-compile-and-load]
+ '("Byte-compile And Load" . emacs-lisp-byte-compile-and-load))
(define-key map [byte-compile]
'("Byte-compile This File" . emacs-lisp-byte-compile))
(define-key map [separator-eval] '("--"))
(interactive)
(if buffer-file-name
(byte-compile-file buffer-file-name)
- (error "The buffer must be saved in a file first.")))
+ (error "The buffer must be saved in a file first")))
+
+(defun emacs-lisp-byte-compile-and-load ()
+ "Byte-compile the current file (if it has changed), then load compiled code."
+ (interactive)
+ (or buffer-file-name
+ (error "The buffer must be saved in a file first"))
+ (require 'bytecomp)
+ ;; Recompile if file or buffer has changed since last compilation.
+ (if (and (buffer-modified-p)
+ (y-or-n-p (format "save buffer %s first? " (buffer-name))))
+ (save-buffer))
+ (let ((compiled-file-name (byte-compile-dest-file buffer-file-name)))
+ (if (file-newer-than-file-p compiled-file-name buffer-file-name)
+ (load-file compiled-file-name)
+ (byte-compile-file buffer-file-name t))))
+
+(defcustom emacs-lisp-mode-hook nil
+ "Hook run when entering Emacs Lisp mode."
+ :options '(turn-on-eldoc-mode imenu-add-menubar-index)
+ :type 'hook
+ :group 'lisp)
+
+(defcustom lisp-mode-hook nil
+ "Hook run when entering Lisp mode."
+ :options '(imenu-add-menubar-index)
+ :type 'hook
+ :group 'lisp)
+
+(defcustom lisp-interaction-mode-hook nil
+ "Hook run when entering Lisp Interaction mode."
+ :options '(turn-on-eldoc-mode)
+ :type 'hook
+ :group 'lisp)
(defun emacs-lisp-mode ()
"Major mode for editing Lisp code to run in Emacs.
(setq major-mode 'emacs-lisp-mode)
(setq mode-name "Emacs-Lisp")
(lisp-mode-variables nil)
+ (setq imenu-case-fold-search nil)
(run-hooks 'emacs-lisp-mode-hook))
(defvar lisp-mode-map ()
(if lisp-mode-map
()
- (setq lisp-mode-map
- (nconc (make-sparse-keymap) shared-lisp-mode-map))
+ (setq lisp-mode-map (make-sparse-keymap))
+ (set-keymap-parent lisp-mode-map shared-lisp-mode-map)
(define-key lisp-mode-map "\e\C-x" 'lisp-eval-defun)
(define-key lisp-mode-map "\C-c\C-z" 'run-lisp))
(setq major-mode 'lisp-mode)
(setq mode-name "Lisp")
(lisp-mode-variables t)
+ (setq imenu-case-fold-search t)
(set-syntax-table lisp-mode-syntax-table)
(run-hooks 'lisp-mode-hook))
(error "Process lisp does not exist"))
(defvar lisp-interaction-mode-map ()
- "Keymap for Lisp Interaction moe.
+ "Keymap for Lisp Interaction mode.
All commands in `shared-lisp-mode-map' are inherited by this map.")
(if lisp-interaction-mode-map
()
- (setq lisp-interaction-mode-map
- (nconc (make-sparse-keymap) shared-lisp-mode-map))
+ (setq lisp-interaction-mode-map (make-sparse-keymap))
+ (set-keymap-parent lisp-interaction-mode-map shared-lisp-mode-map)
(define-key lisp-interaction-mode-map "\e\C-x" 'eval-defun)
(define-key lisp-interaction-mode-map "\e\t" 'lisp-complete-symbol)
(define-key lisp-interaction-mode-map "\n" 'eval-print-last-sexp))
With argument, print output into current buffer."
(interactive "P")
(let ((standard-output (if eval-last-sexp-arg-internal (current-buffer) t))
- (opoint (point)))
- (prin1 (let ((stab (syntax-table)))
- (eval (unwind-protect
+ (debug-on-error eval-expression-debug-on-error))
+ (let ((value
+ (eval (let ((stab (syntax-table))
+ (opoint (point))
+ ignore-quotes
+ expr)
+ (unwind-protect
(save-excursion
(set-syntax-table emacs-lisp-mode-syntax-table)
+ ;; If this sexp appears to be enclosed in `...'
+ ;; then ignore the surrounding quotes.
+ (setq ignore-quotes
+ (or (eq (following-char) ?\')
+ (eq (preceding-char) ?\')))
(forward-sexp -1)
+ ;; If we were after `?\e' (or similar case),
+ ;; use the whole thing, not just the `e'.
+ (when (eq (preceding-char) ?\\)
+ (forward-char -1)
+ (when (eq (preceding-char) ??)
+ (forward-char -1)))
(save-restriction
+ ;; vladimir@cs.ualberta.ca 30-Jul-1997: skip ` in
+ ;; `variable' so that the value is returned, not the
+ ;; name
+ (if (and ignore-quotes
+ (eq (following-char) ?`))
+ (forward-char))
(narrow-to-region (point-min) opoint)
- (read (current-buffer))))
- (set-syntax-table stab)))))))
+ (setq expr (read (current-buffer)))
+ ;; If it's an (interactive ...) form, it's more
+ ;; useful to show how an interactive call would
+ ;; use it.
+ (and (consp expr)
+ (eq (car expr) 'interactive)
+ (setq expr
+ (list 'call-interactively
+ (list 'quote
+ (list 'lambda
+ '(&rest args)
+ expr
+ 'args)))))
+ expr))
+ (set-syntax-table stab))))))
+ (let ((print-length eval-expression-print-length)
+ (print-level eval-expression-print-level))
+ (prin1 value)))))
+
+;; Change defvar into defconst within FORM,
+;; and likewise for other constructs as necessary.
+(defun eval-defun-1 (form)
+ (cond ((and (eq (car form) 'defvar)
+ (cdr-safe (cdr-safe form)))
+ ;; Force variable to be bound.
+ (cons 'defconst (cdr form)))
+ ((and (eq (car form) 'defcustom)
+ (default-boundp (nth 1 form)))
+ ;; Force variable to be bound.
+ (set-default (nth 1 form) (eval (nth 2 form)))
+ form)
+ ((eq (car form) 'progn)
+ (cons 'progn (mapcar 'eval-defun-1 (cdr form))))
+ (t form)))
(defun eval-defun (eval-defun-arg-internal)
"Evaluate defun that point is in or before.
-Print value in minibuffer.
-With argument, insert value in current buffer after the defun."
+The value is displayed in the minibuffer.
+If the current defun is actually a call to `defvar',
+then reset the variable using the initial value expression
+even if the variable already has some other value.
+\(Normally `defvar' does not change the variable's value
+if it already has a value.\)
+
+With argument, insert value in current buffer after the defun.
+Return the result of evaluation."
(interactive "P")
- (let ((standard-output (if eval-defun-arg-internal (current-buffer) t))
- (form (save-excursion
- (end-of-defun)
- (beginning-of-defun)
- (read (current-buffer)))))
- (if (and (eq (car form) 'defvar)
- (cdr-safe (cdr-safe form)))
- (setq form (cons 'defconst (cdr form))))
- (prin1 (eval form))))
+ (let ((debug-on-error eval-expression-debug-on-error)
+ (print-length eval-expression-print-length)
+ (print-level eval-expression-print-level))
+ (save-excursion
+ ;; Arrange for eval-region to "read" the (possibly) altered form.
+ ;; eval-region handles recording which file defines a function or
+ ;; variable. Re-written using `apply' to avoid capturing
+ ;; variables like `end'.
+ (apply
+ #'eval-region
+ (let ((standard-output (if eval-defun-arg-internal (current-buffer) t))
+ beg end form)
+ ;; Read the form from the buffer, and record where it ends.
+ (save-excursion
+ (end-of-defun)
+ (beginning-of-defun)
+ (setq beg (point))
+ (setq form (read (current-buffer)))
+ (setq end (point)))
+ ;; Alter the form if necessary, changing defvar into defconst, etc.
+ (setq form (eval-defun-1 (macroexpand form)))
+ (list beg end standard-output
+ `(lambda (ignore)
+ ;; Skipping to the end of the specified region
+ ;; will make eval-region return.
+ (goto-char ,end)
+ ',form))))))
+ ;; The result of evaluation has been put onto VALUES. So return it.
+ (car values))
\f
(defun lisp-comment-indent ()
(if (looking-at "\\s<\\s<\\s<")
(current-column)
(if (looking-at "\\s<\\s<")
- (let ((tem (calculate-lisp-indent)))
+ (let ((tem (or (calculate-lisp-indent) (current-column))))
(if (listp tem) (car tem) tem))
(skip-chars-backward " \t")
(max (if (bolp) 0 (1+ (current-column)))
comment-column))))
-(defconst lisp-indent-offset nil "")
-(defconst lisp-indent-function 'lisp-indent-function "")
+(defun lisp-mode-auto-fill ()
+ (if (> (current-column) (current-fill-column))
+ (if (save-excursion
+ (nth 4 (parse-partial-sexp (save-excursion
+ (beginning-of-defun)
+ (point))
+ (point))))
+ (do-auto-fill)
+ (let ((comment-start nil) (comment-start-skip nil))
+ (do-auto-fill)))))
+
+(defvar lisp-indent-offset nil "")
+(defvar lisp-indent-function 'lisp-indent-function "")
(defun lisp-indent-line (&optional whole-exp)
"Indent current line as Lisp code.
(beginning-of-line)
(setq beg (point))
(skip-chars-forward " \t")
- (if (looking-at "\\s<\\s<\\s<")
- ;; Don't alter indentation of a ;;; comment line.
+ (if (or (null indent) (looking-at "\\s<\\s<\\s<"))
+ ;; Don't alter indentation of a ;;; comment line
+ ;; or a line that starts in a string.
(goto-char (- (point-max) pos))
(if (and (looking-at "\\s<") (not (looking-at "\\s<\\s<")))
;; Single-semicolon comment lines should be indented
(defun calculate-lisp-indent (&optional parse-start)
"Return appropriate indentation for current line as Lisp code.
In usual case returns an integer: the column to indent to.
-Can instead return a list, whose car is the column to indent to.
+If the value is nil, that means don't change the indentation
+because the line starts inside a string.
+
+The value can also be a list of the form (COLUMN CONTAINING-SEXP-START).
This means that following lines at the same level of indentation
-should not necessarily be indented the same way.
-The second element of the list is the buffer position
-of the start of the containing expression."
+should not necessarily be indented the same as this line.
+Then COLUMN is the column to indent to, and CONTAINING-SEXP-START
+is the buffer position of the start of the containing expression."
(save-excursion
(beginning-of-line)
(let ((indent-point (point))
(let ((normal-indent (current-column)))
(cond ((elt state 3)
;; Inside a string, don't change indentation.
- (goto-char indent-point)
- (skip-chars-forward " \t")
- (current-column))
+ nil)
((and (integerp lisp-indent-offset) containing-sexp)
;; Indent by constant offset
(goto-char containing-sexp)
(method
(funcall method state indent-point)))))))
-(defconst lisp-body-indent 2
+(defvar lisp-body-indent 2
"Number of columns to indent the second line of a `(def...)' form.")
(defun lisp-indent-specform (count state indent-point normal-indent)
(put 'save-selected-window 'lisp-indent-function 0)
(put 'save-restriction 'lisp-indent-function 0)
(put 'save-match-data 'lisp-indent-function 0)
+(put 'save-current-buffer 'lisp-indent-function 0)
+(put 'with-current-buffer 'lisp-indent-function 1)
+(put 'combine-after-change-calls 'lisp-indent-function 0)
+(put 'with-output-to-string 'lisp-indent-function 0)
+(put 'with-temp-file 'lisp-indent-function 1)
+(put 'with-temp-buffer 'lisp-indent-function 0)
+(put 'with-temp-message 'lisp-indent-function 1)
(put 'let 'lisp-indent-function 1)
(put 'let* 'lisp-indent-function 1)
(put 'while 'lisp-indent-function 1)
(put 'condition-case 'lisp-indent-function 2)
(put 'unwind-protect 'lisp-indent-function 1)
(put 'with-output-to-temp-buffer 'lisp-indent-function 1)
+(put 'eval-after-load 'lisp-indent-function 1)
(defun indent-sexp (&optional endpos)
"Indent each line of the list starting just after point.
(let ((val (calculate-lisp-indent
(if (car indent-stack) (- (car indent-stack))
starting-point))))
- (if (integerp val)
- (setcar indent-stack
- (setq this-indent val))
- (setcar indent-stack (- (car (cdr val))))
- (setq this-indent (car val)))))
- (if (/= (current-column) this-indent)
+ (if (null val)
+ (setq this-indent val)
+ (if (integerp val)
+ (setcar indent-stack
+ (setq this-indent val))
+ (setcar indent-stack (- (car (cdr val))))
+ (setq this-indent (car val))))))
+ (if (and this-indent (/= (current-column) this-indent))
(progn (delete-region bol (point))
(indent-to this-indent)))))
(or outer-loop-done
;; Non-nil if the current line contains a comment.
has-comment
+ ;; Non-nil if the current line contains code and a comment.
+ has-code-and-comment
+
;; If has-comment, the appropriate fill-prefix for the comment.
comment-fill-prefix
)
;; A line with some code, followed by a comment? Remember that the
;; semi which starts the comment shouldn't be part of a string or
;; character.
- ((progn
- (while (not (looking-at ";\\|$"))
- (skip-chars-forward "^;\n\"\\\\?")
- (cond
- ((eq (char-after (point)) ?\\) (forward-char 2))
- ((memq (char-after (point)) '(?\" ??)) (forward-sexp 1))))
- (looking-at ";+[\t ]*"))
- (setq has-comment t)
+ ((condition-case nil
+ (save-restriction
+ (narrow-to-region (point-min)
+ (save-excursion (end-of-line) (point)))
+ (while (not (looking-at ";\\|$"))
+ (skip-chars-forward "^;\n\"\\\\?")
+ (cond
+ ((eq (char-after (point)) ?\\) (forward-char 2))
+ ((memq (char-after (point)) '(?\" ??)) (forward-sexp 1))))
+ (looking-at ";+[\t ]*"))
+ (error nil))
+ (setq has-comment t has-code-and-comment t)
(setq comment-fill-prefix
- (concat (make-string (current-column) ? )
+ (concat (make-string (/ (current-column) 8) ?\t)
+ (make-string (% (current-column) 8) ?\ )
(buffer-substring (match-beginning 0) (match-end 0)))))))
(if (not has-comment)
- (fill-paragraph justify)
+ ;; `paragraph-start' is set here (not in the buffer-local
+ ;; variable so that `forward-paragraph' et al work as
+ ;; expected) so that filling (doc) strings works sensibly.
+ ;; Adding the opening paren to avoid the following sexp being
+ ;; filled means that sexps generally aren't filled as normal
+ ;; text, which is probably sensible. The `;' and `:' stop the
+ ;; filled para at following comment lines and keywords
+ ;; (typically in `defcustom').
+ (let ((paragraph-start (concat paragraph-start
+ "\\|\\s-*[\(;:\"]")))
+ (fill-paragraph justify))
;; Narrow to include only the comment, and then fill the region.
- (save-restriction
- (narrow-to-region
- ;; Find the first line we should include in the region to fill.
- (save-excursion
- (while (and (zerop (forward-line -1))
- (looking-at "^[ \t]*;")))
- ;; We may have gone to far. Go forward again.
- (or (looking-at "^[ \t]*;")
- (forward-line 1))
- (point))
- ;; Find the beginning of the first line past the region to fill.
- (save-excursion
- (while (progn (forward-line 1)
+ (save-excursion
+ (save-restriction
+ (beginning-of-line)
+ (narrow-to-region
+ ;; Find the first line we should include in the region to fill.
+ (save-excursion
+ (while (and (zerop (forward-line -1))
(looking-at "^[ \t]*;")))
- (point)))
-
- ;; Lines with only semicolons on them can be paragraph boundaries.
- (let ((paragraph-start (concat paragraph-start "\\|^[ \t;]*$"))
- (paragraph-separate (concat paragraph-start "\\|^[ \t;]*$"))
- (fill-prefix comment-fill-prefix))
- (fill-paragraph justify))))
+ ;; We may have gone too far. Go forward again.
+ (or (looking-at ".*;")
+ (forward-line 1))
+ (point))
+ ;; Find the beginning of the first line past the region to fill.
+ (save-excursion
+ (while (progn (forward-line 1)
+ (looking-at "^[ \t]*;")))
+ (point)))
+
+ ;; Lines with only semicolons on them can be paragraph boundaries.
+ (let* ((paragraph-start (concat paragraph-start "\\|[ \t;]*$"))
+ (paragraph-separate (concat paragraph-start "\\|[ \t;]*$"))
+ (paragraph-ignore-fill-prefix nil)
+ (fill-prefix comment-fill-prefix)
+ (after-line (if has-code-and-comment
+ (save-excursion
+ (forward-line 1) (point))))
+ (end (progn
+ (forward-paragraph)
+ (or (bolp) (newline 1))
+ (point)))
+ ;; If this comment starts on a line with code,
+ ;; include that like in the filling.
+ (beg (progn (backward-paragraph)
+ (if (eq (point) after-line)
+ (forward-line -1))
+ (point))))
+ (fill-region-as-paragraph beg end
+ justify nil
+ (save-excursion
+ (goto-char beg)
+ (if (looking-at fill-prefix)
+ nil
+ (re-search-forward comment-start-skip)
+ (point))))))))
t))
-
\f
(defun indent-code-rigidly (start end arg &optional nochange-regexp)
"Indent all lines of code, starting in the region, sideways by ARG columns.