;;; fill.el --- fill commands for Emacs
-;; Copyright (C) 1985,86,92,94,95,96,97,1999,2001,02,2003
+;; Copyright (C) 1985,86,92,94,95,96,97,1999,2001,02,03,2004
;; Free Software Foundation, Inc.
;; Maintainer: FSF
;;; Code:
+(defgroup fill nil
+ "Indenting and filling text."
+ :link '(custom-manual "(emacs)Filling")
+ :group 'editing)
+
(defcustom fill-individual-varying-indent nil
"*Controls criterion for a new paragraph in `fill-individual-paragraphs'.
Non-nil means changing indent doesn't end a paragraph.
If the function returns nil, then `fill-paragraph' does its normal work.")
(defvar fill-paragraph-handle-comment t
- "If non-nil, paragraph filling will try to pay attention to comments.")
+ "Non-nil means paragraph filling will try to pay attention to comments.")
-(defvar enable-kinsoku t
- "*Non-nil means enable \"kinsoku\" processing on filling paragraph.
+(defcustom enable-kinsoku t
+ "*Non-nil means enable \"kinsoku\" processing on filling paragraphs.
Kinsoku processing is designed to prevent certain characters from being
placed at the beginning or end of a line by filling.
-See the documentation of `kinsoku' for more information.")
+See the documentation of `kinsoku' for more information."
+ :type 'boolean)
(defun set-fill-prefix ()
"Set the fill prefix to the current line up to point.
and `sentence-end-without-period').
Remove indentation from each line."
(interactive "*r")
- (let ((end-spc-re (concat "\\(" sentence-end "\\) *\\| +")))
+ (let ((end-spc-re (concat "\\(" (sentence-end) "\\) *\\| +")))
(save-excursion
(goto-char beg)
;; Nuke tabs; they get screwed up in a fill.
:options '(fill-french-nobreak-p fill-single-word-nobreak-p))
(defcustom fill-nobreak-invisible nil
- "Non-nil means that fill command do not break lines in invisible text."
+ "Non-nil means that fill commands do not break lines in invisible text."
:type 'boolean
:group 'fill)
(save-excursion
(skip-chars-backward ". ")
(and (looking-at "\\.")
- (not (looking-at sentence-end))))
+ (not (looking-at (sentence-end)))))
;; Don't split a line if the rest would look like a new paragraph.
(unless use-hard-newlines
(save-excursion
- (skip-chars-forward " \t") (looking-at paragraph-start)))
+ (skip-chars-forward " \t")
+ ;; If this break point is at the end of the line,
+ ;; which can occur for auto-fill, don't consider the newline
+ ;; which follows as a reason to return t.
+ (and (not (eolp))
+ (looking-at paragraph-start))))
(run-hook-with-args-until-success 'fill-nobreak-predicate)))))
;; Put `fill-find-break-point-function' property to charsets which
Don't move back past the buffer position LIMIT.
This function is called when we are going to break the current line
-after or before a non-ascii character. If the charset of the
+after or before a non-ASCII character. If the charset of the
character has the property `fill-find-break-point-function', this
function calls the property value as a function with one arg LINEBEG.
If the charset has no such property, do nothing."
;; loses on split abbrevs ("Mr.\nSmith")
(let ((eol-double-space-re
(cond
- ((not colon-double-space) (concat sentence-end "$"))
+ ((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) "$"))
+ ((string-match "\\[[^][]*\\(\\.\\)[^][]*\\]" (sentence-end))
+ (concat (replace-match ".:" nil nil (sentence-end) 1) "$"))
;; Can't find the right spot to insert the colon.
- (t "[.?!:][])}\"']*$"))))
+ (t "[.?!:][])}\"']*$")))
+ (sentence-end-without-space-list
+ (string-to-list sentence-end-without-space)))
(while (re-search-forward eol-double-space-re to t)
(or (>= (point) to) (memq (char-before) '(?\t ?\ ))
+ (memq (char-after (match-beginning 0))
+ sentence-end-without-space-list)
(insert-and-inherit ?\ ))))
(goto-char from)
;; Then try our syntax-aware filling code.
(and fill-paragraph-handle-comment
;; Our code only handles \n-terminated comments right now.
- comment-start comment-start-skip (equal comment-end "")
+ comment-start (equal comment-end "")
(let ((fill-paragraph-handle-comment nil))
(fill-comment-paragraph arg)))
;; If it all fails, default to the good ol' text paragraph filling.
(save-excursion
(goto-char comstart)
(if has-code-and-comment
- (concat (make-string (/ (current-column) tab-width) ?\t)
- (make-string (% (current-column) tab-width) ?\ )
- (buffer-substring (point) comin))
+ (concat
+ (if (not indent-tabs-mode)
+ (make-string (current-column) ?\ )
+ (concat
+ (make-string (/ (current-column) tab-width) ?\t)
+ (make-string (% (current-column) tab-width) ?\ )))
+ (buffer-substring (point) comin))
(buffer-substring (line-beginning-position) comin))))
beg end)
(save-excursion
(looking-at comment-re)))
;; We may have gone too far. Go forward again.
(line-beginning-position
- (if (looking-at (concat ".*\\(?:" comment-start-skip "\\)"))
+ (if (progn
+ (goto-char
+ (or (comment-search-forward (line-end-position) t)
+ (point)))
+ (looking-at comment-re))
1 2))))
;; Find the beginning of the first line past the region to fill.
(save-excursion
(concat paragraph-start "\\|[ \t]*\\(?:"
comment-start-skip "\\)\\(?:"
(default-value 'paragraph-start) "\\)"))
- (paragraph-ignore-fill-prefix nil)
- (fill-prefix comment-fill-prefix)
+ ;; We used to reply on fill-prefix to break paragraph at
+ ;; comment-starter changes, but it did not work for the
+ ;; first line (mixed comment&code).
+ ;; We now use comment-re instead to "manually" make sure
+ ;; we treat comment-marker changes as paragraph boundaries.
+ ;; (paragraph-ignore-fill-prefix nil)
+ ;; (fill-prefix comment-fill-prefix)
(after-line (if has-code-and-comment
(line-beginning-position 2))))
(setq end (progn (forward-paragraph) (point)))
The fourth arg NOSQUEEZE non-nil means to leave
whitespace other than line breaks untouched, and fifth arg TO-EOP
non-nil means to keep filling to the end of the paragraph (or next
-hard newline, if `use-hard-newlines' is on).
+hard newline, if variable `use-hard-newlines' is on).
Return the fill-prefix used for filling the last paragraph.
moved to the beginning and end \(respectively) of the paragraphs they
are in.
-If `use-hard-newlines' is true, all hard newlines are taken to be paragraph
-breaks.
+If variable `use-hard-newlines' is true, all hard newlines are
+taken to be paragraph breaks.
When calling from a program, operates just on region between BEGIN and END,
unless optional fourth arg WHOLE-PAR is non-nil. In that case bounds are