[bpt/emacs.git] / lisp / textmodes / paragraphs.el

;;; paragraphs.el --- paragraph and sentence parsing.

;; Copyright (C) 1985, 86, 87, 91, 94, 95 Free Software Foundation, Inc.

;; Maintainer: FSF
;; Keywords: wp

;; This file is part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; 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.

;;; Commentary:

;; This package provides the paragraph-oriented commands documented in the
;; Emacs manual.

;;; 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)

(defconst paragraph-start "[ \t\n\f]" "\
*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
\(and are part of that paragraph).

This is matched against the text at the left margin, which is not necessarily
the beginning of the line, so it should never use \"^\" as an anchor.  This
ensures that the paragraph functions will work equally well within a region
of text indented by a margin setting.

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.")

;; paragraph-start requires a hard newline, but paragraph-separate does not:
;; It is assumed that paragraph-separate is distinctive enough to be believed
;; whenever it occurs, while it is reasonable to set paragraph-start to
;; 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.

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.
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.")

(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.

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."
  (interactive "p")
  (or arg (setq arg 1))
  (let* ((fill-prefix-regexp
	  (and fill-prefix (not (equal fill-prefix ""))
	       (not paragraph-ignore-fill-prefix)
	       (regexp-quote fill-prefix)))
	 ;; Remove ^ from paragraph-start and paragraph-sep if they are there.
	 ;; These regexps shouldn't be anchored, because we look for them
	 ;; 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
	  (if fill-prefix-regexp
	      (concat paragraph-separate "\\|"
		      fill-prefix-regexp "[ \t]*$")
	    paragraph-separate))
	 ;; This is used for searching.
	 (sp-paragraph-start (concat "^[ \t]*\\(" paragraph-start "\\)"))
	 start)
    (while (and (< arg 0) (not (bobp)))
      (if (and (not (looking-at paragraph-separate))
	       (re-search-backward "^\n" (max (1- (point)) (point-min)) t)
	       (looking-at paragraph-separate))
	  nil
	(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)) 
	(if (bobp)
	    nil
	  ;; 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.
		  (let (multiple-lines)
		    (while (and (progn (beginning-of-line) (not (bobp)))
				(progn (move-to-left-margin)
				       (not (looking-at paragraph-separate)))
				(looking-at fill-prefix-regexp))
		      (if (not (= (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))
		    (not (bobp)))
		(while (and (re-search-backward sp-paragraph-start nil 1)
			    ;; Found a candidate, but need to check if it is a
			    ;; REAL paragraph-start.
			    (not (bobp))
			    (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)))))
		  (goto-char start))
		(> (point) (point-min)))
	      ;; Found one.
	      (progn
		;; Move forward over paragraph separators.
		;; We know this cannot reach the place we started
		;; because we know we moved back over a non-separator.
		(while (and (not (eobp))
			    (progn (move-to-left-margin)
				   (looking-at paragraph-separate)))
		  (forward-line 1))
		;; If line before paragraph is just margin, back up to there.
		(end-of-line 0)
		(if (> (current-column) (current-left-margin))
		    (forward-char 1)
		  (skip-chars-backward " \t")
		  (if (not (bolp))
		      (forward-line 1))))
	    ;; No starter or separator line => use buffer beg.
	    (goto-char (point-min)))))
      (setq arg (1+ arg)))
    (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)))
      (if fill-prefix-regexp
	  ;; There is a fill prefix; it overrides paragraph-start.
	  (while (and (not (eobp))
		      (progn (move-to-left-margin) (not (eobp)))
		      (not (looking-at paragraph-separate))
		      (looking-at fill-prefix-regexp))
	    (forward-line 1))
	(while (and (re-search-forward sp-paragraph-start 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))
			(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)))))

(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.

A paragraph start is the beginning of a line which is a
`first-line-of-paragraph' or which is ordinary text and follows a
paragraph-separating line; except: if the first real line of a
paragraph is preceded by a blank line, the paragraph starts at that
blank line.

See `forward-paragraph' for more information."
  (interactive "p")
  (or arg (setq arg 1))
  (forward-paragraph (- arg)))

