1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
|
;; Fill commands for Emacs
;; Copyright (C) 1985, 1986, 1992 Free Software Foundation, Inc.
;; 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
(defconst 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.
That mode can handle paragraphs with extra indentation on the first line,
but it requires separator lines between paragraphs.
Nil means that any change in indentation starts a new paragraph.")
(defun set-fill-prefix ()
"Set the fill-prefix to the current line up to point.
Filling expects lines to start with the fill prefix and
reinserts the fill prefix in each resulting line."
(interactive)
(setq fill-prefix (buffer-substring
(save-excursion (beginning-of-line) (point))
(point)))
(if (equal fill-prefix "")
(setq fill-prefix nil))
(if fill-prefix
(message "fill-prefix: \"%s\"" fill-prefix)
(message "fill-prefix cancelled")))
(defconst adaptive-fill-mode t
"*Non-nil means determine a paragraph's fill prefix from its text.")
(defconst adaptive-fill-regexp "[ \t]*\\([>*] +\\)?"
"*Regexp to match text at start of line that constitutes indentation.
If Adaptive Fill mode is enabled, whatever text matches this pattern
on the second line of a paragraph is used as the standard indentation
for the paragraph.")
(defun fill-region-as-paragraph (from to &optional justify-flag)
"Fill region as one paragraph: break lines to fit fill-column.
Prefix arg means justify too.
From program, pass args FROM, TO and JUSTIFY-FLAG."
(interactive "r\nP")
;; 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.
(if adaptive-fill-mode
(save-excursion
(goto-char (min from to))
(if (eolp) (forward-line 1))
(forward-line 1)
(if (< (point) (max from to))
(let ((start (point)))
(re-search-forward adaptive-fill-regexp)
(setq fill-prefix (buffer-substring start (point))))
(goto-char (min from to))
(if (eolp) (forward-line 1))
;; If paragraph has only one line, don't assume
;; that additional lines would have the same starting
;; decoration. Instead, assume they would have white space
;; reaching to the same column.
(re-search-forward adaptive-fill-regexp)
(setq fill-prefix (make-string (current-column) ?\ )))))
(save-restriction
(narrow-to-region from to)
(goto-char (point-min))
(skip-chars-forward "\n")
(narrow-to-region (point) (point-max))
(setq from (point))
(goto-char (point-max))
(let ((fpre (and fill-prefix (not (equal fill-prefix ""))
(regexp-quote fill-prefix))))
;; Delete the fill prefix from every line except the first.
;; The first line may not even have a fill prefix.
(and fpre
(progn
(if (>= (length fill-prefix) fill-column)
(error "fill-prefix too long for specified width"))
(goto-char (point-min))
(forward-line 1)
(while (not (eobp))
(if (looking-at fpre)
(delete-region (point) (match-end 0)))
(forward-line 1))
(goto-char (point-min))
(and (looking-at fpre) (forward-char (length fill-prefix)))
(setq from (point)))))
;; from is now before the text to fill,
;; but after any fill prefix on the first line.
;; Make sure sentences ending at end of line get an extra space.
;; loses on split abbrevs ("Mr.\nSmith")
(goto-char from)
(while (re-search-forward "[.?!][])\"']*$" nil t)
(insert ? ))
;; Then change all newlines to spaces.
(subst-char-in-region from (point-max) ?\n ?\ )
;; Flush excess spaces, except in the paragraph indentation.
(goto-char from)
(skip-chars-forward " \t")
;; nuke tabs while we're at it; they get screwed up in a fill
;; this is quick, but loses when a sole tab follows the end of a sentence.
;; actually, it is difficult to tell that from "Mr.\tSmith".
;; blame the typist.
(subst-char-in-region (point) (point-max) ?\t ?\ )
(while (re-search-forward " *" nil t)
(delete-region
(+ (match-beginning 0)
(if (save-excursion
(skip-chars-backward " ])\"'")
(memq (preceding-char) '(?. ?? ?!)))
2 1))
(match-end 0)))
(goto-char (point-max))
(delete-horizontal-space)
(insert " ")
(goto-char (point-min))
(let ((prefixcol 0))
(while (not (eobp))
(move-to-column (1+ fill-column))
(if (eobp)
nil
(skip-chars-backward "^ \n")
(if (if (zerop prefixcol) (bolp) (>= prefixcol (current-column)))
(skip-chars-forward "^ \n")
(forward-char -1)))
;; Inserting the newline first prevents losing track of point.
(skip-chars-backward " ")
(insert ?\n)
(delete-horizontal-space)
(and (not (eobp)) fill-prefix (not (equal fill-prefix ""))
(progn
(insert fill-prefix)
(setq prefixcol (current-column))))
(and justify-flag (not (eobp))
(progn
(forward-line -1)
(justify-current-line)
(forward-line 1))))))))
(defun fill-paragraph (arg)
"Fill paragraph at or after point. Prefix arg means justify as well."
(interactive "P")
(save-excursion
(forward-paragraph)
(or (bolp) (newline 1))
(let ((end (point)))
(backward-paragraph)
(fill-region-as-paragraph (point) end arg))))
(defun fill-region (from to &optional justify-flag)
"Fill each of the paragraphs in the region.
Prefix arg (non-nil third arg, if called from program) means justify as well."
(interactive "r\nP")
(save-restriction
(narrow-to-region from to)
(goto-char (point-min))
(while (not (eobp))
(let ((initial (point))
(end (progn
(forward-paragraph 1) (point))))
(forward-paragraph -1)
(if (>= (point) initial)
(fill-region-as-paragraph (point) end justify-flag)
(goto-char end))))))
(defun justify-current-line ()
"Add spaces to line point is in, so it ends at `fill-column'."
(interactive)
(save-excursion
(save-restriction
(let (ncols beg indent)
(beginning-of-line)
(forward-char (length fill-prefix))
(skip-chars-forward " \t")
(setq indent (current-column))
(setq beg (point))
(end-of-line)
(narrow-to-region beg (point))
(goto-char beg)
(while (re-search-forward " *" nil t)
(delete-region
(+ (match-beginning 0)
(if (save-excursion
(skip-chars-backward " ])\"'")
(memq (preceding-char) '(?. ?? ?!)))
2 1))
(match-end 0)))
(goto-char beg)
(while (re-search-forward "[.?!][])""']*\n" nil t)
(forward-char -1)
(insert ? ))
(goto-char (point-max))
;; Note that the buffer bounds start after the indentation,
;; so the columns counted by INDENT don't appear in (current-column).
(setq ncols (- fill-column (current-column) indent))
(if (search-backward " " nil t)
(while (> ncols 0)
(let ((nmove (+ 3 (random 3))))
(while (> nmove 0)
(or (search-backward " " nil t)
(progn
(goto-char (point-max))
(search-backward " ")))
(skip-chars-backward " ")
(setq nmove (1- nmove))))
(insert " ")
(skip-chars-backward " ")
(setq ncols (1- ncols))))))))
(defun fill-individual-paragraphs (min max &optional justifyp mailp)
"Fill each paragraph in region according to its individual fill prefix.
If `fill-individual-varying-indent' is non-nil,
then a mere change in indentation does not end a paragraph. In this mode,
the indentation for a paragraph is the minimum indentation of any line in it.
When calling from a program, pass range to fill as first two arguments.
Optional third and fourth arguments JUSTIFY-FLAG and MAIL-FLAG:
JUSTIFY-FLAG to justify paragraphs (prefix arg),
MAIL-FLAG for a mail message, i. e. don't fill header lines."
(interactive "r\nP")
(save-restriction
(save-excursion
(goto-char min)
(beginning-of-line)
(if mailp
(while (looking-at "[^ \t\n]*:")
(forward-line 1)))
(narrow-to-region (point) max)
;; Loop over paragraphs.
(while (progn (skip-chars-forward " \t\n") (not (eobp)))
(beginning-of-line)
(let ((start (point))
fill-prefix fill-prefix-regexp)
;; Find end of paragraph, and compute the smallest fill-prefix
;; that fits all the lines in this paragraph.
(while (progn
;; Update the fill-prefix on the first line
;; and whenever the prefix good so far is too long.
(if (not (and fill-prefix
(looking-at fill-prefix-regexp)))
(setq fill-prefix
(buffer-substring (point)
(save-excursion (skip-chars-forward " \t") (point)))
fill-prefix-regexp
(regexp-quote fill-prefix)))
(forward-line 1)
;; Now stop the loop if end of paragraph.
(and (not (eobp))
(if fill-individual-varying-indent
;; If this line is a separator line, with or
;; without prefix, end the paragraph.
(and
(not (looking-at paragraph-separate))
(save-excursion
(not (and (looking-at fill-prefix-regexp)
(progn (forward-char (length fill-prefix))
(looking-at paragraph-separate))))))
;; If this line has more or less indent
;; than the fill prefix wants, end the paragraph.
(and (looking-at fill-prefix-regexp)
(save-excursion
(not (progn (forward-char (length fill-prefix))
(or (looking-at paragraph-separate)
(looking-at paragraph-start))))))))))
;; Fill this paragraph, but don't add a newline at the end.
(let ((had-newline (bolp)))
(fill-region-as-paragraph start (point) justifyp)
(or had-newline (delete-char -1))))))))
|
