|
209
|
1 ;;; paragraphs.el --- paragraph and sentence parsing.
|
|
|
2
|
|
|
3 ;; Copyright (C) 1985, 86, 87, 91, 94, 95, 97 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 ;; Maintainer: FSF
|
|
|
6 ;; Keywords: wp, dumped
|
|
|
7
|
|
|
8 ;; This file is part of XEmacs.
|
|
|
9
|
|
|
10 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
11 ;; under the terms of the GNU General Public License as published by
|
|
|
12 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
13 ;; any later version.
|
|
|
14
|
|
|
15 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
16 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
18 ;; General Public License for more details.
|
|
|
19
|
|
|
20 ;; You should have received a copy of the GNU General Public License
|
|
|
21 ;; along with XEmacs; see the file COPYING. If not, write to the Free
|
|
|
22 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
|
23 ;; 02111-1307, USA.
|
|
|
24
|
|
|
25 ;;; Synched up with: FSF 19.34.
|
|
|
26
|
|
|
27 ;;; Commentary:
|
|
|
28
|
|
|
29 ;; This file is dumped with XEmacs.
|
|
|
30
|
|
|
31 ;; This package provides the paragraph-oriented commands documented in the
|
|
|
32 ;; XEmacs Reference Manual.
|
|
|
33
|
|
|
34 ;; 06/11/1997 - Use char-(after|before) instead of
|
|
|
35 ;; (following|preceding)-char. -slb
|
|
|
36
|
|
|
37 ;;; Code:
|
|
|
38
|
|
|
39 (defvar use-hard-newlines nil
|
|
|
40 "Non-nil means to distinguish hard and soft newlines.
|
|
|
41 When this is non-nil, the functions `newline' and `open-line' add the
|
|
|
42 text-property `hard' to newlines that they insert. Also, a line is
|
|
|
43 only considered as a candidate to match `paragraph-start' or
|
|
|
44 `paragraph-separate' if it follows a hard newline. Newlines not
|
|
|
45 marked hard are called \"soft\", and are always internal to
|
|
|
46 paragraphs. The fill functions always insert soft newlines.
|
|
|
47
|
|
|
48 Each buffer has its own value of this variable.")
|
|
|
49 (make-variable-buffer-local 'use-hard-newlines)
|
|
|
50
|
|
|
51 ;; XEmacs - use purecopy
|
|
|
52 (defconst paragraph-start (purecopy "[ \t\n\f]") "\
|
|
|
53 *Regexp for beginning of a line that starts OR separates paragraphs.
|
|
|
54 This regexp should match lines that separate paragraphs
|
|
|
55 and should also match lines that start a paragraph
|
|
|
56 \(and are part of that paragraph).
|
|
|
57
|
|
|
58 This is matched against the text at the left margin, which is not necessarily
|
|
|
59 the beginning of the line, so it should never use \"^\" as an anchor. This
|
|
|
60 ensures that the paragraph functions will work equally well within a region
|
|
|
61 of text indented by a margin setting.
|
|
|
62
|
|
|
63 The variable `paragraph-separate' specifies how to distinguish
|
|
|
64 lines that start paragraphs from lines that separate them.
|
|
|
65
|
|
|
66 If the variable `use-hard-newlines' is non-nil, then only lines following a
|
|
|
67 hard newline are considered to match.")
|
|
|
68
|
|
|
69 ;; paragraph-start requires a hard newline, but paragraph-separate does not:
|
|
|
70 ;; It is assumed that paragraph-separate is distinctive enough to be believed
|
|
|
71 ;; whenever it occurs, while it is reasonable to set paragraph-start to
|
|
|
72 ;; something very minimal, even including "." (which makes every hard newline
|
|
|
73 ;; start a new paragraph).
|
|
|
74
|
|
|
75 ;; XEmacs -- use purecopy
|
|
|
76 (defconst paragraph-separate (purecopy "[ \t\f]*$") "\
|
|
|
77 *Regexp for beginning of a line that separates paragraphs.
|
|
|
78 If you change this, you may have to change paragraph-start also.
|
|
|
79
|
|
|
80 This is matched against the text at the left margin, which is not necessarily
|
|
|
81 the beginning of the line, so it should not use \"^\" as an anchor. This
|
|
|
82 ensures that the paragraph functions will work equally within a region of
|
|
|
83 text indented by a margin setting.")
|
|
|
84
|
|
|
85 ;; XEmacs -- use purecopy
|
|
|
86 (defconst sentence-end (purecopy "[.?!][]\"')}]*\\($\\| $\\|\t\\| \\)[ \t\n]*") "\
|
|
|
87 *Regexp describing the end of a sentence.
|
|
|
88 All paragraph boundaries also end sentences, regardless.
|
|
|
89
|
|
|
90 In order to be recognized as the end of a sentence, the ending period,
|
|
|
91 question mark, or exclamation point must be followed by two spaces,
|
|
|
92 unless it's inside some sort of quotes or parenthesis.")
|
|
|
93
|
|
|
94 ;; XEmacs -- use purecopy
|
|
|
95 (defconst page-delimiter (purecopy "^\014") "\
|
|
|
96 *Regexp describing line-beginnings that separate pages.")
|
|
|
97
|
|
|
98 (defvar paragraph-ignore-fill-prefix nil "\
|
|
|
99 Non-nil means the paragraph commands are not affected by `fill-prefix'.
|
|
|
100 This is desirable in modes where blank lines are the paragraph delimiters.")
|
|
|
101
|
|
|
102 (defun forward-paragraph (&optional arg)
|
|
|
103 "Move forward to end of paragraph.
|
|
|
104 With arg N, do it N times; negative arg -N means move backward N paragraphs.
|
|
|
105
|
|
|
106 A line which `paragraph-start' matches either separates paragraphs
|
|
|
107 \(if `paragraph-separate' matches it also) or is the first line of a paragraph.
|
|
|
108 A paragraph end is the beginning of a line which is not part of the paragraph
|
|
|
109 to which the end of the previous line belongs, or the end of the buffer."
|
|
|
110 (interactive "_p") ; XEmacs
|
|
|
111 (or arg (setq arg 1))
|
|
|
112 (let* ((fill-prefix-regexp
|
|
|
113 (and fill-prefix (not (equal fill-prefix ""))
|
|
|
114 (not paragraph-ignore-fill-prefix)
|
|
|
115 (regexp-quote fill-prefix)))
|
|
|
116 ;; Remove ^ from paragraph-start and paragraph-sep if they are there.
|
|
|
117 ;; These regexps shouldn't be anchored, because we look for them
|
|
|
118 ;; starting at the left-margin. This allows paragraph commands to
|
|
|
119 ;; work normally with indented text.
|
|
|
120 ;; This hack will not find problem cases like "whatever\\|^something".
|
|
|
121 (paragraph-start (if (and (not (equal "" paragraph-start))
|
|
|
122 (equal ?^ (aref paragraph-start 0)))
|
|
|
123 (substring paragraph-start 1)
|
|
|
124 paragraph-start))
|
|
|
125 (paragraph-separate (if (and (not (equal "" paragraph-start))
|
|
|
126 (equal ?^ (aref paragraph-separate 0)))
|
|
|
127 (substring paragraph-separate 1)
|
|
|
128 paragraph-separate))
|
|
|
129 (paragraph-separate
|
|
|
130 (if fill-prefix-regexp
|
|
|
131 (concat paragraph-separate "\\|"
|
|
|
132 fill-prefix-regexp "[ \t]*$")
|
|
|
133 paragraph-separate))
|
|
|
134 ;; This is used for searching.
|
|
|
135 (sp-paragraph-start (concat "^[ \t]*\\(" paragraph-start "\\)"))
|
|
|
136 start)
|
|
|
137 (while (and (< arg 0) (not (bobp)))
|
|
|
138 (if (and (not (looking-at paragraph-separate))
|
|
|
139 (re-search-backward "^\n" (max (1- (point)) (point-min)) t)
|
|
|
140 (looking-at paragraph-separate))
|
|
|
141 nil
|
|
|
142 (setq start (point))
|
|
|
143 ;; Move back over paragraph-separating lines.
|
|
|
144 (forward-char -1) (beginning-of-line)
|
|
|
145 (while (and (not (bobp))
|
|
|
146 (progn (move-to-left-margin)
|
|
|
147 (looking-at paragraph-separate)))
|
|
|
148 (forward-line -1))
|
|
|
149 (if (bobp)
|
|
|
150 nil
|
|
|
151 ;; Go to end of the previous (non-separating) line.
|
|
|
152 (end-of-line)
|
|
|
153 ;; Search back for line that starts or separates paragraphs.
|
|
|
154 (if (if fill-prefix-regexp
|
|
|
155 ;; There is a fill prefix; it overrides paragraph-start.
|
|
|
156 (let (multiple-lines)
|
|
|
157 (while (and (progn (beginning-of-line) (not (bobp)))
|
|
|
158 (progn (move-to-left-margin)
|
|
|
159 (not (looking-at paragraph-separate)))
|
|
|
160 (looking-at fill-prefix-regexp))
|
|
|
161 (if (not (= (point) start))
|
|
|
162 (setq multiple-lines t))
|
|
|
163 (forward-line -1))
|
|
|
164 (move-to-left-margin)
|
|
|
165 ;; Don't move back over a line before the paragraph
|
|
|
166 ;; which doesn't start with fill-prefix
|
|
|
167 ;; unless that is the only line we've moved over.
|
|
|
168 (and (not (looking-at fill-prefix-regexp))
|
|
|
169 multiple-lines
|
|
|
170 (forward-line 1))
|
|
|
171 (not (bobp)))
|
|
|
172 (while (and (re-search-backward sp-paragraph-start nil 1)
|
|
|
173 ;; Found a candidate, but need to check if it is a
|
|
|
174 ;; REAL paragraph-start.
|
|
|
175 (not (bobp))
|
|
|
176 (progn (setq start (point))
|
|
|
177 (move-to-left-margin)
|
|
|
178 (not (looking-at paragraph-separate)))
|
|
|
179 (or (not (looking-at paragraph-start))
|
|
|
180 (and use-hard-newlines
|
|
|
181 (not (get-text-property (1- start)
|
|
|
182 'hard)))))
|
|
|
183 (goto-char start))
|
|
|
184 (> (point) (point-min)))
|
|
|
185 ;; Found one.
|
|
|
186 (progn
|
|
|
187 ;; Move forward over paragraph separators.
|
|
|
188 ;; We know this cannot reach the place we started
|
|
|
189 ;; because we know we moved back over a non-separator.
|
|
|
190 (while (and (not (eobp))
|
|
|
191 (progn (move-to-left-margin)
|
|
|
192 (looking-at paragraph-separate)))
|
|
|
193 (forward-line 1))
|
|
|
194 ;; If line before paragraph is just margin, back up to there.
|
|
|
195 (end-of-line 0)
|
|
|
196 (if (> (current-column) (current-left-margin))
|
|
|
197 (forward-char 1)
|
|
|
198 (skip-chars-backward " \t")
|
|
|
199 (if (not (bolp))
|
|
|
200 (forward-line 1))))
|
|
|
201 ;; No starter or separator line => use buffer beg.
|
|
|
202 (goto-char (point-min)))))
|
|
|
203 (setq arg (1+ arg)))
|
|
|
204 (while (and (> arg 0) (not (eobp)))
|
|
|
205 ;; Move forward over separator lines, and one more line.
|
|
|
206 (while (prog1 (and (not (eobp))
|
|
|
207 (progn (move-to-left-margin) (not (eobp)))
|
|
|
208 (looking-at paragraph-separate))
|
|
|
209 (forward-line 1)))
|
|
|
210 (if fill-prefix-regexp
|
|
|
211 ;; There is a fill prefix; it overrides paragraph-start.
|
|
|
212 (while (and (not (eobp))
|
|
|
213 (progn (move-to-left-margin) (not (eobp)))
|
|
|
214 (not (looking-at paragraph-separate))
|
|
|
215 (looking-at fill-prefix-regexp))
|
|
|
216 (forward-line 1))
|
|
|
217 (while (and (re-search-forward sp-paragraph-start nil 1)
|
|
|
218 (progn (setq start (match-beginning 0))
|
|
|
219 (goto-char start)
|
|
|
220 (not (eobp)))
|
|
|
221 (progn (move-to-left-margin)
|
|
|
222 (not (looking-at paragraph-separate)))
|
|
|
223 (or (not (looking-at paragraph-start))
|
|
|
224 (and use-hard-newlines
|
|
|
225 (not (get-text-property (1- start) 'hard)))))
|
|
|
226 (forward-char 1))
|
|
|
227 (if (< (point) (point-max))
|
|
|
228 (goto-char start)))
|
|
|
229 (setq arg (1- arg)))))
|
|
|
230
|
|
|
231 (defun backward-paragraph (&optional arg)
|
|
|
232 "Move backward to start of paragraph.
|
|
|
233 With arg N, do it N times; negative arg -N means move forward N paragraphs.
|
|
|
234
|
|
|
235 A paragraph start is the beginning of a line which is a
|
|
|
236 `first-line-of-paragraph' or which is ordinary text and follows a
|
|
|
237 paragraph-separating line; except: if the first real line of a
|
|
|
238 paragraph is preceded by a blank line, the paragraph starts at that
|
|
|
239 blank line.
|
|
|
240
|
|
|
241 See `forward-paragraph' for more information."
|
|
|
242 (interactive "_p") ; XEmacs
|
|
|
243 (or arg (setq arg 1))
|
|
|
244 (forward-paragraph (- arg)))
|
|
|
245
|
|
|
246 (defun mark-paragraph ()
|
|
|
247 "Put point at beginning of this paragraph, mark at end.
|
|
|
248 The paragraph marked is the one that contains point or follows point."
|
|
|
249 (interactive)
|
|
|
250 (forward-paragraph 1)
|
|
|
251 (push-mark nil t t)
|
|
|
252 (backward-paragraph 1))
|
|
|
253
|
|
|
254 (defun kill-paragraph (arg)
|
|
|
255 "Kill forward to end of paragraph.
|
|
|
256 With arg N, kill forward to Nth end of paragraph;
|
|
|
257 negative arg -N means kill backward to Nth start of paragraph."
|
|
|
258 (interactive "*p") ; XEmacs
|
|
|
259 (kill-region (point) (progn (forward-paragraph arg) (point))))
|
|
|
260
|
|
|
261 (defun backward-kill-paragraph (arg)
|
|
|
262 "Kill back to start of paragraph.
|
|
|
263 With arg N, kill back to Nth start of paragraph;
|
|
|
264 negative arg -N means kill forward to Nth end of paragraph."
|
|
|
265 (interactive "*p") ; XEmacs
|
|
|
266 (kill-region (point) (progn (backward-paragraph arg) (point))))
|
|
|
267
|
|
|
268 (defun transpose-paragraphs (arg)
|
|
|
269 "Interchange this (or next) paragraph with previous one."
|
|
|
270 (interactive "*p")
|
|
|
271 (transpose-subr 'forward-paragraph arg))
|
|
|
272
|
|
|
273 (defun start-of-paragraph-text ()
|
|
|
274 (let ((opoint (point)) npoint)
|
|
|
275 (forward-paragraph -1)
|
|
|
276 (setq npoint (point))
|
|
|
277 (skip-chars-forward " \t\n")
|
|
|
278 ;; If the range of blank lines found spans the original start point,
|
|
|
279 ;; try again from the beginning of it.
|
|
|
280 ;; Must be careful to avoid infinite loop
|
|
|
281 ;; when following a single return at start of buffer.
|
|
|
282 (if (and (>= (point) opoint) (< npoint opoint))
|
|
|
283 (progn
|
|
|
284 (goto-char npoint)
|
|
|
285 (if (> npoint (point-min))
|
|
|
286 (start-of-paragraph-text))))))
|
|
|
287
|
|
|
288 (defun end-of-paragraph-text ()
|
|
|
289 (let ((opoint (point)))
|
|
|
290 (forward-paragraph 1)
|
|
|
291 (if (eq (char-before (point)) ?\n) (forward-char -1))
|
|
|
292 (if (<= (point) opoint)
|
|
|
293 (progn
|
|
|
294 (forward-char 1)
|
|
|
295 (if (< (point) (point-max))
|
|
|
296 (end-of-paragraph-text))))))
|
|
|
297
|
|
|
298 (defun forward-sentence (&optional arg)
|
|
|
299 "Move forward to next `sentence-end'. With argument, repeat.
|
|
|
300 With negative argument, move backward repeatedly to `sentence-beginning'.
|
|
|
301
|
|
|
302 The variable `sentence-end' is a regular expression that matches ends of
|
|
|
303 sentences. Also, every paragraph boundary terminates sentences as well."
|
|
|
304 (interactive "_p") ; XEmacs
|
|
|
305 (or arg (setq arg 1))
|
|
|
306 (while (< arg 0)
|
|
|
307 (let ((par-beg (save-excursion (start-of-paragraph-text) (point))))
|
|
|
308 (if (re-search-backward (concat sentence-end "[^ \t\n]") par-beg t)
|
|
|
309 (goto-char (1- (match-end 0)))
|
|
|
310 (goto-char par-beg)))
|
|
|
311 (setq arg (1+ arg)))
|
|
|
312 (while (> arg 0)
|
|
|
313 (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
|
|
|
314 (if (re-search-forward sentence-end par-end t)
|
|
|
315 (skip-chars-backward " \t\n")
|
|
|
316 (goto-char par-end)))
|
|
|
317 (setq arg (1- arg))))
|
|
|
318
|
|
|
319 (defun backward-sentence (&optional arg)
|
|
|
320 "Move backward to start of sentence. With arg, do it arg times.
|
|
|
321 See `forward-sentence' for more information."
|
|
|
322 (interactive "_p") ; XEmacs
|
|
|
323 (or arg (setq arg 1))
|
|
|
324 (forward-sentence (- arg)))
|
|
|
325
|
|
|
326 (defun kill-sentence (&optional arg)
|
|
|
327 "Kill from point to end of sentence.
|
|
|
328 With arg, repeat; negative arg -N means kill back to Nth start of sentence."
|
|
|
329 (interactive "*p") ; XEmacs
|
|
|
330 (kill-region (point) (progn (forward-sentence arg) (point))))
|
|
|
331
|
|
|
332 (defun backward-kill-sentence (&optional arg)
|
|
|
333 "Kill back from point to start of sentence.
|
|
|
334 With arg, repeat, or kill forward to Nth end of sentence if negative arg -N."
|
|
|
335 (interactive "*p") ; XEmacs
|
|
|
336 (kill-region (point) (progn (backward-sentence arg) (point))))
|
|
|
337
|
|
|
338 (defun mark-end-of-sentence (arg)
|
|
|
339 "Put mark at end of sentence. Arg works as in `forward-sentence'."
|
|
|
340 (interactive "p")
|
|
|
341 ;; FSF Version:
|
|
|
342 ; (push-mark
|
|
|
343 ; (save-excursion
|
|
|
344 ; (forward-sentence arg)
|
|
|
345 ; (point))
|
|
|
346 ; nil t))
|
|
|
347 (mark-something 'mark-end-of-sentence 'forward-sentence arg))
|
|
|
348
|
|
211
|
349 (defun mark-end-of-line (arg)
|
|
|
350 "Put mark at end of line. Arg works as in `end-of-line'."
|
|
|
351 (interactive "p")
|
|
|
352 (mark-something 'mark-end-of-line 'end-of-line arg))
|
|
|
353
|
|
|
354
|
|
209
|
355 (defun transpose-sentences (arg)
|
|
|
356 "Interchange this (next) and previous sentence."
|
|
|
357 (interactive "*p")
|
|
|
358 (transpose-subr 'forward-sentence arg))
|
|
|
359
|
|
|
360 ;;; paragraphs.el ends here
|
