Mercurial > hg > xemacs-beta
annotate lisp/paragraphs.el @ 5553:62edcc6a11ec
Add an assertion about argument order to #'apply-partially compiler macro
lisp/ChangeLog addition:
2011-08-24 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (apply-partially):
Add an assertion to this compiler macro, requiring that the order
of the placeholders corresponding to the arguments in the
constants vector of the constructed compiled function be the same
as the order of the arguments to #'apply-partially.
tests/ChangeLog addition:
2011-08-24 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-tests.el:
Add a test of apply partially that depends on the relative order
of its arguments.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Wed, 24 Aug 2011 11:06:41 +0100 |
| parents | 1f0b15040456 |
| 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 |