| blob | f63085011b7b96e8c42a2d7b15b45a2c5aea9e7b |
1 ;;; align.el --- align text to a specific column, by regexp
3 ;; Copyright (C) 1999, 2000, 2002, 2003, 2004,
4 ;; 2005 Free Software Foundation, Inc.
6 ;; Author: John Wiegley <johnw@gnu.org>
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 2, or (at your option)
14 ;; 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; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 ;; Boston, MA 02110-1301, USA.
26 ;;; Commentary:
28 ;; This mode allows you to align regions in a context-sensitive fashion.
29 ;; The classic use is to align assignments:
30 ;;
31 ;; int a = 1;
32 ;; short foo = 2;
33 ;; double blah = 4;
34 ;;
35 ;; becomes
36 ;;
37 ;; int a = 1;
38 ;; short foo = 2;
39 ;; double blah = 4;
41 ;;; Usage:
43 ;; There are several variables which define how certain "categories"
44 ;; of syntax are to be treated. These variables go by the name
45 ;; `align-CATEGORY-modes'. For example, "c++" is such a category.
46 ;; There are several rules which apply to c++, but since several other
47 ;; languages have a syntax similar to c++ (e.g., c, java, etc), these
48 ;; modes are treated as belonging to the same category.
49 ;;
50 ;; If you want to add a new mode under a certain category, just
51 ;; customize that list, or add the new mode manually. For example, to
52 ;; make jde-mode a c++ category mode, use this code in your .emacs
53 ;; file:
54 ;;
55 ;; (setq align-c++-modes (cons 'jde-mode align-c++-modes))
57 ;; In some programming modes, it's useful to have the aligner run only
58 ;; after indentation is performed. To achieve this, customize or set
59 ;; the variable `align-indent-before-aligning' to t.
61 ;;; Module Authors:
63 ;; In order to incorporate align's functionality into your own
64 ;; modules, there are only a few steps you have to follow.
66 ;; 1. Require or load in the align.el library.
67 ;;
68 ;; 2. Define your alignment and exclusion rules lists, either
69 ;; customizable or not.
70 ;;
71 ;; 3. In your mode function, set the variables
72 ;; `align-mode-rules-list' and `align-mode-exclude-rules-list'
73 ;; to your own rules lists.
75 ;; If there is any need to add your mode name to one of the
76 ;; align-?-modes variables (for example, `align-dq-string-modes'), use
77 ;; `add-to-list', or some similar function which checks first to see
78 ;; if the value is already there. Since the user may customize that
79 ;; mode list, and then write your mode name into their .emacs file,
80 ;; causing the symbol already to be present the next time they load
81 ;; your package.
83 ;; Example:
84 ;;
85 ;; (require 'align)
86 ;;
87 ;; (defcustom my-align-rules-list
88 ;; '((my-rule
89 ;; (regexp . "Sample")))
90 ;; :type align-rules-list-type
91 ;; :group 'my-package)
92 ;;
93 ;; (put 'my-align-rules-list 'risky-local-variable t)
94 ;;
95 ;; (add-to-list 'align-dq-string-modes 'my-package-mode)
96 ;; (add-to-list 'align-open-comment-modes 'my-package-mode)
97 ;;
98 ;; (defun my-mode ()
99 ;; ...
100 ;; (setq align-mode-rules-list my-align-rules-list))
101 ;;
102 ;; Note that if you need to install your own exclusion rules, then you
103 ;; will also need to reproduce any double-quoted string, or open
104 ;; comment exclusion rules that are defined in the standard
105 ;; `align-exclude-rules-list'. At the moment there is no convenient
106 ;; way to mix both mode-local and global rules lists.
108 ;;; History:
110 ;; Version 1.0 was created in the earlier part of 1996, using a very
111 ;; simple algorithm that understand only basic regular expressions.
112 ;; Parts of the code were broken up and included in vhdl-mode.el
113 ;; around this time. After several comments from users, and a need to
114 ;; find a more robust, performant algorithm, 2.0 was born in late
115 ;; 1998. Many different approaches were taken (mostly due to the
116 ;; complexity of TeX tables), but finally a scheme was discovered
117 ;; which worked fairly well for most common usage cases. Development
118 ;; beyond version 2.8 is not planned, except for problems that users
119 ;; might encounter.
121 ;;; Code:
124 "Align text to a specific column, by regexp."
128 ;;; User Variables:
131 "*Hook that gets run after the aligner has been loaded."
136 "*If non-nil, indent the marked region before aligning it."
141 "*An integer that represents the default amount of padding to use.
142 If `align-to-tab-stop' is non-nil, this will represent the number of
143 tab stops to use for alignment, rather than the number of spaces.
144 Each alignment rule can optionally override both this variable. See
145 `align-mode-alist'."
150 "*If non-nil, alignments will always fall on a tab boundary.
151 It may also be a symbol, whose value will be taken."
156 "*If non-nil, used as a heuristic by `align-current'.
157 Since each alignment rule can possibly have its own set of alignment
158 sections (whenever `align-region-separate' is non-nil, and not a
159 string), this heuristic is used to determine how far before and after
160 point we should search in looking for a region separator. Larger
161 values can mean slower perform in large files, although smaller values
162 may cause unexpected behavior at times."
167 "*The face to highlight with if changes are necessary."
172 "*The face to highlight with if no changes are necessary."
178 If nil,then no messages will ever be printed to the minibuffer."
183 "*A list of modes whose syntax resembles C/C++."
188 "*A list of modes where perl syntax is to be seen."
194 "*A list of modes whose syntax resembles Lisp."
200 "*A list of modes whose syntax resembles TeX (and family)."
205 "*A list of modes whose content is plain text."
212 "*A list of modes where double quoted strings should be excluded."
218 "*A list of modes where single quoted strings should be excluded."
225 "*A list of modes with a single-line comment syntax.
226 These are comments as in Lisp, which have a beginning but, end with
227 the line (i.e., `comment-end' is an empty string)."
232 "*Select the method by which alignment sections will be separated.
233 If this is a symbol, that symbol's value will be used.
235 For the sake of clarification, consider the following example, which
236 will be referred to in the descriptions below.
238 int alpha = 1; /* one */
239 double beta = 2.0;
240 long gamma; /* ten */
242 unsigned int delta = 1; /* one */
243 long double epsilon = 3.0;
244 long long omega; /* ten */
246 The possible settings for `align-region-separate' are:
248 `entire' The entire region being aligned will be considered as a
249 single alignment section. Assuming that comments were not
250 being aligned to a particular column, the example would
251 become:
253 int alpha = 1; /* one */
254 double beta = 2.0;
255 long gamma; /* ten */
257 unsigned int delta = 1; /* one */
258 long double epsilon;
259 long long chi = 10; /* ten */
261 `group' Each contiguous set of lines where a specific alignment
262 occurs is considered a section for that alignment rule.
263 Note that each rule will may have any entirely different
264 set of section divisions than another.
266 int alpha = 1; /* one */
267 double beta = 2.0;
268 long gamma; /* ten */
270 unsigned int delta = 1; /* one */
271 long double epsilon;
272 long long chi = 10; /* ten */
274 `largest' When contiguous rule sets overlap, the largest section
275 described will be taken as the alignment section for each
276 rule touched by that section.
278 int alpha = 1; /* one */
279 double beta = 2.0;
280 long gamma; /* ten */
282 unsigned int delta = 1; /* one */
283 long double epsilon;
284 long long chi = 10; /* ten */
286 NOTE: This option is not supported yet, due to algorithmic
287 issues which haven't been satisfactorily resolved. There
288 are ways to do it, but they're both ugly and resource
289 consumptive.
291 regexp A regular expression string which defines the section
292 divider. If the mode you're in has a consistent divider
293 between sections, the behavior will be very similar to
294 `largest', and faster. But if the mode does not use clear
295 separators (for example, if you collapse your braces onto
296 the preceding statement in C or perl), `largest' is
297 probably the better alternative.
299 function A function that will be passed the beginning and ending
300 locations of the region in which to look for the section
301 separator. At the very beginning of the attempt to align,
302 both of these parameters will be nil, in which case the
303 function should return non-nil if it wants each rule to
304 define its own section, or nil if it wants the largest
305 section found to be used as the common section for all rules
306 that occur there.
308 list A list of markers within the buffer that represent where
309 the section dividers lie. Be certain to use markers! For
310 when the aligning begins, the ensuing contract/expanding of
311 whitespace will throw off any non-marker positions.
313 This method is intended for use in Lisp programs, and not
314 by the user."
318 ; (const largest)
339 repeat)
350 case-fold)
354 tab-stop)
358 valid)
362 run-if)
367 integer symbol))
373 justify)
375 ;; make sure this stays up-to-date with any changes
376 ;; in `align-region-separate'
379 separate)
383 ; (const largest)
384 regexp function)))))))
467 ; (valid
468 ; . ,(function
469 ; (lambda ()
470 ; (memq (caar (c-guess-basic-syntax))
471 ; '(brace-list-intro
472 ; brace-list-entry
473 ; brace-entry-open))))))
475 ;; With a prefix argument, comma delimiter will be aligned. Since
476 ;; perl-mode doesn't give us enough syntactic information (and we
477 ;; don't do our own parsing yet), this rule is too destructive to
478 ;; run normally.
526 ; (valid
527 ; . ,(function
528 ; (lambda ()
529 ; (memq (caar (c-guess-basic-syntax))
530 ; '(cpp-macro cpp-macro-cont))))))
559 ;; With a numeric prefix argument, or C-u, space delimited text
560 ;; tables will be aligned.
571 ;; With a negative prefix argument, lists of dollar figures will
572 ;; be aligned.
585 "*A list describing all of the available alignment rules.
586 The format is:
588 ((TITLE
589 (ATTRIBUTE . VALUE) ...)
590 ...)
592 The following attributes are meaningful:
594 `regexp' This required attribute must be either a string describing
595 a regular expression, or a function (described below).
596 For every line within the section that this regular
597 expression matches, the given rule will be applied to that
598 line. The exclusion rules denote which part(s) of the
599 line should not be modified; the alignment rules cause the
600 identified whitespace group to be contracted/expanded such
602 immediately following the identified parenthesis group),
603 occurs in the same column for every line within the
604 alignment section (see `align-region-separate' for a
605 description of how the region is broken up into alignment
606 sections).
608 The `regexp' attribute describes how the text should be
609 treated. Within this regexp, there must be at least one
610 group of characters (typically whitespace) identified by
611 the special opening and closing parens used in regexp
613 the syntax of regular expressions for more info).
615 If `regexp' is a function, it will be called as a
616 replacement for `re-search-forward'. This means that it
617 should return nil if nothing is found to match the rule,
618 or it should set the match data appropriately, move point
619 to the end of the match, and return the value of point.
621 `group' For exclusion rules, the group identifies the range of
622 characters that should be ignored. For alignment rules,
623 these are the characters that will be deleted/expanded for
625 always the first character immediately following this
626 parenthesis group. This attribute may also be a list of
627 integer, in which case multiple alignment characters will
628 be aligned, with the list of integer identifying the
629 whitespace groups which precede them. The default for
630 this attribute is 1.
632 `modes' The `modes' attribute, if set, should name a list of
633 major modes -- or evaluate to such a value -- in which the
634 rule is valid. If not set, the rule will apply to all
635 modes.
637 `case-fold' If `regexp' is an ordinary regular expression string
638 containing alphabetic character, sometimes you may want
639 the search to proceed case-insensitively (for languages
640 that ignore case, such as pascal for example). In that
641 case, set `case-fold' to a non-nil value, and the regular
642 expression search will ignore case. If `regexp' is set to
643 a function, that function must handle the job of ignoring
644 case by itself.
646 `tab-stop' If the `tab-stop' attribute is set, and non-nil, the
647 alignment character will always fall on a tab stop
648 (whether it uses tabs to get there or not depends on the
649 value of `indent-tabs-mode'). If the `tab-stop' attribute
650 is set to nil, tab stops will never be used. Otherwise,
651 the value of `align-to-tab-stop' determines whether or not
652 to align to a tab stop. The `tab-stop' attribute may also
653 be a list of t or nil values, corresponding to the number
654 of parenthesis groups specified by the `group' attribute.
656 `repeat' If the `repeat' attribute is present, and non-nil, the
657 rule will be applied to the line continuously until no
658 further matches are found.
660 `valid' If the `valid' attribute is set, it will be used to
661 determine whether the rule should be invoked. This form
662 is evaluated after the regular expression match has been
663 performed, so that it is possible to use the results of
664 that match to determine whether the alignment should be
665 performed. The buffer should not be modified during the
666 evaluation of this form.
668 `run-if' Like `valid', the `run-if' attribute tests whether the
669 rule should be run at all -- even before any searches are
670 done to determine if the rule applies to the alignment
671 region. This can save time, since `run-if' will only be
672 run once for each rule. If it returns nil, the rule will
673 not be attempted.
675 `column' For alignment rules, if the `column' attribute is set --
676 which must be an integer, or a symbol whose value is an
677 integer -- it will be used as the column in which to align
678 the alignment character. If the text on a particular line
679 happens to overrun that column, a single space character,
680 or tab stop (see `align-to-tab-stop') will be added
681 between the last text character and the alignment
682 character.
684 `spacing' Alignment rules may also override the amount of spacing
685 that would normally be used by providing a `spacing'
686 attribute. This must be an integer, or a list of integers
687 corresponding to the number of parenthesis groups matched
688 by the `group' attribute. If a list of value is used, and
689 any of those values is nil, `align-default-spacing' will
690 be used for that subgroup. See `align-default-spacing'
691 for more details on spacing, tab stops, and how to
692 indicate how much spacing should be used. If TAB-STOP is
693 present, it will override the value of `align-to-tab-stop'
694 for that rule.
696 `justify' It is possible with `regexp' and `group' to identify a
697 character group that contains more than just whitespace
698 characters. By default, any non-whitespace characters in
699 that group will also be deleted while aligning the
700 alignment character. However, if the `justify' attribute
701 is set to a non-nil value, only the initial whitespace
702 characters within that group will be deleted. This has
703 the effect of right-justifying the characters that remain,
704 and can be used for outdenting or just plain old right-
705 justification.
707 `separate' Each rule can define its own section separator, which
709 within the region to be aligned. Setting the `separate'
710 attribute overrides the value of `align-region-separate'
711 (see the documentation of that variable for possible
712 values), and any separation argument passed to `align'."
713 :type align-rules-list-type
732 repeat)
743 case-fold)
783 "*A list describing text that should be excluded from alignment.
784 See the documentation for `align-rules-list' for more info."
785 :type align-exclude-rules-list-type
790 ;;; Internal Variables:
793 "Alignment rules specific to the current major mode.
799 "Alignment exclusion rules specific to the current major mode.
807 ;; Sample extension rule set, for vhdl-mode. This should properly be
808 ;; in vhdl-mode.el itself.
841 "*Alignment rules for `vhdl-mode'. See `align-rules-list' for more info."
842 :type align-rules-list-type
848 "Setup the `align-mode-rules-list' variable for `vhdl-mode'."
856 ;;; User Functions:
858 ;;;###autoload
860 "Attempt to align a region based on a set of alignment rules.
861 BEG and END mark the region. If BEG and END are specifically set to
862 nil (this can only be done programmatically), the beginning and end of
863 the current alignment section will be calculated based on the location
864 of point, and the value of `align-region-separate' (or possibly each
865 rule's `separate' attribute).
867 If SEPARATE is non-nil, it overrides the value of
868 `align-region-separate' for all rules, except those that have their
869 `separate' attribute set.
871 RULES and EXCLUDE-RULES, if either is non-nil, will replace the
872 default rule lists defined in `align-rules-list' and
873 `align-exclude-rules-list'. See `align-rules-list' for more details
874 on the format of these lists."
881 align-region-separate)
889 align-exclude-rules-list))
894 align-mode-exclude-rules-list
895 align-exclude-rules-list) nil
896 separator
906 align-exclude-rules-list)))))))
908 ;;;###autoload
910 "Align the current region using an ad-hoc rule read from the minibuffer.
911 BEG and END mark the limits of the region. This function will prompt
912 for the REGEXP to align with. If no prefix arg was specified, you
913 only need to supply the characters to be lined up and any preceding
914 whitespace is replaced. If a prefix arg was specified, the full
915 regexp with parenthesized whitespace should be supplied; it will also
916 prompt for which parenthesis GROUP within REGEXP to modify, the amount
917 of SPACING to use, and whether or not to REPEAT the rule throughout
918 the line. See `align-rules-list' for more information about these
919 options.
921 For example, let's say you had a list of phone numbers, and wanted to
922 align them so that the opening parentheses would line up:
924 Fred (123) 456-7890
925 Alice (123) 456-7890
926 Mary-Anne (123) 456-7890
927 Joe (123) 456-7890
929 There is no predefined rule to handle this, but you could easily do it
931 region, call `align-regexp' and type in that regular expression."
960 ;;;###autoload
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."
970 ;;;###autoload
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."
981 ;;;###autoload
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."
992 "Title of rule to highlight: "
1002 align-exclude-rules-list)))
1003 face)
1006 beg end 'entire
1009 align-exclude-rules-list)
1012 align-exclude-rules-list))
1018 align-highlight-nochange-face))
1029 ;;;###autoload
1031 "Remove any highlighting that was added by `align-highlight-rule'."
1038 ;;;###autoload
1040 "A replacement function for `newline-and-indent', aligning as it goes."
1045 align-region-separate)
1056 ;;; Internal Functions:
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."
1078 result))
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."
1086 nil)
1107 yes))))
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."
1116 column
1124 stops nil)
1126 column)))
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."
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."
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."
1160 column))
1164 ecol change look)
1166 ;; Determine the alignment column.
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.
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.
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.
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)
1277 Otherwise BEG to END will be a region of text that matches the rule's
1279 (unless (and mode (listp mode))
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."
1299 ;; unless the `run-if' form tells us not to, look for the
1300 ;; rule..
1311 group group-c
1312 spacing spacing-c
1313 tab-stop tab-stop-c
1314 repeat repeat-c
1315 valid valid-c
1316 pos-list first
1317 regions index
1318 last-point b e
1319 save-match-data
1320 exclude-p
1321 align-props)
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.
1343 align-region-heuristic))))
1347 terminus t))))
1350 here nil)
1362 align-region-heuristic))))
1368 here nil)
1377 ;; If we have a region to align, and `func' is set and
1378 ;; reports back that the region is ok, then align it.
1383 ;; determine first of all where the exclusions
1384 ;; lie in this region
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'
1393 nil)
1395 beg end 'entire
1396 exclude-rules nil
1408 ;; set `case-fold-search' according to the
1409 ;; (optional) `case-fold' property
1413 ;; while we can find the rule in the alignment
1414 ;; region..
1419 end-mark t)))
1421 ;; give the user some indication of where we
1422 ;; are, if it's a very large region being
1423 ;; aligned
1428 "Aligning `%s' (rule %d of %d) %d%%..."
1433 "Aligning %d%%..."
1437 ;; if the search ended us on the beginning of
1438 ;; the next line, move back to the end of the
1439 ;; previous line.
1443 ;; lookup the `group' attribute the first time
1444 ;; that we need it
1454 spacing-c t))
1463 align-to-tab-stop)))
1464 tab-stop-c t))
1466 ;; test whether we have found a match on the same
1467 ;; line as a previous match
1474 ;; lookup the `repeat' attribute the first time
1477 repeat-c t))
1479 ;; lookup the `valid' attribute the first time
1482 valid-c t))
1484 ;; remember the beginning position of this rule
1485 ;; match, and save the match-data, since either
1486 ;; the `valid' form, or the code that searches for
1487 ;; section separation, might alter it
1491 ;; unless the `valid' attribute is set, and tells
1492 ;; us that the rule is not valid at this point in
1493 ;; the code..
1496 ;; look to see if this match begins a new
1497 ;; section. If so, we should align what we've
1498 ;; collected so far, and then begin collecting
1499 ;; anew for the next alignment section
1502 thissep))
1505 rule func)
1507 regions nil
1508 align-props nil))
1511 ;; restore the match data
1514 ;; check whether the region to be aligned
1515 ;; straddles an exclusion area
1524 excls nil)
1527 ;; go through the list of parenthesis groups
1528 ;; matching whitespace text to be
1529 ;; contracted/expanded (or possibly
1530 ;; justified, if the `justify' attribute was
1531 ;; set)
1536 ;; we have to use markers, since
1537 ;; `align-areas' may modify the buffer
1542 ;; record this text region for alignment
1548 spacing)
1551 tab-stop))))
1565 ;; if any further rule matches are
1566 ;; found before `eol', then they are
1567 ;; on the same line as this one; this
1568 ;; can only happen if the `repeat'
1569 ;; attribute is non-nil
1576 ;; if `repeat' has not been set, move to
1577 ;; the next line; don't bother searching
1578 ;; anymore on this one
1582 ;; when they are no more matches for this rule,
1583 ;; align whatever was left over
1594 ;; Provide:
1600 ;;; arch-tag: ef79cccf-1db8-4888-a8a1-d7ce2d1532f7
1601 ;;; align.el ends here