Mercurial > emacs
annotate lisp/align.el @ 107777:13c077500eb3
2010-04-04 John Wiegley <jwiegley@gmail.com>
* ido.el (ido-use-virtual-buffers): New variable to indicate
whether "virtual buffer" support is enabled for IDO. Essentially
it works as follows: Say you are visiting a file and the buffer
gets cleaned up by mignight.el. Later, you want to switch to that
buffer, but find it's no longer open. With virtual buffers
enabled, the buffer name stays in the buffer list (using the
ido-virtual face, and always at the end), and if you select it, it
opens the file back up again. This allows you to think less about
whether recently opened files are still open or not. Most of the
time you can quit Emacs, restart, and then switch to a file buffer
that was previously open as if it still were. NOTE: This feature
has been present in iswitchb for several years now, and I'm
porting the same logic to IDO.
(ido-virtual): Face used to indicate virtual buffers in the list.
(ido-buffer-internal): If a buffer is chosen, and no such buffer
exists, but a virtual buffer of that name does (which would be why
it was in the list), recreate the buffer by reopening the file.
(ido-make-buffer-list): If virtual buffers are being used, call
`ido-add-virtual-buffers-to-list' before the make list hook.
(ido-virtual-buffers): New variable which contains a copy of the
current contents of the `recentf-list', albeit pared down for the
sake of speed, and with proper faces applied.
(ido-add-virtual-buffers-to-list): Using the `recentf-list',
create a list of "virtual buffers" to present to the user in
addition to the currently open set. Note that this logic could
get rather slow if that list is too large. With the default
`recentf-max-saved-items' of 200, there is little speed penalty.
author | jwiegley@gmail.com |
---|---|
date | Sun, 04 Apr 2010 02:55:19 -0400 |
parents | 1d1d5d9bd884 |
children | 215efa9f5db1 |
rev | line source |
---|---|
38436
b174db545cfd
Some fixes to follow coding conventions.
Pavel Janík <Pavel@Janik.cz>
parents:
32451
diff
changeset
|
1 ;;; align.el --- align text to a specific column, by regexp |
27327 | 2 |
74439 | 3 ;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, |
106815 | 4 ;; 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
27327 | 5 |
100171 | 6 ;; Author: John Wiegley <johnw@gnu.org> |
74615
ac990ee1126d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
74439
diff
changeset
|
7 ;; Maintainer: FSF |
27327 | 8 ;; Keywords: convenience languages lisp |
9 | |
10 ;; This file is part of GNU Emacs. | |
11 | |
94678
ee5932bf781d
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93975
diff
changeset
|
12 ;; GNU Emacs is free software: you can redistribute it and/or modify |
27327 | 13 ;; it under the terms of the GNU General Public License as published by |
94678
ee5932bf781d
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93975
diff
changeset
|
14 ;; the Free Software Foundation, either version 3 of the License, or |
ee5932bf781d
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93975
diff
changeset
|
15 ;; (at your option) any later version. |
27327 | 16 |
17 ;; GNU Emacs is distributed in the hope that it will be useful, | |
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
20 ;; GNU General Public License for more details. | |
21 | |
22 ;; You should have received a copy of the GNU General Public License | |
94678
ee5932bf781d
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93975
diff
changeset
|
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. |
27327 | 24 |
25 ;;; Commentary: | |
26 | |
27 ;; This mode allows you to align regions in a context-sensitive fashion. | |
28 ;; The classic use is to align assignments: | |
29 ;; | |
30 ;; int a = 1; | |
31 ;; short foo = 2; | |
32 ;; double blah = 4; | |
33 ;; | |
34 ;; becomes | |
35 ;; | |
36 ;; int a = 1; | |
37 ;; short foo = 2; | |
38 ;; double blah = 4; | |
39 | |
40 ;;; Usage: | |
41 | |
42 ;; There are several variables which define how certain "categories" | |
43 ;; of syntax are to be treated. These variables go by the name | |
44 ;; `align-CATEGORY-modes'. For example, "c++" is such a category. | |
45 ;; There are several rules which apply to c++, but since several other | |
46 ;; languages have a syntax similar to c++ (e.g., c, java, etc), these | |
47 ;; modes are treated as belonging to the same category. | |
48 ;; | |
49 ;; If you want to add a new mode under a certain category, just | |
50 ;; customize that list, or add the new mode manually. For example, to | |
51 ;; make jde-mode a c++ category mode, use this code in your .emacs | |
52 ;; file: | |
53 ;; | |
54 ;; (setq align-c++-modes (cons 'jde-mode align-c++-modes)) | |
55 | |
56 ;; In some programming modes, it's useful to have the aligner run only | |
57 ;; after indentation is performed. To achieve this, customize or set | |
58 ;; the variable `align-indent-before-aligning' to t. | |
59 | |
60 ;;; Module Authors: | |
61 | |
62 ;; In order to incorporate align's functionality into your own | |
63 ;; modules, there are only a few steps you have to follow. | |
64 | |
65 ;; 1. Require or load in the align.el library. | |
66 ;; | |
67 ;; 2. Define your alignment and exclusion rules lists, either | |
68 ;; customizable or not. | |
69 ;; | |
70 ;; 3. In your mode function, set the variables | |
71 ;; `align-mode-rules-list' and `align-mode-exclude-rules-list' | |
72 ;; to your own rules lists. | |
73 | |
74 ;; If there is any need to add your mode name to one of the | |
75 ;; align-?-modes variables (for example, `align-dq-string-modes'), use | |
76 ;; `add-to-list', or some similar function which checks first to see | |
77 ;; if the value is already there. Since the user may customize that | |
78 ;; mode list, and then write your mode name into their .emacs file, | |
79 ;; causing the symbol already to be present the next time they load | |
80 ;; your package. | |
81 | |
82 ;; Example: | |
83 ;; | |
84 ;; (require 'align) | |
85 ;; | |
86 ;; (defcustom my-align-rules-list | |
87 ;; '((my-rule | |
88 ;; (regexp . "Sample"))) | |
89 ;; :type align-rules-list-type | |
90 ;; :group 'my-package) | |
91 ;; | |
92 ;; (put 'my-align-rules-list 'risky-local-variable t) | |
93 ;; | |
94 ;; (add-to-list 'align-dq-string-modes 'my-package-mode) | |
95 ;; (add-to-list 'align-open-comment-modes 'my-package-mode) | |
96 ;; | |
97 ;; (defun my-mode () | |
98 ;; ... | |
99 ;; (setq align-mode-rules-list my-align-rules-list)) | |
100 ;; | |
101 ;; Note that if you need to install your own exclusion rules, then you | |
102 ;; will also need to reproduce any double-quoted string, or open | |
103 ;; comment exclusion rules that are defined in the standard | |
104 ;; `align-exclude-rules-list'. At the moment there is no convenient | |
105 ;; way to mix both mode-local and global rules lists. | |
106 | |
107 ;;; History: | |
108 | |
109 ;; Version 1.0 was created in the earlier part of 1996, using a very | |
110 ;; simple algorithm that understand only basic regular expressions. | |
111 ;; Parts of the code were broken up and included in vhdl-mode.el | |
112 ;; around this time. After several comments from users, and a need to | |
113 ;; find a more robust, performant algorithm, 2.0 was born in late | |
114 ;; 1998. Many different approaches were taken (mostly due to the | |
115 ;; complexity of TeX tables), but finally a scheme was discovered | |
116 ;; which worked fairly well for most common usage cases. Development | |
117 ;; beyond version 2.8 is not planned, except for problems that users | |
118 ;; might encounter. | |
119 | |
120 ;;; Code: | |
121 | |
122 (defgroup align nil | |
123 "Align text to a specific column, by regexp." | |
30890 | 124 :version "21.1" |
27327 | 125 :group 'fill) |
126 | |
127 ;;; User Variables: | |
128 | |
129 (defcustom align-load-hook nil | |
100171 | 130 "Hook that gets run after the aligner has been loaded." |
27327 | 131 :type 'hook |
132 :group 'align) | |
133 | |
134 (defcustom align-indent-before-aligning nil | |
100171 | 135 "If non-nil, indent the marked region before aligning it." |
27327 | 136 :type 'boolean |
137 :group 'align) | |
138 | |
139 (defcustom align-default-spacing 1 | |
100171 | 140 "An integer that represents the default amount of padding to use. |
27327 | 141 If `align-to-tab-stop' is non-nil, this will represent the number of |
142 tab stops to use for alignment, rather than the number of spaces. | |
143 Each alignment rule can optionally override both this variable. See | |
144 `align-mode-alist'." | |
145 :type 'integer | |
146 :group 'align) | |
147 | |
148 (defcustom align-to-tab-stop 'indent-tabs-mode | |
100171 | 149 "If non-nil, alignments will always fall on a tab boundary. |
27327 | 150 It may also be a symbol, whose value will be taken." |
151 :type '(choice (const nil) symbol) | |
152 :group 'align) | |
153 | |
154 (defcustom align-region-heuristic 500 | |
100171 | 155 "If non-nil, used as a heuristic by `align-current'. |
27327 | 156 Since each alignment rule can possibly have its own set of alignment |
157 sections (whenever `align-region-separate' is non-nil, and not a | |
158 string), this heuristic is used to determine how far before and after | |
159 point we should search in looking for a region separator. Larger | |
160 values can mean slower perform in large files, although smaller values | |
161 may cause unexpected behavior at times." | |
162 :type 'integer | |
163 :group 'align) | |
164 | |
165 (defcustom align-highlight-change-face 'highlight | |
100171 | 166 "The face to highlight with if changes are necessary." |
27327 | 167 :type 'face |
168 :group 'align) | |
169 | |
170 (defcustom align-highlight-nochange-face 'secondary-selection | |
100171 | 171 "The face to highlight with if no changes are necessary." |
27327 | 172 :type 'face |
173 :group 'align) | |
174 | |
175 (defcustom align-large-region 10000 | |
100171 | 176 "If an integer, defines what constitutes a \"large\" region. |
102734
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
177 If nil, then no messages will ever be printed to the minibuffer." |
27327 | 178 :type 'integer |
179 :group 'align) | |
180 | |
181 (defcustom align-c++-modes '(c++-mode c-mode java-mode) | |
100171 | 182 "A list of modes whose syntax resembles C/C++." |
27327 | 183 :type '(repeat symbol) |
184 :group 'align) | |
185 | |
186 (defcustom align-perl-modes '(perl-mode cperl-mode) | |
102734
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
187 "A list of modes where Perl syntax is to be seen." |
27327 | 188 :type '(repeat symbol) |
189 :group 'align) | |
190 | |
191 (defcustom align-lisp-modes | |
192 '(emacs-lisp-mode lisp-interaction-mode lisp-mode scheme-mode) | |
100171 | 193 "A list of modes whose syntax resembles Lisp." |
27327 | 194 :type '(repeat symbol) |
195 :group 'align) | |
196 | |
197 (defcustom align-tex-modes | |
198 '(tex-mode plain-tex-mode latex-mode slitex-mode) | |
100171 | 199 "A list of modes whose syntax resembles TeX (and family)." |
27327 | 200 :type '(repeat symbol) |
201 :group 'align) | |
202 | |
203 (defcustom align-text-modes '(text-mode outline-mode) | |
100171 | 204 "A list of modes whose content is plain text." |
27327 | 205 :type '(repeat symbol) |
206 :group 'align) | |
207 | |
29493 | 208 (defcustom align-dq-string-modes |
209 (append align-lisp-modes align-c++-modes align-perl-modes | |
210 '(python-mode)) | |
100171 | 211 "A list of modes where double quoted strings should be excluded." |
27327 | 212 :type '(repeat symbol) |
213 :group 'align) | |
214 | |
29493 | 215 (defcustom align-sq-string-modes |
216 (append align-perl-modes '(python-mode)) | |
100171 | 217 "A list of modes where single quoted strings should be excluded." |
27327 | 218 :type '(repeat symbol) |
219 :group 'align) | |
220 | |
29493 | 221 (defcustom align-open-comment-modes |
222 (append align-lisp-modes align-c++-modes align-perl-modes | |
223 '(python-mode makefile-mode)) | |
100171 | 224 "A list of modes with a single-line comment syntax. |
102734
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
225 These are comments as in Lisp, which have a beginning, but end with |
27327 | 226 the line (i.e., `comment-end' is an empty string)." |
227 :type '(repeat symbol) | |
228 :group 'align) | |
229 | |
230 (defcustom align-region-separate "^\\s-*[{}]?\\s-*$" | |
100171 | 231 "Select the method by which alignment sections will be separated. |
27327 | 232 If this is a symbol, that symbol's value will be used. |
233 | |
234 For the sake of clarification, consider the following example, which | |
235 will be referred to in the descriptions below. | |
236 | |
237 int alpha = 1; /* one */ | |
238 double beta = 2.0; | |
239 long gamma; /* ten */ | |
240 | |
241 unsigned int delta = 1; /* one */ | |
242 long double epsilon = 3.0; | |
243 long long omega; /* ten */ | |
244 | |
245 The possible settings for `align-region-separate' are: | |
246 | |
247 `entire' The entire region being aligned will be considered as a | |
248 single alignment section. Assuming that comments were not | |
249 being aligned to a particular column, the example would | |
250 become: | |
251 | |
252 int alpha = 1; /* one */ | |
253 double beta = 2.0; | |
254 long gamma; /* ten */ | |
255 | |
256 unsigned int delta = 1; /* one */ | |
257 long double epsilon; | |
258 long long chi = 10; /* ten */ | |
259 | |
260 `group' Each contiguous set of lines where a specific alignment | |
261 occurs is considered a section for that alignment rule. | |
102734
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
262 Note that each rule may have any entirely different set |
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
263 of section divisions than another. |
27327 | 264 |
265 int alpha = 1; /* one */ | |
266 double beta = 2.0; | |
267 long gamma; /* ten */ | |
268 | |
269 unsigned int delta = 1; /* one */ | |
270 long double epsilon; | |
271 long long chi = 10; /* ten */ | |
272 | |
273 `largest' When contiguous rule sets overlap, the largest section | |
274 described will be taken as the alignment section for each | |
275 rule touched by that section. | |
276 | |
277 int alpha = 1; /* one */ | |
278 double beta = 2.0; | |
279 long gamma; /* ten */ | |
280 | |
281 unsigned int delta = 1; /* one */ | |
282 long double epsilon; | |
283 long long chi = 10; /* ten */ | |
284 | |
285 NOTE: This option is not supported yet, due to algorithmic | |
286 issues which haven't been satisfactorily resolved. There | |
287 are ways to do it, but they're both ugly and resource | |
288 consumptive. | |
289 | |
290 regexp A regular expression string which defines the section | |
291 divider. If the mode you're in has a consistent divider | |
292 between sections, the behavior will be very similar to | |
293 `largest', and faster. But if the mode does not use clear | |
294 separators (for example, if you collapse your braces onto | |
102734
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
295 the preceding statement in C or Perl), `largest' is |
27327 | 296 probably the better alternative. |
297 | |
298 function A function that will be passed the beginning and ending | |
299 locations of the region in which to look for the section | |
300 separator. At the very beginning of the attempt to align, | |
301 both of these parameters will be nil, in which case the | |
302 function should return non-nil if it wants each rule to | |
303 define its own section, or nil if it wants the largest | |
102734
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
304 section found to be used as the common section for all |
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
305 rules that occur there. |
27327 | 306 |
307 list A list of markers within the buffer that represent where | |
308 the section dividers lie. Be certain to use markers! For | |
309 when the aligning begins, the ensuing contract/expanding of | |
310 whitespace will throw off any non-marker positions. | |
311 | |
312 This method is intended for use in Lisp programs, and not | |
313 by the user." | |
314 :type '(choice | |
315 (const :tag "Entire region is one section" entire) | |
316 (const :tag "Align by contiguous groups" group) | |
317 ; (const largest) | |
318 (regexp :tag "Regexp defines section boundaries") | |
319 (function :tag "Function defines section boundaries")) | |
320 :group 'align) | |
321 | |
322 (put 'align-region-separate 'risky-local-variable t) | |
323 | |
324 (defvar align-rules-list-type | |
325 '(repeat | |
326 (cons | |
327 :tag "Alignment rule" | |
328 (symbol :tag "Title") | |
329 (cons :tag "Required attributes" | |
330 (cons :tag "Regexp" | |
331 (const :tag "(Regular expression to match)" regexp) | |
332 (choice :value "\\(\\s-+\\)" regexp function)) | |
333 (repeat | |
334 :tag "Optional attributes" | |
335 (choice | |
336 (cons :tag "Repeat" | |
337 (const :tag "(Repeat this rule throughout line)" | |
338 repeat) | |
339 (boolean :value t)) | |
340 (cons :tag "Paren group" | |
341 (const :tag "(Parenthesis group to use)" group) | |
342 (choice :value 2 | |
343 integer (repeat integer))) | |
344 (cons :tag "Modes" | |
345 (const :tag "(Modes where this rule applies)" modes) | |
346 (sexp :value (text-mode))) | |
347 (cons :tag "Case-fold" | |
348 (const :tag "(Should case be ignored for this rule)" | |
349 case-fold) | |
350 (boolean :value t)) | |
351 (cons :tag "To Tab Stop" | |
352 (const :tag "(Should rule align to tab stops)" | |
353 tab-stop) | |
354 (boolean :value nil)) | |
355 (cons :tag "Valid" | |
356 (const :tag "(Return non-nil if rule is valid)" | |
357 valid) | |
358 (function :value t)) | |
359 (cons :tag "Run If" | |
360 (const :tag "(Return non-nil if rule should run)" | |
361 run-if) | |
362 (function :value t)) | |
363 (cons :tag "Column" | |
364 (const :tag "(Column to fix alignment at)" column) | |
365 (choice :value comment-column | |
366 integer symbol)) | |
367 (cons :tag "Spacing" | |
368 (const :tag "(Amount of spacing to use)" spacing) | |
369 (integer :value 1)) | |
370 (cons :tag "Justify" | |
371 (const :tag "(Should text be right justified)" | |
372 justify) | |
373 (boolean :value t)) | |
374 ;; make sure this stays up-to-date with any changes | |
375 ;; in `align-region-separate' | |
376 (cons :tag "Separate" | |
377 (const :tag "(Separation to use for this rule)" | |
378 separate) | |
379 (choice :value "^\\s-*$" | |
380 (const entire) | |
381 (const group) | |
382 ; (const largest) | |
383 regexp function))))))) | |
384 "The `type' form for any `align-rules-list' variable.") | |
385 | |
386 (defcustom align-rules-list | |
387 `((lisp-second-arg | |
388 (regexp . "\\(^\\s-+[^( \t\n]\\|(\\(\\S-+\\)\\s-+\\)\\S-+\\(\\s-+\\)") | |
389 (group . 3) | |
390 (modes . align-lisp-modes) | |
391 (run-if . ,(function (lambda () current-prefix-arg)))) | |
392 | |
393 (lisp-alist-dot | |
394 (regexp . "\\(\\s-*\\)\\.\\(\\s-*\\)") | |
395 (group . (1 2)) | |
396 (modes . align-lisp-modes)) | |
397 | |
398 (open-comment | |
399 (regexp . ,(function | |
400 (lambda (end reverse) | |
401 (funcall (if reverse 're-search-backward | |
402 're-search-forward) | |
403 (concat "[^ \t\n\\\\]" | |
404 (regexp-quote comment-start) | |
405 "\\(.+\\)$") end t)))) | |
406 (modes . align-open-comment-modes)) | |
407 | |
408 (c-macro-definition | |
409 (regexp . "^\\s-*#\\s-*define\\s-+\\S-+\\(\\s-+\\)") | |
410 (modes . align-c++-modes)) | |
411 | |
412 (c-variable-declaration | |
413 (regexp . ,(concat "[*&0-9A-Za-z_]>?[&*]*\\(\\s-+[*&]*\\)" | |
414 "[A-Za-z_][0-9A-Za-z:_]*\\s-*\\(\\()\\|" | |
415 "=[^=\n].*\\|(.*)\\|\\(\\[.*\\]\\)*\\)?" | |
416 "\\s-*[;,]\\|)\\s-*$\\)")) | |
417 (group . 1) | |
418 (modes . align-c++-modes) | |
419 (justify . t) | |
420 (valid | |
421 . ,(function | |
422 (lambda () | |
423 (not (or (save-excursion | |
424 (goto-char (match-beginning 1)) | |
425 (backward-word 1) | |
426 (looking-at | |
427 "\\(goto\\|return\\|new\\|delete\\|throw\\)")) | |
428 (if (and (boundp 'font-lock-mode) font-lock-mode) | |
29493 | 429 (eq (get-text-property (point) 'face) |
27327 | 430 'font-lock-comment-face) |
431 (eq (caar (c-guess-basic-syntax)) 'c)))))))) | |
432 | |
433 (c-assignment | |
434 (regexp . ,(concat "[^-=!^&*+<>/| \t\n]\\(\\s-*[-=!^&*+<>/|]*\\)" | |
435 "=\\(\\s-*\\)\\([^= \t\n]\\|$\\)")) | |
436 (group . (1 2)) | |
437 (modes . align-c++-modes) | |
438 (justify . t) | |
439 (tab-stop . nil)) | |
440 | |
441 (perl-assignment | |
442 (regexp . ,(concat "[^=!^&*-+<>/| \t\n]\\(\\s-*\\)=[~>]?" | |
443 "\\(\\s-*\\)\\([^>= \t\n]\\|$\\)")) | |
444 (group . (1 2)) | |
445 (modes . align-perl-modes) | |
446 (tab-stop . nil)) | |
447 | |
29493 | 448 (python-assignment |
449 (regexp . ,(concat "[^=!<> \t\n]\\(\\s-*\\)=" | |
450 "\\(\\s-*\\)\\([^>= \t\n]\\|$\\)")) | |
451 (group . (1 2)) | |
452 (modes . '(python-mode)) | |
453 (tab-stop . nil)) | |
454 | |
27327 | 455 (make-assignment |
456 (regexp . "^\\s-*\\w+\\(\\s-*\\):?=\\(\\s-*\\)\\([^\t\n \\\\]\\|$\\)") | |
457 (group . (1 2)) | |
458 (modes . '(makefile-mode)) | |
459 (tab-stop . nil)) | |
460 | |
461 (c-comma-delimiter | |
462 (regexp . ",\\(\\s-*\\)[^/ \t\n]") | |
463 (repeat . t) | |
464 (modes . align-c++-modes) | |
465 (run-if . ,(function (lambda () current-prefix-arg)))) | |
60505
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
466 ; (valid |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
467 ; . ,(function |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
468 ; (lambda () |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
469 ; (memq (caar (c-guess-basic-syntax)) |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
470 ; '(brace-list-intro |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
471 ; brace-list-entry |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
472 ; brace-entry-open)))))) |
27327 | 473 |
474 ;; With a prefix argument, comma delimiter will be aligned. Since | |
475 ;; perl-mode doesn't give us enough syntactic information (and we | |
476 ;; don't do our own parsing yet), this rule is too destructive to | |
477 ;; run normally. | |
29493 | 478 (basic-comma-delimiter |
27327 | 479 (regexp . ",\\(\\s-*\\)[^# \t\n]") |
480 (repeat . t) | |
29493 | 481 (modes . (append align-perl-modes '(python-mode))) |
27327 | 482 (run-if . ,(function (lambda () current-prefix-arg)))) |
483 | |
484 (c++-comment | |
485 (regexp . "\\(\\s-*\\)\\(//.*\\|/\\*.*\\*/\\s-*\\)$") | |
486 (modes . align-c++-modes) | |
487 (column . comment-column) | |
488 (valid . ,(function | |
489 (lambda () | |
490 (save-excursion | |
491 (goto-char (match-beginning 1)) | |
492 (not (bolp))))))) | |
493 | |
494 (c-chain-logic | |
495 (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)") | |
496 (modes . align-c++-modes) | |
497 (valid . ,(function | |
498 (lambda () | |
499 (save-excursion | |
500 (goto-char (match-end 2)) | |
501 (looking-at "\\s-*\\(/[*/]\\|$\\)")))))) | |
502 | |
503 (perl-chain-logic | |
504 (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)") | |
505 (modes . align-perl-modes) | |
506 (valid . ,(function | |
507 (lambda () | |
508 (save-excursion | |
509 (goto-char (match-end 2)) | |
510 (looking-at "\\s-*\\(#\\|$\\)")))))) | |
511 | |
29493 | 512 (python-chain-logic |
513 (regexp . "\\(\\s-*\\)\\(\\<and\\>\\|\\<or\\>\\)") | |
514 (modes . '(python-mode)) | |
515 (valid . ,(function | |
516 (lambda () | |
517 (save-excursion | |
518 (goto-char (match-end 2)) | |
519 (looking-at "\\s-*\\(#\\|$\\|\\\\\\)")))))) | |
520 | |
521 (c-macro-line-continuation | |
522 (regexp . "\\(\\s-*\\)\\\\$") | |
523 (modes . align-c++-modes) | |
524 (column . c-backslash-column)) | |
60505
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
525 ; (valid |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
526 ; . ,(function |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
527 ; (lambda () |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
528 ; (memq (caar (c-guess-basic-syntax)) |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
529 ; '(cpp-macro cpp-macro-cont)))))) |
29493 | 530 |
531 (basic-line-continuation | |
532 (regexp . "\\(\\s-*\\)\\\\$") | |
533 (modes . '(python-mode makefile-mode))) | |
534 | |
27327 | 535 (tex-record-separator |
536 (regexp . ,(function | |
537 (lambda (end reverse) | |
538 (align-match-tex-pattern "&" end reverse)))) | |
539 (group . (1 2)) | |
540 (modes . align-tex-modes) | |
541 (repeat . t)) | |
542 | |
543 (tex-tabbing-separator | |
544 (regexp . ,(function | |
545 (lambda (end reverse) | |
546 (align-match-tex-pattern "\\\\[=>]" end reverse)))) | |
547 (group . (1 2)) | |
548 (modes . align-tex-modes) | |
549 (repeat . t) | |
550 (run-if . ,(function | |
551 (lambda () | |
552 (eq major-mode 'latex-mode))))) | |
553 | |
554 (tex-record-break | |
555 (regexp . "\\(\\s-*\\)\\\\\\\\") | |
556 (modes . align-tex-modes)) | |
557 | |
558 ;; With a numeric prefix argument, or C-u, space delimited text | |
559 ;; tables will be aligned. | |
560 (text-column | |
67698
fe96c1f121e3
(align-rules-list): Use [ \t] instead of \s-
Thien-Thi Nguyen <ttn@gnuvola.org>
parents:
67480
diff
changeset
|
561 (regexp . "\\(^\\|\\S-\\)\\([ \t]+\\)\\(\\S-\\|$\\)") |
27327 | 562 (group . 2) |
563 (modes . align-text-modes) | |
564 (repeat . t) | |
565 (run-if . ,(function | |
566 (lambda () | |
567 (and current-prefix-arg | |
568 (not (eq '- current-prefix-arg))))))) | |
569 | |
570 ;; With a negative prefix argument, lists of dollar figures will | |
571 ;; be aligned. | |
572 (text-dollar-figure | |
573 (regexp . "\\$?\\(\\s-+[0-9]+\\)\\.") | |
574 (modes . align-text-modes) | |
575 (justify . t) | |
576 (run-if . ,(function | |
577 (lambda () | |
60505
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
578 (eq '- current-prefix-arg))))) |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
579 |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
580 (css-declaration |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
581 (regexp . "^\\s-*\\w+:\\(\\s-*\\).*;") |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
582 (group . (1)) |
c919a3aa031f
2005-03-07 Karl Chen <quarl@cs.berkeley.edu>
John Wiegley <johnw@newartisans.com>
parents:
57972
diff
changeset
|
583 (modes . '(css-mode html-mode)))) |
100171 | 584 "A list describing all of the available alignment rules. |
27327 | 585 The format is: |
586 | |
587 ((TITLE | |
588 (ATTRIBUTE . VALUE) ...) | |
589 ...) | |
590 | |
591 The following attributes are meaningful: | |
592 | |
593 `regexp' This required attribute must be either a string describing | |
594 a regular expression, or a function (described below). | |
595 For every line within the section that this regular | |
596 expression matches, the given rule will be applied to that | |
597 line. The exclusion rules denote which part(s) of the | |
598 line should not be modified; the alignment rules cause the | |
599 identified whitespace group to be contracted/expanded such | |
600 that the \"alignment character\" (the character | |
601 immediately following the identified parenthesis group), | |
602 occurs in the same column for every line within the | |
603 alignment section (see `align-region-separate' for a | |
604 description of how the region is broken up into alignment | |
605 sections). | |
606 | |
607 The `regexp' attribute describes how the text should be | |
608 treated. Within this regexp, there must be at least one | |
609 group of characters (typically whitespace) identified by | |
610 the special opening and closing parens used in regexp | |
611 expressions (`\\\\(' and `\\\\)') (see the Emacs manual on | |
612 the syntax of regular expressions for more info). | |
613 | |
614 If `regexp' is a function, it will be called as a | |
615 replacement for `re-search-forward'. This means that it | |
616 should return nil if nothing is found to match the rule, | |
617 or it should set the match data appropriately, move point | |
618 to the end of the match, and return the value of point. | |
619 | |
620 `group' For exclusion rules, the group identifies the range of | |
621 characters that should be ignored. For alignment rules, | |
622 these are the characters that will be deleted/expanded for | |
623 the purposes of alignment. The \"alignment character\" is | |
624 always the first character immediately following this | |
625 parenthesis group. This attribute may also be a list of | |
102734
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
626 integers, in which case multiple alignment characters will |
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
627 be aligned, with the list of integers identifying the |
27327 | 628 whitespace groups which precede them. The default for |
629 this attribute is 1. | |
630 | |
631 `modes' The `modes' attribute, if set, should name a list of | |
632 major modes -- or evaluate to such a value -- in which the | |
633 rule is valid. If not set, the rule will apply to all | |
634 modes. | |
635 | |
636 `case-fold' If `regexp' is an ordinary regular expression string | |
637 containing alphabetic character, sometimes you may want | |
638 the search to proceed case-insensitively (for languages | |
102734
c4853c1bf38c
* align.el (align-large-region, align-perl-modes, align-rules-list)
Juanma Barranquero <lekktu@gmail.com>
parents:
101449
diff
changeset
|
639 that ignore case, such as Pascal for example). In that |
51264 | 640 case, set `case-fold' to a non-nil value, and the regular |
641 expression search will ignore case. If `regexp' is set to | |
642 a function, that function must handle the job of ignoring | |
27327 | 643 case by itself. |
644 | |
645 `tab-stop' If the `tab-stop' attribute is set, and non-nil, the | |
646 alignment character will always fall on a tab stop | |
647 (whether it uses tabs to get there or not depends on the | |
648 value of `indent-tabs-mode'). If the `tab-stop' attribute | |
649 is set to nil, tab stops will never be used. Otherwise, | |
650 the value of `align-to-tab-stop' determines whether or not | |
651 to align to a tab stop. The `tab-stop' attribute may also | |
652 be a list of t or nil values, corresponding to the number | |
653 of parenthesis groups specified by the `group' attribute. | |
654 | |
655 `repeat' If the `repeat' attribute is present, and non-nil, the | |
656 rule will be applied to the line continuously until no | |
657 further matches are found. | |
658 | |
659 `valid' If the `valid' attribute is set, it will be used to | |
660 determine whether the rule should be invoked. This form | |
661 is evaluated after the regular expression match has been | |
662 performed, so that it is possible to use the results of | |
663 that match to determine whether the alignment should be | |
664 performed. The buffer should not be modified during the | |
665 evaluation of this form. | |
666 | |
667 `run-if' Like `valid', the `run-if' attribute tests whether the | |
668 rule should be run at all -- even before any searches are | |
669 done to determine if the rule applies to the alignment | |
670 region. This can save time, since `run-if' will only be | |
671 run once for each rule. If it returns nil, the rule will | |
672 not be attempted. | |
673 | |
674 `column' For alignment rules, if the `column' attribute is set -- | |
675 which must be an integer, or a symbol whose value is an | |
676 integer -- it will be used as the column in which to align | |
677 the alignment character. If the text on a particular line | |
678 happens to overrun that column, a single space character, | |
679 or tab stop (see `align-to-tab-stop') will be added | |
680 between the last text character and the alignment | |
681 character. | |
682 | |
683 `spacing' Alignment rules may also override the amount of spacing | |
684 that would normally be used by providing a `spacing' | |
685 attribute. This must be an integer, or a list of integers | |
686 corresponding to the number of parenthesis groups matched | |
687 by the `group' attribute. If a list of value is used, and | |
688 any of those values is nil, `align-default-spacing' will | |
689 be used for that subgroup. See `align-default-spacing' | |
690 for more details on spacing, tab stops, and how to | |
691 indicate how much spacing should be used. If TAB-STOP is | |
692 present, it will override the value of `align-to-tab-stop' | |
693 for that rule. | |
694 | |
695 `justify' It is possible with `regexp' and `group' to identify a | |
696 character group that contains more than just whitespace | |
697 characters. By default, any non-whitespace characters in | |
698 that group will also be deleted while aligning the | |
699 alignment character. However, if the `justify' attribute | |
700 is set to a non-nil value, only the initial whitespace | |
701 characters within that group will be deleted. This has | |
702 the effect of right-justifying the characters that remain, | |
703 and can be used for outdenting or just plain old right- | |
704 justification. | |
705 | |
706 `separate' Each rule can define its own section separator, which | |
707 describes how to identify the separation of \"sections\" | |
708 within the region to be aligned. Setting the `separate' | |
709 attribute overrides the value of `align-region-separate' | |
710 (see the documentation of that variable for possible | |
711 values), and any separation argument passed to `align'." | |
712 :type align-rules-list-type | |
713 :group 'align) | |
714 | |
715 (put 'align-rules-list 'risky-local-variable t) | |
716 | |
717 (defvar align-exclude-rules-list-type | |
718 '(repeat | |
719 (cons | |
720 :tag "Exclusion rule" | |
721 (symbol :tag "Title") | |
722 (cons :tag "Required attributes" | |
723 (cons :tag "Regexp" | |
724 (const :tag "(Regular expression to match)" regexp) | |
725 (choice :value "\\(\\s-+\\)" regexp function)) | |
726 (repeat | |
727 :tag "Optional attributes" | |
728 (choice | |
729 (cons :tag "Repeat" | |
730 (const :tag "(Repeat this rule throughout line)" | |
731 repeat) | |
732 (boolean :value t)) | |
733 (cons :tag "Paren group" | |
734 (const :tag "(Parenthesis group to use)" group) | |
735 (choice :value 2 | |
736 integer (repeat integer))) | |
737 (cons :tag "Modes" | |
738 (const :tag "(Modes where this rule applies)" modes) | |
739 (sexp :value (text-mode))) | |
740 (cons :tag "Case-fold" | |
741 (const :tag "(Should case be ignored for this rule)" | |
742 case-fold) | |
743 (boolean :value t))))))) | |
744 "The `type' form for any `align-exclude-rules-list' variable.") | |
745 | |
746 (defcustom align-exclude-rules-list | |
747 `((exc-dq-string | |
748 (regexp . "\"\\([^\"\n]+\\)\"") | |
749 (repeat . t) | |
750 (modes . align-dq-string-modes)) | |
751 | |
752 (exc-sq-string | |
753 (regexp . "'\\([^'\n]+\\)'") | |
754 (repeat . t) | |
755 (modes . align-sq-string-modes)) | |
756 | |
757 (exc-open-comment | |
758 (regexp | |
759 . ,(function | |
760 (lambda (end reverse) | |
761 (funcall (if reverse 're-search-backward | |
762 're-search-forward) | |
763 (concat "[^ \t\n\\\\]" | |
764 (regexp-quote comment-start) | |
765 "\\(.+\\)$") end t)))) | |
766 (modes . align-open-comment-modes)) | |
767 | |
768 (exc-c-comment | |
769 (regexp . "/\\*\\(.+\\)\\*/") | |
770 (repeat . t) | |
771 (modes . align-c++-modes)) | |
772 | |
773 (exc-c-func-params | |
774 (regexp . "(\\([^)\n]+\\))") | |
775 (repeat . t) | |
776 (modes . align-c++-modes)) | |
777 | |
778 (exc-c-macro | |
779 (regexp . "^\\s-*#\\s-*\\(if\\w*\\|endif\\)\\(.*\\)$") | |
780 (group . 2) | |
781 (modes . align-c++-modes))) | |
100171 | 782 "A list describing text that should be excluded from alignment. |
27327 | 783 See the documentation for `align-rules-list' for more info." |
784 :type align-exclude-rules-list-type | |
785 :group 'align) | |
786 | |
787 (put 'align-exclude-rules-list 'risky-local-variable t) | |
788 | |
789 ;;; Internal Variables: | |
790 | |
791 (defvar align-mode-rules-list nil | |
792 "Alignment rules specific to the current major mode. | |
793 See the variable `align-rules-list' for more details.") | |
794 | |
795 (make-variable-buffer-local 'align-mode-rules-list) | |
796 | |
797 (defvar align-mode-exclude-rules-list nil | |
798 "Alignment exclusion rules specific to the current major mode. | |
799 See the variable `align-exclude-rules-list' for more details.") | |
800 | |
801 (make-variable-buffer-local 'align-mode-exclude-rules-list) | |
802 | |
803 (defvar align-highlight-overlays nil | |
804 "The current overlays highlighting the text matched by a rule.") | |
805 | |
806 ;; Sample extension rule set, for vhdl-mode. This should properly be | |
807 ;; in vhdl-mode.el itself. | |
808 | |
809 (defcustom align-vhdl-rules-list | |
810 `((vhdl-declaration | |
811 (regexp . "\\(signal\\|variable\\|constant\\)\\(\\s-+\\)\\S-") | |
812 (group . 2)) | |
813 | |
814 (vhdl-case | |
815 (regexp . "\\(others\\|[^ \t\n=<]\\)\\(\\s-*\\)=>\\(\\s-*\\)\\S-") | |
816 (group . (2 3)) | |
817 (valid | |
818 . ,(function | |
819 (lambda () | |
820 (not (string= (downcase (match-string 1)) | |
821 "others")))))) | |
822 | |
823 (vhdl-colon | |
824 (regexp . "[^ \t\n:]\\(\\s-*\\):\\(\\s-*\\)[^=\n]") | |
825 (group . (1 2))) | |
826 | |
827 (direction | |
828 (regexp . ":\\s-*\\(in\\|out\\|inout\\|buffer\\)\\(\\s-*\\)") | |
829 (group . 2)) | |
830 | |
831 (sig-assign | |
832 (regexp . "[^ \t\n=<]\\(\\s-*\\)<=\\(\\s-*\\)\\S-") | |
833 (group . (1 2))) | |
834 | |
835 (var-assign | |
836 (regexp . "[^ \t\n:]\\(\\s-*\\):=")) | |
837 | |
838 (use-entity | |
839 (regexp . "\\(\\s-+\\)use\\s-+entity"))) | |
100171 | 840 "Alignment rules for `vhdl-mode'. See `align-rules-list' for more info." |
27327 | 841 :type align-rules-list-type |
842 :group 'align) | |
843 | |
844 (put 'align-vhdl-rules-list 'risky-local-variable t) | |
845 | |
846 (defun align-set-vhdl-rules () | |
847 "Setup the `align-mode-rules-list' variable for `vhdl-mode'." | |
848 (setq align-mode-rules-list align-vhdl-rules-list)) | |
849 | |
850 (add-hook 'vhdl-mode-hook 'align-set-vhdl-rules) | |
851 | |
852 (add-to-list 'align-dq-string-modes 'vhdl-mode) | |
853 (add-to-list 'align-open-comment-modes 'vhdl-mode) | |
854 | |
855 ;;; User Functions: | |
856 | |
857 ;;;###autoload | |
858 (defun align (beg end &optional separate rules exclude-rules) | |
859 "Attempt to align a region based on a set of alignment rules. | |
860 BEG and END mark the region. If BEG and END are specifically set to | |
861 nil (this can only be done programmatically), the beginning and end of | |
862 the current alignment section will be calculated based on the location | |
863 of point, and the value of `align-region-separate' (or possibly each | |
864 rule's `separate' attribute). | |
865 | |
866 If SEPARATE is non-nil, it overrides the value of | |
867 `align-region-separate' for all rules, except those that have their | |
868 `separate' attribute set. | |
869 | |
870 RULES and EXCLUDE-RULES, if either is non-nil, will replace the | |
871 default rule lists defined in `align-rules-list' and | |
872 `align-exclude-rules-list'. See `align-rules-list' for more details | |
873 on the format of these lists." | |
874 (interactive "r") | |
875 (let ((separator | |
876 (or separate | |
31241 | 877 (if (and (symbolp align-region-separate) |
878 (boundp align-region-separate)) | |
27327 | 879 (symbol-value align-region-separate) |
880 align-region-separate) | |
881 'entire))) | |
882 (if (not (or ;(eq separator 'largest) | |
883 (and (functionp separator) | |
884 (not (funcall separator nil nil))))) | |
885 (align-region beg end separator | |
886 (or rules align-mode-rules-list align-rules-list) | |
887 (or exclude-rules align-mode-exclude-rules-list | |
888 align-exclude-rules-list)) | |
889 (let ((sec-first end) | |
890 (sec-last beg)) | |
891 (align-region beg end | |
892 (or exclude-rules | |
893 align-mode-exclude-rules-list | |
894 align-exclude-rules-list) nil | |
895 separator | |
896 (function | |
897 (lambda (b e mode) | |
898 (when (and mode (listp mode)) | |
899 (setq sec-first (min sec-first b) | |
900 sec-last (max sec-last e)))))) | |
901 (if (< sec-first sec-last) | |
902 (align-region sec-first sec-last 'entire | |
903 (or rules align-mode-rules-list align-rules-list) | |
904 (or exclude-rules align-mode-exclude-rules-list | |
905 align-exclude-rules-list))))))) | |
906 | |
907 ;;;###autoload | |
908 (defun align-regexp (beg end regexp &optional group spacing repeat) | |
909 "Align the current region using an ad-hoc rule read from the minibuffer. | |
910 BEG and END mark the limits of the region. This function will prompt | |
911 for the REGEXP to align with. If no prefix arg was specified, you | |
912 only need to supply the characters to be lined up and any preceding | |
913 whitespace is replaced. If a prefix arg was specified, the full | |
914 regexp with parenthesized whitespace should be supplied; it will also | |
915 prompt for which parenthesis GROUP within REGEXP to modify, the amount | |
916 of SPACING to use, and whether or not to REPEAT the rule throughout | |
917 the line. See `align-rules-list' for more information about these | |
918 options. | |
919 | |
920 For example, let's say you had a list of phone numbers, and wanted to | |
921 align them so that the opening parentheses would line up: | |
922 | |
923 Fred (123) 456-7890 | |
924 Alice (123) 456-7890 | |
925 Mary-Anne (123) 456-7890 | |
926 Joe (123) 456-7890 | |
927 | |
928 There is no predefined rule to handle this, but you could easily do it | |
929 using a REGEXP like \"(\". All you would have to do is to mark the | |
930 region, call `align-regexp' and type in that regular expression." | |
931 (interactive | |
932 (append | |
67480
b34c1d612bd4
(align-regexp, align-highlight-rule): Use region-beginning and region-end
Eli Zaretskii <eliz@gnu.org>
parents:
64818
diff
changeset
|
933 (list (region-beginning) (region-end)) |
27327 | 934 (if current-prefix-arg |
935 (list (read-string "Complex align using regexp: " | |
936 "\\(\\s-*\\)") | |
62402
a7e02ef1e3d6
Replace `string-to-int' by `string-to-number'.
Juanma Barranquero <lekktu@gmail.com>
parents:
60505
diff
changeset
|
937 (string-to-number |
27327 | 938 (read-string |
939 "Parenthesis group to modify (justify if negative): " "1")) | |
62402
a7e02ef1e3d6
Replace `string-to-int' by `string-to-number'.
Juanma Barranquero <lekktu@gmail.com>
parents:
60505
diff
changeset
|
940 (string-to-number |
27327 | 941 (read-string "Amount of spacing (or column if negative): " |
942 (number-to-string align-default-spacing))) | |
943 (y-or-n-p "Repeat throughout line? ")) | |
944 (list (concat "\\(\\s-*\\)" | |
945 (read-string "Align regexp: ")) | |
946 1 align-default-spacing nil)))) | |
947 (let ((rule | |
948 (list (list nil (cons 'regexp regexp) | |
949 (cons 'group (abs group)) | |
950 (if (< group 0) | |
951 (cons 'justify t) | |
952 (cons 'bogus nil)) | |
953 (if (>= spacing 0) | |
954 (cons 'spacing spacing) | |
955 (cons 'column (abs spacing))) | |
956 (cons 'repeat repeat))))) | |
957 (align-region beg end 'entire rule nil nil))) | |
958 | |
959 ;;;###autoload | |
960 (defun align-entire (beg end &optional rules exclude-rules) | |
961 "Align the selected region as if it were one alignment section. | |
962 BEG and END mark the extent of the region. If RULES or EXCLUDE-RULES | |
963 is set to a list of rules (see `align-rules-list'), it can be used to | |
964 override the default alignment rules that would have been used to | |
965 align that section." | |
966 (interactive "r") | |
967 (align beg end 'entire rules exclude-rules)) | |
968 | |
969 ;;;###autoload | |
970 (defun align-current (&optional rules exclude-rules) | |
971 "Call `align' on the current alignment section. | |
972 This function assumes you want to align only the current section, and | |
973 so saves you from having to specify the region. If RULES or | |
974 EXCLUDE-RULES is set to a list of rules (see `align-rules-list'), it | |
975 can be used to override the default alignment rules that would have | |
976 been used to align that section." | |
977 (interactive) | |
978 (align nil nil nil rules exclude-rules)) | |
979 | |
980 ;;;###autoload | |
981 (defun align-highlight-rule (beg end title &optional rules exclude-rules) | |
982 "Highlight the whitespace which a given rule would have modified. | |
983 BEG and END mark the extent of the region. TITLE identifies the rule | |
984 that should be highlighted. If RULES or EXCLUDE-RULES is set to a | |
985 list of rules (see `align-rules-list'), it can be used to override the | |
986 default alignment rules that would have been used to identify the text | |
987 to be colored." | |
988 (interactive | |
67480
b34c1d612bd4
(align-regexp, align-highlight-rule): Use region-beginning and region-end
Eli Zaretskii <eliz@gnu.org>
parents:
64818
diff
changeset
|
989 (list (region-beginning) (region-end) |
27327 | 990 (completing-read |
991 "Title of rule to highlight: " | |
992 (mapcar | |
993 (function | |
994 (lambda (rule) | |
995 (list (symbol-name (car rule))))) | |
996 (append (or align-mode-rules-list align-rules-list) | |
997 (or align-mode-exclude-rules-list | |
998 align-exclude-rules-list))) nil t))) | |
999 (let ((ex-rule (assq (intern title) | |
1000 (or align-mode-exclude-rules-list | |
1001 align-exclude-rules-list))) | |
1002 face) | |
1003 (align-unhighlight-rule) | |
1004 (align-region | |
1005 beg end 'entire | |
1006 (or rules (if ex-rule | |
1007 (or exclude-rules align-mode-exclude-rules-list | |
1008 align-exclude-rules-list) | |
1009 (or align-mode-rules-list align-rules-list))) | |
1010 (unless ex-rule (or exclude-rules align-mode-exclude-rules-list | |
1011 align-exclude-rules-list)) | |
1012 (function | |
1013 (lambda (b e mode) | |
1014 (if (and mode (listp mode)) | |
1015 (if (equal (symbol-name (car mode)) title) | |
1016 (setq face (cons align-highlight-change-face | |
1017 align-highlight-nochange-face)) | |
1018 (setq face nil)) | |
1019 (when face | |
1020 (let ((overlay (make-overlay b e))) | |
1021 (setq align-highlight-overlays | |
1022 (cons overlay align-highlight-overlays)) | |
1023 (overlay-put overlay 'face | |
1024 (if mode | |
1025 (car face) | |
1026 (cdr face))))))))))) | |
1027 | |
1028 ;;;###autoload | |
1029 (defun align-unhighlight-rule () | |
1030 "Remove any highlighting that was added by `align-highlight-rule'." | |
1031 (interactive) | |
1032 (while align-highlight-overlays | |
1033 (delete-overlay (car align-highlight-overlays)) | |
1034 (setq align-highlight-overlays | |
1035 (cdr align-highlight-overlays)))) | |
1036 | |
30254
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1037 ;;;###autoload |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1038 (defun align-newline-and-indent () |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1039 "A replacement function for `newline-and-indent', aligning as it goes." |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1040 (interactive) |
31241 | 1041 (let ((separate (or (if (and (symbolp align-region-separate) |
1042 (boundp align-region-separate)) | |
30254
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1043 (symbol-value align-region-separate) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1044 align-region-separate) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1045 'entire)) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1046 (end (point))) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1047 (call-interactively 'newline-and-indent) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1048 (save-excursion |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1049 (forward-line -1) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1050 (while (not (or (bobp) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1051 (align-new-section-p (point) end separate))) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1052 (forward-line -1)) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1053 (align (point) end)))) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1054 |
27327 | 1055 ;;; Internal Functions: |
1056 | |
1057 (defun align-match-tex-pattern (regexp end &optional reverse) | |
1058 "Match REGEXP in TeX mode, counting backslashes appropriately. | |
1059 END denotes the end of the region to be searched, while REVERSE, if | |
1060 non-nil, indicates that the search should proceed backward from the | |
1061 current position." | |
1062 (let (result) | |
1063 (while | |
1064 (and (setq result | |
1065 (funcall | |
1066 (if reverse 're-search-backward | |
1067 're-search-forward) | |
1068 (concat "\\(\\s-*\\)" regexp | |
1069 "\\(\\s-*\\)") end t)) | |
1070 (let ((pos (match-end 1)) | |
1071 (count 0)) | |
1072 (while (and (> pos (point-min)) | |
1073 (eq (char-before pos) ?\\)) | |
1074 (setq count (1+ count) pos (1- pos))) | |
1075 (eq (mod count 2) 1)) | |
74617
92a7d7de57cb
Fix rare bug in align.el
Vinicius Jose Latorre <viniciusjl@ig.com.br>
parents:
74616
diff
changeset
|
1076 (goto-char (match-beginning (if reverse 1 2))))) |
27327 | 1077 result)) |
1078 | |
1079 (defun align-new-section-p (beg end separator) | |
1080 "Is there a section divider between BEG and END? | |
1081 SEPARATOR specifies how to look for the section divider. See the | |
1082 documentation for `align-region-separate' for more details." | |
1083 (cond ((or (not separator) | |
1084 (eq separator 'entire)) | |
1085 nil) | |
1086 ((eq separator 'group) | |
1087 (let ((amount 2)) | |
1088 (save-excursion | |
1089 (goto-char end) | |
1090 (if (bolp) | |
1091 (setq amount 1))) | |
1092 (> (count-lines beg end) amount))) | |
1093 ((stringp separator) | |
1094 (save-excursion | |
1095 (goto-char beg) | |
1096 (re-search-forward separator end t))) | |
1097 ((functionp separator) | |
1098 (funcall separator beg end)) | |
1099 ((listp separator) | |
1100 (let ((seps separator) yes) | |
1101 (while seps | |
1102 (if (and (>= (car seps) beg) | |
1103 (<= (car seps) end)) | |
1104 (setq yes t seps nil) | |
1105 (setq seps (cdr seps)))) | |
1106 yes)))) | |
1107 | |
1108 (defun align-adjust-col-for-rule (column rule spacing tab-stop) | |
1109 "Adjust COLUMN according to the given RULE. | |
1110 SPACING specifies how much spacing to use. | |
1111 TAB-STOP specifies whether SPACING refers to tab-stop boundaries." | |
1112 (unless spacing | |
1113 (setq spacing align-default-spacing)) | |
1114 (if (<= spacing 0) | |
1115 column | |
1116 (if (not tab-stop) | |
1117 (+ column spacing) | |
1118 (let ((stops tab-stop-list)) | |
1119 (while stops | |
1120 (if (and (> (car stops) column) | |
1121 (= (setq spacing (1- spacing)) 0)) | |
1122 (setq column (car stops) | |
1123 stops nil) | |
1124 (setq stops (cdr stops))))) | |
1125 column))) | |
1126 | |
1127 (defsubst align-column (pos) | |
1128 "Given a position in the buffer, state what column it's in. | |
1129 POS is the position whose column will be taken. Note that this | |
1130 function will change the location of point." | |
1131 (goto-char pos) | |
1132 (current-column)) | |
1133 | |
1134 (defsubst align-regions (regions props rule func) | |
1135 "Align the regions specified in REGIONS, a list of cons cells. | |
1136 PROPS describes formatting features specific to the given regions. | |
1137 RULE specifies exactly how to perform the alignments. | |
1138 If FUNC is specified, it will be called with each region that would | |
1139 have been aligned, rather than modifying the text." | |
1140 (while regions | |
1141 (save-excursion | |
1142 (align-areas (car regions) (car props) rule func)) | |
1143 (setq regions (cdr regions) | |
1144 props (cdr props)))) | |
1145 | |
1146 (defun align-areas (areas props rule func) | |
1147 "Given a list of AREAS and formatting PROPS, align according to RULE. | |
1148 AREAS should be a list of cons cells containing beginning and ending | |
1149 markers. This function sweeps through all of the beginning markers, | |
1150 finds out which one starts in the furthermost column, and then deletes | |
1151 and inserts text such that all of the ending markers occur in the same | |
1152 column. | |
1153 | |
1154 If FUNC is non-nil, it will be called for each text region that would | |
1155 have been aligned. No changes will be made to the buffer." | |
1156 (let* ((column (cdr (assq 'column rule))) | |
1157 (fixed (if (symbolp column) | |
1158 (symbol-value column) | |
1159 column)) | |
1160 (justify (cdr (assq 'justify rule))) | |
1161 (col (or fixed 0)) | |
1162 (width 0) | |
1163 ecol change look) | |
1164 | |
1165 ;; Determine the alignment column. | |
1166 (let ((a areas)) | |
1167 (while a | |
1168 (unless fixed | |
1169 (setq col (max col (align-column (caar a))))) | |
1170 (unless change | |
1171 (goto-char (cdar a)) | |
1172 (if ecol | |
29493 | 1173 (if (/= ecol (current-column)) |
27327 | 1174 (setq change t)) |
1175 (setq ecol (current-column)))) | |
1176 (when justify | |
1177 (goto-char (caar a)) | |
1178 (if (and (re-search-forward "\\s-*" (cdar a) t) | |
29493 | 1179 (/= (point) (cdar a))) |
27327 | 1180 (let ((bcol (current-column))) |
1181 (setcdr (car a) (cons (point-marker) (cdar a))) | |
1182 (goto-char (cdr (cdar a))) | |
1183 (setq width (max width (- (current-column) bcol)))))) | |
1184 (setq a (cdr a)))) | |
1185 | |
1186 (unless fixed | |
1187 (setq col (+ (align-adjust-col-for-rule | |
1188 col rule (car props) (cdr props)) width))) | |
1189 | |
1190 ;; Make all ending positions to occur in the goal column. Since | |
1191 ;; the whitespace to be modified was already deleted by | |
1192 ;; `align-region', all we have to do here is indent. | |
1193 | |
1194 (unless change | |
29493 | 1195 (setq change (and ecol (/= col ecol)))) |
27327 | 1196 |
1197 (when (or func change) | |
1198 (while areas | |
1199 (let ((area (car areas)) | |
1200 (gocol col) cur) | |
1201 (when area | |
1202 (if func | |
1203 (funcall func (car area) (cdr area) change) | |
1204 (if (not (and justify | |
1205 (consp (cdr area)))) | |
1206 (goto-char (cdr area)) | |
1207 (goto-char (cddr area)) | |
1208 (let ((ecol (current-column))) | |
1209 (goto-char (cadr area)) | |
1210 (setq gocol (- col (- ecol (current-column)))))) | |
1211 (setq cur (current-column)) | |
1212 (cond ((< gocol 0) t) ; don't do anything | |
1213 ((= cur gocol) t) ; don't need to | |
1214 ((< cur gocol) ; just add space | |
57972
fc790bd5db8f
(align-areas): Delete whitespace before reindenting, so
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
1215 ;; FIXME: It is stated above that "...the |
fc790bd5db8f
(align-areas): Delete whitespace before reindenting, so
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
1216 ;; whitespace to be modified was already |
fc790bd5db8f
(align-areas): Delete whitespace before reindenting, so
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
1217 ;; deleted by `align-region', all we have |
fc790bd5db8f
(align-areas): Delete whitespace before reindenting, so
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
1218 ;; to do here is indent." However, this |
fc790bd5db8f
(align-areas): Delete whitespace before reindenting, so
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
1219 ;; doesn't seem to be true, so we first |
fc790bd5db8f
(align-areas): Delete whitespace before reindenting, so
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
1220 ;; delete the whitespace to avoid tabs |
fc790bd5db8f
(align-areas): Delete whitespace before reindenting, so
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
1221 ;; after spaces. |
fc790bd5db8f
(align-areas): Delete whitespace before reindenting, so
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
1222 (delete-horizontal-space t) |
27327 | 1223 (indent-to gocol)) |
1224 (t | |
1225 ;; This code works around an oddity in the | |
1226 ;; FORCE argument of `move-to-column', which | |
1227 ;; tends to screw up markers if there is any | |
1228 ;; tabbing. | |
1229 (let ((endcol (align-column | |
1230 (if (and justify | |
1231 (consp (cdr area))) | |
1232 (cadr area) | |
1233 (cdr area)))) | |
1234 (abuts (<= gocol | |
1235 (align-column (car area))))) | |
1236 (if abuts | |
1237 (goto-char (car area)) | |
1238 (move-to-column gocol t)) | |
1239 (let ((here (point))) | |
1240 (move-to-column endcol t) | |
1241 (delete-region here (point)) | |
1242 (if abuts | |
1243 (indent-to (align-adjust-col-for-rule | |
1244 (current-column) rule | |
1245 (car props) (cdr props))))))))))) | |
1246 (setq areas (cdr areas)))))) | |
1247 | |
1248 (defun align-region (beg end separate rules exclude-rules | |
1249 &optional func) | |
1250 "Align a region based on a given set of alignment rules. | |
1251 BEG and END specify the region to be aligned. Either may be nil, in | |
1252 which case the range will stop at the nearest section division (see | |
1253 `align-region-separate', and `align-region-heuristic' for more | |
1254 information'). | |
1255 | |
1256 The region will be divided into separate alignment sections based on | |
1257 the value of SEPARATE. | |
1258 | |
1259 RULES and EXCLUDE-RULES are a pair of lists describing how to align | |
1260 the region, and which text areas within it should be excluded from | |
1261 alignment. See the `align-rules-list' for more information on the | |
1262 required format of these two lists. | |
1263 | |
1264 If FUNC is specified, no text will be modified. What `align-region' | |
1265 will do with the rules is to search for the alignment areas, as it | |
1266 regularly would, taking account for exclusions, and then call FUNC, | |
1267 first with the beginning and ending of the region to be aligned | |
1268 according to that rule (this can be different for each rule, if BEG | |
1269 and END were nil), and then with the beginning and ending of each | |
1270 text region that the rule would have applied to. | |
1271 | |
1272 The signature of FUNC should thus be: | |
1273 | |
1274 (defun my-align-function (beg end mode) | |
1275 \"If MODE is a rule (a list), return t if BEG to END are to be searched. | |
1276 Otherwise BEG to END will be a region of text that matches the rule's | |
1277 definition, and MODE will be non-nil if any changes are necessary.\" | |
1278 (unless (and mode (listp mode)) | |
1279 (message \"Would have aligned from %d to %d...\" beg end))) | |
1280 | |
1281 This feature (of passing a FUNC) is used internally to locate the | |
1282 position of exclusion areas, but could also be used for any other | |
1283 purpose where you might want to know where the regions that the | |
1284 aligner would have dealt with are." | |
1285 (let ((end-mark (and end (copy-marker end t))) | |
1286 (real-beg beg) | |
1287 (real-end end) | |
1288 (report (and (not func) align-large-region beg end | |
1289 (>= (- end beg) align-large-region))) | |
1290 (rule-index 1) | |
1291 (rule-count (length rules))) | |
1292 (if (and align-indent-before-aligning real-beg end-mark) | |
1293 (indent-region real-beg end-mark nil)) | |
1294 (while rules | |
1295 (let* ((rule (car rules)) | |
1296 (run-if (assq 'run-if rule)) | |
1297 (modes (assq 'modes rule))) | |
1298 ;; unless the `run-if' form tells us not to, look for the | |
1299 ;; rule.. | |
1300 (unless (or (and modes (not (memq major-mode | |
1301 (eval (cdr modes))))) | |
1302 (and run-if (not (funcall (cdr run-if))))) | |
1303 (let* ((current-case-fold case-fold-search) | |
1304 (case-fold (assq 'case-fold rule)) | |
1305 (regexp (cdr (assq 'regexp rule))) | |
1306 (regfunc (and (functionp regexp) regexp)) | |
1307 (rulesep (assq 'separate rule)) | |
1308 (thissep (if rulesep (cdr rulesep) separate)) | |
1309 same (eol 0) | |
101449
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1310 search-start |
27327 | 1311 group group-c |
1312 spacing spacing-c | |
1313 tab-stop tab-stop-c | |
1314 repeat repeat-c | |
1315 valid valid-c | |
1316 pos-list first | |
1317 regions index | |
1318 last-point b e | |
1319 save-match-data | |
1320 exclude-p | |
1321 align-props) | |
1322 (save-excursion | |
1323 ;; if beg and end were not given, figure out what the | |
1324 ;; current alignment region should be. Depending on the | |
1325 ;; value of `align-region-separate' it's possible for | |
1326 ;; each rule to have its own definition of what that | |
1327 ;; current alignment section is. | |
1328 (if real-beg | |
1329 (goto-char beg) | |
1330 (if (or (not thissep) (eq thissep 'entire)) | |
1331 (error "Cannot determine alignment region for '%s'" | |
1332 (symbol-name (cdr (assq 'title rule))))) | |
1333 (beginning-of-line) | |
1334 (while (and (not (eobp)) | |
1335 (looking-at "^\\s-*$")) | |
1336 (forward-line)) | |
1337 (let* ((here (point)) | |
1338 (start here)) | |
1339 (while (and here | |
1340 (let ((terminus | |
1341 (and align-region-heuristic | |
1342 (- (point) | |
1343 align-region-heuristic)))) | |
1344 (if regfunc | |
1345 (funcall regfunc terminus t) | |
1346 (re-search-backward regexp | |
1347 terminus t)))) | |
1348 (if (align-new-section-p (point) here thissep) | |
1349 (setq beg here | |
1350 here nil) | |
1351 (setq here (point)))) | |
1352 (if (not here) | |
1353 (goto-char beg)) | |
1354 (beginning-of-line) | |
1355 (setq beg (point)) | |
1356 (goto-char start) | |
1357 (setq here (point)) | |
1358 (while (and here | |
1359 (let ((terminus | |
1360 (and align-region-heuristic | |
1361 (+ (point) | |
1362 align-region-heuristic)))) | |
1363 (if regfunc | |
1364 (funcall regfunc terminus nil) | |
1365 (re-search-forward regexp terminus t)))) | |
1366 (if (align-new-section-p here (point) thissep) | |
1367 (setq end here | |
1368 here nil) | |
1369 (setq here (point)))) | |
1370 (if (not here) | |
1371 (goto-char end)) | |
1372 (forward-line) | |
1373 (setq end (point) | |
1374 end-mark (copy-marker end t)) | |
1375 (goto-char beg))) | |
1376 | |
1377 ;; If we have a region to align, and `func' is set and | |
1378 ;; reports back that the region is ok, then align it. | |
1379 (when (or (not func) | |
1380 (funcall func beg end rule)) | |
1381 (unwind-protect | |
1382 (let (exclude-areas) | |
1383 ;; determine first of all where the exclusions | |
1384 ;; lie in this region | |
1385 (when exclude-rules | |
1386 ;; guard against a problem with recursion and | |
1387 ;; dynamic binding vs. lexical binding, since | |
1388 ;; the call to `align-region' below will | |
1389 ;; re-enter this function, and rebind | |
1390 ;; `exclude-areas' | |
1391 (set (setq exclude-areas | |
1392 (make-symbol "align-exclude-areas")) | |
1393 nil) | |
1394 (align-region | |
1395 beg end 'entire | |
1396 exclude-rules nil | |
1397 `(lambda (b e mode) | |
1398 (or (and mode (listp mode)) | |
1399 (set (quote ,exclude-areas) | |
1400 (cons (cons b e) | |
1401 ,exclude-areas))))) | |
1402 (setq exclude-areas | |
1403 (sort (symbol-value exclude-areas) | |
1404 (function | |
1405 (lambda (l r) | |
1406 (>= (car l) (car r))))))) | |
1407 | |
1408 ;; set `case-fold-search' according to the | |
1409 ;; (optional) `case-fold' property | |
1410 (and case-fold | |
1411 (setq case-fold-search (cdr case-fold))) | |
1412 | |
1413 ;; while we can find the rule in the alignment | |
1414 ;; region.. | |
1415 (while (and (< (point) end-mark) | |
101449
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1416 (setq search-start (point)) |
27327 | 1417 (if regfunc |
1418 (funcall regfunc end-mark nil) | |
1419 (re-search-forward regexp | |
1420 end-mark t))) | |
1421 | |
1422 ;; give the user some indication of where we | |
1423 ;; are, if it's a very large region being | |
1424 ;; aligned | |
1425 (if report | |
45029
18577b549577
(align-region): Fix call to `message'.
Richard M. Stallman <rms@gnu.org>
parents:
43115
diff
changeset
|
1426 (let ((symbol (car rule))) |
18577b549577
(align-region): Fix call to `message'.
Richard M. Stallman <rms@gnu.org>
parents:
43115
diff
changeset
|
1427 (if (and symbol (symbolp symbol)) |
30254
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1428 (message |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1429 "Aligning `%s' (rule %d of %d) %d%%..." |
45052
8357077d84d7
(align-region): Fixed the fix to align-region, because the "name"
John Wiegley <johnw@newartisans.com>
parents:
45029
diff
changeset
|
1430 (symbol-name symbol) rule-index rule-count |
30254
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1431 (/ (* (- (point) real-beg) 100) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1432 (- end-mark real-beg))) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1433 (message |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1434 "Aligning %d%%..." |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1435 (/ (* (- (point) real-beg) 100) |
857a458d569d
Added a new feature to align.el
John Wiegley <johnw@newartisans.com>
parents:
29493
diff
changeset
|
1436 (- end-mark real-beg)))))) |
27327 | 1437 |
1438 ;; if the search ended us on the beginning of | |
1439 ;; the next line, move back to the end of the | |
1440 ;; previous line. | |
101449
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1441 (if (and (bolp) (> (point) search-start)) |
27327 | 1442 (forward-char -1)) |
1443 | |
1444 ;; lookup the `group' attribute the first time | |
1445 ;; that we need it | |
1446 (unless group-c | |
1447 (setq group (or (cdr (assq 'group rule)) 1)) | |
1448 (if (listp group) | |
1449 (setq first (car group)) | |
1450 (setq first group group (list group))) | |
1451 (setq group-c t)) | |
1452 | |
1453 (unless spacing-c | |
1454 (setq spacing (cdr (assq 'spacing rule)) | |
1455 spacing-c t)) | |
1456 | |
1457 (unless tab-stop-c | |
1458 (setq tab-stop | |
1459 (let ((rule-ts (assq 'tab-stop rule))) | |
1460 (if rule-ts | |
1461 (cdr rule-ts) | |
1462 (if (symbolp align-to-tab-stop) | |
1463 (symbol-value align-to-tab-stop) | |
1464 align-to-tab-stop))) | |
1465 tab-stop-c t)) | |
1466 | |
1467 ;; test whether we have found a match on the same | |
1468 ;; line as a previous match | |
1469 (if (> (point) eol) | |
1470 (setq same nil | |
1471 eol (save-excursion | |
1472 (end-of-line) | |
1473 (point-marker)))) | |
1474 | |
1475 ;; lookup the `repeat' attribute the first time | |
1476 (or repeat-c | |
1477 (setq repeat (cdr (assq 'repeat rule)) | |
1478 repeat-c t)) | |
1479 | |
1480 ;; lookup the `valid' attribute the first time | |
1481 (or valid-c | |
1482 (setq valid (assq 'valid rule) | |
1483 valid-c t)) | |
1484 | |
1485 ;; remember the beginning position of this rule | |
1486 ;; match, and save the match-data, since either | |
1487 ;; the `valid' form, or the code that searches for | |
1488 ;; section separation, might alter it | |
1489 (setq b (match-beginning first) | |
1490 save-match-data (match-data)) | |
1491 | |
1492 ;; unless the `valid' attribute is set, and tells | |
1493 ;; us that the rule is not valid at this point in | |
1494 ;; the code.. | |
1495 (unless (and valid (not (funcall (cdr valid)))) | |
1496 | |
1497 ;; look to see if this match begins a new | |
1498 ;; section. If so, we should align what we've | |
1499 ;; collected so far, and then begin collecting | |
1500 ;; anew for the next alignment section | |
1501 (if (and last-point | |
1502 (align-new-section-p last-point b | |
1503 thissep)) | |
1504 (progn | |
1505 (align-regions regions align-props | |
1506 rule func) | |
1507 (setq last-point (copy-marker b t) | |
1508 regions nil | |
1509 align-props nil)) | |
1510 (setq last-point (copy-marker b t))) | |
1511 | |
1512 ;; restore the match data | |
1513 (set-match-data save-match-data) | |
1514 | |
1515 ;; check whether the region to be aligned | |
1516 ;; straddles an exclusion area | |
1517 (let ((excls exclude-areas)) | |
1518 (setq exclude-p nil) | |
1519 (while excls | |
1520 (if (and (< (match-beginning (car group)) | |
1521 (cdar excls)) | |
1522 (> (match-end (car (last group))) | |
1523 (caar excls))) | |
1524 (setq exclude-p t | |
1525 excls nil) | |
1526 (setq excls (cdr excls))))) | |
1527 | |
1528 ;; go through the list of parenthesis groups | |
1529 ;; matching whitespace text to be | |
1530 ;; contracted/expanded (or possibly | |
1531 ;; justified, if the `justify' attribute was | |
1532 ;; set) | |
1533 (unless exclude-p | |
1534 (let ((g group)) | |
1535 (while g | |
1536 | |
1537 ;; we have to use markers, since | |
1538 ;; `align-areas' may modify the buffer | |
1539 (setq b (copy-marker | |
1540 (match-beginning (car g)) t) | |
1541 e (copy-marker (match-end (car g)) t)) | |
1542 | |
1543 ;; record this text region for alignment | |
1544 (setq index (if same (1+ index) 0)) | |
1545 (let ((region (cons b e)) | |
1546 (props (cons | |
1547 (if (listp spacing) | |
1548 (car spacing) | |
1549 spacing) | |
1550 (if (listp tab-stop) | |
1551 (car tab-stop) | |
1552 tab-stop)))) | |
1553 (if (nth index regions) | |
1554 (setcar (nthcdr index regions) | |
1555 (cons region | |
1556 (nth index regions))) | |
1557 (if regions | |
1558 (progn | |
1559 (nconc regions | |
1560 (list (list region))) | |
1561 (nconc align-props (list props))) | |
1562 (setq regions | |
1563 (list (list region))) | |
1564 (setq align-props (list props))))) | |
1565 | |
1566 ;; if any further rule matches are | |
1567 ;; found before `eol', then they are | |
1568 ;; on the same line as this one; this | |
1569 ;; can only happen if the `repeat' | |
1570 ;; attribute is non-nil | |
1571 (if (listp spacing) | |
1572 (setq spacing (cdr spacing))) | |
1573 (if (listp tab-stop) | |
1574 (setq tab-stop (cdr tab-stop))) | |
1575 (setq same t g (cdr g)))) | |
1576 | |
1577 ;; if `repeat' has not been set, move to | |
1578 ;; the next line; don't bother searching | |
1579 ;; anymore on this one | |
1580 (if (and (not repeat) (not (bolp))) | |
101449
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1581 (forward-line)) |
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1582 |
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1583 ;; if the search did not change point, |
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1584 ;; move forward to avoid an infinite loop |
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1585 (if (= (point) search-start) |
577a3b5b05f5
(align-region): Avoid infloop.
Chong Yidong <cyd@stupidchicken.com>
parents:
100908
diff
changeset
|
1586 (forward-char))))) |
27327 | 1587 |
1588 ;; when they are no more matches for this rule, | |
1589 ;; align whatever was left over | |
1590 (if regions | |
1591 (align-regions regions align-props rule func))) | |
1592 | |
1593 (setq case-fold-search current-case-fold))))))) | |
1594 (setq rules (cdr rules) | |
1595 rule-index (1+ rule-index))) | |
1596 | |
1597 (if report | |
1598 (message "Aligning...done")))) | |
1599 | |
1600 ;; Provide: | |
1601 | |
1602 (provide 'align) | |
1603 | |
1604 (run-hooks 'align-load-hook) | |
1605 | |
93975
1e3a407766b9
Fix up comment convention on the arch-tag lines.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
79721
diff
changeset
|
1606 ;; arch-tag: ef79cccf-1db8-4888-a8a1-d7ce2d1532f7 |
27327 | 1607 ;;; align.el ends here |