User: ben Date: 05/02/03 08:15:57 Modified: xemacs/lisp ChangeLog paragraphs.el Log: behavior ws #5: paragraphs.el sync to 21.3 paragraphs.el: Sync to 21.3. Depends on easy-mmode in core. Revision Changes Path 1.625 +18 -19 XEmacs/xemacs/lisp/ChangeLog (In the diff below, changes in quantity of whitespace are not shown.) Index: ChangeLog =================================================================== RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/ChangeLog,v retrieving revision 1.624 retrieving revision 1.625 diff -u -b -r1.624 -r1.625 --- ChangeLog 2005/02/03 07:11:19 1.624 +++ ChangeLog 2005/02/03 07:15:56 1.625 ＠＠ -1,3 +1,21 ＠＠ +2005-02-03 Ben Wing <ben(a)xemacs.org&gt; + + * paragraphs.el: + * paragraphs.el (paragraphs): New. + * paragraphs.el (use-hard-newlines): Removed. + * paragraphs.el (paragraph-start): + * paragraphs.el (paragraph-separate): + * paragraphs.el (sentence-end-double-space): New. + * paragraphs.el (sentence-end-without-period): New. + * paragraphs.el (sentence-end): + * paragraphs.el (forward-paragraph): + * paragraphs.el (backward-paragraph): + * paragraphs.el (mark-paragraph): + * paragraphs.el (forward-sentence): + * paragraphs.el (mark-end-of-sentence): + * paragraphs.el (transpose-sentences): + Sync to 21.3. Depends on easy-mmode in core. + 2005-02-02 Ben Wing <ben(a)xemacs.org&gt; * easy-mmode.el, regexp-opt.el: ＠＠ -249,25 +267,6 ＠＠ * custom.el (custom-theme-reset-variables): * custom.el (custom-reset-variables): Sync with FSF 21.3. - -2004-11-09 Ben Wing <ben(a)xemacs.org&gt; - - * paragraphs.el: - * paragraphs.el (paragraphs): New. - * paragraphs.el (use-hard-newlines): Removed. - * paragraphs.el (paragraph-start): - * paragraphs.el (paragraph-separate): - * paragraphs.el (sentence-end-double-space): New. - * paragraphs.el (sentence-end-without-period): New. - * paragraphs.el (sentence-end): - * paragraphs.el (forward-paragraph): - * paragraphs.el (backward-paragraph): - * paragraphs.el (mark-paragraph): - * paragraphs.el (forward-sentence): - * paragraphs.el (mark-end-of-sentence): - * paragraphs.el (transpose-sentences): - Sync to 21.3. Depends on easy-mmode in core. - 2005-01-31 Ben Wing <ben(a)xemacs.org&gt; 1.8 +201 -134 XEmacs/xemacs/lisp/paragraphs.el (In the diff below, changes in quantity of whitespace are not shown.) Index: paragraphs.el =================================================================== RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/paragraphs.el,v retrieving revision 1.7 retrieving revision 1.8 diff -u -b -r1.7 -r1.8 --- paragraphs.el 2001/12/05 04:09:25 1.7 +++ paragraphs.el 2005/02/03 07:15:56 1.8 ＠＠ -1,6 +1,6 ＠＠ -;;; paragraphs.el --- paragraph and sentence parsing. +;;; paragraphs.el --- paragraph and sentence parsing -;; Copyright (C) 1985, 86, 87, 91, 94, 95, 97, 2001 +;; Copyright (C) 1985, 86, 87, 91, 94, 95, 96, 1997, 1999, 2000, 2001 ;; Free Software Foundation, Inc. ;; Maintainer: FSF ＠＠ -23,7 +23,7 ＠＠ ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA ;; 02111-1307, USA. -;;; Synched up with: FSF 19.34. +;;; Synched up with: FSF 21.3. ;;; Commentary: ＠＠ -37,19 +37,11 ＠＠ ;;; Code: -(defvar use-hard-newlines nil - "Non-nil means to distinguish hard and soft newlines. -When this is non-nil, the functions `newline' and `open-line' add the -text-property `hard' to newlines that they insert. Also, a line is -only considered as a candidate to match `paragraph-start' or -`paragraph-separate' if it follows a hard newline. Newlines not -marked hard are called \"soft\", and are always internal to -paragraphs. The fill functions always insert soft newlines. - -Each buffer has its own value of this variable.") -(make-variable-buffer-local 'use-hard-newlines) +(defgroup paragraphs nil + "Paragraph and sentence parsing." + :group 'editing) -(defun use-hard-newlines (&optional arg insert) +(define-minor-mode use-hard-newlines "Minor mode to distinguish hard and soft newlines. When active, the functions `newline' and `open-line' add the text-property `hard' to newlines that they insert, and a line is ＠＠ -58,7 +50,7 ＠＠ Prefix argument says to turn mode on if positive, off if negative. When the mode is turned on, if there are newlines in the buffer but no hard -newlines, ask the user whether to mark as hard any newlines preceding a +newlines, ask the user whether to mark as hard any newlines preceeding a `paragraph-start' line. From a program, second arg INSERT specifies whether to do this; it can be `never' to change nothing, t or `always' to force marking, `guess' to try to do the right thing with no questions, nil ＠＠ -66,17 +58,14 ＠＠ Newlines not marked hard are called \"soft\", and are always internal to paragraphs. The fill functions insert and delete only soft newlines." - (interactive (list current-prefix-arg nil)) - (if (or (<= (prefix-numeric-value arg) 0) - (and use-hard-newlines (null arg))) - ;; Turn mode off - (setq use-hard-newlines nil) + :group 'paragraphs + :extra-args (insert) + (when use-hard-newlines ;; Turn mode on ;; Intuit hard newlines -- ;; mark as hard any newlines preceding a paragraph-start line. (if (or (eq insert t) (eq insert 'always) (and (not (eq 'never insert)) - (not use-hard-newlines) (not (text-property-any (point-min) (point-max) 'hard t)) (save-excursion (goto-char (point-min)) ＠＠ -88,19 +77,16 ＠＠ (while (search-forward "\n" nil t) (let ((pos (point))) (move-to-left-margin) - (if (looking-at paragraph-start) - (progn - (set-hard-newline-properties (1- pos) pos) + (when (looking-at paragraph-start) + (set-hard-newline-properties (1- pos) pos)) ;; If paragraph-separate, newline after it is hard too. - (if (looking-at paragraph-separate) - (progn + (when (looking-at paragraph-separate) + (set-hard-newline-properties (1- pos) pos) (end-of-line) - (if (not (eobp)) - (set-hard-newline-properties - (point) (1+ (point)))))))))))) - (setq use-hard-newlines t))) + (unless (eobp) + (set-hard-newline-properties (point) (1+ (point))))))))))) -(defconst paragraph-start "[ \t\n\f]" "\ +(defcustom paragraph-start "\f\\|[ \t]*$" "\ *Regexp for beginning of a line that starts OR separates paragraphs. This regexp should match lines that separate paragraphs and should also match lines that start a paragraph ＠＠ -115,7 +101,9 ＠＠ lines that start paragraphs from lines that separate them. If the variable `use-hard-newlines' is non-nil, then only lines following a -hard newline are considered to match.") +hard newline are considered to match." + :group 'paragraphs + :type 'regexp) ;; paragraph-start requires a hard newline, but paragraph-separate does not: ;; It is assumed that paragraph-separate is distinctive enough to be believed ＠＠ -123,8 +111,8 ＠＠ ;; something very minimal, even including "." (which makes every hard newline ;; start a new paragraph). -(defconst paragraph-separate "[ \t\f]*$" "\ -*Regexp for beginning of a line that separates paragraphs. +(defcustom paragraph-separate "[ \t\f]*$" + "*Regexp for beginning of a line that separates paragraphs. If you change this, you may have to change `paragraph-start' also. A line matching this is not part of any paragraph. ＠＠ -132,34 +120,78 ＠＠ This is matched against the text at the left margin, which is not necessarily the beginning of the line, so it should not use \"^\" as an anchor. This ensures that the paragraph functions will work equally within a region of -text indented by a margin setting.") - -(defconst sentence-end "[.?!][]\"')}]*\\($\\| $\\|\t\\| \\)[ \t\n]*" "\ -*Regexp describing the end of a sentence. +text indented by a margin setting." + :group 'paragraphs + :type 'regexp) + +(defcustom sentence-end-double-space t + "*Non-nil means a single space does not end a sentence. +This is relevant for filling. See also `sentence-end-without-period' +and `colon-double-space'. + +This variable applies only to filling, not motion commands. To +change the behavior of motion commands, see `sentence-end'. + +If you change this, you should also change `sentence-end'. See Info +node `Sentences'." + :type 'boolean + :group 'fill) + +(defcustom sentence-end-without-period nil + "*Non-nil means a sentence will end without a period. +For example, a sentence in Thai text ends with double space but +without a period." + :type 'boolean + :group 'fill) + +(defcustom sentence-end + (purecopy + ;; This is a bit stupid since it's not auto-updated when the + ;; other variables are changes, but it's still useful info. + (concat (if sentence-end-without-period "\\w \\|") + "[.?!$B!#!%!)!*$A!##.#?#!$(0!$!%!)!*$(G!$!%!)!*(B][]\"')}]*" + (if sentence-end-double-space + "\\($\\| $\\|\t\\| \\)" "\\($\\|[\t ]\\)") + "[ \t\n]*")) + "*Regexp describing the end of a sentence. +The value includes the whitespace following the sentence. All paragraph boundaries also end sentences, regardless. -In order to be recognized as the end of a sentence, the ending period, -question mark, or exclamation point must be followed by two spaces, -unless it's inside some sort of quotes or parenthesis.") - -(defconst page-delimiter "^\014" "\ -*Regexp describing line-beginnings that separate pages.") - -(defvar paragraph-ignore-fill-prefix nil "\ -Non-nil means the paragraph commands are not affected by `fill-prefix'. -This is desirable in modes where blank lines are the paragraph delimiters.") +The default value specifies that in order to be recognized as the end +of a sentence, the ending period, question mark, or exclamation point +must be followed by two spaces, unless it's inside some sort of quotes +or parenthesis. + +See also the variable `sentence-end-double-space', the variable +`sentence-end-without-period' and Info node `Sentences'." + :group 'paragraphs + :type 'regexp) + +(defcustom page-delimiter "^\014" + "*Regexp describing line-beginnings that separate pages." + :group 'paragraphs + :type 'regexp) + +(defcustom paragraph-ignore-fill-prefix nil + "*Non-nil means the paragraph commands are not affected by `fill-prefix'. +This is desirable in modes where blank lines are the paragraph delimiters." + :group 'paragraphs + :type 'boolean) (defun forward-paragraph (&optional arg) "Move forward to end of paragraph. -With arg N, do it N times; negative arg -N means move backward N paragraphs. +With argument ARG, do it ARG times; +a negative argument ARG = -N means move backward N paragraphs. A line which `paragraph-start' matches either separates paragraphs \(if `paragraph-separate' matches it also) or is the first line of a paragraph. A paragraph end is the beginning of a line which is not part of the paragraph -to which the end of the previous line belongs, or the end of the buffer." +to which the end of the previous line belongs, or the end of the buffer. +Returns the count of paragraphs left to move." (interactive "_p") ; XEmacs (or arg (setq arg 1)) - (let* ((fill-prefix-regexp + (let* ((opoint (point)) + (fill-prefix-regexp (and fill-prefix (not (equal fill-prefix "")) (not paragraph-ignore-fill-prefix) (regexp-quote fill-prefix))) ＠＠ -168,70 +200,74 ＠＠ ;; starting at the left-margin. This allows paragraph commands to ;; work normally with indented text. ;; This hack will not find problem cases like "whatever\\|^something". - (paragraph-start (if (and (not (equal "" paragraph-start)) + (parstart (if (and (not (equal "" paragraph-start)) (equal ?^ (aref paragraph-start 0))) (substring paragraph-start 1) paragraph-start)) - (paragraph-separate (if (and (not (equal "" paragraph-start)) + (parsep (if (and (not (equal "" paragraph-separate)) (equal ?^ (aref paragraph-separate 0))) (substring paragraph-separate 1) paragraph-separate)) - (paragraph-separate + (parsep (if fill-prefix-regexp - (concat paragraph-separate "\\|" + (concat parsep "\\|" fill-prefix-regexp "[ \t]*$") - paragraph-separate)) + parsep)) ;; This is used for searching. - (sp-paragraph-start (concat "^[ \t]*\\(" paragraph-start "\\)")) - start) + (sp-parstart (concat "^[ \t]*\\(?:" parstart "\\|" parsep "\\)")) + start found-start) (while (and (< arg 0) (not (bobp))) - (if (and (not (looking-at paragraph-separate)) + (if (and (not (looking-at parsep)) (re-search-backward "^\n" (max (1- (point)) (point-min)) t) - (looking-at paragraph-separate)) - nil + (looking-at parsep)) + (setq arg (1+ arg)) (setq start (point)) ;; Move back over paragraph-separating lines. (backward-char 1) (beginning-of-line) (while (and (not (bobp)) (progn (move-to-left-margin) - (looking-at paragraph-separate))) + (looking-at parsep))) (forward-line -1)) (if (bobp) nil + (setq arg (1+ arg)) ;; Go to end of the previous (non-separating) line. (end-of-line) ;; Search back for line that starts or separates paragraphs. (if (if fill-prefix-regexp - ;; There is a fill prefix; it overrides paragraph-start. + ;; There is a fill prefix; it overrides parstart. (let (multiple-lines) (while (and (progn (beginning-of-line) (not (bobp))) (progn (move-to-left-margin) - (not (looking-at paragraph-separate))) + (not (looking-at parsep))) (looking-at fill-prefix-regexp)) - (if (not (= (point) start)) + (unless (= (point) start) (setq multiple-lines t)) (forward-line -1)) (move-to-left-margin) - ;; Don't move back over a line before the paragraph - ;; which doesn't start with fill-prefix - ;; unless that is the only line we've moved over. - (and (not (looking-at fill-prefix-regexp)) - multiple-lines - (forward-line 1)) + ;; This deleted code caused a long hanging-indent line + ;; not to be filled together with the following lines. + ;; ;; Don't move back over a line before the paragraph + ;; ;; which doesn't start with fill-prefix + ;; ;; unless that is the only line we've moved over. + ;; (and (not (looking-at fill-prefix-regexp)) + ;; multiple-lines + ;; (forward-line 1)) (not (bobp))) - (while (and (re-search-backward sp-paragraph-start nil 1) + (while (and (re-search-backward sp-parstart nil 1) + (setq found-start t) ;; Found a candidate, but need to check if it is a - ;; REAL paragraph-start. - (not (bobp)) + ;; REAL parstart. (progn (setq start (point)) (move-to-left-margin) - (not (looking-at paragraph-separate))) - (or (not (looking-at paragraph-start)) - (and use-hard-newlines - (not (get-text-property (1- start) - 'hard))))) + (not (looking-at parsep))) + (not (and (looking-at parstart) + (or (not use-hard-newlines) + (get-text-property (1- start) 'hard) + (bobp))))) + (setq found-start nil) (goto-char start)) - (> (point) (point-min))) + found-start) ;; Found one. (progn ;; Move forward over paragraph separators. ＠＠ -239,7 +275,7 ＠＠ ;; because we know we moved back over a non-separator. (while (and (not (eobp)) (progn (move-to-left-margin) - (looking-at paragraph-separate))) + (looking-at parsep))) (forward-line 1)) ;; If line before paragraph is just margin, back up to there. (end-of-line 0) ＠＠ -249,38 +285,44 ＠＠ (if (not (bolp)) (forward-line 1)))) ;; No starter or separator line => use buffer beg. - (goto-char (point-min))))) - (setq arg (1+ arg))) + (goto-char (point-min)))))) + (while (and (> arg 0) (not (eobp))) - ;; Move forward over separator lines, and one more line. - (while (prog1 (and (not (eobp)) + ;; Move forward over separator lines... + (while (and (not (eobp)) (progn (move-to-left-margin) (not (eobp))) - (looking-at paragraph-separate)) - (forward-line 1))) + (looking-at parsep)) + (forward-line 1)) + (unless (eobp) (setq arg (1- arg))) + ;; ... and one more line. + (forward-line 1) (if fill-prefix-regexp - ;; There is a fill prefix; it overrides paragraph-start. + ;; There is a fill prefix; it overrides parstart. (while (and (not (eobp)) (progn (move-to-left-margin) (not (eobp))) - (not (looking-at paragraph-separate)) + (not (looking-at parsep)) (looking-at fill-prefix-regexp)) (forward-line 1)) - (while (and (re-search-forward sp-paragraph-start nil 1) + (while (and (re-search-forward sp-parstart nil 1) (progn (setq start (match-beginning 0)) (goto-char start) (not (eobp))) (progn (move-to-left-margin) - (not (looking-at paragraph-separate))) - (or (not (looking-at paragraph-start)) + (not (looking-at parsep))) + (or (not (looking-at parstart)) (and use-hard-newlines (not (get-text-property (1- start) 'hard))))) (forward-char 1)) (if (< (point) (point-max)) - (goto-char start))) - (setq arg (1- arg))))) + (goto-char start)))) + (constrain-to-field nil opoint t) + ;; Return the number of steps that could not be done. + arg)) (defun backward-paragraph (&optional arg) "Move backward to start of paragraph. -With arg N, do it N times; negative arg -N means move forward N paragraphs. +With argument ARG, do it ARG times; +a negative argument ARG = -N means move forward N paragraphs. A paragraph start is the beginning of a line which is a `first-line-of-paragraph' or which is ordinary text and follows a ＠＠ -296,16 +338,29 ＠＠ (defun mark-paragraph (&optional arg) "Put point at beginning of this paragraph, mark at end. The paragraph marked is the one that contains point or follows point. -With arg N, puts mark at end of following N paragraphs; -negative arg -N means point is put at end of this paragraph, mark is put -at beginning of this or a previous paragraph." + +With argument ARG, puts mark at end of a following paragraph, so that +the number of paragraphs marked equals ARG. + +If ARG is negative, point is put at end of this paragraph, mark is put +at beginning of this or a previous paragraph. + +If this command is repeated, it marks the next ARG paragraphs after (or +before, if arg is negative) the ones already marked." (interactive "p") (unless arg (setq arg 1)) (when (zerop arg) (error "Cannot mark zero paragraphs")) + (cond ((and (eq last-command this-command) (mark t)) + (set-mark + (save-excursion + (goto-char (mark)) + (forward-paragraph arg) + (point)))) + (t (forward-paragraph arg) (push-mark nil t t) - (backward-paragraph arg)) + (backward-paragraph arg)))) (defun kill-paragraph (arg) "Kill forward to end of paragraph. ＠＠ -359,10 +414,14 ＠＠ sentences. A paragraph boundary also terminates a sentence." (interactive "_p") ; XEmacs (or arg (setq arg 1)) + (let ((opoint (point))) (while (< arg 0) - (let ((par-beg (save-excursion (start-of-paragraph-text) (point)))) - (if (re-search-backward (concat sentence-end "[^ \t\n]") par-beg t) - (goto-char (1- (match-end 0))) + (let ((pos (point)) + (par-beg (save-excursion (start-of-paragraph-text) (point)))) + (if (and (re-search-backward sentence-end par-beg t) + (or (< (match-end 0) pos) + (re-search-backward sentence-end par-beg t))) + (goto-char (match-end 0)) (goto-char par-beg))) (setq arg (1+ arg))) (while (> arg 0) ＠＠ -370,7 +429,8 ＠＠ (if (re-search-forward sentence-end par-end t) (skip-chars-backward " \t\n") (goto-char par-end))) - (setq arg (1- arg)))) + (setq arg (1- arg))) + (constrain-to-field nil opoint t))) (defun backward-sentence (&optional arg) "Move backward to start of sentence. With arg, do it arg times. ＠＠ -392,11 +452,15 ＠＠ (kill-region (point) (progn (backward-sentence arg) (point)))) (defun mark-end-of-sentence (arg) - "Put mark at end of sentence. Arg works as in `forward-sentence'." + "Put mark at end of sentence. Arg works as in `forward-sentence'. +If this command is repeated, it marks the next ARG sentences after the +ones already marked." (interactive "p") ;; FSF Version: ; (push-mark ; (save-excursion +; (if (and (eq last-command this-command) (mark t)) +; (goto-char (mark))) ; (forward-sentence arg) ; (point)) ; nil t)) ＠＠ -407,10 +471,13 ＠＠ (interactive "p") (mark-something 'mark-end-of-line 'end-of-line arg)) - (defun transpose-sentences (arg) "Interchange this (next) and previous sentence." (interactive "*p") (transpose-subr 'forward-sentence arg)) + +;;; Local Variables: +;;; coding: iso-2022-7bit +;;; End: ;;; paragraphs.el ends here