;; along with GNU Emacs; see the file COPYING. If not, write to
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-;;; Code:
-
;;; Commentary:
;; The base major mode for editing Lisp code (used also for Emacs Lisp).
(modify-syntax-entry ? " " emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?\t " " emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?\n "> " emacs-lisp-mode-syntax-table)
- (modify-syntax-entry ?\f "> " 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)
(setq indent-region-function 'lisp-indent-region)
(make-local-variable 'parse-sexp-ignore-comments)
(setq parse-sexp-ignore-comments t)
+ (make-local-variable 'outline-regexp)
+ (setq outline-regexp ";;; \\|(....")
(make-local-variable 'comment-start)
(setq comment-start ";")
(make-local-variable 'comment-start-skip)
()
(setq lisp-mode-map
(nconc (make-sparse-keymap) shared-lisp-mode-map))
- (define-key lisp-mode-map "\e\C-x" 'lisp-send-defun)
- (define-key lisp-mode-map "\C-c\C-l" 'run-lisp))
+ (define-key lisp-mode-map "\e\C-x" 'lisp-eval-defun)
+ (define-key lisp-mode-map "\C-c\C-z" 'run-lisp))
(defun lisp-mode ()
"Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
(run-hooks 'lisp-mode-hook))
;; This will do unless shell.el is loaded.
-(defun lisp-send-defun nil
+(defun lisp-eval-defun nil
"Send the current defun to the Lisp process made by \\[run-lisp]."
(interactive)
(error "Process lisp does not exist"))
(> end beg))
(indent-code-rigidly beg end shift-amt)))))
+(defvar calculate-lisp-indent-last-sexp)
+
(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.
;; setting this to a number inhibits calling hook
(desired-indent nil)
(retry t)
- last-sexp containing-sexp)
+ calculate-lisp-indent-last-sexp containing-sexp)
(if parse-start
(goto-char parse-start)
(beginning-of-defun))
state
(> (setq paren-depth (elt state 0)) 0))
(setq retry nil)
- (setq last-sexp (elt state 2))
+ (setq calculate-lisp-indent-last-sexp (elt state 2))
(setq containing-sexp (elt state 1))
;; Position following last unclosed open.
(goto-char (1+ containing-sexp))
;; Is there a complete sexp since then?
- (if (and last-sexp (> last-sexp (point)))
+ (if (and calculate-lisp-indent-last-sexp
+ (> calculate-lisp-indent-last-sexp (point)))
;; Yes, but is there a containing sexp after that?
- (let ((peek (parse-partial-sexp last-sexp indent-point 0)))
+ (let ((peek (parse-partial-sexp calculate-lisp-indent-last-sexp
+ indent-point 0)))
(if (setq retry (car (cdr peek))) (setq state peek)))))
(if retry
nil
;; Innermost containing sexp found
(goto-char (1+ containing-sexp))
- (if (not last-sexp)
+ (if (not calculate-lisp-indent-last-sexp)
;; indent-point immediately follows open paren.
;; Don't call hook.
(setq desired-indent (current-column))
;; Find the start of first element of containing sexp.
- (parse-partial-sexp (point) last-sexp 0 t)
+ (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t)
(cond ((looking-at "\\s(")
;; First element of containing sexp is a list.
;; Indent under that list.
)
((> (save-excursion (forward-line 1) (point))
- last-sexp)
+ calculate-lisp-indent-last-sexp)
;; This is the first line to start within the containing sexp.
;; It's almost certainly a function call.
- (if (= (point) last-sexp)
+ (if (= (point) calculate-lisp-indent-last-sexp)
;; Containing sexp has nothing before this line
;; except the first element. Indent under that element.
nil
;; Skip the first element, find start of second (the first
;; argument of the function call) and indent under.
(progn (forward-sexp 1)
- (parse-partial-sexp (point) last-sexp 0 t)))
+ (parse-partial-sexp (point)
+ calculate-lisp-indent-last-sexp
+ 0 t)))
(backward-prefix-chars))
(t
- ;; Indent beneath first sexp on same line as last-sexp.
- ;; Again, it's almost certainly a function call.
- (goto-char last-sexp)
+ ;; Indent beneath first sexp on same line as
+ ;; calculate-lisp-indent-last-sexp. Again, it's
+ ;; almost certainly a function call.
+ (goto-char calculate-lisp-indent-last-sexp)
(beginning-of-line)
- (parse-partial-sexp (point) last-sexp 0 t)
+ (parse-partial-sexp (point) calculate-lisp-indent-last-sexp
+ 0 t)
(backward-prefix-chars)))))
;; Point is at the point to indent under unless we are inside a string.
- ;; Call indentation hook except when overriden by lisp-indent-offset
+ ;; Call indentation hook except when overridden by lisp-indent-offset
;; or if the desired indentation has already been computed.
(let ((normal-indent (current-column)))
(cond ((elt state 3)
(defun lisp-indent-function (indent-point state)
(let ((normal-indent (current-column)))
(goto-char (1+ (elt state 1)))
- (parse-partial-sexp (point) last-sexp 0 t)
+ (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t)
(if (and (elt state 2)
(not (looking-at "\\sw\\|\\s_")))
;; car of form doesn't seem to be a a symbol
(progn
(if (not (> (save-excursion (forward-line 1) (point))
- last-sexp))
- (progn (goto-char last-sexp)
+ calculate-lisp-indent-last-sexp))
+ (progn (goto-char calculate-lisp-indent-last-sexp)
(beginning-of-line)
- (parse-partial-sexp (point) last-sexp 0 t)))
- ;; Indent under the list or under the first sexp on the
- ;; same line as last-sexp. Note that first thing on that
- ;; line has to be complete sexp since we are inside the
- ;; innermost containing sexp.
+ (parse-partial-sexp (point)
+ calculate-lisp-indent-last-sexp 0 t)))
+ ;; Indent under the list or under the first sexp on the same
+ ;; line as calculate-lisp-indent-last-sexp. Note that first
+ ;; thing on that line has to be complete sexp since we are
+ ;; inside the innermost containing sexp.
(backward-prefix-chars)
(current-column))
(let ((function (buffer-substring (point)
(progn (forward-sexp 1) (point))))
method)
- (setq method (get (intern-soft function) 'lisp-indent-function))
+ (setq method (or (get (intern-soft function) 'lisp-indent-function)
+ (get (intern-soft function) 'lisp-indent-hook)))
(cond ((or (eq method 'defun)
(and (null method)
(> (length function) 3)
(method
(funcall method state indent-point)))))))
-(defconst lisp-body-indent 2 "")
+(defconst 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)
(let ((containing-form-start (elt state 1))
(interactive)
(let ((indent-stack (list nil))
(next-depth 0)
- (starting-point (point))
+ ;; If ENDPOS is non-nil, use nil as STARTING-POINT
+ ;; so that calculate-lisp-indent will find the beginning of
+ ;; the defun we are in.
+ ;; If ENDPOS is nil, it is safe not to scan before point
+ ;; since every line we indent is more deeply nested than point is.
+ (starting-point (if endpos nil (point)))
(last-point (point))
last-depth bol outer-loop-done inner-loop-done state this-indent)
- ;; Get error now if we don't have a complete sexp after point.
- (save-excursion (forward-sexp 1))
+ (or endpos
+ ;; Get error now if we don't have a complete sexp after point.
+ (save-excursion (forward-sexp 1)))
(save-excursion
(setq outer-loop-done nil)
(while (if endpos (< (point) endpos)
(make-list (- next-depth) nil))
last-depth (- last-depth next-depth)
next-depth 0)))
- (or outer-loop-done
+ (or outer-loop-done endpos
(setq outer-loop-done (<= next-depth 0)))
(if outer-loop-done
- nil
+ (forward-line 1)
(while (> last-depth next-depth)
(setq indent-stack (cdr indent-stack)
last-depth (1- last-depth)))
;; Indent every line whose first char is between START and END inclusive.
(defun lisp-indent-region (start end)
(save-excursion
- (goto-char start)
- (and (bolp) (not (eolp))
- (lisp-indent-line))
(let ((endmark (copy-marker end)))
+ (goto-char start)
+ (and (bolp) (not (eolp))
+ (lisp-indent-line))
(indent-sexp endmark)
(set-marker endmark nil))))
\f