1 ;;; paragraphs.el --- paragraph and sentence parsing.
3 ;; Copyright (C) 1985, 86, 87, 1991 Free Software Foundation, Inc.
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation; either version 2, or (at your option)
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs; see the file COPYING. If not, write to
22 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
26 ;; This package provides the paragraph-oriented commands documented in the
31 (defconst paragraph-start
"^[ \t\n\f]" "\
32 *Regexp for beginning of a line that starts OR separates paragraphs.
33 This regexp should match lines that separate paragraphs
34 and should also match lines that start a paragraph
35 \(and are part of that paragraph).
36 The variable `paragraph-separate' specifies how to distinguish
37 lines that start paragraphs from lines that separate them.")
39 (defconst paragraph-separate
"^[ \t\f]*$" "\
40 *Regexp for beginning of a line that separates paragraphs.
41 If you change this, you may have to change paragraph-start also.")
43 (defconst sentence-end
(purecopy "[.?!][]\"')}]*\\($\\| $\\|\t\\| \\)[ \t\n]*") "\
44 *Regexp describing the end of a sentence.
45 All paragraph boundaries also end sentences, regardless.
47 In order to be recognized as the end of a sentence, the ending period,
48 question mark, or exclamation point must be followed by two spaces,
49 unless it's inside some sort of quotes or parenthesis.")
51 (defconst page-delimiter
"^\014" "\
52 *Regexp describing line-beginnings that separate pages.")
54 (defvar paragraph-ignore-fill-prefix nil
"\
55 Non-nil means the paragraph commands are not affected by `fill-prefix'.
56 This is desirable in modes where blank lines are the paragraph delimiters.")
59 (defun forward-paragraph (&optional arg
)
60 "Move forward to end of paragraph.
61 With arg N, do it N times; negative arg -N means move backward N paragraphs.
63 A line which `paragraph-start' matches either separates paragraphs
64 \(if `paragraph-separate' matches it also) or is the first line of a paragraph.
65 A paragraph end is the beginning of a line which is not part of the paragraph
66 to which the end of the previous line belongs, or the end of the buffer."
69 (let* ((fill-prefix-regexp
70 (and fill-prefix
(not (equal fill-prefix
""))
71 (not paragraph-ignore-fill-prefix
)
72 (regexp-quote fill-prefix
)))
74 (if fill-prefix-regexp
75 (concat paragraph-separate
"\\|^"
76 fill-prefix-regexp
"[ \t]*$")
78 (while (and (< arg
0) (not (bobp)))
79 (if (and (not (looking-at paragraph-separate
))
80 (re-search-backward "^\n" (max (1- (point)) (point-min)) t
))
82 ;; Move back over paragraph-separating lines.
83 (forward-char -
1) (beginning-of-line)
84 (while (and (not (bobp)) (looking-at paragraph-separate
))
88 ;; Go to end of the previous (non-separating) line.
90 ;; Search back for line that starts or separates paragraphs.
91 (if (if fill-prefix-regexp
92 ;; There is a fill prefix; it overrides paragraph-start.
94 (while (progn (beginning-of-line)
96 (not (looking-at paragraph-separate
))
97 (looking-at fill-prefix-regexp
)))
100 (re-search-backward paragraph-start nil t
))
103 ;; Move forward over paragraph separators.
104 ;; We know this cannot reach the place we started
105 ;; because we know we moved back over a non-separator.
106 (while (and (not (eobp)) (looking-at paragraph-separate
))
108 (if (eq (char-after (- (point) 2)) ?
\n)
110 ;; No starter or separator line => use buffer beg.
111 (goto-char (point-min)))))
113 (while (and (> arg
0) (not (eobp)))
115 (while (prog1 (and (not (eobp))
116 (looking-at paragraph-separate
))
118 (if fill-prefix-regexp
119 ;; There is a fill prefix; it overrides paragraph-start.
120 (while (and (not (eobp))
121 (not (looking-at paragraph-separate
))
122 (looking-at fill-prefix-regexp
))
124 (if (re-search-forward paragraph-start nil t
)
125 (goto-char (match-beginning 0))
126 (goto-char (point-max))))
127 (setq arg
(1- arg
)))))
129 (defun backward-paragraph (&optional arg
)
130 "Move backward to start of paragraph.
131 With arg N, do it N times; negative arg -N means move forward N paragraphs.
133 A paragraph start is the beginning of a line which is a
134 `first-line-of-paragraph' or which is ordinary text and follows a
135 paragraph-separating line; except: if the first real line of a
136 paragraph is preceded by a blank line, the paragraph starts at that
139 See `forward-paragraph' for more information."
141 (or arg
(setq arg
1))
142 (forward-paragraph (- arg
)))
144 (defun mark-paragraph ()
145 "Put point at beginning of this paragraph, mark at end.
146 The paragraph marked is the one that contains point or follows point."
148 (forward-paragraph 1)
150 (backward-paragraph 1))
152 (defun kill-paragraph (arg)
153 "Kill forward to end of paragraph.
154 With arg N, kill forward to Nth end of paragraph;
155 negative arg -N means kill backward to Nth start of paragraph."
157 (kill-region (point) (save-excursion (forward-paragraph arg
) (point))))
159 (defun backward-kill-paragraph (arg)
160 "Kill back to start of paragraph.
161 With arg N, kill back to Nth start of paragraph;
162 negative arg -N means kill forward to Nth end of paragraph."
164 (kill-region (point) (save-excursion (backward-paragraph arg
) (point))))
166 (defun transpose-paragraphs (arg)
167 "Interchange this (or next) paragraph with previous one."
169 (transpose-subr 'forward-paragraph arg
))
171 (defun start-of-paragraph-text ()
172 (let ((opoint (point)) npoint
)
173 (forward-paragraph -
1)
174 (setq npoint
(point))
175 (skip-chars-forward " \t\n")
176 ;; If the range of blank lines found spans the original start point,
177 ;; try again from the beginning of it.
178 ;; Must be careful to avoid infinite loop
179 ;; when following a single return at start of buffer.
180 (if (and (>= (point) opoint
) (< npoint opoint
))
183 (if (> npoint
(point-min))
184 (start-of-paragraph-text))))))
186 (defun end-of-paragraph-text ()
187 (let ((opoint (point)))
188 (forward-paragraph 1)
189 (if (eq (preceding-char) ?
\n) (forward-char -
1))
190 (if (<= (point) opoint
)
193 (if (< (point) (point-max))
194 (end-of-paragraph-text))))))
196 (defun forward-sentence (&optional arg
)
197 "Move forward to next `sentence-end'. With argument, repeat.
198 With negative argument, move backward repeatedly to `sentence-beginning'.
200 The variable `sentence-end' is a regular expression that matches ends of
201 sentences. Also, every paragraph boundary terminates sentences as well."
203 (or arg
(setq arg
1))
205 (let ((par-beg (save-excursion (start-of-paragraph-text) (point))))
206 (if (re-search-backward (concat sentence-end
"[^ \t\n]") par-beg t
)
207 (goto-char (1- (match-end 0)))
208 (goto-char par-beg
)))
211 (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
212 (if (re-search-forward sentence-end par-end t
)
213 (skip-chars-backward " \t\n")
214 (goto-char par-end
)))
215 (setq arg
(1- arg
))))
217 (defun backward-sentence (&optional arg
)
218 "Move backward to start of sentence. With arg, do it arg times.
219 See `forward-sentence' for more information."
221 (or arg
(setq arg
1))
222 (forward-sentence (- arg
)))
224 (defun kill-sentence (&optional arg
)
225 "Kill from point to end of sentence.
226 With arg, repeat; negative arg -N means kill back to Nth start of sentence."
228 (kill-region (point) (save-excursion (forward-sentence arg
) (point))))
230 (defun backward-kill-sentence (&optional arg
)
231 "Kill back from point to start of sentence.
232 With arg, repeat, or kill forward to Nth end of sentence if negative arg -N."
234 (kill-region (point) (save-excursion (backward-sentence arg
) (point))))
236 (defun mark-end-of-sentence (arg)
237 "Put mark at end of sentence. Arg works as in `forward-sentence'."
241 (forward-sentence arg
)
245 (defun transpose-sentences (arg)
246 "Interchange this (next) and previous sentence."
248 (transpose-subr 'forward-sentence arg
))
250 ;;; paragraphs.el ends here