(do_check_ram_size): Don't hardcode the lisp address space size.
[emacs.git] / lisp / align.el
blobbae09d749db62ebcb7a1686292df806b04c9f6d1
1 ;;; align.el --- align text to a specific column, by regexp
3 ;; Copyright (C) 1999, 2000, 2002 Free Sofware Foundation
5 ;; Author: John Wiegley <johnw@gnu.org>
6 ;; Keywords: convenience languages lisp
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation; either version 2, or (at your option)
13 ;; any later version.
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs; see the file COPYING. If not, write to the
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 ;; Boston, MA 02111-1307, USA.
25 ;;; Commentary:
27 ;; This mode allows you to align regions in a context-sensitive fashion.
28 ;; The classic use is to align assignments:
30 ;; int a = 1;
31 ;; short foo = 2;
32 ;; double blah = 4;
34 ;; becomes
36 ;; int a = 1;
37 ;; short foo = 2;
38 ;; double blah = 4;
40 ;;; Usage:
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.
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:
54 ;; (setq align-c++-modes (cons 'jde-mode align-c++-modes))
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.
60 ;;; Module Authors:
62 ;; In order to incorporate align's functionality into your own
63 ;; modules, there are only a few steps you have to follow.
65 ;; 1. Require or load in the align.el library.
67 ;; 2. Define your alignment and exclusion rules lists, either
68 ;; customizable or not.
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.
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.
82 ;; Example:
84 ;; (require 'align)
86 ;; (defcustom my-align-rules-list
87 ;; '((my-rule
88 ;; (regexp . "Sample")))
89 ;; :type align-rules-list-type
90 ;; :group 'my-package)
92 ;; (put 'my-align-rules-list 'risky-local-variable t)
94 ;; (add-to-list 'align-dq-string-modes 'my-package-mode)
95 ;; (add-to-list 'align-open-comment-modes 'my-package-mode)
97 ;; (defun my-mode ()
98 ;; ...
99 ;; (setq align-mode-rules-list my-align-rules-list))
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.
107 ;;; History:
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.
120 ;;; Code:
122 (defgroup align nil
123 "Align text to a specific column, by regexp."
124 :version "21.1"
125 :group 'fill)
127 ;;; User Variables:
129 (defcustom align-load-hook nil
130 "*Hook that gets run after the aligner has been loaded."
131 :type 'hook
132 :group 'align)
134 (defcustom align-indent-before-aligning nil
135 "*If non-nil, indent the marked region before aligning it."
136 :type 'boolean
137 :group 'align)
139 (defcustom align-default-spacing 1
140 "*An integer that represents the default amount of padding to use.
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)
148 (defcustom align-to-tab-stop 'indent-tabs-mode
149 "*If non-nil, alignments will always fall on a tab boundary.
150 It may also be a symbol, whose value will be taken."
151 :type '(choice (const nil) symbol)
152 :group 'align)
154 (defcustom align-region-heuristic 500
155 "*If non-nil, used as a heuristic by `align-current'.
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)
165 (defcustom align-highlight-change-face 'highlight
166 "*The face to highlight with if changes are necessary."
167 :type 'face
168 :group 'align)
170 (defcustom align-highlight-nochange-face 'secondary-selection
171 "*The face to highlight with if no changes are necessary."
172 :type 'face
173 :group 'align)
175 (defcustom align-large-region 10000
176 "*If an integer, defines what constitutes a \"large\" region.
177 If nil,then no messages will ever be printed to the minibuffer."
178 :type 'integer
179 :group 'align)
181 (defcustom align-c++-modes '(c++-mode c-mode java-mode)
182 "*A list of modes whose syntax resembles C/C++."
183 :type '(repeat symbol)
184 :group 'align)
186 (defcustom align-perl-modes '(perl-mode cperl-mode)
187 "*A list of modes where perl syntax is to be seen."
188 :type '(repeat symbol)
189 :group 'align)
191 (defcustom align-lisp-modes
192 '(emacs-lisp-mode lisp-interaction-mode lisp-mode scheme-mode)
193 "*A list of modes whose syntax resembles Lisp."
194 :type '(repeat symbol)
195 :group 'align)
197 (defcustom align-tex-modes
198 '(tex-mode plain-tex-mode latex-mode slitex-mode)
199 "*A list of modes whose syntax resembles TeX (and family)."
200 :type '(repeat symbol)
201 :group 'align)
203 (defcustom align-text-modes '(text-mode outline-mode)
204 "*A list of modes whose content is plain text."
205 :type '(repeat symbol)
206 :group 'align)
208 (defcustom align-dq-string-modes
209 (append align-lisp-modes align-c++-modes align-perl-modes
210 '(python-mode))
211 "*A list of modes where double quoted strings should be excluded."
212 :type '(repeat symbol)
213 :group 'align)
215 (defcustom align-sq-string-modes
216 (append align-perl-modes '(python-mode))
217 "*A list of modes where single quoted strings should be excluded."
218 :type '(repeat symbol)
219 :group 'align)
221 (defcustom align-open-comment-modes
222 (append align-lisp-modes align-c++-modes align-perl-modes
223 '(python-mode makefile-mode))
224 "*A list of modes with a single-line comment syntax.
225 These are comments as in Lisp, which have a beginning but, end with
226 the line (i.e., `comment-end' is an empty string)."
227 :type '(repeat symbol)
228 :group 'align)
230 (defcustom align-region-separate "^\\s-*[{}]?\\s-*$"
231 "*Select the method by which alignment sections will be separated.
232 If this is a symbol, that symbol's value will be used.
234 For the sake of clarification, consider the following example, which
235 will be referred to in the descriptions below.
237 int alpha = 1; /* one */
238 double beta = 2.0;
239 long gamma; /* ten */
241 unsigned int delta = 1; /* one */
242 long double epsilon = 3.0;
243 long long omega; /* ten */
245 The possible settings for `align-region-separate' are:
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:
252 int alpha = 1; /* one */
253 double beta = 2.0;
254 long gamma; /* ten */
256 unsigned int delta = 1; /* one */
257 long double epsilon;
258 long long chi = 10; /* ten */
260 `group' Each contiguous set of lines where a specific alignment
261 occurs is considered a section for that alignment rule.
262 Note that each rule will may have any entirely different
263 set of section divisions than another.
265 int alpha = 1; /* one */
266 double beta = 2.0;
267 long gamma; /* ten */
269 unsigned int delta = 1; /* one */
270 long double epsilon;
271 long long chi = 10; /* ten */
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.
277 int alpha = 1; /* one */
278 double beta = 2.0;
279 long gamma; /* ten */
281 unsigned int delta = 1; /* one */
282 long double epsilon;
283 long long chi = 10; /* ten */
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.
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
295 the preceding statement in C or perl), `largest' is
296 probably the better alternative.
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
304 section found to be used as the common section for all rules
305 that occur there.
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.
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)
322 (put 'align-region-separate 'risky-local-variable t)
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.")
386 (unless (functionp 'c-guess-basic-syntax)
387 (autoload 'c-guess-basic-syntax "cc-engine"))
389 (defcustom align-rules-list
390 `((lisp-second-arg
391 (regexp . "\\(^\\s-+[^( \t\n]\\|(\\(\\S-+\\)\\s-+\\)\\S-+\\(\\s-+\\)")
392 (group . 3)
393 (modes . align-lisp-modes)
394 (run-if . ,(function (lambda () current-prefix-arg))))
396 (lisp-alist-dot
397 (regexp . "\\(\\s-*\\)\\.\\(\\s-*\\)")
398 (group . (1 2))
399 (modes . align-lisp-modes))
401 (open-comment
402 (regexp . ,(function
403 (lambda (end reverse)
404 (funcall (if reverse 're-search-backward
405 're-search-forward)
406 (concat "[^ \t\n\\\\]"
407 (regexp-quote comment-start)
408 "\\(.+\\)$") end t))))
409 (modes . align-open-comment-modes))
411 (c-macro-definition
412 (regexp . "^\\s-*#\\s-*define\\s-+\\S-+\\(\\s-+\\)")
413 (modes . align-c++-modes))
415 (c-variable-declaration
416 (regexp . ,(concat "[*&0-9A-Za-z_]>?[&*]*\\(\\s-+[*&]*\\)"
417 "[A-Za-z_][0-9A-Za-z:_]*\\s-*\\(\\()\\|"
418 "=[^=\n].*\\|(.*)\\|\\(\\[.*\\]\\)*\\)?"
419 "\\s-*[;,]\\|)\\s-*$\\)"))
420 (group . 1)
421 (modes . align-c++-modes)
422 (justify . t)
423 (valid
424 . ,(function
425 (lambda ()
426 (not (or (save-excursion
427 (goto-char (match-beginning 1))
428 (backward-word 1)
429 (looking-at
430 "\\(goto\\|return\\|new\\|delete\\|throw\\)"))
431 (if (and (boundp 'font-lock-mode) font-lock-mode)
432 (eq (get-text-property (point) 'face)
433 'font-lock-comment-face)
434 (eq (caar (c-guess-basic-syntax)) 'c))))))))
436 (c-assignment
437 (regexp . ,(concat "[^-=!^&*+<>/| \t\n]\\(\\s-*[-=!^&*+<>/|]*\\)"
438 "=\\(\\s-*\\)\\([^= \t\n]\\|$\\)"))
439 (group . (1 2))
440 (modes . align-c++-modes)
441 (justify . t)
442 (tab-stop . nil))
444 (perl-assignment
445 (regexp . ,(concat "[^=!^&*-+<>/| \t\n]\\(\\s-*\\)=[~>]?"
446 "\\(\\s-*\\)\\([^>= \t\n]\\|$\\)"))
447 (group . (1 2))
448 (modes . align-perl-modes)
449 (tab-stop . nil))
451 (python-assignment
452 (regexp . ,(concat "[^=!<> \t\n]\\(\\s-*\\)="
453 "\\(\\s-*\\)\\([^>= \t\n]\\|$\\)"))
454 (group . (1 2))
455 (modes . '(python-mode))
456 (tab-stop . nil))
458 (make-assignment
459 (regexp . "^\\s-*\\w+\\(\\s-*\\):?=\\(\\s-*\\)\\([^\t\n \\\\]\\|$\\)")
460 (group . (1 2))
461 (modes . '(makefile-mode))
462 (tab-stop . nil))
464 (c-comma-delimiter
465 (regexp . ",\\(\\s-*\\)[^/ \t\n]")
466 (repeat . t)
467 (modes . align-c++-modes)
468 (run-if . ,(function (lambda () current-prefix-arg))))
469 ; (valid
470 ; . ,(function
471 ; (lambda ()
472 ; (memq (caar (c-guess-basic-syntax))
473 ; '(brace-list-intro
474 ; brace-list-entry
475 ; brace-entry-open))))))
477 ;; With a prefix argument, comma delimiter will be aligned. Since
478 ;; perl-mode doesn't give us enough syntactic information (and we
479 ;; don't do our own parsing yet), this rule is too destructive to
480 ;; run normally.
481 (basic-comma-delimiter
482 (regexp . ",\\(\\s-*\\)[^# \t\n]")
483 (repeat . t)
484 (modes . (append align-perl-modes '(python-mode)))
485 (run-if . ,(function (lambda () current-prefix-arg))))
487 (c++-comment
488 (regexp . "\\(\\s-*\\)\\(//.*\\|/\\*.*\\*/\\s-*\\)$")
489 (modes . align-c++-modes)
490 (column . comment-column)
491 (valid . ,(function
492 (lambda ()
493 (save-excursion
494 (goto-char (match-beginning 1))
495 (not (bolp)))))))
497 (c-chain-logic
498 (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)")
499 (modes . align-c++-modes)
500 (valid . ,(function
501 (lambda ()
502 (save-excursion
503 (goto-char (match-end 2))
504 (looking-at "\\s-*\\(/[*/]\\|$\\)"))))))
506 (perl-chain-logic
507 (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)")
508 (modes . align-perl-modes)
509 (valid . ,(function
510 (lambda ()
511 (save-excursion
512 (goto-char (match-end 2))
513 (looking-at "\\s-*\\(#\\|$\\)"))))))
515 (python-chain-logic
516 (regexp . "\\(\\s-*\\)\\(\\<and\\>\\|\\<or\\>\\)")
517 (modes . '(python-mode))
518 (valid . ,(function
519 (lambda ()
520 (save-excursion
521 (goto-char (match-end 2))
522 (looking-at "\\s-*\\(#\\|$\\|\\\\\\)"))))))
524 (c-macro-line-continuation
525 (regexp . "\\(\\s-*\\)\\\\$")
526 (modes . align-c++-modes)
527 (column . c-backslash-column))
528 ; (valid
529 ; . ,(function
530 ; (lambda ()
531 ; (memq (caar (c-guess-basic-syntax))
532 ; '(cpp-macro cpp-macro-cont))))))
534 (basic-line-continuation
535 (regexp . "\\(\\s-*\\)\\\\$")
536 (modes . '(python-mode makefile-mode)))
538 (tex-record-separator
539 (regexp . ,(function
540 (lambda (end reverse)
541 (align-match-tex-pattern "&" end reverse))))
542 (group . (1 2))
543 (modes . align-tex-modes)
544 (repeat . t))
546 (tex-tabbing-separator
547 (regexp . ,(function
548 (lambda (end reverse)
549 (align-match-tex-pattern "\\\\[=>]" end reverse))))
550 (group . (1 2))
551 (modes . align-tex-modes)
552 (repeat . t)
553 (run-if . ,(function
554 (lambda ()
555 (eq major-mode 'latex-mode)))))
557 (tex-record-break
558 (regexp . "\\(\\s-*\\)\\\\\\\\")
559 (modes . align-tex-modes))
561 ;; With a numeric prefix argument, or C-u, space delimited text
562 ;; tables will be aligned.
563 (text-column
564 (regexp . "\\(^\\|\\S-\\)\\(\\s-+\\)\\(\\S-\\|$\\)")
565 (group . 2)
566 (modes . align-text-modes)
567 (repeat . t)
568 (run-if . ,(function
569 (lambda ()
570 (and current-prefix-arg
571 (not (eq '- current-prefix-arg)))))))
573 ;; With a negative prefix argument, lists of dollar figures will
574 ;; be aligned.
575 (text-dollar-figure
576 (regexp . "\\$?\\(\\s-+[0-9]+\\)\\.")
577 (modes . align-text-modes)
578 (justify . t)
579 (run-if . ,(function
580 (lambda ()
581 (eq '- current-prefix-arg))))))
582 "*A list describing all of the available alignment rules.
583 The format is:
585 ((TITLE
586 (ATTRIBUTE . VALUE) ...)
587 ...)
589 The following attributes are meaningful:
591 `regexp' This required attribute must be either a string describing
592 a regular expression, or a function (described below).
593 For every line within the section that this regular
594 expression matches, the given rule will be applied to that
595 line. The exclusion rules denote which part(s) of the
596 line should not be modified; the alignment rules cause the
597 identified whitespace group to be contracted/expanded such
598 that the \"alignment character\" (the character
599 immediately following the identified parenthesis group),
600 occurs in the same column for every line within the
601 alignment section (see `align-region-separate' for a
602 description of how the region is broken up into alignment
603 sections).
605 The `regexp' attribute describes how the text should be
606 treated. Within this regexp, there must be at least one
607 group of characters (typically whitespace) identified by
608 the special opening and closing parens used in regexp
609 expressions (`\\\\(' and `\\\\)') (see the Emacs manual on
610 the syntax of regular expressions for more info).
612 If `regexp' is a function, it will be called as a
613 replacement for `re-search-forward'. This means that it
614 should return nil if nothing is found to match the rule,
615 or it should set the match data appropriately, move point
616 to the end of the match, and return the value of point.
618 `group' For exclusion rules, the group identifies the range of
619 characters that should be ignored. For alignment rules,
620 these are the characters that will be deleted/expanded for
621 the purposes of alignment. The \"alignment character\" is
622 always the first character immediately following this
623 parenthesis group. This attribute may also be a list of
624 integer, in which case multiple alignment characters will
625 be aligned, with the list of integer identifying the
626 whitespace groups which precede them. The default for
627 this attribute is 1.
629 `modes' The `modes' attribute, if set, should name a list of
630 major modes -- or evaluate to such a value -- in which the
631 rule is valid. If not set, the rule will apply to all
632 modes.
634 `case-fold' If `regexp' is an ordinary regular expression string
635 containing alphabetic character, sometimes you may want
636 the search to proceed case-insensitively (for languages
637 that ignore case, such as pascal for example). In that
638 case, set `case-fold' to a non-nil value, and the regular
639 expression search will ignore case. If `regexp' is set to
640 a function, that function must handle the job of ignoring
641 case by itself.
643 `tab-stop' If the `tab-stop' attribute is set, and non-nil, the
644 alignment character will always fall on a tab stop
645 (whether it uses tabs to get there or not depends on the
646 value of `indent-tabs-mode'). If the `tab-stop' attribute
647 is set to nil, tab stops will never be used. Otherwise,
648 the value of `align-to-tab-stop' determines whether or not
649 to align to a tab stop. The `tab-stop' attribute may also
650 be a list of t or nil values, corresponding to the number
651 of parenthesis groups specified by the `group' attribute.
653 `repeat' If the `repeat' attribute is present, and non-nil, the
654 rule will be applied to the line continuously until no
655 further matches are found.
657 `valid' If the `valid' attribute is set, it will be used to
658 determine whether the rule should be invoked. This form
659 is evaluated after the regular expression match has been
660 performed, so that it is possible to use the results of
661 that match to determine whether the alignment should be
662 performed. The buffer should not be modified during the
663 evaluation of this form.
665 `run-if' Like `valid', the `run-if' attribute tests whether the
666 rule should be run at all -- even before any searches are
667 done to determine if the rule applies to the alignment
668 region. This can save time, since `run-if' will only be
669 run once for each rule. If it returns nil, the rule will
670 not be attempted.
672 `column' For alignment rules, if the `column' attribute is set --
673 which must be an integer, or a symbol whose value is an
674 integer -- it will be used as the column in which to align
675 the alignment character. If the text on a particular line
676 happens to overrun that column, a single space character,
677 or tab stop (see `align-to-tab-stop') will be added
678 between the last text character and the alignment
679 character.
681 `spacing' Alignment rules may also override the amount of spacing
682 that would normally be used by providing a `spacing'
683 attribute. This must be an integer, or a list of integers
684 corresponding to the number of parenthesis groups matched
685 by the `group' attribute. If a list of value is used, and
686 any of those values is nil, `align-default-spacing' will
687 be used for that subgroup. See `align-default-spacing'
688 for more details on spacing, tab stops, and how to
689 indicate how much spacing should be used. If TAB-STOP is
690 present, it will override the value of `align-to-tab-stop'
691 for that rule.
693 `justify' It is possible with `regexp' and `group' to identify a
694 character group that contains more than just whitespace
695 characters. By default, any non-whitespace characters in
696 that group will also be deleted while aligning the
697 alignment character. However, if the `justify' attribute
698 is set to a non-nil value, only the initial whitespace
699 characters within that group will be deleted. This has
700 the effect of right-justifying the characters that remain,
701 and can be used for outdenting or just plain old right-
702 justification.
704 `separate' Each rule can define its own section separator, which
705 describes how to identify the separation of \"sections\"
706 within the region to be aligned. Setting the `separate'
707 attribute overrides the value of `align-region-separate'
708 (see the documentation of that variable for possible
709 values), and any separation argument passed to `align'."
710 :type align-rules-list-type
711 :group 'align)
713 (put 'align-rules-list 'risky-local-variable t)
715 (defvar align-exclude-rules-list-type
716 '(repeat
717 (cons
718 :tag "Exclusion rule"
719 (symbol :tag "Title")
720 (cons :tag "Required attributes"
721 (cons :tag "Regexp"
722 (const :tag "(Regular expression to match)" regexp)
723 (choice :value "\\(\\s-+\\)" regexp function))
724 (repeat
725 :tag "Optional attributes"
726 (choice
727 (cons :tag "Repeat"
728 (const :tag "(Repeat this rule throughout line)"
729 repeat)
730 (boolean :value t))
731 (cons :tag "Paren group"
732 (const :tag "(Parenthesis group to use)" group)
733 (choice :value 2
734 integer (repeat integer)))
735 (cons :tag "Modes"
736 (const :tag "(Modes where this rule applies)" modes)
737 (sexp :value (text-mode)))
738 (cons :tag "Case-fold"
739 (const :tag "(Should case be ignored for this rule)"
740 case-fold)
741 (boolean :value t)))))))
742 "The `type' form for any `align-exclude-rules-list' variable.")
744 (defcustom align-exclude-rules-list
745 `((exc-dq-string
746 (regexp . "\"\\([^\"\n]+\\)\"")
747 (repeat . t)
748 (modes . align-dq-string-modes))
750 (exc-sq-string
751 (regexp . "'\\([^'\n]+\\)'")
752 (repeat . t)
753 (modes . align-sq-string-modes))
755 (exc-open-comment
756 (regexp
757 . ,(function
758 (lambda (end reverse)
759 (funcall (if reverse 're-search-backward
760 're-search-forward)
761 (concat "[^ \t\n\\\\]"
762 (regexp-quote comment-start)
763 "\\(.+\\)$") end t))))
764 (modes . align-open-comment-modes))
766 (exc-c-comment
767 (regexp . "/\\*\\(.+\\)\\*/")
768 (repeat . t)
769 (modes . align-c++-modes))
771 (exc-c-func-params
772 (regexp . "(\\([^)\n]+\\))")
773 (repeat . t)
774 (modes . align-c++-modes))
776 (exc-c-macro
777 (regexp . "^\\s-*#\\s-*\\(if\\w*\\|endif\\)\\(.*\\)$")
778 (group . 2)
779 (modes . align-c++-modes)))
780 "*A list describing text that should be excluded from alignment.
781 See the documentation for `align-rules-list' for more info."
782 :type align-exclude-rules-list-type
783 :group 'align)
785 (put 'align-exclude-rules-list 'risky-local-variable t)
787 ;;; Internal Variables:
789 (defvar align-mode-rules-list nil
790 "Alignment rules specific to the current major mode.
791 See the variable `align-rules-list' for more details.")
793 (make-variable-buffer-local 'align-mode-rules-list)
795 (defvar align-mode-exclude-rules-list nil
796 "Alignment exclusion rules specific to the current major mode.
797 See the variable `align-exclude-rules-list' for more details.")
799 (make-variable-buffer-local 'align-mode-exclude-rules-list)
801 (defvar align-highlight-overlays nil
802 "The current overlays highlighting the text matched by a rule.")
804 ;; Sample extension rule set, for vhdl-mode. This should properly be
805 ;; in vhdl-mode.el itself.
807 (defcustom align-vhdl-rules-list
808 `((vhdl-declaration
809 (regexp . "\\(signal\\|variable\\|constant\\)\\(\\s-+\\)\\S-")
810 (group . 2))
812 (vhdl-case
813 (regexp . "\\(others\\|[^ \t\n=<]\\)\\(\\s-*\\)=>\\(\\s-*\\)\\S-")
814 (group . (2 3))
815 (valid
816 . ,(function
817 (lambda ()
818 (not (string= (downcase (match-string 1))
819 "others"))))))
821 (vhdl-colon
822 (regexp . "[^ \t\n:]\\(\\s-*\\):\\(\\s-*\\)[^=\n]")
823 (group . (1 2)))
825 (direction
826 (regexp . ":\\s-*\\(in\\|out\\|inout\\|buffer\\)\\(\\s-*\\)")
827 (group . 2))
829 (sig-assign
830 (regexp . "[^ \t\n=<]\\(\\s-*\\)<=\\(\\s-*\\)\\S-")
831 (group . (1 2)))
833 (var-assign
834 (regexp . "[^ \t\n:]\\(\\s-*\\):="))
836 (use-entity
837 (regexp . "\\(\\s-+\\)use\\s-+entity")))
838 "*Alignment rules for `vhdl-mode'. See `align-rules-list' for more info."
839 :type align-rules-list-type
840 :group 'align)
842 (put 'align-vhdl-rules-list 'risky-local-variable t)
844 (defun align-set-vhdl-rules ()
845 "Setup the `align-mode-rules-list' variable for `vhdl-mode'."
846 (setq align-mode-rules-list align-vhdl-rules-list))
848 (add-hook 'vhdl-mode-hook 'align-set-vhdl-rules)
850 (add-to-list 'align-dq-string-modes 'vhdl-mode)
851 (add-to-list 'align-open-comment-modes 'vhdl-mode)
853 ;;; User Functions:
855 ;;;###autoload
856 (defun align (beg end &optional separate rules exclude-rules)
857 "Attempt to align a region based on a set of alignment rules.
858 BEG and END mark the region. If BEG and END are specifically set to
859 nil (this can only be done programmatically), the beginning and end of
860 the current alignment section will be calculated based on the location
861 of point, and the value of `align-region-separate' (or possibly each
862 rule's `separate' attribute).
864 If SEPARATE is non-nil, it overrides the value of
865 `align-region-separate' for all rules, except those that have their
866 `separate' attribute set.
868 RULES and EXCLUDE-RULES, if either is non-nil, will replace the
869 default rule lists defined in `align-rules-list' and
870 `align-exclude-rules-list'. See `align-rules-list' for more details
871 on the format of these lists."
872 (interactive "r")
873 (let ((separator
874 (or separate
875 (if (and (symbolp align-region-separate)
876 (boundp align-region-separate))
877 (symbol-value align-region-separate)
878 align-region-separate)
879 'entire)))
880 (if (not (or ;(eq separator 'largest)
881 (and (functionp separator)
882 (not (funcall separator nil nil)))))
883 (align-region beg end separator
884 (or rules align-mode-rules-list align-rules-list)
885 (or exclude-rules align-mode-exclude-rules-list
886 align-exclude-rules-list))
887 (let ((sec-first end)
888 (sec-last beg))
889 (align-region beg end
890 (or exclude-rules
891 align-mode-exclude-rules-list
892 align-exclude-rules-list) nil
893 separator
894 (function
895 (lambda (b e mode)
896 (when (and mode (listp mode))
897 (setq sec-first (min sec-first b)
898 sec-last (max sec-last e))))))
899 (if (< sec-first sec-last)
900 (align-region sec-first sec-last 'entire
901 (or rules align-mode-rules-list align-rules-list)
902 (or exclude-rules align-mode-exclude-rules-list
903 align-exclude-rules-list)))))))
905 ;;;###autoload
906 (defun align-regexp (beg end regexp &optional group spacing repeat)
907 "Align the current region using an ad-hoc rule read from the minibuffer.
908 BEG and END mark the limits of the region. This function will prompt
909 for the REGEXP to align with. If no prefix arg was specified, you
910 only need to supply the characters to be lined up and any preceding
911 whitespace is replaced. If a prefix arg was specified, the full
912 regexp with parenthesized whitespace should be supplied; it will also
913 prompt for which parenthesis GROUP within REGEXP to modify, the amount
914 of SPACING to use, and whether or not to REPEAT the rule throughout
915 the line. See `align-rules-list' for more information about these
916 options.
918 For example, let's say you had a list of phone numbers, and wanted to
919 align them so that the opening parentheses would line up:
921 Fred (123) 456-7890
922 Alice (123) 456-7890
923 Mary-Anne (123) 456-7890
924 Joe (123) 456-7890
926 There is no predefined rule to handle this, but you could easily do it
927 using a REGEXP like \"(\". All you would have to do is to mark the
928 region, call `align-regexp' and type in that regular expression."
929 (interactive
930 (append
931 (list (min (point) (mark))
932 (max (point) (mark)))
933 (if current-prefix-arg
934 (list (read-string "Complex align using regexp: "
935 "\\(\\s-*\\)")
936 (string-to-int
937 (read-string
938 "Parenthesis group to modify (justify if negative): " "1"))
939 (string-to-int
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 (let ((rule
947 (list (list nil (cons 'regexp regexp)
948 (cons 'group (abs group))
949 (if (< group 0)
950 (cons 'justify t)
951 (cons 'bogus nil))
952 (if (>= spacing 0)
953 (cons 'spacing spacing)
954 (cons 'column (abs spacing)))
955 (cons 'repeat repeat)))))
956 (align-region beg end 'entire rule nil nil)))
958 ;;;###autoload
959 (defun align-entire (beg end &optional rules exclude-rules)
960 "Align the selected region as if it were one alignment section.
961 BEG and END mark the extent of the region. If RULES or EXCLUDE-RULES
962 is set to a list of rules (see `align-rules-list'), it can be used to
963 override the default alignment rules that would have been used to
964 align that section."
965 (interactive "r")
966 (align beg end 'entire rules exclude-rules))
968 ;;;###autoload
969 (defun align-current (&optional rules exclude-rules)
970 "Call `align' on the current alignment section.
971 This function assumes you want to align only the current section, and
972 so saves you from having to specify the region. If RULES or
973 EXCLUDE-RULES is set to a list of rules (see `align-rules-list'), it
974 can be used to override the default alignment rules that would have
975 been used to align that section."
976 (interactive)
977 (align nil nil nil rules exclude-rules))
979 ;;;###autoload
980 (defun align-highlight-rule (beg end title &optional rules exclude-rules)
981 "Highlight the whitespace which a given rule would have modified.
982 BEG and END mark the extent of the region. TITLE identifies the rule
983 that should be highlighted. If RULES or EXCLUDE-RULES is set to a
984 list of rules (see `align-rules-list'), it can be used to override the
985 default alignment rules that would have been used to identify the text
986 to be colored."
987 (interactive
988 (list (min (mark) (point))
989 (max (mark) (point))
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)))))))))))
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))))
1037 ;;;###autoload
1038 (defun align-newline-and-indent ()
1039 "A replacement function for `newline-and-indent', aligning as it goes."
1040 (interactive)
1041 (let ((separate (or (if (and (symbolp align-region-separate)
1042 (boundp align-region-separate))
1043 (symbol-value align-region-separate)
1044 align-region-separate)
1045 'entire))
1046 (end (point)))
1047 (call-interactively 'newline-and-indent)
1048 (save-excursion
1049 (forward-line -1)
1050 (while (not (or (bobp)
1051 (align-new-section-p (point) end separate)))
1052 (forward-line -1))
1053 (align (point) end))))
1055 ;;; Internal Functions:
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))
1076 (goto-char (match-beginning 2))))
1077 result))
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))))
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)))
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))
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))))
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.
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)
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
1173 (if (/= ecol (current-column))
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)
1179 (/= (point) (cdar a)))
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))))
1186 (unless fixed
1187 (setq col (+ (align-adjust-col-for-rule
1188 col rule (car props) (cdr props)) width)))
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.
1194 (unless change
1195 (setq change (and ecol (/= col ecol))))
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
1215 (indent-to gocol))
1217 ;; This code works around an oddity in the
1218 ;; FORCE argument of `move-to-column', which
1219 ;; tends to screw up markers if there is any
1220 ;; tabbing.
1221 (let ((endcol (align-column
1222 (if (and justify
1223 (consp (cdr area)))
1224 (cadr area)
1225 (cdr area))))
1226 (abuts (<= gocol
1227 (align-column (car area)))))
1228 (if abuts
1229 (goto-char (car area))
1230 (move-to-column gocol t))
1231 (let ((here (point)))
1232 (move-to-column endcol t)
1233 (delete-region here (point))
1234 (if abuts
1235 (indent-to (align-adjust-col-for-rule
1236 (current-column) rule
1237 (car props) (cdr props)))))))))))
1238 (setq areas (cdr areas))))))
1240 (defun align-region (beg end separate rules exclude-rules
1241 &optional func)
1242 "Align a region based on a given set of alignment rules.
1243 BEG and END specify the region to be aligned. Either may be nil, in
1244 which case the range will stop at the nearest section division (see
1245 `align-region-separate', and `align-region-heuristic' for more
1246 information').
1248 The region will be divided into separate alignment sections based on
1249 the value of SEPARATE.
1251 RULES and EXCLUDE-RULES are a pair of lists describing how to align
1252 the region, and which text areas within it should be excluded from
1253 alignment. See the `align-rules-list' for more information on the
1254 required format of these two lists.
1256 If FUNC is specified, no text will be modified. What `align-region'
1257 will do with the rules is to search for the alignment areas, as it
1258 regularly would, taking account for exclusions, and then call FUNC,
1259 first with the beginning and ending of the region to be aligned
1260 according to that rule (this can be different for each rule, if BEG
1261 and END were nil), and then with the beginning and ending of each
1262 text region that the rule would have applied to.
1264 The signature of FUNC should thus be:
1266 (defun my-align-function (beg end mode)
1267 \"If MODE is a rule (a list), return t if BEG to END are to be searched.
1268 Otherwise BEG to END will be a region of text that matches the rule's
1269 definition, and MODE will be non-nil if any changes are necessary.\"
1270 (unless (and mode (listp mode))
1271 (message \"Would have aligned from %d to %d...\" beg end)))
1273 This feature (of passing a FUNC) is used internally to locate the
1274 position of exclusion areas, but could also be used for any other
1275 purpose where you might want to know where the regions that the
1276 aligner would have dealt with are."
1277 (let ((end-mark (and end (copy-marker end t)))
1278 (real-beg beg)
1279 (real-end end)
1280 (report (and (not func) align-large-region beg end
1281 (>= (- end beg) align-large-region)))
1282 (rule-index 1)
1283 (rule-count (length rules)))
1284 (if (and align-indent-before-aligning real-beg end-mark)
1285 (indent-region real-beg end-mark nil))
1286 (while rules
1287 (let* ((rule (car rules))
1288 (run-if (assq 'run-if rule))
1289 (modes (assq 'modes rule)))
1290 ;; unless the `run-if' form tells us not to, look for the
1291 ;; rule..
1292 (unless (or (and modes (not (memq major-mode
1293 (eval (cdr modes)))))
1294 (and run-if (not (funcall (cdr run-if)))))
1295 (let* ((current-case-fold case-fold-search)
1296 (case-fold (assq 'case-fold rule))
1297 (regexp (cdr (assq 'regexp rule)))
1298 (regfunc (and (functionp regexp) regexp))
1299 (rulesep (assq 'separate rule))
1300 (thissep (if rulesep (cdr rulesep) separate))
1301 same (eol 0)
1302 group group-c
1303 spacing spacing-c
1304 tab-stop tab-stop-c
1305 repeat repeat-c
1306 valid valid-c
1307 pos-list first
1308 regions index
1309 last-point b e
1310 save-match-data
1311 exclude-p
1312 align-props)
1313 (save-excursion
1314 ;; if beg and end were not given, figure out what the
1315 ;; current alignment region should be. Depending on the
1316 ;; value of `align-region-separate' it's possible for
1317 ;; each rule to have its own definition of what that
1318 ;; current alignment section is.
1319 (if real-beg
1320 (goto-char beg)
1321 (if (or (not thissep) (eq thissep 'entire))
1322 (error "Cannot determine alignment region for '%s'"
1323 (symbol-name (cdr (assq 'title rule)))))
1324 (beginning-of-line)
1325 (while (and (not (eobp))
1326 (looking-at "^\\s-*$"))
1327 (forward-line))
1328 (let* ((here (point))
1329 (start here))
1330 (while (and here
1331 (let ((terminus
1332 (and align-region-heuristic
1333 (- (point)
1334 align-region-heuristic))))
1335 (if regfunc
1336 (funcall regfunc terminus t)
1337 (re-search-backward regexp
1338 terminus t))))
1339 (if (align-new-section-p (point) here thissep)
1340 (setq beg here
1341 here nil)
1342 (setq here (point))))
1343 (if (not here)
1344 (goto-char beg))
1345 (beginning-of-line)
1346 (setq beg (point))
1347 (goto-char start)
1348 (setq here (point))
1349 (while (and here
1350 (let ((terminus
1351 (and align-region-heuristic
1352 (+ (point)
1353 align-region-heuristic))))
1354 (if regfunc
1355 (funcall regfunc terminus nil)
1356 (re-search-forward regexp terminus t))))
1357 (if (align-new-section-p here (point) thissep)
1358 (setq end here
1359 here nil)
1360 (setq here (point))))
1361 (if (not here)
1362 (goto-char end))
1363 (forward-line)
1364 (setq end (point)
1365 end-mark (copy-marker end t))
1366 (goto-char beg)))
1368 ;; If we have a region to align, and `func' is set and
1369 ;; reports back that the region is ok, then align it.
1370 (when (or (not func)
1371 (funcall func beg end rule))
1372 (unwind-protect
1373 (let (exclude-areas)
1374 ;; determine first of all where the exclusions
1375 ;; lie in this region
1376 (when exclude-rules
1377 ;; guard against a problem with recursion and
1378 ;; dynamic binding vs. lexical binding, since
1379 ;; the call to `align-region' below will
1380 ;; re-enter this function, and rebind
1381 ;; `exclude-areas'
1382 (set (setq exclude-areas
1383 (make-symbol "align-exclude-areas"))
1384 nil)
1385 (align-region
1386 beg end 'entire
1387 exclude-rules nil
1388 `(lambda (b e mode)
1389 (or (and mode (listp mode))
1390 (set (quote ,exclude-areas)
1391 (cons (cons b e)
1392 ,exclude-areas)))))
1393 (setq exclude-areas
1394 (sort (symbol-value exclude-areas)
1395 (function
1396 (lambda (l r)
1397 (>= (car l) (car r)))))))
1399 ;; set `case-fold-search' according to the
1400 ;; (optional) `case-fold' property
1401 (and case-fold
1402 (setq case-fold-search (cdr case-fold)))
1404 ;; while we can find the rule in the alignment
1405 ;; region..
1406 (while (and (< (point) end-mark)
1407 (if regfunc
1408 (funcall regfunc end-mark nil)
1409 (re-search-forward regexp
1410 end-mark t)))
1412 ;; give the user some indication of where we
1413 ;; are, if it's a very large region being
1414 ;; aligned
1415 (if report
1416 (let ((symbol (car rule)))
1417 (if (and symbol (symbolp symbol))
1418 (message
1419 "Aligning `%s' (rule %d of %d) %d%%..."
1420 (symbol-name symbol) rule-index rule-count
1421 (/ (* (- (point) real-beg) 100)
1422 (- end-mark real-beg)))
1423 (message
1424 "Aligning %d%%..."
1425 (/ (* (- (point) real-beg) 100)
1426 (- end-mark real-beg))))))
1428 ;; if the search ended us on the beginning of
1429 ;; the next line, move back to the end of the
1430 ;; previous line.
1431 (if (bolp)
1432 (forward-char -1))
1434 ;; lookup the `group' attribute the first time
1435 ;; that we need it
1436 (unless group-c
1437 (setq group (or (cdr (assq 'group rule)) 1))
1438 (if (listp group)
1439 (setq first (car group))
1440 (setq first group group (list group)))
1441 (setq group-c t))
1443 (unless spacing-c
1444 (setq spacing (cdr (assq 'spacing rule))
1445 spacing-c t))
1447 (unless tab-stop-c
1448 (setq tab-stop
1449 (let ((rule-ts (assq 'tab-stop rule)))
1450 (if rule-ts
1451 (cdr rule-ts)
1452 (if (symbolp align-to-tab-stop)
1453 (symbol-value align-to-tab-stop)
1454 align-to-tab-stop)))
1455 tab-stop-c t))
1457 ;; test whether we have found a match on the same
1458 ;; line as a previous match
1459 (if (> (point) eol)
1460 (setq same nil
1461 eol (save-excursion
1462 (end-of-line)
1463 (point-marker))))
1465 ;; lookup the `repeat' attribute the first time
1466 (or repeat-c
1467 (setq repeat (cdr (assq 'repeat rule))
1468 repeat-c t))
1470 ;; lookup the `valid' attribute the first time
1471 (or valid-c
1472 (setq valid (assq 'valid rule)
1473 valid-c t))
1475 ;; remember the beginning position of this rule
1476 ;; match, and save the match-data, since either
1477 ;; the `valid' form, or the code that searches for
1478 ;; section separation, might alter it
1479 (setq b (match-beginning first)
1480 save-match-data (match-data))
1482 ;; unless the `valid' attribute is set, and tells
1483 ;; us that the rule is not valid at this point in
1484 ;; the code..
1485 (unless (and valid (not (funcall (cdr valid))))
1487 ;; look to see if this match begins a new
1488 ;; section. If so, we should align what we've
1489 ;; collected so far, and then begin collecting
1490 ;; anew for the next alignment section
1491 (if (and last-point
1492 (align-new-section-p last-point b
1493 thissep))
1494 (progn
1495 (align-regions regions align-props
1496 rule func)
1497 (setq last-point (copy-marker b t)
1498 regions nil
1499 align-props nil))
1500 (setq last-point (copy-marker b t)))
1502 ;; restore the match data
1503 (set-match-data save-match-data)
1505 ;; check whether the region to be aligned
1506 ;; straddles an exclusion area
1507 (let ((excls exclude-areas))
1508 (setq exclude-p nil)
1509 (while excls
1510 (if (and (< (match-beginning (car group))
1511 (cdar excls))
1512 (> (match-end (car (last group)))
1513 (caar excls)))
1514 (setq exclude-p t
1515 excls nil)
1516 (setq excls (cdr excls)))))
1518 ;; go through the list of parenthesis groups
1519 ;; matching whitespace text to be
1520 ;; contracted/expanded (or possibly
1521 ;; justified, if the `justify' attribute was
1522 ;; set)
1523 (unless exclude-p
1524 (let ((g group))
1525 (while g
1527 ;; we have to use markers, since
1528 ;; `align-areas' may modify the buffer
1529 (setq b (copy-marker
1530 (match-beginning (car g)) t)
1531 e (copy-marker (match-end (car g)) t))
1533 ;; record this text region for alignment
1534 (setq index (if same (1+ index) 0))
1535 (let ((region (cons b e))
1536 (props (cons
1537 (if (listp spacing)
1538 (car spacing)
1539 spacing)
1540 (if (listp tab-stop)
1541 (car tab-stop)
1542 tab-stop))))
1543 (if (nth index regions)
1544 (setcar (nthcdr index regions)
1545 (cons region
1546 (nth index regions)))
1547 (if regions
1548 (progn
1549 (nconc regions
1550 (list (list region)))
1551 (nconc align-props (list props)))
1552 (setq regions
1553 (list (list region)))
1554 (setq align-props (list props)))))
1556 ;; if any further rule matches are
1557 ;; found before `eol', then they are
1558 ;; on the same line as this one; this
1559 ;; can only happen if the `repeat'
1560 ;; attribute is non-nil
1561 (if (listp spacing)
1562 (setq spacing (cdr spacing)))
1563 (if (listp tab-stop)
1564 (setq tab-stop (cdr tab-stop)))
1565 (setq same t g (cdr g))))
1567 ;; if `repeat' has not been set, move to
1568 ;; the next line; don't bother searching
1569 ;; anymore on this one
1570 (if (and (not repeat) (not (bolp)))
1571 (forward-line)))))
1573 ;; when they are no more matches for this rule,
1574 ;; align whatever was left over
1575 (if regions
1576 (align-regions regions align-props rule func)))
1578 (setq case-fold-search current-case-fold)))))))
1579 (setq rules (cdr rules)
1580 rule-index (1+ rule-index)))
1582 (if report
1583 (message "Aligning...done"))))
1585 ;; Provide:
1587 (provide 'align)
1589 (run-hooks 'align-load-hook)
1591 ;;; arch-tag: ef79cccf-1db8-4888-a8a1-d7ce2d1532f7
1592 ;;; align.el ends here