-;;; paragraphs.el --- paragraph and sentence parsing.
+;;; paragraphs.el --- paragraph and sentence parsing
-;; Copyright (C) 1985, 86, 87, 91, 94, 95, 96, 1997, 1999
+;; Copyright (C) 1985, 86, 87, 91, 94, 95, 96, 1997, 1999, 2000, 2001
;; Free Software Foundation, Inc.
;; Maintainer: FSF
"Paragraph and sentence parsing."
:group 'editing)
-;; It isn't useful to use defcustom for this variable
-;; because it is always buffer-local.
-(defvar use-hard-newlines nil
- "Non-nil means to distinguish hard and soft newlines.
-See also the documentation for the function `use-hard-newlines'.")
-(make-variable-buffer-local 'use-hard-newlines)
-
-(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
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 preceeding 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
+marking, `guess' to try to do the right thing with no questions, nil
or anything else to ask the user.
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))
(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)
- ;; If paragraph-separate, newline after it is hard too.
- (if (looking-at paragraph-separate)
- (progn
- (end-of-line)
- (if (not (eobp))
- (set-hard-newline-properties
- (point) (1+ (point))))))))))))
- (setq use-hard-newlines t)))
-
-(defcustom paragraph-start "[ \t\n\f]" "\
+ (when (looking-at paragraph-start)
+ (set-hard-newline-properties (1- pos) pos))
+ ;; If paragraph-separate, newline after it is hard too.
+ (when (looking-at paragraph-separate)
+ (set-hard-newline-properties (1- pos) pos)
+ (end-of-line)
+ (unless (eobp)
+ (set-hard-newline-properties (point) (1+ (point)))))))))))
+
+(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
:group 'paragraphs
:type 'regexp)
-(defcustom sentence-end (purecopy "[.?!][]\"')}]*\\($\\| $\\|\t\\| \\)[ \t\n]*")
+(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'.
+
+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 \\|")
+ "[.?!\e$B!#!%!)!*\e$A!##.#?#!\e$(0!$!%!)!*\e$(G!$!%!)!*\e(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.
The default value specifies that in order to be recognized as the end
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")
(or arg (setq arg 1))
(let* ((opoint (point))
;; 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))
- (equal ?^ (aref paragraph-start 0)))
- (substring paragraph-start 1)
- paragraph-start))
- (paragraph-separate (if (and (not (equal "" paragraph-separate))
- (equal ?^ (aref paragraph-separate 0)))
- (substring paragraph-separate 1)
- paragraph-separate))
- (paragraph-separate
+ (parstart (if (and (not (equal "" paragraph-start))
+ (equal ?^ (aref paragraph-start 0)))
+ (substring paragraph-start 1)
+ paragraph-start))
+ (parsep (if (and (not (equal "" paragraph-separate))
+ (equal ?^ (aref paragraph-separate 0)))
+ (substring paragraph-separate 1)
+ 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 "\\)"))
+ (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.
(forward-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))
(unless (= (point) start)
(setq multiple-lines t))
(forward-line -1))
(move-to-left-margin)
-;;; 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))
+ ;; 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.
+ ;; REAL parstart.
(progn (setq start (point))
(move-to-left-margin)
- (not (looking-at paragraph-separate)))
- (not (and (looking-at paragraph-start)
- (not
- (and use-hard-newlines
- (not (bobp))
- (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))
found-start)
;; 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)
(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))
- (progn (move-to-left-margin) (not (eobp)))
- (looking-at paragraph-separate))
- (forward-line 1)))
+ ;; Move forward over separator lines...
+ (while (and (not (eobp))
+ (progn (move-to-left-margin) (not (eobp)))
+ (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)))
- (constrain-to-field nil opoint t)))
+ (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.
(or arg (setq arg 1))
(forward-paragraph (- arg)))
-(defun mark-paragraph ()
+(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."
- (interactive)
- (forward-paragraph 1)
- (push-mark nil t t)
- (backward-paragraph 1))
+The paragraph marked is the one that contains point or follows point.
+
+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))))
(defun kill-paragraph (arg)
"Kill forward to end of paragraph.
(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)
(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")
(push-mark
- (save-excursion
- (forward-sentence arg)
- (point))
- nil t))
+ (save-excursion
+ (if (and (eq last-command this-command) (mark t))
+ (goto-char (mark)))
+ (forward-sentence arg)
+ (point))
+ nil t))
(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
HCoop / bpt / emacs.git / blobdiff