Mercurial > hg > xemacs-beta
annotate lisp/paragraphs.el @ 5495:1f0b15040456
Merge.
author | Aidan Kehoe <kehoea@parhasard.net> |
---|---|
date | Sun, 01 May 2011 18:44:03 +0100 |
parents | f62141fe007d 4dee0387b9de |
children | 00a421d2b2ba |
rev | line source |
---|---|
2549 | 1 ;;; paragraphs.el --- paragraph and sentence parsing |
428 | 2 |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
3 ;; Copyright (C) 1985-87, 1991, 1994-97, 1999-2010 Free Software Foundation, Inc. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
4 ;; Copyright (C) 2010 Ben Wing. |
428 | 5 |
6 ;; Maintainer: FSF | |
7 ;; Keywords: wp, dumped | |
8 | |
9 ;; This file is part of XEmacs. | |
10 | |
5495 | 11 ;; XEmacs is free software: you can redistribute it and/or modify |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
12 ;; it under the terms of the GNU General Public License as published by |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
13 ;; the Free Software Foundation, either version 3 of the License, or |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
14 ;; (at your option) any later version. |
428 | 15 |
16 ;; XEmacs is distributed in the hope that it will be useful, but | |
17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
19 ;; General Public License for more details. | |
20 | |
21 ;; You should have received a copy of the GNU General Public License | |
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5229
diff
changeset
|
22 ;; along with XEmacs. If not, see <http://www.gnu.org/licenses/>. |
428 | 23 |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
24 ;;; Synced up with: FSF 23.1.92. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
25 ;;; Synced by: Ben Wing, 2-17-10. |
428 | 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 | |
2549 | 39 (defgroup paragraphs nil |
40 "Paragraph and sentence parsing." | |
41 :group 'editing) | |
428 | 42 |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
43 (put 'use-hard-newlines 'permanent-local t) |
2549 | 44 (define-minor-mode use-hard-newlines |
428 | 45 "Minor mode to distinguish hard and soft newlines. |
46 When active, the functions `newline' and `open-line' add the | |
47 text-property `hard' to newlines that they insert, and a line is | |
48 only considered as a candidate to match `paragraph-start' or | |
49 `paragraph-separate' if it follows a hard newline. | |
50 | |
51 Prefix argument says to turn mode on if positive, off if negative. | |
52 When the mode is turned on, if there are newlines in the buffer but no hard | |
2549 | 53 newlines, ask the user whether to mark as hard any newlines preceeding a |
428 | 54 `paragraph-start' line. From a program, second arg INSERT specifies whether |
55 to do this; it can be `never' to change nothing, t or `always' to force | |
2549 | 56 marking, `guess' to try to do the right thing with no questions, nil |
428 | 57 or anything else to ask the user. |
58 | |
59 Newlines not marked hard are called \"soft\", and are always internal | |
60 to paragraphs. The fill functions insert and delete only soft newlines." | |
2549 | 61 :group 'paragraphs |
62 :extra-args (insert) | |
63 (when use-hard-newlines | |
428 | 64 ;; Turn mode on |
65 ;; Intuit hard newlines -- | |
66 ;; mark as hard any newlines preceding a paragraph-start line. | |
67 (if (or (eq insert t) (eq insert 'always) | |
68 (and (not (eq 'never insert)) | |
69 (not (text-property-any (point-min) (point-max) 'hard t)) | |
70 (save-excursion | |
71 (goto-char (point-min)) | |
72 (search-forward "\n" nil t)) | |
73 (or (eq insert 'guess) | |
74 (y-or-n-p "Make newlines between paragraphs hard? ")))) | |
75 (save-excursion | |
76 (goto-char (point-min)) | |
77 (while (search-forward "\n" nil t) | |
78 (let ((pos (point))) | |
79 (move-to-left-margin) | |
2549 | 80 (when (looking-at paragraph-start) |
81 (set-hard-newline-properties (1- pos) pos)) | |
82 ;; If paragraph-separate, newline after it is hard too. | |
83 (when (looking-at paragraph-separate) | |
84 (set-hard-newline-properties (1- pos) pos) | |
85 (end-of-line) | |
86 (unless (eobp) | |
87 (set-hard-newline-properties (point) (1+ (point))))))))))) | |
428 | 88 |
2549 | 89 (defcustom paragraph-start "\f\\|[ \t]*$" "\ |
428 | 90 *Regexp for beginning of a line that starts OR separates paragraphs. |
91 This regexp should match lines that separate paragraphs | |
92 and should also match lines that start a paragraph | |
93 \(and are part of that paragraph). | |
94 | |
95 This is matched against the text at the left margin, which is not necessarily | |
96 the beginning of the line, so it should never use \"^\" as an anchor. This | |
97 ensures that the paragraph functions will work equally well within a region | |
98 of text indented by a margin setting. | |
99 | |
100 The variable `paragraph-separate' specifies how to distinguish | |
101 lines that start paragraphs from lines that separate them. | |
102 | |
103 If the variable `use-hard-newlines' is non-nil, then only lines following a | |
2549 | 104 hard newline are considered to match." |
105 :group 'paragraphs | |
106 :type 'regexp) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
107 (put 'paragraph-start 'safe-local-variable 'stringp) |
428 | 108 |
109 ;; paragraph-start requires a hard newline, but paragraph-separate does not: | |
110 ;; It is assumed that paragraph-separate is distinctive enough to be believed | |
111 ;; whenever it occurs, while it is reasonable to set paragraph-start to | |
112 ;; something very minimal, even including "." (which makes every hard newline | |
113 ;; start a new paragraph). | |
114 | |
2549 | 115 (defcustom paragraph-separate "[ \t\f]*$" |
116 "*Regexp for beginning of a line that separates paragraphs. | |
450 | 117 If you change this, you may have to change `paragraph-start' also. |
118 | |
119 A line matching this is not part of any paragraph. | |
428 | 120 |
121 This is matched against the text at the left margin, which is not necessarily | |
122 the beginning of the line, so it should not use \"^\" as an anchor. This | |
123 ensures that the paragraph functions will work equally within a region of | |
2549 | 124 text indented by a margin setting." |
125 :group 'paragraphs | |
126 :type 'regexp) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
127 (put 'paragraph-separate 'safe-local-variable 'stringp) |
2549 | 128 |
129 (defcustom sentence-end-double-space t | |
130 "*Non-nil means a single space does not end a sentence. | |
131 This is relevant for filling. See also `sentence-end-without-period' | |
132 and `colon-double-space'. | |
133 | |
134 This variable applies only to filling, not motion commands. To | |
135 change the behavior of motion commands, see `sentence-end'. | |
136 | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
137 This value is used by the function `sentence-end' to construct the |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
138 regexp describing the end of a sentence, when the value of the variable |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
139 `sentence-end' is nil. See Info node `(lispref)Standard Regexps'." |
2549 | 140 :type 'boolean |
141 :group 'fill) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
142 (put 'sentence-end-double-space 'safe-local-variable 'booleanp) |
428 | 143 |
2549 | 144 (defcustom sentence-end-without-period nil |
145 "*Non-nil means a sentence will end without a period. | |
146 For example, a sentence in Thai text ends with double space but | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
147 without a period. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
148 |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
149 This value is used by the function `sentence-end' to construct the |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
150 regexp describing the end of a sentence, when the value of the variable |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
151 `sentence-end' is nil. See Info node `(lispref)Standard Regexps'." |
2549 | 152 :type 'boolean |
153 :group 'fill) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
154 (put 'sentence-end-without-period 'safe-local-variable 'booleanp) |
2549 | 155 |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
156 (defcustom sentence-end-without-space |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
157 (cond ((featurep 'unicode-internal) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
158 (decode-coding-string "\343\200\202\357\274\216\357\274\237\357\274\201" 'utf-8)) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
159 ((featurep 'mule) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
160 (decode-coding-string "\033$B!#!%!)!*\033$A!##.#?#!\033$(0!$!%!)!*\033$(G!$!%!)!*\033(B" 'iso-2022-7bit)) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
161 (t "")) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
162 "String of characters that end sentence without following spaces. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
163 |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
164 This value is used by the function `sentence-end' to construct the |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
165 regexp describing the end of a sentence, when the value of the variable |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
166 `sentence-end' is nil. See Info node `(lispref)Standard Regexps'." |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
167 :group 'paragraphs |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
168 :type 'string) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
169 (put 'sentence-end-without-space 'safe-local-variable 'stringp) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
170 |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
171 (defcustom sentence-end nil |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
172 "Regexp describing the end of a sentence. |
2549 | 173 The value includes the whitespace following the sentence. |
428 | 174 All paragraph boundaries also end sentences, regardless. |
175 | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
176 The value nil means to use the default value defined by the |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
177 function `sentence-end'. You should always use this function |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
178 to obtain the value of this variable." |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
179 :group 'paragraphs |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
180 :type '(choice regexp (const :tag "Use default value" nil))) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
181 (put 'sentence-end 'safe-local-variable 'string-or-null-p) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
182 |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
183 (defcustom sentence-end-base "[.?!][]\"'”)}]*" |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
184 "Regexp matching the basic end of a sentence, not including following space." |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
185 :group 'paragraphs |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
186 :type 'string |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
187 :version "22.1") |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
188 (put 'sentence-end-base 'safe-local-variable 'stringp) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
189 |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
190 (defun sentence-end () |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
191 "Return the regexp describing the end of a sentence. |
2549 | 192 |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
193 This function returns either the value of the variable `sentence-end' |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
194 if it is non-nil, or the default value constructed from the |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
195 variables `sentence-end-base', `sentence-end-double-space', |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
196 `sentence-end-without-period' and `sentence-end-without-space'. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
197 |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
198 The default value specifies that in order to be recognized as the |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
199 end of a sentence, the ending period, question mark, or exclamation point |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
200 must be followed by two spaces, with perhaps some closing delimiters |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
201 in between. See Info node `(elisp)Standard Regexps'." |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
202 (or sentence-end |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
203 ;; We accept non-break space along with space. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
204 (concat (if sentence-end-without-period "\\w[ \u00a0][ \u00a0]\\|") |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
205 "\\(" |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
206 sentence-end-base |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
207 (if sentence-end-double-space |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
208 "\\($\\|[ \u00a0]$\\|\t\\|[ \u00a0][ \u00a0]\\)" "\\($\\|[\t \u00a0]\\)") |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
209 "\\|[" sentence-end-without-space "]+" |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
210 "\\)" |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
211 "[ \u00a0\t\n]*"))) |
428 | 212 |
2549 | 213 (defcustom page-delimiter "^\014" |
214 "*Regexp describing line-beginnings that separate pages." | |
215 :group 'paragraphs | |
216 :type 'regexp) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
217 (put 'page-delimiter 'safe-local-variable 'stringp) |
428 | 218 |
2549 | 219 (defcustom paragraph-ignore-fill-prefix nil |
220 "*Non-nil means the paragraph commands are not affected by `fill-prefix'. | |
221 This is desirable in modes where blank lines are the paragraph delimiters." | |
222 :group 'paragraphs | |
223 :type 'boolean) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
224 (put 'paragraph-ignore-fill-prefix 'safe-local-variable 'booleanp) |
428 | 225 |
226 (defun forward-paragraph (&optional arg) | |
227 "Move forward to end of paragraph. | |
2549 | 228 With argument ARG, do it ARG times; |
229 a negative argument ARG = -N means move backward N paragraphs. | |
428 | 230 |
231 A line which `paragraph-start' matches either separates paragraphs | |
232 \(if `paragraph-separate' matches it also) or is the first line of a paragraph. | |
233 A paragraph end is the beginning of a line which is not part of the paragraph | |
2549 | 234 to which the end of the previous line belongs, or the end of the buffer. |
235 Returns the count of paragraphs left to move." | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
236 ;; #### MERGE! FSF Has (interactive "^p") |
428 | 237 (interactive "_p") ; XEmacs |
238 (or arg (setq arg 1)) | |
2549 | 239 (let* ((opoint (point)) |
240 (fill-prefix-regexp | |
428 | 241 (and fill-prefix (not (equal fill-prefix "")) |
242 (not paragraph-ignore-fill-prefix) | |
243 (regexp-quote fill-prefix))) | |
244 ;; Remove ^ from paragraph-start and paragraph-sep if they are there. | |
245 ;; These regexps shouldn't be anchored, because we look for them | |
246 ;; starting at the left-margin. This allows paragraph commands to | |
247 ;; work normally with indented text. | |
248 ;; This hack will not find problem cases like "whatever\\|^something". | |
2549 | 249 (parstart (if (and (not (equal "" paragraph-start)) |
250 (equal ?^ (aref paragraph-start 0))) | |
251 (substring paragraph-start 1) | |
252 paragraph-start)) | |
253 (parsep (if (and (not (equal "" paragraph-separate)) | |
254 (equal ?^ (aref paragraph-separate 0))) | |
255 (substring paragraph-separate 1) | |
256 paragraph-separate)) | |
257 (parsep | |
428 | 258 (if fill-prefix-regexp |
2549 | 259 (concat parsep "\\|" |
428 | 260 fill-prefix-regexp "[ \t]*$") |
2549 | 261 parsep)) |
428 | 262 ;; This is used for searching. |
2549 | 263 (sp-parstart (concat "^[ \t]*\\(?:" parstart "\\|" parsep "\\)")) |
264 start found-start) | |
428 | 265 (while (and (< arg 0) (not (bobp))) |
2549 | 266 (if (and (not (looking-at parsep)) |
428 | 267 (re-search-backward "^\n" (max (1- (point)) (point-min)) t) |
2549 | 268 (looking-at parsep)) |
269 (setq arg (1+ arg)) | |
428 | 270 (setq start (point)) |
271 ;; Move back over paragraph-separating lines. | |
446 | 272 (backward-char 1) (beginning-of-line) |
428 | 273 (while (and (not (bobp)) |
274 (progn (move-to-left-margin) | |
2549 | 275 (looking-at parsep))) |
276 (forward-line -1)) | |
428 | 277 (if (bobp) |
278 nil | |
2549 | 279 (setq arg (1+ arg)) |
428 | 280 ;; Go to end of the previous (non-separating) line. |
281 (end-of-line) | |
282 ;; Search back for line that starts or separates paragraphs. | |
283 (if (if fill-prefix-regexp | |
2549 | 284 ;; There is a fill prefix; it overrides parstart. |
4103 | 285 (let nil ; (multiple-lines) |
428 | 286 (while (and (progn (beginning-of-line) (not (bobp))) |
287 (progn (move-to-left-margin) | |
2549 | 288 (not (looking-at parsep))) |
428 | 289 (looking-at fill-prefix-regexp)) |
4103 | 290 ; (unless (= (point) start) |
291 ; (setq multiple-lines t)) | |
428 | 292 (forward-line -1)) |
293 (move-to-left-margin) | |
2549 | 294 ;; This deleted code caused a long hanging-indent line |
295 ;; not to be filled together with the following lines. | |
296 ;; ;; Don't move back over a line before the paragraph | |
297 ;; ;; which doesn't start with fill-prefix | |
298 ;; ;; unless that is the only line we've moved over. | |
299 ;; (and (not (looking-at fill-prefix-regexp)) | |
300 ;; multiple-lines | |
301 ;; (forward-line 1)) | |
428 | 302 (not (bobp))) |
2549 | 303 (while (and (re-search-backward sp-parstart nil 1) |
304 (setq found-start t) | |
428 | 305 ;; Found a candidate, but need to check if it is a |
2549 | 306 ;; REAL parstart. |
428 | 307 (progn (setq start (point)) |
308 (move-to-left-margin) | |
2549 | 309 (not (looking-at parsep))) |
310 (not (and (looking-at parstart) | |
311 (or (not use-hard-newlines) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
312 ;; #### XEmacs: We've reversed |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
313 ;; the order of the following two -- |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
314 ;; does it matter? |
2549 | 315 (get-text-property (1- start) 'hard) |
316 (bobp))))) | |
317 (setq found-start nil) | |
428 | 318 (goto-char start)) |
2549 | 319 found-start) |
428 | 320 ;; Found one. |
321 (progn | |
322 ;; Move forward over paragraph separators. | |
323 ;; We know this cannot reach the place we started | |
324 ;; because we know we moved back over a non-separator. | |
325 (while (and (not (eobp)) | |
326 (progn (move-to-left-margin) | |
2549 | 327 (looking-at parsep))) |
428 | 328 (forward-line 1)) |
329 ;; If line before paragraph is just margin, back up to there. | |
330 (end-of-line 0) | |
331 (if (> (current-column) (current-left-margin)) | |
332 (forward-char 1) | |
333 (skip-chars-backward " \t") | |
334 (if (not (bolp)) | |
335 (forward-line 1)))) | |
336 ;; No starter or separator line => use buffer beg. | |
2549 | 337 (goto-char (point-min)))))) |
338 | |
428 | 339 (while (and (> arg 0) (not (eobp))) |
2549 | 340 ;; Move forward over separator lines... |
341 (while (and (not (eobp)) | |
342 (progn (move-to-left-margin) (not (eobp))) | |
343 (looking-at parsep)) | |
344 (forward-line 1)) | |
345 (unless (eobp) (setq arg (1- arg))) | |
346 ;; ... and one more line. | |
347 (forward-line 1) | |
428 | 348 (if fill-prefix-regexp |
2549 | 349 ;; There is a fill prefix; it overrides parstart. |
428 | 350 (while (and (not (eobp)) |
351 (progn (move-to-left-margin) (not (eobp))) | |
2549 | 352 (not (looking-at parsep)) |
428 | 353 (looking-at fill-prefix-regexp)) |
354 (forward-line 1)) | |
2549 | 355 (while (and (re-search-forward sp-parstart nil 1) |
428 | 356 (progn (setq start (match-beginning 0)) |
357 (goto-char start) | |
358 (not (eobp))) | |
359 (progn (move-to-left-margin) | |
2549 | 360 (not (looking-at parsep))) |
361 (or (not (looking-at parstart)) | |
428 | 362 (and use-hard-newlines |
363 (not (get-text-property (1- start) 'hard))))) | |
364 (forward-char 1)) | |
365 (if (< (point) (point-max)) | |
2549 | 366 (goto-char start)))) |
5368
ed74d2ca7082
Use ', not #', when a given symbol may not have a function binding at read time
Aidan Kehoe <kehoea@parhasard.net>
parents:
5229
diff
changeset
|
367 (if-fboundp 'constrain-to-field |
4103 | 368 (constrain-to-field nil opoint t) |
369 (error | |
370 'void-function | |
371 "constrain-to-field not available; is xemacs-base installed?")) | |
2549 | 372 ;; Return the number of steps that could not be done. |
373 arg)) | |
428 | 374 |
375 (defun backward-paragraph (&optional arg) | |
376 "Move backward to start of paragraph. | |
2549 | 377 With argument ARG, do it ARG times; |
378 a negative argument ARG = -N means move forward N paragraphs. | |
428 | 379 |
380 A paragraph start is the beginning of a line which is a | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
381 `paragraph-start' or which is ordinary text and follows a |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
382 `paragraph-separate'ing line; except: if the first real line of a |
428 | 383 paragraph is preceded by a blank line, the paragraph starts at that |
384 blank line. | |
385 | |
386 See `forward-paragraph' for more information." | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
387 ;; #### MERGE! FSF Has (interactive "^p") |
428 | 388 (interactive "_p") ; XEmacs |
389 (or arg (setq arg 1)) | |
390 (forward-paragraph (- arg))) | |
391 | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
392 (defun mark-paragraph (&optional arg allow-extend) |
428 | 393 "Put point at beginning of this paragraph, mark at end. |
687 | 394 The paragraph marked is the one that contains point or follows point. |
2549 | 395 |
396 With argument ARG, puts mark at end of a following paragraph, so that | |
397 the number of paragraphs marked equals ARG. | |
398 | |
399 If ARG is negative, point is put at end of this paragraph, mark is put | |
400 at beginning of this or a previous paragraph. | |
401 | |
402 If this command is repeated, it marks the next ARG paragraphs after (or | |
403 before, if arg is negative) the ones already marked." | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
404 (interactive "p\np") |
687 | 405 (unless arg (setq arg 1)) |
406 (when (zerop arg) | |
407 (error "Cannot mark zero paragraphs")) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
408 (cond ((and allow-extend |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
409 (eq last-command this-command) (mark t)) |
2549 | 410 (set-mark |
411 (save-excursion | |
412 (goto-char (mark)) | |
413 (forward-paragraph arg) | |
414 (point)))) | |
415 (t | |
416 (forward-paragraph arg) | |
417 (push-mark nil t t) | |
418 (backward-paragraph arg)))) | |
428 | 419 |
420 (defun kill-paragraph (arg) | |
421 "Kill forward to end of paragraph. | |
422 With arg N, kill forward to Nth end of paragraph; | |
423 negative arg -N means kill backward to Nth start of paragraph." | |
424 (interactive "*p") ; XEmacs | |
425 (kill-region (point) (progn (forward-paragraph arg) (point)))) | |
426 | |
427 (defun backward-kill-paragraph (arg) | |
428 "Kill back to start of paragraph. | |
429 With arg N, kill back to Nth start of paragraph; | |
430 negative arg -N means kill forward to Nth end of paragraph." | |
431 (interactive "*p") ; XEmacs | |
432 (kill-region (point) (progn (backward-paragraph arg) (point)))) | |
433 | |
434 (defun transpose-paragraphs (arg) | |
435 "Interchange this (or next) paragraph with previous one." | |
436 (interactive "*p") | |
437 (transpose-subr 'forward-paragraph arg)) | |
438 | |
439 (defun start-of-paragraph-text () | |
440 (let ((opoint (point)) npoint) | |
441 (forward-paragraph -1) | |
442 (setq npoint (point)) | |
443 (skip-chars-forward " \t\n") | |
444 ;; If the range of blank lines found spans the original start point, | |
445 ;; try again from the beginning of it. | |
446 ;; Must be careful to avoid infinite loop | |
447 ;; when following a single return at start of buffer. | |
448 (if (and (>= (point) opoint) (< npoint opoint)) | |
449 (progn | |
450 (goto-char npoint) | |
451 (if (> npoint (point-min)) | |
452 (start-of-paragraph-text)))))) | |
453 | |
454 (defun end-of-paragraph-text () | |
455 (let ((opoint (point))) | |
456 (forward-paragraph 1) | |
446 | 457 (if (eq (char-before (point)) ?\n) (backward-char 1)) |
428 | 458 (if (<= (point) opoint) |
459 (progn | |
460 (forward-char 1) | |
461 (if (< (point) (point-max)) | |
462 (end-of-paragraph-text)))))) | |
463 | |
464 (defun forward-sentence (&optional arg) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
465 "Move forward to next end of sentence. With argument, repeat. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
466 With negative argument, move backward repeatedly to start of sentence. |
428 | 467 |
468 The variable `sentence-end' is a regular expression that matches ends of | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
469 sentences. Also, every paragraph boundary terminates sentences as well." |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
470 ;; #### MERGE! FSF Has (interactive "^p") |
428 | 471 (interactive "_p") ; XEmacs |
472 (or arg (setq arg 1)) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
473 (let ((opoint (point)) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
474 (sentence-end (sentence-end))) |
2549 | 475 (while (< arg 0) |
476 (let ((pos (point)) | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
477 ;; We used to use (start-of-paragraph-text), but this can |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
478 ;; prevent sentence-end from matching if it is anchored at |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
479 ;; BOL and the paragraph starts indented. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
480 (par-beg (save-excursion (backward-paragraph) (point)))) |
2549 | 481 (if (and (re-search-backward sentence-end par-beg t) |
482 (or (< (match-end 0) pos) | |
483 (re-search-backward sentence-end par-beg t))) | |
484 (goto-char (match-end 0)) | |
485 (goto-char par-beg))) | |
486 (setq arg (1+ arg))) | |
487 (while (> arg 0) | |
488 (let ((par-end (save-excursion (end-of-paragraph-text) (point)))) | |
489 (if (re-search-forward sentence-end par-end t) | |
490 (skip-chars-backward " \t\n") | |
491 (goto-char par-end))) | |
492 (setq arg (1- arg))) | |
5368
ed74d2ca7082
Use ', not #', when a given symbol may not have a function binding at read time
Aidan Kehoe <kehoea@parhasard.net>
parents:
5229
diff
changeset
|
493 (if-fboundp 'constrain-to-field |
4103 | 494 (constrain-to-field nil opoint t) |
495 (error | |
496 'void-function | |
497 "constrain-to-field not available; is xemacs-base installed?")))) | |
428 | 498 |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
499 (defun repunctuate-sentences () |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
500 "Put two spaces at the end of sentences from point to the end of buffer. |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
501 It works using `query-replace-regexp'." |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
502 (interactive) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
503 (query-replace-regexp "\\([]\"')]?\\)\\([.?!]\\)\\([]\"')]?\\) +" |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
504 "\\1\\2\\3 ")) |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
505 |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
506 |
428 | 507 (defun backward-sentence (&optional arg) |
508 "Move backward to start of sentence. With arg, do it arg times. | |
509 See `forward-sentence' for more information." | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
510 ;; #### MERGE! FSF Has (interactive "^p") |
428 | 511 (interactive "_p") ; XEmacs |
512 (or arg (setq arg 1)) | |
513 (forward-sentence (- arg))) | |
514 | |
515 (defun kill-sentence (&optional arg) | |
516 "Kill from point to end of sentence. | |
517 With arg, repeat; negative arg -N means kill back to Nth start of sentence." | |
518 (interactive "*p") ; XEmacs | |
519 (kill-region (point) (progn (forward-sentence arg) (point)))) | |
520 | |
521 (defun backward-kill-sentence (&optional arg) | |
522 "Kill back from point to start of sentence. | |
523 With arg, repeat, or kill forward to Nth end of sentence if negative arg -N." | |
524 (interactive "*p") ; XEmacs | |
525 (kill-region (point) (progn (backward-sentence arg) (point)))) | |
526 | |
527 (defun mark-end-of-sentence (arg) | |
2549 | 528 "Put mark at end of sentence. Arg works as in `forward-sentence'. |
529 If this command is repeated, it marks the next ARG sentences after the | |
530 ones already marked." | |
428 | 531 (interactive "p") |
532 ;; FSF Version: | |
2549 | 533 ; (push-mark |
534 ; (save-excursion | |
535 ; (if (and (eq last-command this-command) (mark t)) | |
536 ; (goto-char (mark))) | |
537 ; (forward-sentence arg) | |
538 ; (point)) | |
539 ; nil t)) | |
428 | 540 (mark-something 'mark-end-of-sentence 'forward-sentence arg)) |
541 | |
542 (defun mark-end-of-line (arg) | |
543 "Put mark at end of line. Arg works as in `end-of-line'." | |
544 (interactive "p") | |
545 (mark-something 'mark-end-of-line 'end-of-line arg)) | |
546 | |
547 (defun transpose-sentences (arg) | |
548 "Interchange this (next) and previous sentence." | |
549 (interactive "*p") | |
550 (transpose-subr 'forward-sentence arg)) | |
551 | |
5493
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
552 ;; Local Variables: |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
553 ;; coding: utf-8 |
f62141fe007d
Sync paragraphs.el to FSF 23.1.92
Ben Wing <ben@xemacs.org>
parents:
4103
diff
changeset
|
554 ;; End: |
2549 | 555 |
428 | 556 ;;; paragraphs.el ends here |