(defun mark-paragraph ()
  "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))

(defun kill-paragraph (arg)
  "Kill forward to end of paragraph.
With arg N, kill forward to Nth end of paragraph;
negative arg -N means kill backward to Nth start of paragraph."
  (interactive "p")
  (kill-region (point) (progn (forward-paragraph arg) (point))))

(defun backward-kill-paragraph (arg)
  "Kill back to start of paragraph.
With arg N, kill back to Nth start of paragraph;
negative arg -N means kill forward to Nth end of paragraph."
  (interactive "p")
  (kill-region (point) (progn (backward-paragraph arg) (point))))

(defun transpose-paragraphs (arg)
  "Interchange this (or next) paragraph with previous one."
  (interactive "*p")
  (transpose-subr 'forward-paragraph arg))

(defun start-of-paragraph-text ()
  (let ((opoint (point)) npoint)
    (forward-paragraph -1)
    (setq npoint (point))
    (skip-chars-forward " \t\n")
    ;; If the range of blank lines found spans the original start point,
    ;; try again from the beginning of it.
    ;; Must be careful to avoid infinite loop
    ;; when following a single return at start of buffer.
    (if (and (>= (point) opoint) (< npoint opoint))
	(progn
	  (goto-char npoint)
	  (if (> npoint (point-min))
	      (start-of-paragraph-text))))))

(defun end-of-paragraph-text ()
  (let ((opoint (point)))
    (forward-paragraph 1)
    (if (eq (preceding-char) ?\n) (forward-char -1))
    (if (<= (point) opoint)
	(progn
	  (forward-char 1)
	  (if (< (point) (point-max))
	      (end-of-paragraph-text))))))

(defun forward-sentence (&optional arg)
  "Move forward to next `sentence-end'.  With argument, repeat.
With negative argument, move backward repeatedly to `sentence-beginning'.

The variable `sentence-end' is a regular expression that matches ends of
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))))

