;;; fill.el --- fill commands for Emacs
-;; Copyright (C) 1985, 86, 92, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
+;; Copyright (C) 1985,86,92,94,95,96,97,1999,2001,2002
+;; Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: wp
:group 'fill)
(defcustom adaptive-fill-regexp
- (purecopy "[ \t]*\\([-|#;>*]+[ \t]*\\|(?[0-9]+[.)][ \t]*\\)*")
+ ;; Added `!' for doxygen comments starting with `//!' or `/*!'.
+ ;; Added `%' for TeX comments.
+ (purecopy "[ \t]*\\([-!|#%;>*]+[ \t]*\\|(?[0-9]+[.)][ \t]*\\)*")
"*Regexp to match text at start of line that constitutes indentation.
If Adaptive Fill mode is enabled, a prefix matching this pattern
on the first and second lines of a paragraph is used as the
(unless first-line-prefix (setq first-line-prefix ""))
(if ;; If the non-whitespace chars match the first line,
- ;; just use it (this subsumes the 2 previous checks).
+ ;; just use it (this subsumes the 2 checks used previously).
;; Used when first line is `/* ...' and second-line is
;; ` * ...'.
(string-match
;; The reason is that if a period ends up at the end of a
;; line, further fills will assume it ends a sentence.
;; If we now know it does not end a sentence, avoid putting
- ;; it at the end of the line.
+ ;; it at the end of the line.
(and sentence-end-double-space
(save-excursion
(skip-chars-backward ". ")
"Delete the fill prefix from every line except the first.
The first line may not even have a fill prefix.
Point is moved to just past the fill prefix on the first line."
- (goto-char from)
- (let ((fpre (and prefix (not (equal prefix ""))
- (concat "[ \t]*"
- (replace-regexp-in-string
- "[ \t]+" "[ \t]*"
- (regexp-quote prefix))
- "[ \t]*"))))
- (when fpre
- (if (>= (+ (current-left-margin) (length prefix))
- (current-fill-column))
- (error "fill-prefix too long for specified width"))
- (forward-line 1)
- (while (< (point) to)
- (if (looking-at fpre)
- (delete-region (point) (match-end 0)))
- (forward-line 1))
- (goto-char from)
+ (let ((fpre (if (and prefix (not (string-match "\\`[ \t]*\\'" prefix)))
+ (concat "[ \t]*\\("
+ (replace-regexp-in-string
+ "[ \t]+" "[ \t]*"
+ (regexp-quote prefix))
+ "\\)?[ \t]*")
+ "[ \t]*")))
+ (goto-char from)
+ (if (>= (+ (current-left-margin) (length prefix))
+ (current-fill-column))
+ (error "fill-prefix too long for specified width"))
+ (forward-line 1)
+ (while (< (point) to)
(if (looking-at fpre)
- (goto-char (match-end 0)))
- (setq from (point))))
- ;; Remove indentation from lines other than the first.
- (beginning-of-line 2)
- (indent-region (point) to 0)
- (goto-char from))
+ (delete-region (point) (match-end 0)))
+ (forward-line 1))
+ (goto-char from)
+ (if (looking-at fpre)
+ (goto-char (match-end 0)))
+ (setq from (point))))
(defun fill-delete-newlines (from to justify nosqueeze squeeze-after)
(goto-char from)
;; Make sure sentences ending at end of line get an extra space.
;; loses on split abbrevs ("Mr.\nSmith")
- (let ((eol-double-space-re (if colon-double-space
- "[.?!:][])}\"']*$"
- "[.?!][])}\"']*$")))
+ (let ((eol-double-space-re
+ (cond
+ ((not colon-double-space) (concat sentence-end "$"))
+ ;; Try to add the : inside the `sentence-end' regexp.
+ ((string-match "\\[[^][]*\\(\\.\\)[^][]*\\]" sentence-end)
+ (concat (replace-match ".:" nil nil sentence-end 1) "$"))
+ ;; Can't find the right spot to insert the colon.
+ (t "[.?!:][])}\"']*$"))))
(while (re-search-forward eol-double-space-re to t)
- (or (>= (point) to) (insert-and-inherit ?\ ))))
+ (or (>= (point) to) (memq (char-before) '(?\t ?\ ))
+ (insert-and-inherit ?\ ))))
(goto-char from)
(if enable-multibyte-characters
(insert-and-inherit " "))
(goto-char from))
+(defun fill-move-to-break-point (linebeg)
+ "Move to the position where the line should be broken.
+The break position will normally be after LINEBEG and before point."
+ ;; If the fill column is before linebeg, we have an insanely
+ ;; wide prefix and might as well ignore it.
+ (if (> linebeg (point)) (setq linebeg (line-beginning-position)))
+ ;; Move back to the point where we can break the line
+ ;; at. We break the line between word or after/before
+ ;; the character which has character category `|'. We
+ ;; search space, \c| followed by a character, or \c|
+ ;; following a character. If not found, place
+ ;; the point at linebeg.
+ (while
+ (when (re-search-backward "[ \t]\\|\\c|.\\|.\\c|" linebeg 0)
+ ;; In case of space, we place the point at next to
+ ;; the point where the break occurs actually,
+ ;; because we don't want to change the following
+ ;; logic of original Emacs. In case of \c|, the
+ ;; point is at the place where the break occurs.
+ (forward-char 1)
+ (when (fill-nobreak-p) (skip-chars-backward " \t" linebeg))))
+ ;; If the left margin and fill prefix by themselves
+ ;; pass the fill-column. or if they are zero
+ ;; but we have no room for even one word,
+ ;; keep at least one word or a character which has
+ ;; category `|' anyway.
+ (if (>= linebeg (point))
+ ;; Ok, skip at least one word or one \c| character.
+ ;; Meanwhile, don't stop at a period followed by one space.
+ (let ((to (line-end-position))
+ (fill-nobreak-predicate nil) ;to break sooner.
+ (first t))
+ (goto-char linebeg)
+ (while (and (< (point) to) (or first (fill-nobreak-p)))
+ ;; Find a breakable point while ignoring the
+ ;; following spaces.
+ (skip-chars-forward " \t")
+ (if (looking-at "\\c|")
+ (forward-char 1)
+ (let ((pos (save-excursion
+ (skip-chars-forward "^ \n\t")
+ (point))))
+ (if (re-search-forward "\\c|" pos t)
+ (forward-char -1)
+ (goto-char pos))))
+ (setq first nil)))
+ ;; Normally, move back over the single space between
+ ;; the words.
+ (skip-chars-backward " \t")
+
+ (if enable-multibyte-characters
+ ;; If we are going to break the line after or
+ ;; before a non-ascii character, we may have to
+ ;; run a special function for the charset of the
+ ;; character to find the correct break point.
+ (if (not (and (eq (charset-after (1- (point))) 'ascii)
+ (eq (charset-after (point)) 'ascii)))
+ ;; Make sure we take SOMETHING after the fill prefix if any.
+ (fill-find-break-point linebeg)))))
+
+(defun fill-newline ()
+ ;; Replace whitespace here with one newline, then
+ ;; indent to left margin.
+ (skip-chars-backward " \t")
+ (if (and (= (following-char) ?\ )
+ (or (aref (char-category-set (preceding-char)) ?|)
+ (looking-at "[ \t]+\\c|")))
+ ;; We need one space at end of line so that
+ ;; further filling won't delete it. NOTE: We
+ ;; intentionally leave this one space to
+ ;; distingush the case that user wants to put
+ ;; space between \c| characters.
+ (forward-char 1))
+ (insert ?\n)
+ ;; Give newline the properties of the space(s) it replaces
+ (set-text-properties (1- (point)) (point)
+ (text-properties-at (point)))
+ (if (or fill-prefix
+ (not fill-indent-according-to-mode))
+ (indent-to-left-margin)
+ (indent-according-to-mode))
+ ;; Insert the fill prefix after indentation.
+ ;; Set prefixcol so whitespace in the prefix won't get lost.
+ (and fill-prefix (not (equal fill-prefix ""))
+ (insert-and-inherit fill-prefix)))
+
(defun fill-region-as-paragraph (from to &optional justify
nosqueeze squeeze-after)
"Fill the region as one paragraph.
(goto-char from-plus-indent))
(if (not (> to (point)))
- nil ; There is no paragraph, only whitespace: exit now.
+ nil ;; There is no paragraph, only whitespace: exit now.
(or justify (setq justify (current-justification)))
- ;; Never indent-according-to-mode with brain dead "indenting" functions.
- (when (and fill-indent-according-to-mode
- (memq indent-line-function
- '(indent-relative-maybe indent-relative
- indent-to-left-margin)))
- (set (make-local-variable 'fill-indent-according-to-mode) nil))
-
;; Don't let Adaptive Fill mode alter the fill prefix permanently.
(let ((fill-prefix fill-prefix))
;; Figure out how this paragraph is indented, if desired.
(beginning-of-line)
(narrow-to-region (point) to)
- (if (not justify) ; filling disabled: just check indentation
+ (if (not justify) ; filling disabled: just check indentation
(progn
(goto-char from)
(while (< (point) to)
(fill-delete-newlines from to justify nosqueeze squeeze-after)
;; This is the actual filling loop.
- (let ((prefixcol 0) linebeg)
- (while (not (eobp))
+ (goto-char from)
+ (let (linebeg)
+ (while (< (point) to)
(setq linebeg (point))
(move-to-column (1+ (current-fill-column)))
- (if (eobp)
+ (if (>= (point) to)
(or nosqueeze (delete-horizontal-space))
- ;; Move back to the point where we can break the line
- ;; at. We break the line between word or after/before
- ;; the character which has character category `|'. We
- ;; search space, \c| followed by a character, or \c|
- ;; following a character. If not found, place
- ;; the point at linebeg.
- (while
- (when (re-search-backward "[ \t]\\|\\c|.\\|.\\c|" linebeg 0)
- ;; In case of space, we place the point at next to
- ;; the point where the break occurs actually,
- ;; because we don't want to change the following
- ;; logic of original Emacs. In case of \c|, the
- ;; point is at the place where the break occurs.
- (forward-char 1)
- (when (fill-nobreak-p) (skip-chars-backward " \t"))))
- ;; If the left margin and fill prefix by themselves
- ;; pass the fill-column. or if they are zero
- ;; but we have no room for even one word,
- ;; keep at least one word or a character which has
- ;; category `|'anyway .
- ;; This handles ALL BUT the first line of the paragraph.
- (if (if (zerop prefixcol)
- (save-excursion
- (skip-chars-backward " \t" linebeg)
- (bolp))
- (>= prefixcol (current-column)))
- ;; Ok, skip at least one word or one \c| character.
- ;; Meanwhile, don't stop at a period followed by one space.
- (let ((fill-nobreak-predicate nil) ;to break sooner.
- (first t))
- (move-to-column prefixcol)
- (while (and (not (eobp)) (or first (fill-nobreak-p)))
- ;; Find a breakable point while ignoring the
- ;; following spaces.
- (skip-chars-forward " \t")
- (if (looking-at "\\c|")
- (forward-char 1)
- (let ((pos (save-excursion
- (skip-chars-forward "^ \n\t")
- (point))))
- (if (re-search-forward "\\c|" pos t)
- (forward-char -1)
- (goto-char pos))))
- (setq first nil)))
- ;; Normally, move back over the single space between
- ;; the words.
- (skip-chars-backward " \t")
-
- (if enable-multibyte-characters
- ;; If we are going to break the line after or
- ;; before a non-ascii character, we may have to
- ;; run a special function for the charset of the
- ;; character to find the correct break point.
- (if (not (and (eq (charset-after (1- (point))) 'ascii)
- (eq (charset-after (point)) 'ascii)))
- ;; Make sure we take SOMETHING after the
- ;; fill prefix if any.
- (fill-find-break-point
- (save-excursion
- (goto-char linebeg)
- (move-to-column prefixcol)
- (point))))))
-
- ;; If the left margin and fill prefix by themselves
- ;; pass the fill-column, keep at least one word.
- ;; This handles the first line of the paragraph.
- (if (and (zerop prefixcol)
- (let ((fill-point (point)) nchars)
- (save-excursion
- (move-to-left-margin)
- (setq nchars (- fill-point (point)))
- (or (< nchars 0)
- (and fill-prefix
- (< nchars (length fill-prefix))
- (string= (buffer-substring (point)
- fill-point)
- (substring fill-prefix
- 0 nchars)))))))
- ;; Ok, skip at least one word. But
- ;; don't stop at a period followed by just one space.
- (let ((fill-nobreak-predicate nil) ;to break sooner.
- (first t))
- (while (and (not (eobp)) (or first (fill-nobreak-p)))
- ;; Find a breakable point while ignoring the
- ;; following spaces.
- (skip-chars-forward " \t")
- (if (looking-at "\\c|")
- (forward-char 1)
- (let ((pos (save-excursion
- (skip-chars-forward "^ \n\t")
- (point))))
- (if (re-search-forward "\\c|" pos t)
- (forward-char -1)
- (goto-char pos))))
- (setq first nil))))
+ ;; Find the position where we'll break the line.
+ (fill-move-to-break-point linebeg)
+
;; Check again to see if we got to the end of the paragraph.
- (if (save-excursion (skip-chars-forward " \t") (eobp))
+ (if (save-excursion (skip-chars-forward " \t") (>= (point) to))
(or nosqueeze (delete-horizontal-space))
- ;; Replace whitespace here with one newline, then
- ;; indent to left margin.
- (skip-chars-backward " \t")
- (if (and (= (following-char) ?\ )
- (or (aref (char-category-set (preceding-char)) ?|)
- (looking-at "[ \t]+\\c|")))
- ;; We need one space at end of line so that
- ;; further filling won't delete it. NOTE: We
- ;; intentionally leave this one space to
- ;; distingush the case that user wants to put
- ;; space between \c| characters.
- (forward-char 1))
- (insert ?\n)
- ;; Give newline the properties of the space(s) it replaces
- (set-text-properties (1- (point)) (point)
- (text-properties-at (point)))
- (if (or fill-prefix
- (not fill-indent-according-to-mode))
- (indent-to-left-margin)
- (indent-according-to-mode))
- ;; Insert the fill prefix after indentation.
- ;; Set prefixcol so whitespace in the prefix won't get lost.
- (and fill-prefix (not (equal fill-prefix ""))
- (progn
- (insert-and-inherit fill-prefix)
- (setq prefixcol (current-column))))))
+ (fill-newline)))
;; Justify the line just ended, if desired.
(if justify
(if (save-excursion (skip-chars-forward " \t") (eobp))
(justify-current-line justify nil t)
(forward-line 1))))))
;; Leave point after final newline.
- (goto-char (point-max)))
+ (goto-char to))
(unless (eobp)
(forward-char 1))
;; Return the fill-prefix we used
projects / emacs.git / commitdiff