-;; Lisp mode, and its idiosyncratic commands.
-;; Copyright (C) 1985 Free Software Foundation, Inc.
+;;; lisp-mode.el --- Lisp mode, and its idiosyncratic commands.
+
+;; Copyright (C) 1985, 1986 Free Software Foundation, Inc.
+
+;; Maintainer: FSF
+;; Keywords: lisp, languages
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 1, or (at your option)
+;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; 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:
+
+;; The base major mode for editing Lisp code (used also for Emacs Lisp).
+;; This mode is documented in the Emacs manual
+;;; Code:
(defvar lisp-mode-syntax-table nil "")
(defvar emacs-lisp-mode-syntax-table nil "")
(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)
(modify-syntax-entry ?\[ "(] " emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?\] ")[ " emacs-lisp-mode-syntax-table)))
+(if (not lisp-mode-syntax-table)
+ (progn (setq lisp-mode-syntax-table
+ (copy-syntax-table emacs-lisp-mode-syntax-table))
+ (modify-syntax-entry ?\| "\" " lisp-mode-syntax-table)
+ (modify-syntax-entry ?\[ "_ " lisp-mode-syntax-table)
+ (modify-syntax-entry ?\] "_ " lisp-mode-syntax-table)))
+
(define-abbrev-table 'lisp-mode-abbrev-table ())
+(defvar lisp-imenu-generic-expression
+ '(
+ (nil
+ "^\\s-*(def\\(un\\|subst\\|macro\\|advice\\)\\s-+\\([-A-Za-z0-9+]+\\)" 2)
+ ("Variables"
+ "^\\s-*(def\\(var\\|const\\)\\s-+\\([-A-Za-z0-9+]+\\)" 2)
+ ("Types"
+ "^\\s-*(def\\(type\\|struct\\|class\\|ine-condition\\)\\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
- (if (not lisp-mode-syntax-table)
- (progn (setq lisp-mode-syntax-table
- (copy-syntax-table emacs-lisp-mode-syntax-table))
- (modify-syntax-entry ?\| "\" "
- lisp-mode-syntax-table)
- (modify-syntax-entry ?\[ "_ "
- lisp-mode-syntax-table)
- (modify-syntax-entry ?\] "_ "
- lisp-mode-syntax-table)))
(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 'indent-line-function)
(setq indent-line-function 'lisp-indent-line)
(make-local-variable 'indent-region-function)
(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 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-hook)
- (setq comment-indent-hook 'lisp-comment-indent))
+ (make-local-variable 'comment-indent-function)
+ (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
()
- (setq emacs-lisp-mode-map
- (nconc (make-sparse-keymap) shared-lisp-mode-map))
- (define-key emacs-lisp-mode-map "\e\C-x" 'eval-defun))
+ (let ((map (make-sparse-keymap "Emacs-Lisp")))
+ (setq emacs-lisp-mode-map
+ (nconc (make-sparse-keymap) 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))
+ (define-key emacs-lisp-mode-map [menu-bar emacs-lisp]
+ (cons "Emacs-Lisp" map))
+ (define-key map [edebug-defun]
+ '("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] '("--"))
+ (define-key map [eval-buffer] '("Evaluate Buffer" . eval-current-buffer))
+ (define-key map [eval-region] '("Evaluate Region" . eval-region))
+ (define-key map [eval-sexp] '("Evaluate Last S-expression" . eval-last-sexp))
+ (define-key map [separator-format] '("--"))
+ (define-key map [comment-region] '("Comment Out Region" . comment-region))
+ (define-key map [indent-region] '("Indent Region" . indent-region))
+ (define-key map [indent-line] '("Indent Line" . lisp-indent-line))
+ (put 'eval-region 'menu-enable 'mark-active)
+ (put 'comment-region 'menu-enable 'mark-active)
+ (put 'indent-region 'menu-enable 'mark-active)))
+
+(defun emacs-lisp-byte-compile ()
+ "Byte compile the file containing the current buffer."
+ (interactive)
+ (if buffer-file-name
+ (byte-compile-file buffer-file-name)
+ (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))))
(defun emacs-lisp-mode ()
"Major mode for editing Lisp code to run in Emacs.
()
(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"))
(setq lisp-interaction-mode-map
(nconc (make-sparse-keymap) 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))
(defun lisp-interaction-mode ()
(defun eval-print-last-sexp ()
"Evaluate sexp before point; print value into current buffer."
(interactive)
- (terpri (current-buffer))
- (eval-last-sexp t)
- (terpri (current-buffer)))
+ (let ((standard-output (current-buffer)))
+ (terpri)
+ (eval-last-sexp t)
+ (terpri)))
\f
-(defun eval-last-sexp (arg)
+(defun eval-last-sexp (eval-last-sexp-arg-internal)
"Evaluate sexp before point; print value in minibuffer.
With argument, print output into current buffer."
(interactive "P")
- (let ((standard-output (if arg (current-buffer) t)))
+ (let ((standard-output (if eval-last-sexp-arg-internal (current-buffer) t))
+ (opoint (point)))
(prin1 (let ((stab (syntax-table)))
(eval (unwind-protect
(save-excursion
(set-syntax-table emacs-lisp-mode-syntax-table)
(forward-sexp -1)
- (read (current-buffer)))
+ (save-restriction
+ (narrow-to-region (point-min) opoint)
+ (read (current-buffer))))
(set-syntax-table stab)))))))
-(defun eval-defun (arg)
+(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."
(interactive "P")
- (let ((standard-output (if arg (current-buffer) t)))
- (prin1 (eval (save-excursion
- (end-of-defun)
- (beginning-of-defun)
- (read (current-buffer)))))))
+ (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))))
\f
(defun lisp-comment-indent ()
(if (looking-at "\\s<\\s<\\s<")
(skip-chars-forward " \t")
(if (looking-at "\\s<\\s<\\s<")
;; Don't alter indentation of a ;;; comment line.
- nil
+ (goto-char (- (point-max) pos))
(if (and (looking-at "\\s<") (not (looking-at "\\s<\\s<")))
;; Single-semicolon comment lines should be indented
;; as comment lines, not as code.
(> 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))
(put 'prog2 'lisp-indent-function 2)
(put 'save-excursion 'lisp-indent-function 0)
(put 'save-window-excursion 'lisp-indent-function 0)
+(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 1)
+(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 '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.
If optional arg ENDPOS is given, indent each line, stopping when
ENDPOS is encountered."
(interactive)
- (let ((indent-stack (list nil)) (next-depth 0) last-depth bol
- outer-loop-done inner-loop-done state this-indent
- (last-point (point)))
- ;; Get error now if we don't have a complete sexp after point.
- (save-excursion (forward-sexp 1))
+ (let ((indent-stack (list nil))
+ (next-depth 0)
+ ;; 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)
+ (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)
(setcar (nthcdr 5 state) nil))
(setq inner-loop-done t)))
(and endpos
- (while (<= next-depth 0)
- (setq indent-stack (append indent-stack (list nil)))
- (setq next-depth (1+ next-depth))
- (setq last-depth (1+ last-depth))))
- (or outer-loop-done
+ (<= next-depth 0)
+ (progn
+ (setq indent-stack (append indent-stack
+ (make-list (- next-depth) nil))
+ last-depth (- last-depth next-depth)
+ next-depth 0)))
+ (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)))
(setq this-indent (car indent-stack))
(let ((val (calculate-lisp-indent
(if (car indent-stack) (- (car indent-stack))
- last-point))))
+ starting-point))))
(if (integerp val)
(setcar indent-stack
(setq this-indent val))
;; 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
+;;;; Lisp paragraph filling commands.
+
+(defun lisp-fill-paragraph (&optional justify)
+ "Like \\[fill-paragraph], but handle Emacs Lisp comments.
+If any of the current line is a comment, fill the comment or the
+paragraph of it that point is in, preserving the comment's indentation
+and initial semicolons."
+ (interactive "P")
+ (let (
+ ;; 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
+ )
+
+ ;; Figure out what kind of comment we are looking at.
+ (save-excursion
+ (beginning-of-line)
+ (cond
+
+ ;; A line with nothing but a comment on it?
+ ((looking-at "[ \t]*;[; \t]*")
+ (setq has-comment t
+ comment-fill-prefix (buffer-substring (match-beginning 0)
+ (match-end 0))))
+
+ ;; 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.
+ ((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) 8) ?\t)
+ (make-string (% (current-column) 8) ?\ )
+ (buffer-substring (match-beginning 0) (match-end 0)))))))
+
+ (if (not has-comment)
+ (fill-paragraph justify)
+
+ ;; Narrow to include only the comment, and then fill the region.
+ (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]*;")))
+ ;; 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.
Does not affect lines starting inside comments or strings, assuming that
(progn
(forward-line 1) (point))
nil nil state))))))
+
+(provide 'lisp-mode)
+
+;;; lisp-mode.el ends here
HCoop / bpt / emacs.git / blobdiff