-;;; paragraphs.el --- paragraph and sentence parsing.
+;;; paragraphs.el --- paragraph and sentence parsing
-;; Copyright (C) 1985, 86, 87, 91, 94, 95 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 86, 87, 91, 94, 95, 96, 1997, 1999, 2000, 2001, 2004
+;; Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: wp
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
;;; 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)
-(defconst paragraph-start "[ \t\n\f]" "\
+(put 'use-hard-newlines 'permanent-local t)
+(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
+only considered as a candidate to match `paragraph-start' or
+`paragraph-separate' if it follows a hard newline.
+
+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
+`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
+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."
+ :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 (text-property-any (point-min) (point-max) 'hard t))
+ (save-excursion
+ (goto-char (point-min))
+ (search-forward "\n" nil t))
+ (or (eq insert 'guess)
+ (y-or-n-p "Make newlines between paragraphs hard? "))))
+ (save-excursion
+ (goto-char (point-min))
+ (while (search-forward "\n" nil t)
+ (let ((pos (point)))
+ (move-to-left-margin)
+ (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
The variable `paragraph-separate' specifies how to distinguish
lines that start paragraphs from lines that separate them.
-If the variable `use-hard-newlines' is nonnil, then only lines following a
-hard newline are considered to match.")
+If the variable `use-hard-newlines' is non-nil, then only lines following a
+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
;; 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.
-If you change this, you may have to change paragraph-start also.
+(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.
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 (purecopy "[.?!][]\"')}]*\\($\\| $\\|\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 value is used by the function `sentence-end' to construct the
+regexp describing the end of a sentence, when the value of the variable
+`sentence-end' is nil. See Info node `(elisp)Standard Regexps'."
+ :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.
+
+This value is used by the function `sentence-end' to construct the
+regexp describing the end of a sentence, when the value of the variable
+`sentence-end' is nil. See Info node `(elisp)Standard Regexps'."
+ :type 'boolean
+ :group 'fill)
+
+(defcustom sentence-end-without-space
+ "\e$B!#!%!)!*\e$A!##.#?#!\e$(0!$!%!)!*\e$(G!$!%!)!*\e(B"
+ "*String of characters that end sentence without following spaces.
+
+This value is used by the function `sentence-end' to construct the
+regexp describing the end of a sentence, when the value of the variable
+`sentence-end' is nil. See Info node `(elisp)Standard Regexps'."
+ :group 'paragraphs
+ :type 'string)
+
+(defcustom sentence-end nil
+ "*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 value nil means to use the default value defined by the
+function `sentence-end'. You should always use this function
+to obtain the value of this variable."
+ :group 'paragraphs
+ :type '(choice regexp (const :tag "Use default value" nil)))
+
+(defun sentence-end ()
+ "Return the regexp describing the end of a sentence.
+
+This function returns either the value of the variable `sentence-end'
+if it is non-nil, or the default value constructed from the
+variables `sentence-end-double-space', `sentence-end-without-period'
+and `sentence-end-without-space'. 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 Info node `(elisp)Standard Regexps'."
+ (or sentence-end
+ (concat (if sentence-end-without-period "\\w \\|")
+ "\\([.?!][]\"'\xd0c9\x5397d)}]*"
+ (if sentence-end-double-space
+ "\\($\\| $\\|\t\\| \\)" "\\($\\|[\t ]\\)")
+ "\\|[" sentence-end-without-space "]+\\)"
+ "[ \t\n]*")))
+
+(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")
(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)))
;; 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-start))
- (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 "\\)"))
- 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)))
- (forward-line -1))
+ (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))
- (setq multiple-lines t))
+ (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)
+ (bobp)
+ (get-text-property
+ (1- start) 'hard)))))
+ (setq found-start nil)
(goto-char start))
- (> (point) (point-min)))
+ found-start)
;; Found one.
(progn
;; Move forward over paragraph separators.
;; 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)))))
+ (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
(or arg (setq arg 1))
(forward-paragraph (- arg)))
-(defun mark-paragraph ()
+(defun mark-paragraph (&optional arg allow-extend)
"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.
+
+Interactively, if this command is repeated
+or (in Transient Mark mode) if the mark is active,
+it marks the next ARG paragraphs after the ones already marked."
+ (interactive "p\np")
+ (unless arg (setq arg 1))
+ (when (zerop arg)
+ (error "Cannot mark zero paragraphs"))
+ (cond ((and allow-extend
+ (or (and (eq last-command this-command) (mark t))
+ (and transient-mark-mode mark-active)))
+ (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.
sentences. Also, every paragraph boundary terminates sentences as well."
(interactive "p")
(or arg (setq arg 1))
- (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)))
- (goto-char par-beg)))
- (setq arg (1+ arg)))
- (while (> arg 0)
- (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
- (if (re-search-forward sentence-end par-end t)
- (skip-chars-backward " \t\n")
- (goto-char par-end)))
- (setq arg (1- arg))))
+ (let ((opoint (point))
+ (sentence-end (sentence-end)))
+ (while (< arg 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)
+ (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
+ (if (re-search-forward sentence-end par-end t)
+ (skip-chars-backward " \t\n")
+ (goto-char par-end)))
+ (setq arg (1- arg)))
+ (constrain-to-field nil opoint t)))
+
+(defun repunctuate-sentences ()
+ "Put two spaces at the end of sentences from point to the end of buffer.
+It works using `query-replace-regexp'."
+ (interactive)
+ (query-replace-regexp "\\([]\"')]?\\)\\([.?!]\\)\\([]\"')]?\\) +"
+ "\\1\\2\\3 "))
+
(defun backward-sentence (&optional arg)
"Move backward to start of sentence. With arg, do it arg times.
(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:
+
+;;; arch-tag: e727eb1a-527a-4464-b9d7-9d3ec0d1a575
;;; paragraphs.el ends here
HCoop / bpt / emacs.git / blobdiff