(defun backward-sentence (&optional arg)
  "Move backward to start of sentence.  With arg, do it arg times.
See `forward-sentence' for more information."
  (interactive "p")
  (or arg (setq arg 1))
  (forward-sentence (- arg)))

(defun kill-sentence (&optional arg)
  "Kill from point to end of sentence.
With arg, repeat; negative arg -N means kill back to Nth start of sentence."
  (interactive "p")
  (kill-region (point) (progn (forward-sentence arg) (point))))

(defun backward-kill-sentence (&optional arg)
  "Kill back from point to start of sentence.
With arg, repeat, or kill forward to Nth end of sentence if negative arg -N."
  (interactive "p")
  (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'."
  (interactive "p")
  (push-mark
    (save-excursion
      (forward-sentence arg)
      (point))
    nil t))

(defun transpose-sentences (arg)
  "Interchange this (next) and previous sentence."
  (interactive "*p")
  (transpose-subr 'forward-sentence arg))

;;; paragraphs.el ends here
Commit	Line	Data
6594deb0 ER	1	;;; paragraphs.el --- paragraph and sentence parsing.
6594deb0 ER	2
f8c25f1b	3	;; Copyright (C) 1985, 86, 87, 91, 94, 95 Free Software Foundation, Inc.
9750e079	4
4821e2af	5	;; Maintainer: FSF
d7b4d18f	6	;; Keywords: wp
4821e2af	7
a2535589 JA	8	;; This file is part of GNU Emacs.
	9
	10	;; GNU Emacs is free software; you can redistribute it and/or modify
	11	;; it under the terms of the GNU General Public License as published by
29add8b9	12	;; the Free Software Foundation; either version 2, or (at your option)
a2535589 JA	13	;; any later version.
	14
	15	;; GNU Emacs is distributed in the hope that it will be useful,
	16	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	;; GNU General Public License for more details.
	19
	20	;; You should have received a copy of the GNU General Public License
b578f267 EN	21	;; along with GNU Emacs; see the file COPYING. If not, write to the
	22	;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	23	;; Boston, MA 02111-1307, USA.
a2535589	24
edbd2f74 ER	25	;;; Commentary:
	26
	27	;; This package provides the paragraph-oriented commands documented in the
	28	;; Emacs manual.
	29
4821e2af	30	;;; Code:
a2535589	31
55cc5677 BG	32	(defvar use-hard-newlines nil
	33	"Non-nil means to distinguish hard and soft newlines.
	34	When this is non-nil, the functions `newline' and `open-line' add the
	35	text-property `hard' to newlines that they insert. Also, a line is
	36	only considered as a candidate to match `paragraph-start' or
	37	`paragraph-separate' if it follows a hard newline. Newlines not
	38	marked hard are called \"soft\", and are always internal to
	39	paragraphs. The fill functions always insert soft newlines.
	40
	41	Each buffer has its own value of this variable.")
	42	(make-variable-buffer-local 'use-hard-newlines)
	43
	44	(defconst paragraph-start "[ \t\n\f]" "\
1f2007b3 RS	45	*Regexp for beginning of a line that starts OR separates paragraphs.
	46	This regexp should match lines that separate paragraphs
	47	and should also match lines that start a paragraph
	48	\(and are part of that paragraph).
a37669ec	49
55cc5677 BG	50	This is matched against the text at the left margin, which is not necessarily
	51	the beginning of the line, so it should never use \"^\" as an anchor. This
	52	ensures that the paragraph functions will work equally well within a region
	53	of text indented by a margin setting.
	54
1f2007b3	55	The variable `paragraph-separate' specifies how to distinguish
a37669ec RS	56	lines that start paragraphs from lines that separate them.
	57
	58	If the variable `use-hard-newlines' is nonnil, then only lines following a
	59	hard newline are considered to match.")
6503cec3	60
55cc5677 BG	61	;; paragraph-start requires a hard newline, but paragraph-separate does not:
	62	;; It is assumed that paragraph-separate is distinctive enough to be believed
	63	;; whenever it occurs, while it is reasonable to set paragraph-start to
	64	;; something very minimal, even including "." (which makes every hard newline
	65	;; start a new paragraph).
	66
	67	(defconst paragraph-separate "[ \t\f]*$" "\
6503cec3	68	*Regexp for beginning of a line that separates paragraphs.
a37669ec RS	69	If you change this, you may have to change paragraph-start also.
a37669ec RS	70
55cc5677 BG	71	This is matched against the text at the left margin, which is not necessarily
	72	the beginning of the line, so it should not use \"^\" as an anchor. This
	73	ensures that the paragraph functions will work equally within a region of
	74	text indented by a margin setting.")
6503cec3	75
6503cec3 JB	76	(defconst sentence-end (purecopy "[.?!][]\"')}]\\($\\\| $\\\|\t\\\| \\)[ \t\n]") "\
6503cec3 JB	77	*Regexp describing the end of a sentence.
51534471 JB	78	All paragraph boundaries also end sentences, regardless.
	79
	80	In order to be recognized as the end of a sentence, the ending period,
	81	question mark, or exclamation point must be followed by two spaces,
	82	unless it's inside some sort of quotes or parenthesis.")
6503cec3	83
6503cec3 JB	84	(defconst page-delimiter "^\014" "\
	85	*Regexp describing line-beginnings that separate pages.")
	86
6503cec3 JB	87	(defvar paragraph-ignore-fill-prefix nil "\
	88	Non-nil means the paragraph commands are not affected by `fill-prefix'.
	89	This is desirable in modes where blank lines are the paragraph delimiters.")
77176e73	90
a2535589 JA	91	(defun forward-paragraph (&optional arg)
a2535589 JA	92	"Move forward to end of paragraph.
85de1612	93	With arg N, do it N times; negative arg -N means move backward N paragraphs.
a2535589 JA	94
	95	A line which `paragraph-start' matches either separates paragraphs
	96	\(if `paragraph-separate' matches it also) or is the first line of a paragraph.
	97	A paragraph end is the beginning of a line which is not part of the paragraph
	98	to which the end of the previous line belongs, or the end of the buffer."
	99	(interactive "p")
	100	(or arg (setq arg 1))
	101	(let* ((fill-prefix-regexp
	102	(and fill-prefix (not (equal fill-prefix ""))
	103	(not paragraph-ignore-fill-prefix)
	104	(regexp-quote fill-prefix)))
55cc5677 BG	105	;; Remove ^ from paragraph-start and paragraph-sep if they are there.
	106	;; These regexps shouldn't be anchored, because we look for them
	107	;; starting at the left-margin. This allows paragraph commands to
	108	;; work normally with indented text.
	109	;; This hack will not find problem cases like "whatever\\\|^something".
	110	(paragraph-start (if (and (not (equal "" paragraph-start))
	111	(equal ?^ (aref paragraph-start 0)))
	112	(substring paragraph-start 1)
	113	paragraph-start))
	114	(paragraph-separate (if (and (not (equal "" paragraph-start))
	115	(equal ?^ (aref paragraph-separate 0)))
	116	(substring paragraph-separate 1)
	117	paragraph-separate))
a2535589 JA	118	(paragraph-separate
a2535589 JA	119	(if fill-prefix-regexp
55cc5677	120	(concat paragraph-separate "\\\|"
a2535589	121	fill-prefix-regexp "[ \t]*$")
55cc5677 BG	122	paragraph-separate))
	123	;; This is used for searching.
	124	(sp-paragraph-start (concat "^[ \t]*\\(" paragraph-start "\\)"))
	125	start)
8a2a4ced	126	(while (and (< arg 0) (not (bobp)))
55cc5677	127	(if (and (not (looking-at paragraph-separate))
a37669ec	128	(re-search-backward "^\n" (max (1- (point)) (point-min)) t)
55cc5677	129	(looking-at paragraph-separate))
a2535589	130	nil
2be01738	131	(setq start (point))
8a2a4ced	132	;; Move back over paragraph-separating lines.
a2535589	133	(forward-char -1) (beginning-of-line)
a37669ec	134	(while (and (not (bobp))
55cc5677 BG	135	(progn (move-to-left-margin)
	136	(looking-at paragraph-separate)))
	137	(forward-line -1))
8a2a4ced RS	138	(if (bobp)
	139	nil
	140	;; Go to end of the previous (non-separating) line.
	141	(end-of-line)
	142	;; Search back for line that starts or separates paragraphs.
	143	(if (if fill-prefix-regexp
	144	;; There is a fill prefix; it overrides paragraph-start.
2be01738	145	(let (multiple-lines)
55cc5677 BG	146	(while (and (progn (beginning-of-line) (not (bobp)))
	147	(progn (move-to-left-margin)
	148	(not (looking-at paragraph-separate)))
	149	(looking-at fill-prefix-regexp))
2be01738 RS	150	(if (not (= (point) start))
2be01738 RS	151	(setq multiple-lines t))
55cc5677	152	(forward-line -1))
2be01738 RS	153	(move-to-left-margin)
	154	;; Don't move back over a line before the paragraph
	155	;; which doesn't start with fill-prefix
	156	;; unless that is the only line we've moved over.
	157	(and (not (looking-at fill-prefix-regexp))
	158	multiple-lines
	159	(forward-line 1))
	160	(not (bobp)))
55cc5677 BG	161	(while (and (re-search-backward sp-paragraph-start nil 1)
	162	;; Found a candidate, but need to check if it is a
	163	;; REAL paragraph-start.
a37669ec	164	(not (bobp))
55cc5677 BG	165	(progn (setq start (point))
	166	(move-to-left-margin)
	167	(not (looking-at paragraph-separate)))
	168	(or (not (looking-at paragraph-start))
	169	(and use-hard-newlines
	170	(not (get-text-property (1- start)
	171	'hard)))))
	172	(goto-char start))
a37669ec	173	(> (point) (point-min)))
8a2a4ced RS	174	;; Found one.
	175	(progn
	176	;; Move forward over paragraph separators.
	177	;; We know this cannot reach the place we started
	178	;; because we know we moved back over a non-separator.
55cc5677 BG	179	(while (and (not (eobp))
	180	(progn (move-to-left-margin)
	181	(looking-at paragraph-separate)))
8a2a4ced	182	(forward-line 1))
55cc5677 BG	183	;; If line before paragraph is just margin, back up to there.
	184	(end-of-line 0)
	185	(if (> (current-column) (current-left-margin))
	186	(forward-char 1)
	187	(skip-chars-backward " \t")
	188	(if (not (bolp))
	189	(forward-line 1))))
8a2a4ced RS	190	;; No starter or separator line => use buffer beg.
8a2a4ced RS	191	(goto-char (point-min)))))
a2535589	192	(setq arg (1+ arg)))
8a2a4ced	193	(while (and (> arg 0) (not (eobp)))
88c2fc2c	194	;; Move forward over separator lines, and one more line.
a2535589	195	(while (prog1 (and (not (eobp))
55cc5677 BG	196	(progn (move-to-left-margin) (not (eobp)))
55cc5677 BG	197	(looking-at paragraph-separate))
a37669ec	198	(forward-line 1)))
a2535589 JA	199	(if fill-prefix-regexp
	200	;; There is a fill prefix; it overrides paragraph-start.
	201	(while (and (not (eobp))
55cc5677 BG	202	(progn (move-to-left-margin) (not (eobp)))
55cc5677 BG	203	(not (looking-at paragraph-separate))
a2535589 JA	204	(looking-at fill-prefix-regexp))
a2535589 JA	205	(forward-line 1))
55cc5677	206	(while (and (re-search-forward sp-paragraph-start nil 1)
55cc5677 BG	207	(progn (setq start (match-beginning 0))
55cc5677 BG	208	(goto-char start)
4669fb3c RS	209	(not (eobp)))
4669fb3c RS	210	(progn (move-to-left-margin)
55cc5677 BG	211	(not (looking-at paragraph-separate)))
	212	(or (not (looking-at paragraph-start))
	213	(and use-hard-newlines
	214	(not (get-text-property (1- start) 'hard)))))
a37669ec RS	215	(forward-char 1))
a37669ec RS	216	(if (< (point) (point-max))
55cc5677	217	(goto-char start)))
a2535589 JA	218	(setq arg (1- arg)))))
	219
	220	(defun backward-paragraph (&optional arg)
	221	"Move backward to start of paragraph.
	222	With arg N, do it N times; negative arg -N means move forward N paragraphs.
	223
23b34992 BP	224	A paragraph start is the beginning of a line which is a
	225	`first-line-of-paragraph' or which is ordinary text and follows a
	226	paragraph-separating line; except: if the first real line of a
	227	paragraph is preceded by a blank line, the paragraph starts at that
	228	blank line.
	229
	230	See `forward-paragraph' for more information."
a2535589 JA	231	(interactive "p")
	232	(or arg (setq arg 1))
	233	(forward-paragraph (- arg)))
	234
	235	(defun mark-paragraph ()
	236	"Put point at beginning of this paragraph, mark at end.
	237	The paragraph marked is the one that contains point or follows point."
	238	(interactive)
	239	(forward-paragraph 1)
0b108c01	240	(push-mark nil t t)
a2535589 JA	241	(backward-paragraph 1))
	242
	243	(defun kill-paragraph (arg)
	244	"Kill forward to end of paragraph.
	245	With arg N, kill forward to Nth end of paragraph;
	246	negative arg -N means kill backward to Nth start of paragraph."
23b34992	247	(interactive "p")
8d6eaa00	248	(kill-region (point) (progn (forward-paragraph arg) (point))))
a2535589 JA	249
	250	(defun backward-kill-paragraph (arg)
	251	"Kill back to start of paragraph.
	252	With arg N, kill back to Nth start of paragraph;
	253	negative arg -N means kill forward to Nth end of paragraph."
23b34992	254	(interactive "p")
8d6eaa00	255	(kill-region (point) (progn (backward-paragraph arg) (point))))
a2535589 JA	256
	257	(defun transpose-paragraphs (arg)
	258	"Interchange this (or next) paragraph with previous one."
	259	(interactive "*p")
	260	(transpose-subr 'forward-paragraph arg))
	261
	262	(defun start-of-paragraph-text ()
	263	(let ((opoint (point)) npoint)
	264	(forward-paragraph -1)
	265	(setq npoint (point))
	266	(skip-chars-forward " \t\n")
b4e6c391 RS	267	;; If the range of blank lines found spans the original start point,
	268	;; try again from the beginning of it.
	269	;; Must be careful to avoid infinite loop
	270	;; when following a single return at start of buffer.
	271	(if (and (>= (point) opoint) (< npoint opoint))
a2535589 JA	272	(progn
	273	(goto-char npoint)
	274	(if (> npoint (point-min))
	275	(start-of-paragraph-text))))))
	276
	277	(defun end-of-paragraph-text ()
	278	(let ((opoint (point)))
	279	(forward-paragraph 1)
	280	(if (eq (preceding-char) ?\n) (forward-char -1))
	281	(if (<= (point) opoint)
	282	(progn
	283	(forward-char 1)
	284	(if (< (point) (point-max))
	285	(end-of-paragraph-text))))))
	286
	287	(defun forward-sentence (&optional arg)
51534471	288	"Move forward to next `sentence-end'. With argument, repeat.
23b34992	289	With negative argument, move backward repeatedly to `sentence-beginning'.
a2535589	290
23b34992 BP	291	The variable `sentence-end' is a regular expression that matches ends of
23b34992 BP	292	sentences. Also, every paragraph boundary terminates sentences as well."
a2535589 JA	293	(interactive "p")
	294	(or arg (setq arg 1))
	295	(while (< arg 0)
	296	(let ((par-beg (save-excursion (start-of-paragraph-text) (point))))
	297	(if (re-search-backward (concat sentence-end "[^ \t\n]") par-beg t)
	298	(goto-char (1- (match-end 0)))
	299	(goto-char par-beg)))
	300	(setq arg (1+ arg)))
	301	(while (> arg 0)
	302	(let ((par-end (save-excursion (end-of-paragraph-text) (point))))
	303	(if (re-search-forward sentence-end par-end t)
	304	(skip-chars-backward " \t\n")
	305	(goto-char par-end)))
	306	(setq arg (1- arg))))
	307
	308	(defun backward-sentence (&optional arg)
	309	"Move backward to start of sentence. With arg, do it arg times.
23b34992	310	See `forward-sentence' for more information."
a2535589 JA	311	(interactive "p")
	312	(or arg (setq arg 1))
	313	(forward-sentence (- arg)))
	314
	315	(defun kill-sentence (&optional arg)
	316	"Kill from point to end of sentence.
	317	With arg, repeat; negative arg -N means kill back to Nth start of sentence."
b0e1e38f	318	(interactive "p")
8d6eaa00	319	(kill-region (point) (progn (forward-sentence arg) (point))))
a2535589 JA	320
	321	(defun backward-kill-sentence (&optional arg)
	322	"Kill back from point to start of sentence.
	323	With arg, repeat, or kill forward to Nth end of sentence if negative arg -N."
b0e1e38f	324	(interactive "p")
8d6eaa00	325	(kill-region (point) (progn (backward-sentence arg) (point))))
a2535589 JA	326
a2535589 JA	327	(defun mark-end-of-sentence (arg)
23b34992	328	"Put mark at end of sentence. Arg works as in `forward-sentence'."
a2535589 JA	329	(interactive "p")
	330	(push-mark
	331	(save-excursion
	332	(forward-sentence arg)
a524dc5b RS	333	(point))
a524dc5b RS	334	nil t))
a2535589 JA	335
	336	(defun transpose-sentences (arg)
	337	"Interchange this (next) and previous sentence."
	338	(interactive "*p")
	339	(transpose-subr 'forward-sentence arg))
6594deb0 ER	340
6594deb0 ER	341	;;; paragraphs.el ends here