Merge from trunk.
[emacs.git] / lisp / align.el
blob8767b6ff306855bddb9aa3fe9bab7d46e282c294
1 ;;; align.el --- align text to a specific column, by regexp
3 ;; Copyright (C) 1999-2011 Free Software Foundation, Inc.
5 ;; Author: John Wiegley <johnw@gnu.org>
6 ;; Maintainer: FSF
7 ;; Keywords: convenience languages lisp
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software: you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation, either version 3 of the License, or
14 ;; (at your option) any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
24 ;;; Commentary:
26 ;; This mode allows you to align regions in a context-sensitive fashion.
27 ;; The classic use is to align assignments:
29 ;; int a = 1;
30 ;; short foo = 2;
31 ;; double blah = 4;
33 ;; becomes
35 ;; int a = 1;
36 ;; short foo = 2;
37 ;; double blah = 4;
39 ;;; Usage:
41 ;; There are several variables which define how certain "categories"
42 ;; of syntax are to be treated. These variables go by the name
43 ;; `align-CATEGORY-modes'. For example, "c++" is such a category.
44 ;; There are several rules which apply to c++, but since several other
45 ;; languages have a syntax similar to c++ (e.g., c, java, etc), these
46 ;; modes are treated as belonging to the same category.
48 ;; If you want to add a new mode under a certain category, just
49 ;; customize that list, or add the new mode manually. For example, to
50 ;; make jde-mode a c++ category mode, use this code in your .emacs
51 ;; file:
53 ;; (setq align-c++-modes (cons 'jde-mode align-c++-modes))
55 ;; In some programming modes, it's useful to have the aligner run only
56 ;; after indentation is performed. To achieve this, customize or set
57 ;; the variable `align-indent-before-aligning' to t.
59 ;;; Module Authors:
61 ;; In order to incorporate align's functionality into your own
62 ;; modules, there are only a few steps you have to follow.
64 ;; 1. Require or load in the align.el library.
66 ;; 2. Define your alignment and exclusion rules lists, either
67 ;; customizable or not.
69 ;; 3. In your mode function, set the variables
70 ;; `align-mode-rules-list' and `align-mode-exclude-rules-list'
71 ;; to your own rules lists.
73 ;; If there is any need to add your mode name to one of the
74 ;; align-?-modes variables (for example, `align-dq-string-modes'), use
75 ;; `add-to-list', or some similar function which checks first to see
76 ;; if the value is already there. Since the user may customize that
77 ;; mode list, and then write your mode name into their .emacs file,
78 ;; causing the symbol already to be present the next time they load
79 ;; your package.
81 ;; Example:
83 ;; (require 'align)
85 ;; (defcustom my-align-rules-list
86 ;; '((my-rule
87 ;; (regexp . "Sample")))
88 ;; :type align-rules-list-type
89 ;; :group 'my-package)
91 ;; (put 'my-align-rules-list 'risky-local-variable t)
93 ;; (add-to-list 'align-dq-string-modes 'my-package-mode)
94 ;; (add-to-list 'align-open-comment-modes 'my-package-mode)
96 ;; (defun my-mode ()
97 ;; ...
98 ;; (setq align-mode-rules-list my-align-rules-list))
100 ;; Note that if you need to install your own exclusion rules, then you
101 ;; will also need to reproduce any double-quoted string, or open
102 ;; comment exclusion rules that are defined in the standard
103 ;; `align-exclude-rules-list'. At the moment there is no convenient
104 ;; way to mix both mode-local and global rules lists.
106 ;;; History:
108 ;; Version 1.0 was created in the earlier part of 1996, using a very
109 ;; simple algorithm that understand only basic regular expressions.
110 ;; Parts of the code were broken up and included in vhdl-mode.el
111 ;; around this time. After several comments from users, and a need to
112 ;; find a more robust, performant algorithm, 2.0 was born in late
113 ;; 1998. Many different approaches were taken (mostly due to the
114 ;; complexity of TeX tables), but finally a scheme was discovered
115 ;; which worked fairly well for most common usage cases. Development
116 ;; beyond version 2.8 is not planned, except for problems that users
117 ;; might encounter.
119 ;;; Code:
121 (defgroup align nil
122 "Align text to a specific column, by regexp."
123 :version "21.1"
124 :group 'fill)
126 ;;; User Variables:
128 (defcustom align-load-hook nil
129 "Hook that gets run after the aligner has been loaded."
130 :type 'hook
131 :group 'align)
133 (defcustom align-indent-before-aligning nil
134 "If non-nil, indent the marked region before aligning it."
135 :type 'boolean
136 :group 'align)
138 (defcustom align-default-spacing 1
139 "An integer that represents the default amount of padding to use.
140 If `align-to-tab-stop' is non-nil, this will represent the number of
141 tab stops to use for alignment, rather than the number of spaces.
142 Each alignment rule can optionally override both this variable and
143 `align-to-tab-stop'. See `align-rules-list'."
144 :type 'integer
145 :group 'align)
147 (defcustom align-to-tab-stop 'indent-tabs-mode
148 "If non-nil, alignments will always fall on a tab boundary.
149 It may also be a symbol, whose value will be taken."
150 :type '(choice (const nil) symbol)
151 :group 'align)
153 (defcustom align-region-heuristic 500
154 "If non-nil, used as a heuristic by `align-current'.
155 Since each alignment rule can possibly have its own set of alignment
156 sections (whenever `align-region-separate' is non-nil, and not a
157 string), this heuristic is used to determine how far before and after
158 point we should search in looking for a region separator. Larger
159 values can mean slower performance in large files, although smaller
160 values may cause unexpected behavior at times."
161 :type 'integer
162 :group 'align)
164 (defcustom align-highlight-change-face 'highlight
165 "The face to highlight with if changes are necessary."
166 :type 'face
167 :group 'align)
169 (defcustom align-highlight-nochange-face 'secondary-selection
170 "The face to highlight with if no changes are necessary."
171 :type 'face
172 :group 'align)
174 (defcustom align-large-region 10000
175 "If an integer, defines what constitutes a \"large\" region.
176 If nil, then no messages will ever be printed to the minibuffer."
177 :type 'integer
178 :group 'align)
180 (defcustom align-c++-modes '(c++-mode c-mode java-mode)
181 "A list of modes whose syntax resembles C/C++."
182 :type '(repeat symbol)
183 :group 'align)
185 (defcustom align-perl-modes '(perl-mode cperl-mode)
186 "A list of modes where Perl syntax is to be seen."
187 :type '(repeat symbol)
188 :group 'align)
190 (defcustom align-lisp-modes
191 '(emacs-lisp-mode lisp-interaction-mode lisp-mode scheme-mode)
192 "A list of modes whose syntax resembles Lisp."
193 :type '(repeat symbol)
194 :group 'align)
196 (defcustom align-tex-modes
197 '(tex-mode plain-tex-mode latex-mode slitex-mode)
198 "A list of modes whose syntax resembles TeX (and family)."
199 :type '(repeat symbol)
200 :group 'align)
202 (defcustom align-text-modes '(text-mode outline-mode)
203 "A list of modes whose content is plain text."
204 :type '(repeat symbol)
205 :group 'align)
207 (defcustom align-dq-string-modes
208 (append align-lisp-modes align-c++-modes align-perl-modes
209 '(python-mode))
210 "A list of modes where double quoted strings should be excluded."
211 :type '(repeat symbol)
212 :group 'align)
214 (defcustom align-sq-string-modes
215 (append align-perl-modes '(python-mode))
216 "A list of modes where single quoted strings should be excluded."
217 :type '(repeat symbol)
218 :group 'align)
220 (defcustom align-open-comment-modes
221 (append align-lisp-modes align-c++-modes align-perl-modes
222 '(python-mode makefile-mode))
223 "A list of modes with a single-line comment syntax.
224 These are comments as in Lisp, which have a beginning, but end with
225 the line (i.e., `comment-end' is an empty string)."
226 :type '(repeat symbol)
227 :group 'align)
229 (defcustom align-region-separate "^\\s-*[{}]?\\s-*$"
230 "Select the method by which alignment sections will be separated.
231 If this is a symbol, that symbol's value will be used.
233 For the sake of clarification, consider the following example, which
234 will be referred to in the descriptions below.
236 int alpha = 1; /* one */
237 double beta = 2.0;
238 long gamma; /* ten */
240 unsigned int delta = 1; /* one */
241 long double epsilon = 3.0;
242 long long omega; /* ten */
244 The possible settings for `align-region-separate' are:
246 `entire' The entire region being aligned will be considered as a
247 single alignment section. Assuming that comments were not
248 being aligned to a particular column, the example would
249 become:
251 int alpha = 1; /* one */
252 double beta = 2.0;
253 long gamma; /* ten */
255 unsigned int delta = 1; /* one */
256 long double epsilon;
257 long long chi = 10; /* ten */
259 `group' Each contiguous set of lines where a specific alignment
260 occurs is considered a section for that alignment rule.
261 Note that each rule may have any entirely different set
262 of section divisions than another.
264 int alpha = 1; /* one */
265 double beta = 2.0;
266 long gamma; /* ten */
268 unsigned int delta = 1; /* one */
269 long double epsilon;
270 long long chi = 10; /* ten */
272 `largest' When contiguous rule sets overlap, the largest section
273 described will be taken as the alignment section for each
274 rule touched by that section.
276 int alpha = 1; /* one */
277 double beta = 2.0;
278 long gamma; /* ten */
280 unsigned int delta = 1; /* one */
281 long double epsilon;
282 long long chi = 10; /* ten */
284 NOTE: This option is not supported yet, due to algorithmic
285 issues which haven't been satisfactorily resolved. There
286 are ways to do it, but they're both ugly and resource
287 consumptive.
289 regexp A regular expression string which defines the section
290 divider. If the mode you're in has a consistent divider
291 between sections, the behavior will be very similar to
292 `largest', and faster. But if the mode does not use clear
293 separators (for example, if you collapse your braces onto
294 the preceding statement in C or Perl), `largest' is
295 probably the better alternative.
297 function A function that will be passed the beginning and ending
298 locations of the region in which to look for the section
299 separator. At the very beginning of the attempt to align,
300 both of these parameters will be nil, in which case the
301 function should return non-nil if it wants each rule to
302 define its own section, or nil if it wants the largest
303 section found to be used as the common section for all
304 rules that occur there.
306 list A list of markers within the buffer that represent where
307 the section dividers lie. Be certain to use markers! For
308 when the aligning begins, the ensuing contract/expanding of
309 whitespace will throw off any non-marker positions.
311 This method is intended for use in Lisp programs, and not
312 by the user."
313 :type '(choice
314 (const :tag "Entire region is one section" entire)
315 (const :tag "Align by contiguous groups" group)
316 ; (const largest)
317 (regexp :tag "Regexp defines section boundaries")
318 (function :tag "Function defines section boundaries"))
319 :group 'align)
321 (put 'align-region-separate 'risky-local-variable t)
323 (defvar align-rules-list-type
324 '(repeat
325 (cons
326 :tag "Alignment rule"
327 (symbol :tag "Title")
328 (cons :tag "Required attributes"
329 (cons :tag "Regexp"
330 (const :tag "(Regular expression to match)" regexp)
331 (choice :value "\\(\\s-+\\)" regexp function))
332 (repeat
333 :tag "Optional attributes"
334 (choice
335 (cons :tag "Repeat"
336 (const :tag "(Repeat this rule throughout line)"
337 repeat)
338 (boolean :value t))
339 (cons :tag "Paren group"
340 (const :tag "(Parenthesis group to use)" group)
341 (choice :value 2
342 integer (repeat integer)))
343 (cons :tag "Modes"
344 (const :tag "(Modes where this rule applies)" modes)
345 (sexp :value (text-mode)))
346 (cons :tag "Case-fold"
347 (const :tag "(Should case be ignored for this rule)"
348 case-fold)
349 (boolean :value t))
350 (cons :tag "To Tab Stop"
351 (const :tag "(Should rule align to tab stops)"
352 tab-stop)
353 (boolean :value nil))
354 (cons :tag "Valid"
355 (const :tag "(Return non-nil if rule is valid)"
356 valid)
357 (function :value t))
358 (cons :tag "Run If"
359 (const :tag "(Return non-nil if rule should run)"
360 run-if)
361 (function :value t))
362 (cons :tag "Column"
363 (const :tag "(Column to fix alignment at)" column)
364 (choice :value comment-column
365 integer symbol))
366 (cons :tag "Spacing"
367 (const :tag "(Amount of spacing to use)" spacing)
368 (integer :value 1))
369 (cons :tag "Justify"
370 (const :tag "(Should text be right justified)"
371 justify)
372 (boolean :value t))
373 ;; make sure this stays up-to-date with any changes
374 ;; in `align-region-separate'
375 (cons :tag "Separate"
376 (const :tag "(Separation to use for this rule)"
377 separate)
378 (choice :value "^\\s-*$"
379 (const entire)
380 (const group)
381 ; (const largest)
382 regexp function)))))))
383 "The `type' form for any `align-rules-list' variable.")
385 (defcustom align-rules-list
386 `((lisp-second-arg
387 (regexp . "\\(^\\s-+[^( \t\n]\\|(\\(\\S-+\\)\\s-+\\)\\S-+\\(\\s-+\\)")
388 (group . 3)
389 (modes . align-lisp-modes)
390 (run-if . ,(function (lambda () current-prefix-arg))))
392 (lisp-alist-dot
393 (regexp . "\\(\\s-*\\)\\.\\(\\s-*\\)")
394 (group . (1 2))
395 (modes . align-lisp-modes))
397 (open-comment
398 (regexp . ,(function
399 (lambda (end reverse)
400 (funcall (if reverse 're-search-backward
401 're-search-forward)
402 (concat "[^ \t\n\\\\]"
403 (regexp-quote comment-start)
404 "\\(.+\\)$") end t))))
405 (modes . align-open-comment-modes))
407 (c-macro-definition
408 (regexp . "^\\s-*#\\s-*define\\s-+\\S-+\\(\\s-+\\)")
409 (modes . align-c++-modes))
411 (c-variable-declaration
412 (regexp . ,(concat "[*&0-9A-Za-z_]>?[&*]*\\(\\s-+[*&]*\\)"
413 "[A-Za-z_][0-9A-Za-z:_]*\\s-*\\(\\()\\|"
414 "=[^=\n].*\\|(.*)\\|\\(\\[.*\\]\\)*\\)?"
415 "\\s-*[;,]\\|)\\s-*$\\)"))
416 (group . 1)
417 (modes . align-c++-modes)
418 (justify . t)
419 (valid
420 . ,(function
421 (lambda ()
422 (not (or (save-excursion
423 (goto-char (match-beginning 1))
424 (backward-word 1)
425 (looking-at
426 "\\(goto\\|return\\|new\\|delete\\|throw\\)"))
427 (if (and (boundp 'font-lock-mode) font-lock-mode)
428 (eq (get-text-property (point) 'face)
429 'font-lock-comment-face)
430 (eq (caar (c-guess-basic-syntax)) 'c))))))))
432 (c-assignment
433 (regexp . ,(concat "[^-=!^&*+<>/| \t\n]\\(\\s-*[-=!^&*+<>/|]*\\)"
434 "=\\(\\s-*\\)\\([^= \t\n]\\|$\\)"))
435 (group . (1 2))
436 (modes . align-c++-modes)
437 (justify . t)
438 (tab-stop . nil))
440 (perl-assignment
441 (regexp . ,(concat "[^=!^&*-+<>/| \t\n]\\(\\s-*\\)=[~>]?"
442 "\\(\\s-*\\)\\([^>= \t\n]\\|$\\)"))
443 (group . (1 2))
444 (modes . align-perl-modes)
445 (tab-stop . nil))
447 (python-assignment
448 (regexp . ,(concat "[^=!<> \t\n]\\(\\s-*\\)="
449 "\\(\\s-*\\)\\([^>= \t\n]\\|$\\)"))
450 (group . (1 2))
451 (modes . '(python-mode))
452 (tab-stop . nil))
454 (make-assignment
455 (regexp . "^\\s-*\\w+\\(\\s-*\\):?=\\(\\s-*\\)\\([^\t\n \\\\]\\|$\\)")
456 (group . (1 2))
457 (modes . '(makefile-mode))
458 (tab-stop . nil))
460 (c-comma-delimiter
461 (regexp . ",\\(\\s-*\\)[^/ \t\n]")
462 (repeat . t)
463 (modes . align-c++-modes)
464 (run-if . ,(function (lambda () current-prefix-arg))))
465 ; (valid
466 ; . ,(function
467 ; (lambda ()
468 ; (memq (caar (c-guess-basic-syntax))
469 ; '(brace-list-intro
470 ; brace-list-entry
471 ; brace-entry-open))))))
473 ;; With a prefix argument, comma delimiter will be aligned. Since
474 ;; perl-mode doesn't give us enough syntactic information (and we
475 ;; don't do our own parsing yet), this rule is too destructive to
476 ;; run normally.
477 (basic-comma-delimiter
478 (regexp . ",\\(\\s-*\\)[^# \t\n]")
479 (repeat . t)
480 (modes . (append align-perl-modes '(python-mode)))
481 (run-if . ,(function (lambda () current-prefix-arg))))
483 (c++-comment
484 (regexp . "\\(\\s-*\\)\\(//.*\\|/\\*.*\\*/\\s-*\\)$")
485 (modes . align-c++-modes)
486 (column . comment-column)
487 (valid . ,(function
488 (lambda ()
489 (save-excursion
490 (goto-char (match-beginning 1))
491 (not (bolp)))))))
493 (c-chain-logic
494 (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)")
495 (modes . align-c++-modes)
496 (valid . ,(function
497 (lambda ()
498 (save-excursion
499 (goto-char (match-end 2))
500 (looking-at "\\s-*\\(/[*/]\\|$\\)"))))))
502 (perl-chain-logic
503 (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)")
504 (modes . align-perl-modes)
505 (valid . ,(function
506 (lambda ()
507 (save-excursion
508 (goto-char (match-end 2))
509 (looking-at "\\s-*\\(#\\|$\\)"))))))
511 (python-chain-logic
512 (regexp . "\\(\\s-*\\)\\(\\<and\\>\\|\\<or\\>\\)")
513 (modes . '(python-mode))
514 (valid . ,(function
515 (lambda ()
516 (save-excursion
517 (goto-char (match-end 2))
518 (looking-at "\\s-*\\(#\\|$\\|\\\\\\)"))))))
520 (c-macro-line-continuation
521 (regexp . "\\(\\s-*\\)\\\\$")
522 (modes . align-c++-modes)
523 (column . c-backslash-column))
524 ; (valid
525 ; . ,(function
526 ; (lambda ()
527 ; (memq (caar (c-guess-basic-syntax))
528 ; '(cpp-macro cpp-macro-cont))))))
530 (basic-line-continuation
531 (regexp . "\\(\\s-*\\)\\\\$")
532 (modes . '(python-mode makefile-mode)))
534 (tex-record-separator
535 (regexp . ,(function
536 (lambda (end reverse)
537 (align-match-tex-pattern "&" end reverse))))
538 (group . (1 2))
539 (modes . align-tex-modes)
540 (repeat . t))
542 (tex-tabbing-separator
543 (regexp . ,(function
544 (lambda (end reverse)
545 (align-match-tex-pattern "\\\\[=>]" end reverse))))
546 (group . (1 2))
547 (modes . align-tex-modes)
548 (repeat . t)
549 (run-if . ,(function
550 (lambda ()
551 (eq major-mode 'latex-mode)))))
553 (tex-record-break
554 (regexp . "\\(\\s-*\\)\\\\\\\\")
555 (modes . align-tex-modes))
557 ;; With a numeric prefix argument, or C-u, space delimited text
558 ;; tables will be aligned.
559 (text-column
560 (regexp . "\\(^\\|\\S-\\)\\([ \t]+\\)\\(\\S-\\|$\\)")
561 (group . 2)
562 (modes . align-text-modes)
563 (repeat . t)
564 (run-if . ,(function
565 (lambda ()
566 (and current-prefix-arg
567 (not (eq '- current-prefix-arg)))))))
569 ;; With a negative prefix argument, lists of dollar figures will
570 ;; be aligned.
571 (text-dollar-figure
572 (regexp . "\\$?\\(\\s-+[0-9]+\\)\\.")
573 (modes . align-text-modes)
574 (justify . t)
575 (run-if . ,(function
576 (lambda ()
577 (eq '- current-prefix-arg)))))
579 (css-declaration
580 (regexp . "^\\s-*\\w+:\\(\\s-*\\).*;")
581 (group . (1))
582 (modes . '(css-mode html-mode))))
583 "A list describing all of the available alignment rules.
584 The format is:
586 ((TITLE
587 (ATTRIBUTE . VALUE) ...)
588 ...)
590 The following attributes are meaningful:
592 `regexp' This required attribute must be either a string describing
593 a regular expression, or a function (described below).
594 For every line within the section that this regular
595 expression matches, the given rule will be applied to that
596 line. The exclusion rules denote which part(s) of the
597 line should not be modified; the alignment rules cause the
598 identified whitespace group to be contracted/expanded such
599 that the \"alignment character\" (the character
600 immediately following the identified parenthesis group),
601 occurs in the same column for every line within the
602 alignment section (see `align-region-separate' for a
603 description of how the region is broken up into alignment
604 sections).
606 The `regexp' attribute describes how the text should be
607 treated. Within this regexp, there must be at least one
608 group of characters (typically whitespace) identified by
609 the special opening and closing parens used in regexp
610 expressions (`\\\\(' and `\\\\)') (see the Emacs manual on
611 the syntax of regular expressions for more info).
613 If `regexp' is a function, it will be called as a
614 replacement for `re-search-forward'. This means that it
615 should return nil if nothing is found to match the rule,
616 or it should set the match data appropriately, move point
617 to the end of the match, and return the value of point.
619 `group' For exclusion rules, the group identifies the range of
620 characters that should be ignored. For alignment rules,
621 these are the characters that will be deleted/expanded for
622 the purposes of alignment. The \"alignment character\" is
623 always the first character immediately following this
624 parenthesis group. This attribute may also be a list of
625 integers, in which case multiple alignment characters will
626 be aligned, with the list of integers identifying the
627 whitespace groups which precede them. The default for
628 this attribute is 1.
630 `modes' The `modes' attribute, if set, should name a list of
631 major modes -- or evaluate to such a value -- in which the
632 rule is valid. If not set, the rule will apply to all
633 modes.
635 `case-fold' If `regexp' is an ordinary regular expression string
636 containing alphabetic character, sometimes you may want
637 the search to proceed case-insensitively (for languages
638 that ignore case, such as Pascal for example). In that
639 case, set `case-fold' to a non-nil value, and the regular
640 expression search will ignore case. If `regexp' is set to
641 a function, that function must handle the job of ignoring
642 case by itself.
644 `tab-stop' If the `tab-stop' attribute is set, and non-nil, the
645 alignment character will always fall on a tab stop
646 (whether it uses tabs to get there or not depends on the
647 value of `indent-tabs-mode'). If the `tab-stop' attribute
648 is set to nil, tab stops will never be used. Otherwise,
649 the value of `align-to-tab-stop' determines whether or not
650 to align to a tab stop. The `tab-stop' attribute may also
651 be a list of t or nil values, corresponding to the number
652 of parenthesis groups specified by the `group' attribute.
654 `repeat' If the `repeat' attribute is present, and non-nil, the
655 rule will be applied to the line continuously until no
656 further matches are found.
658 `valid' If the `valid' attribute is set, it will be used to
659 determine whether the rule should be invoked. This form
660 is evaluated after the regular expression match has been
661 performed, so that it is possible to use the results of
662 that match to determine whether the alignment should be
663 performed. The buffer should not be modified during the
664 evaluation of this form.
666 `run-if' Like `valid', the `run-if' attribute tests whether the
667 rule should be run at all -- even before any searches are
668 done to determine if the rule applies to the alignment
669 region. This can save time, since `run-if' will only be
670 run once for each rule. If it returns nil, the rule will
671 not be attempted.
673 `column' For alignment rules, if the `column' attribute is set --
674 which must be an integer, or a symbol whose value is an
675 integer -- it will be used as the column in which to align
676 the alignment character. If the text on a particular line
677 happens to overrun that column, a single space character,
678 or tab stop (see `align-to-tab-stop') will be added
679 between the last text character and the alignment
680 character.
682 `spacing' Alignment rules may also override the amount of spacing
683 that would normally be used by providing a `spacing'
684 attribute. This must be an integer, or a list of integers
685 corresponding to the number of parenthesis groups matched
686 by the `group' attribute. If a list of value is used, and
687 any of those values is nil, `align-default-spacing' will
688 be used for that subgroup. See `align-default-spacing'
689 for more details on spacing, tab stops, and how to
690 indicate how much spacing should be used. If TAB-STOP is
691 present, it will override the value of `align-to-tab-stop'
692 for that rule.
694 `justify' It is possible with `regexp' and `group' to identify a
695 character group that contains more than just whitespace
696 characters. By default, any non-whitespace characters in
697 that group will also be deleted while aligning the
698 alignment character. However, if the `justify' attribute
699 is set to a non-nil value, only the initial whitespace
700 characters within that group will be deleted. This has
701 the effect of right-justifying the characters that remain,
702 and can be used for outdenting or just plain old right-
703 justification.
705 `separate' Each rule can define its own section separator, which
706 describes how to identify the separation of \"sections\"
707 within the region to be aligned. Setting the `separate'
708 attribute overrides the value of `align-region-separate'
709 (see the documentation of that variable for possible
710 values), and any separation argument passed to `align'."
711 :type align-rules-list-type
712 :group 'align)
714 (put 'align-rules-list 'risky-local-variable t)
716 (defvar align-exclude-rules-list-type
717 '(repeat
718 (cons
719 :tag "Exclusion rule"
720 (symbol :tag "Title")
721 (cons :tag "Required attributes"
722 (cons :tag "Regexp"
723 (const :tag "(Regular expression to match)" regexp)
724 (choice :value "\\(\\s-+\\)" regexp function))
725 (repeat
726 :tag "Optional attributes"
727 (choice
728 (cons :tag "Repeat"
729 (const :tag "(Repeat this rule throughout line)"
730 repeat)
731 (boolean :value t))
732 (cons :tag "Paren group"
733 (const :tag "(Parenthesis group to use)" group)
734 (choice :value 2
735 integer (repeat integer)))
736 (cons :tag "Modes"
737 (const :tag "(Modes where this rule applies)" modes)
738 (sexp :value (text-mode)))
739 (cons :tag "Case-fold"
740 (const :tag "(Should case be ignored for this rule)"
741 case-fold)
742 (boolean :value t)))))))
743 "The `type' form for any `align-exclude-rules-list' variable.")
745 (defcustom align-exclude-rules-list
746 `((exc-dq-string
747 (regexp . "\"\\([^\"\n]+\\)\"")
748 (repeat . t)
749 (modes . align-dq-string-modes))
751 (exc-sq-string
752 (regexp . "'\\([^'\n]+\\)'")
753 (repeat . t)
754 (modes . align-sq-string-modes))
756 (exc-open-comment
757 (regexp
758 . ,(function
759 (lambda (end reverse)
760 (funcall (if reverse 're-search-backward
761 're-search-forward)
762 (concat "[^ \t\n\\\\]"
763 (regexp-quote comment-start)
764 "\\(.+\\)$") end t))))
765 (modes . align-open-comment-modes))
767 (exc-c-comment
768 (regexp . "/\\*\\(.+\\)\\*/")
769 (repeat . t)
770 (modes . align-c++-modes))
772 (exc-c-func-params
773 (regexp . "(\\([^)\n]+\\))")
774 (repeat . t)
775 (modes . align-c++-modes))
777 (exc-c-macro
778 (regexp . "^\\s-*#\\s-*\\(if\\w*\\|endif\\)\\(.*\\)$")
779 (group . 2)
780 (modes . align-c++-modes)))
781 "A list describing text that should be excluded from alignment.
782 See the documentation for `align-rules-list' for more info."
783 :type align-exclude-rules-list-type
784 :group 'align)
786 (put 'align-exclude-rules-list 'risky-local-variable t)
788 ;;; Internal Variables:
790 (defvar align-mode-rules-list nil
791 "Alignment rules specific to the current major mode.
792 See the variable `align-rules-list' for more details.")
794 (make-variable-buffer-local 'align-mode-rules-list)
796 (defvar align-mode-exclude-rules-list nil
797 "Alignment exclusion rules specific to the current major mode.
798 See the variable `align-exclude-rules-list' for more details.")
800 (make-variable-buffer-local 'align-mode-exclude-rules-list)
802 (defvar align-highlight-overlays nil
803 "The current overlays highlighting the text matched by a rule.")
805 ;; Sample extension rule set, for vhdl-mode. This should properly be
806 ;; in vhdl-mode.el itself.
808 (defcustom align-vhdl-rules-list
809 `((vhdl-declaration
810 (regexp . "\\(signal\\|variable\\|constant\\)\\(\\s-+\\)\\S-")
811 (group . 2))
813 (vhdl-case
814 (regexp . "\\(others\\|[^ \t\n=<]\\)\\(\\s-*\\)=>\\(\\s-*\\)\\S-")
815 (group . (2 3))
816 (valid
817 . ,(function
818 (lambda ()
819 (not (string= (downcase (match-string 1))
820 "others"))))))
822 (vhdl-colon
823 (regexp . "[^ \t\n:]\\(\\s-*\\):\\(\\s-*\\)[^=\n]")
824 (group . (1 2)))
826 (direction
827 (regexp . ":\\s-*\\(in\\|out\\|inout\\|buffer\\)\\(\\s-*\\)")
828 (group . 2))
830 (sig-assign
831 (regexp . "[^ \t\n=<]\\(\\s-*\\)<=\\(\\s-*\\)\\S-")
832 (group . (1 2)))
834 (var-assign
835 (regexp . "[^ \t\n:]\\(\\s-*\\):="))
837 (use-entity
838 (regexp . "\\(\\s-+\\)use\\s-+entity")))
839 "Alignment rules for `vhdl-mode'. See `align-rules-list' for more info."
840 :type align-rules-list-type
841 :group 'align)
843 (put 'align-vhdl-rules-list 'risky-local-variable t)
845 (defun align-set-vhdl-rules ()
846 "Setup the `align-mode-rules-list' variable for `vhdl-mode'."
847 (setq align-mode-rules-list align-vhdl-rules-list))
849 (add-hook 'vhdl-mode-hook 'align-set-vhdl-rules)
851 (add-to-list 'align-dq-string-modes 'vhdl-mode)
852 (add-to-list 'align-open-comment-modes 'vhdl-mode)
854 ;;; User Functions:
856 ;;;###autoload
857 (defun align (beg end &optional separate rules exclude-rules)
858 "Attempt to align a region based on a set of alignment rules.
859 BEG and END mark the region. If BEG and END are specifically set to
860 nil (this can only be done programmatically), the beginning and end of
861 the current alignment section will be calculated based on the location
862 of point, and the value of `align-region-separate' (or possibly each
863 rule's `separate' attribute).
865 If SEPARATE is non-nil, it overrides the value of
866 `align-region-separate' for all rules, except those that have their
867 `separate' attribute set.
869 RULES and EXCLUDE-RULES, if either is non-nil, will replace the
870 default rule lists defined in `align-rules-list' and
871 `align-exclude-rules-list'. See `align-rules-list' for more details
872 on the format of these lists."
873 (interactive "r")
874 (let ((separator
875 (or separate
876 (if (and (symbolp align-region-separate)
877 (boundp align-region-separate))
878 (symbol-value align-region-separate)
879 align-region-separate)
880 'entire)))
881 (if (not (or ;(eq separator 'largest)
882 (and (functionp separator)
883 (not (funcall separator nil nil)))))
884 (align-region beg end separator
885 (or rules align-mode-rules-list align-rules-list)
886 (or exclude-rules align-mode-exclude-rules-list
887 align-exclude-rules-list))
888 (let ((sec-first end)
889 (sec-last beg))
890 (align-region beg end
891 (or exclude-rules
892 align-mode-exclude-rules-list
893 align-exclude-rules-list) nil
894 separator
895 (function
896 (lambda (b e mode)
897 (when (and mode (listp mode))
898 (setq sec-first (min sec-first b)
899 sec-last (max sec-last e))))))
900 (if (< sec-first sec-last)
901 (align-region sec-first sec-last 'entire
902 (or rules align-mode-rules-list align-rules-list)
903 (or exclude-rules align-mode-exclude-rules-list
904 align-exclude-rules-list)))))))
906 ;;;###autoload
907 (defun align-regexp (beg end regexp &optional group spacing repeat)
908 "Align the current region using an ad-hoc rule read from the minibuffer.
909 BEG and END mark the limits of the region. This function will prompt
910 for the REGEXP to align with. If no prefix arg was specified, you
911 only need to supply the characters to be lined up and any preceding
912 whitespace is replaced. If a prefix arg was specified, the full
913 regexp with parenthesized whitespace should be supplied; it will also
914 prompt for which parenthesis GROUP within REGEXP to modify, the amount
915 of SPACING to use, and whether or not to REPEAT the rule throughout
916 the line. See `align-rules-list' for more information about these
917 options.
919 For example, let's say you had a list of phone numbers, and wanted to
920 align them so that the opening parentheses would line up:
922 Fred (123) 456-7890
923 Alice (123) 456-7890
924 Mary-Anne (123) 456-7890
925 Joe (123) 456-7890
927 There is no predefined rule to handle this, but you could easily do it
928 using a REGEXP like \"(\". All you would have to do is to mark the
929 region, call `align-regexp' and type in that regular expression."
930 (interactive
931 (append
932 (list (region-beginning) (region-end))
933 (if current-prefix-arg
934 (list (read-string "Complex align using regexp: "
935 "\\(\\s-*\\)")
936 (string-to-number
937 (read-string
938 "Parenthesis group to modify (justify if negative): " "1"))
939 (string-to-number
940 (read-string "Amount of spacing (or column if negative): "
941 (number-to-string align-default-spacing)))
942 (y-or-n-p "Repeat throughout line? "))
943 (list (concat "\\(\\s-*\\)"
944 (read-string "Align regexp: "))
945 1 align-default-spacing nil))))
946 (or group (setq group 1))
947 (or spacing (setq spacing align-default-spacing))
948 (let ((rule
949 (list (list nil (cons 'regexp regexp)
950 (cons 'group (abs group))
951 (if (< group 0)
952 (cons 'justify t)
953 (cons 'bogus nil))
954 (if (>= spacing 0)
955 (cons 'spacing spacing)
956 (cons 'column (abs spacing)))
957 (cons 'repeat repeat)))))
958 (align-region beg end 'entire rule nil nil)))
960 ;;;###autoload
961 (defun align-entire (beg end &optional rules exclude-rules)
962 "Align the selected region as if it were one alignment section.
963 BEG and END mark the extent of the region. If RULES or EXCLUDE-RULES
964 is set to a list of rules (see `align-rules-list'), it can be used to
965 override the default alignment rules that would have been used to
966 align that section."
967 (interactive "r")
968 (align beg end 'entire rules exclude-rules))
970 ;;;###autoload
971 (defun align-current (&optional rules exclude-rules)
972 "Call `align' on the current alignment section.
973 This function assumes you want to align only the current section, and
974 so saves you from having to specify the region. If RULES or
975 EXCLUDE-RULES is set to a list of rules (see `align-rules-list'), it
976 can be used to override the default alignment rules that would have
977 been used to align that section."
978 (interactive)
979 (align nil nil nil rules exclude-rules))
981 ;;;###autoload
982 (defun align-highlight-rule (beg end title &optional rules exclude-rules)
983 "Highlight the whitespace which a given rule would have modified.
984 BEG and END mark the extent of the region. TITLE identifies the rule
985 that should be highlighted. If RULES or EXCLUDE-RULES is set to a
986 list of rules (see `align-rules-list'), it can be used to override the
987 default alignment rules that would have been used to identify the text
988 to be colored."
989 (interactive
990 (list (region-beginning) (region-end)
991 (completing-read
992 "Title of rule to highlight: "
993 (mapcar
994 (function
995 (lambda (rule)
996 (list (symbol-name (car rule)))))
997 (append (or align-mode-rules-list align-rules-list)
998 (or align-mode-exclude-rules-list
999 align-exclude-rules-list))) nil t)))
1000 (let ((ex-rule (assq (intern title)
1001 (or align-mode-exclude-rules-list
1002 align-exclude-rules-list)))
1003 face)
1004 (align-unhighlight-rule)
1005 (align-region
1006 beg end 'entire
1007 (or rules (if ex-rule
1008 (or exclude-rules align-mode-exclude-rules-list
1009 align-exclude-rules-list)
1010 (or align-mode-rules-list align-rules-list)))
1011 (unless ex-rule (or exclude-rules align-mode-exclude-rules-list
1012 align-exclude-rules-list))
1013 (function
1014 (lambda (b e mode)
1015 (if (and mode (listp mode))
1016 (if (equal (symbol-name (car mode)) title)
1017 (setq face (cons align-highlight-change-face
1018 align-highlight-nochange-face))
1019 (setq face nil))
1020 (when face
1021 (let ((overlay (make-overlay b e)))
1022 (setq align-highlight-overlays
1023 (cons overlay align-highlight-overlays))
1024 (overlay-put overlay 'face
1025 (if mode
1026 (car face)
1027 (cdr face)))))))))))
1029 ;;;###autoload
1030 (defun align-unhighlight-rule ()
1031 "Remove any highlighting that was added by `align-highlight-rule'."
1032 (interactive)
1033 (while align-highlight-overlays
1034 (delete-overlay (car align-highlight-overlays))
1035 (setq align-highlight-overlays
1036 (cdr align-highlight-overlays))))
1038 ;;;###autoload
1039 (defun align-newline-and-indent ()
1040 "A replacement function for `newline-and-indent', aligning as it goes."
1041 (interactive)
1042 (let ((separate (or (if (and (symbolp align-region-separate)
1043 (boundp align-region-separate))
1044 (symbol-value align-region-separate)
1045 align-region-separate)
1046 'entire))
1047 (end (point)))
1048 (call-interactively 'newline-and-indent)
1049 (save-excursion
1050 (forward-line -1)
1051 (while (not (or (bobp)
1052 (align-new-section-p (point) end separate)))
1053 (forward-line -1))
1054 (align (point) end))))
1056 ;;; Internal Functions:
1058 (defun align-match-tex-pattern (regexp end &optional reverse)
1059 "Match REGEXP in TeX mode, counting backslashes appropriately.
1060 END denotes the end of the region to be searched, while REVERSE, if
1061 non-nil, indicates that the search should proceed backward from the
1062 current position."
1063 (let (result)
1064 (while
1065 (and (setq result
1066 (funcall
1067 (if reverse 're-search-backward
1068 're-search-forward)
1069 (concat "\\(\\s-*\\)" regexp
1070 "\\(\\s-*\\)") end t))
1071 (let ((pos (match-end 1))
1072 (count 0))
1073 (while (and (> pos (point-min))
1074 (eq (char-before pos) ?\\))
1075 (setq count (1+ count) pos (1- pos)))
1076 (eq (mod count 2) 1))
1077 (goto-char (match-beginning (if reverse 1 2)))))
1078 result))
1080 (defun align-new-section-p (beg end separator)
1081 "Is there a section divider between BEG and END?
1082 SEPARATOR specifies how to look for the section divider. See the
1083 documentation for `align-region-separate' for more details."
1084 (cond ((or (not separator)
1085 (eq separator 'entire))
1086 nil)
1087 ((eq separator 'group)
1088 (let ((amount 2))
1089 (save-excursion
1090 (goto-char end)
1091 (if (bolp)
1092 (setq amount 1)))
1093 (> (count-lines beg end) amount)))
1094 ((stringp separator)
1095 (save-excursion
1096 (goto-char beg)
1097 (re-search-forward separator end t)))
1098 ((functionp separator)
1099 (funcall separator beg end))
1100 ((listp separator)
1101 (let ((seps separator) yes)
1102 (while seps
1103 (if (and (>= (car seps) beg)
1104 (<= (car seps) end))
1105 (setq yes t seps nil)
1106 (setq seps (cdr seps))))
1107 yes))))
1109 (defun align-adjust-col-for-rule (column _rule spacing tab-stop)
1110 "Adjust COLUMN according to the given RULE.
1111 SPACING specifies how much spacing to use.
1112 TAB-STOP specifies whether SPACING refers to tab-stop boundaries."
1113 (unless spacing
1114 (setq spacing align-default-spacing))
1115 (if (<= spacing 0)
1116 column
1117 (if (not tab-stop)
1118 (+ column spacing)
1119 (let ((stops tab-stop-list))
1120 (while stops
1121 (if (and (> (car stops) column)
1122 (= (setq spacing (1- spacing)) 0))
1123 (setq column (car stops)
1124 stops nil)
1125 (setq stops (cdr stops)))))
1126 column)))
1128 (defsubst align-column (pos)
1129 "Given a position in the buffer, state what column it's in.
1130 POS is the position whose column will be taken. Note that this
1131 function will change the location of point."
1132 (goto-char pos)
1133 (current-column))
1135 (defsubst align-regions (regions props rule func)
1136 "Align the regions specified in REGIONS, a list of cons cells.
1137 PROPS describes formatting features specific to the given regions.
1138 RULE specifies exactly how to perform the alignments.
1139 If FUNC is specified, it will be called with each region that would
1140 have been aligned, rather than modifying the text."
1141 (while regions
1142 (save-excursion
1143 (align-areas (car regions) (car props) rule func))
1144 (setq regions (cdr regions)
1145 props (cdr props))))
1147 (defun align-areas (areas props rule func)
1148 "Given a list of AREAS and formatting PROPS, align according to RULE.
1149 AREAS should be a list of cons cells containing beginning and ending
1150 markers. This function sweeps through all of the beginning markers,
1151 finds out which one starts in the furthermost column, and then deletes
1152 and inserts text such that all of the ending markers occur in the same
1153 column.
1155 If FUNC is non-nil, it will be called for each text region that would
1156 have been aligned. No changes will be made to the buffer."
1157 (let* ((column (cdr (assq 'column rule)))
1158 (fixed (if (symbolp column)
1159 (symbol-value column)
1160 column))
1161 (justify (cdr (assq 'justify rule)))
1162 (col (or fixed 0))
1163 (width 0)
1164 ecol change)
1166 ;; Determine the alignment column.
1167 (let ((a areas))
1168 (while a
1169 (unless fixed
1170 (setq col (max col (align-column (caar a)))))
1171 (unless change
1172 (goto-char (cdar a))
1173 (if ecol
1174 (if (/= ecol (current-column))
1175 (setq change t))
1176 (setq ecol (current-column))))
1177 (when justify
1178 (goto-char (caar a))
1179 (if (and (re-search-forward "\\s-*" (cdar a) t)
1180 (/= (point) (cdar a)))
1181 (let ((bcol (current-column)))
1182 (setcdr (car a) (cons (point-marker) (cdar a)))
1183 (goto-char (cdr (cdar a)))
1184 (setq width (max width (- (current-column) bcol))))))
1185 (setq a (cdr a))))
1187 (unless fixed
1188 (setq col (+ (align-adjust-col-for-rule
1189 col rule (car props) (cdr props)) width)))
1191 ;; Make all ending positions to occur in the goal column. Since
1192 ;; the whitespace to be modified was already deleted by
1193 ;; `align-region', all we have to do here is indent.
1195 (unless change
1196 (setq change (and ecol (/= col ecol))))
1198 (when (or func change)
1199 (while areas
1200 (let ((area (car areas))
1201 (gocol col) cur)
1202 (when area
1203 (if func
1204 (funcall func (car area) (cdr area) change)
1205 (if (not (and justify
1206 (consp (cdr area))))
1207 (goto-char (cdr area))
1208 (goto-char (cddr area))
1209 (let ((ecol (current-column)))
1210 (goto-char (cadr area))
1211 (setq gocol (- col (- ecol (current-column))))))
1212 (setq cur (current-column))
1213 (cond ((< gocol 0) t) ; don't do anything
1214 ((= cur gocol) t) ; don't need to
1215 ((< cur gocol) ; just add space
1216 ;; FIXME: It is stated above that "...the
1217 ;; whitespace to be modified was already
1218 ;; deleted by `align-region', all we have
1219 ;; to do here is indent." However, this
1220 ;; doesn't seem to be true, so we first
1221 ;; delete the whitespace to avoid tabs
1222 ;; after spaces.
1223 (delete-horizontal-space t)
1224 (indent-to gocol))
1226 ;; This code works around an oddity in the
1227 ;; FORCE argument of `move-to-column', which
1228 ;; tends to screw up markers if there is any
1229 ;; tabbing.
1230 (let ((endcol (align-column
1231 (if (and justify
1232 (consp (cdr area)))
1233 (cadr area)
1234 (cdr area))))
1235 (abuts (<= gocol
1236 (align-column (car area)))))
1237 (if abuts
1238 (goto-char (car area))
1239 (move-to-column gocol t))
1240 (let ((here (point)))
1241 (move-to-column endcol t)
1242 (delete-region here (point))
1243 (if abuts
1244 (indent-to (align-adjust-col-for-rule
1245 (current-column) rule
1246 (car props) (cdr props)))))))))))
1247 (setq areas (cdr areas))))))
1249 (defun align-region (beg end separate rules exclude-rules
1250 &optional func)
1251 "Align a region based on a given set of alignment rules.
1252 BEG and END specify the region to be aligned. Either may be nil, in
1253 which case the range will stop at the nearest section division (see
1254 `align-region-separate', and `align-region-heuristic' for more
1255 information').
1257 The region will be divided into separate alignment sections based on
1258 the value of SEPARATE.
1260 RULES and EXCLUDE-RULES are a pair of lists describing how to align
1261 the region, and which text areas within it should be excluded from
1262 alignment. See the `align-rules-list' for more information on the
1263 required format of these two lists.
1265 If FUNC is specified, no text will be modified. What `align-region'
1266 will do with the rules is to search for the alignment areas, as it
1267 regularly would, taking account for exclusions, and then call FUNC,
1268 first with the beginning and ending of the region to be aligned
1269 according to that rule (this can be different for each rule, if BEG
1270 and END were nil), and then with the beginning and ending of each
1271 text region that the rule would have applied to.
1273 The signature of FUNC should thus be:
1275 (defun my-align-function (beg end mode)
1276 \"If MODE is a rule (a list), return t if BEG to END are to be searched.
1277 Otherwise BEG to END will be a region of text that matches the rule's
1278 definition, and MODE will be non-nil if any changes are necessary.\"
1279 (unless (and mode (listp mode))
1280 (message \"Would have aligned from %d to %d...\" beg end)))
1282 This feature (of passing a FUNC) is used internally to locate the
1283 position of exclusion areas, but could also be used for any other
1284 purpose where you might want to know where the regions that the
1285 aligner would have dealt with are."
1286 (let ((end-mark (and end (copy-marker end t)))
1287 (real-beg beg)
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)
1310 search-start
1311 group group-c
1312 spacing spacing-c
1313 tab-stop tab-stop-c
1314 repeat repeat-c
1315 valid valid-c
1316 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)))
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)))))))
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)))
1413 ;; while we can find the rule in the alignment
1414 ;; region..
1415 (while (and (< (point) end-mark)
1416 (setq search-start (point))
1417 (if regfunc
1418 (funcall regfunc end-mark nil)
1419 (re-search-forward regexp
1420 end-mark t)))
1422 ;; give the user some indication of where we
1423 ;; are, if it's a very large region being
1424 ;; aligned
1425 (if report
1426 (let ((symbol (car rule)))
1427 (if (and symbol (symbolp symbol))
1428 (message
1429 "Aligning `%s' (rule %d of %d) %d%%..."
1430 (symbol-name symbol) rule-index rule-count
1431 (/ (* (- (point) real-beg) 100)
1432 (- end-mark real-beg)))
1433 (message
1434 "Aligning %d%%..."
1435 (/ (* (- (point) real-beg) 100)
1436 (- end-mark real-beg))))))
1438 ;; if the search ended us on the beginning of
1439 ;; the next line, move back to the end of the
1440 ;; previous line.
1441 (if (and (bolp) (> (point) search-start))
1442 (forward-char -1))
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))
1453 (unless spacing-c
1454 (setq spacing (cdr (assq 'spacing rule))
1455 spacing-c t))
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))
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))))
1475 ;; lookup the `repeat' attribute the first time
1476 (or repeat-c
1477 (setq repeat (cdr (assq 'repeat rule))
1478 repeat-c t))
1480 ;; lookup the `valid' attribute the first time
1481 (or valid-c
1482 (setq valid (assq 'valid rule)
1483 valid-c t))
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))
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))))
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)))
1512 ;; restore the match data
1513 (set-match-data save-match-data)
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)))))
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
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))
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)))))
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))))
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)))
1581 (forward-line))
1583 ;; if the search did not change point,
1584 ;; move forward to avoid an infinite loop
1585 (if (= (point) search-start)
1586 (forward-char)))))
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)))
1593 (setq case-fold-search current-case-fold)))))))
1594 (setq rules (cdr rules)
1595 rule-index (1+ rule-index)))
1597 (if report
1598 (message "Aligning...done"))))
1600 ;; Provide:
1602 (provide 'align)
1604 (run-hooks 'align-load-hook)
1606 ;;; align.el ends here