| blob | 563e839f5fe9a6381b0588e8e3a806a344cf9623 |
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:
29 ;;
30 ;; int a = 1;
31 ;; short foo = 2;
32 ;; double blah = 4;
33 ;;
34 ;; becomes
35 ;;
36 ;; int a = 1;
37 ;; short foo = 2;
38 ;; double blah = 4;
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.
48 ;;
49 ;; If you want to add a new mode under a certain category, just
50 ;; customize that list, or add the new mode manually. For example, to
51 ;; make jde-mode a c++ category mode, use this code in your .emacs
52 ;; file:
53 ;;
54 ;; (setq align-c++-modes (cons 'jde-mode align-c++-modes))
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.
66 ;;
67 ;; 2. Define your alignment and exclusion rules lists, either
68 ;; customizable or not.
69 ;;
70 ;; 3. In your mode function, set the variables
71 ;; `align-mode-rules-list' and `align-mode-exclude-rules-list'
72 ;; to your own rules lists.
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:
83 ;;
84 ;; (require 'align)
85 ;;
86 ;; (defcustom my-align-rules-list
87 ;; '((my-rule
88 ;; (regexp . "Sample")))
89 ;; :type align-rules-list-type
90 ;; :group 'my-package)
91 ;;
92 ;; (put 'my-align-rules-list 'risky-local-variable t)
93 ;;
94 ;; (add-to-list 'align-dq-string-modes 'my-package-mode)
95 ;; (add-to-list 'align-open-comment-modes 'my-package-mode)
96 ;;
97 ;; (defun my-mode ()
98 ;; ...
99 ;; (setq align-mode-rules-list my-align-rules-list))
100 ;;
101 ;; Note that if you need to install your own exclusion rules, then you
102 ;; will also need to reproduce any double-quoted string, or open
103 ;; comment exclusion rules that are defined in the standard
104 ;; `align-exclude-rules-list'. At the moment there is no convenient
105 ;; way to mix both mode-local and global rules lists.
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:
123 "Align text to a specific column, by regexp."
127 ;;; User Variables:
130 "*Hook that gets run after the aligner has been loaded."
135 "*If non-nil, indent the marked region before aligning it."
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'."
149 "*If non-nil, alignments will always fall on a tab boundary.
150 It may also be a symbol, whose value will be taken."
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."
166 "*The face to highlight with if changes are necessary."
171 "*The face to highlight with if no changes are necessary."
177 If nil,then no messages will ever be printed to the minibuffer."
182 "*A list of modes whose syntax resembles C/C++."
187 "*A list of modes where perl syntax is to be seen."
193 "*A list of modes whose syntax resembles Lisp."
199 "*A list of modes whose syntax resembles TeX (and family)."
204 "*A list of modes whose content is plain text."
211 "*A list of modes where double quoted strings should be excluded."
217 "*A list of modes where single quoted strings should be excluded."
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)."
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."
317 ; (const largest)
338 repeat)
349 case-fold)
353 tab-stop)
357 valid)
361 run-if)
366 integer symbol))
372 justify)
374 ;; make sure this stays up-to-date with any changes
375 ;; in `align-region-separate'
378 separate)
382 ; (const largest)
383 regexp function)))))))
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.
528 ; (valid
529 ; . ,(function
530 ; (lambda ()
531 ; (memq (caar (c-guess-basic-syntax))
532 ; '(cpp-macro cpp-macro-cont))))))
561 ;; With a numeric prefix argument, or C-u, space delimited text
562 ;; tables will be aligned.
573 ;; With a negative prefix argument, lists of dollar figures will
574 ;; be aligned.
587 "*A list describing all of the available alignment rules.
588 The format is:
590 ((TITLE
591 (ATTRIBUTE . VALUE) ...)
592 ...)
594 The following attributes are meaningful:
596 `regexp' This required attribute must be either a string describing
597 a regular expression, or a function (described below).
598 For every line within the section that this regular
599 expression matches, the given rule will be applied to that
600 line. The exclusion rules denote which part(s) of the
601 line should not be modified; the alignment rules cause the
602 identified whitespace group to be contracted/expanded such
604 immediately following the identified parenthesis group),
605 occurs in the same column for every line within the
606 alignment section (see `align-region-separate' for a
607 description of how the region is broken up into alignment
608 sections).
610 The `regexp' attribute describes how the text should be
611 treated. Within this regexp, there must be at least one
612 group of characters (typically whitespace) identified by
613 the special opening and closing parens used in regexp
615 the syntax of regular expressions for more info).
617 If `regexp' is a function, it will be called as a
618 replacement for `re-search-forward'. This means that it
619 should return nil if nothing is found to match the rule,
620 or it should set the match data appropriately, move point
621 to the end of the match, and return the value of point.
623 `group' For exclusion rules, the group identifies the range of
624 characters that should be ignored. For alignment rules,
625 these are the characters that will be deleted/expanded for
627 always the first character immediately following this
628 parenthesis group. This attribute may also be a list of
629 integer, in which case multiple alignment characters will
630 be aligned, with the list of integer identifying the
631 whitespace groups which precede them. The default for
632 this attribute is 1.
634 `modes' The `modes' attribute, if set, should name a list of
635 major modes -- or evaluate to such a value -- in which the
636 rule is valid. If not set, the rule will apply to all
637 modes.
639 `case-fold' If `regexp' is an ordinary regular expression string
640 containing alphabetic character, sometimes you may want
641 the search to proceed case-insensitively (for languages
642 that ignore case, such as pascal for example). In that
643 case, set `case-fold' to a non-nil value, and the regular
644 expression search will ignore case. If `regexp' is set to
645 a function, that function must handle the job of ignoring
646 case by itself.
648 `tab-stop' If the `tab-stop' attribute is set, and non-nil, the
649 alignment character will always fall on a tab stop
650 (whether it uses tabs to get there or not depends on the
651 value of `indent-tabs-mode'). If the `tab-stop' attribute
652 is set to nil, tab stops will never be used. Otherwise,
653 the value of `align-to-tab-stop' determines whether or not
654 to align to a tab stop. The `tab-stop' attribute may also
655 be a list of t or nil values, corresponding to the number
656 of parenthesis groups specified by the `group' attribute.
658 `repeat' If the `repeat' attribute is present, and non-nil, the
659 rule will be applied to the line continuously until no
660 further matches are found.
662 `valid' If the `valid' attribute is set, it will be used to
663 determine whether the rule should be invoked. This form
664 is evaluated after the regular expression match has been
665 performed, so that it is possible to use the results of
666 that match to determine whether the alignment should be
667 performed. The buffer should not be modified during the
668 evaluation of this form.
670 `run-if' Like `valid', the `run-if' attribute tests whether the
671 rule should be run at all -- even before any searches are
672 done to determine if the rule applies to the alignment
673 region. This can save time, since `run-if' will only be
674 run once for each rule. If it returns nil, the rule will
675 not be attempted.
677 `column' For alignment rules, if the `column' attribute is set --
678 which must be an integer, or a symbol whose value is an
679 integer -- it will be used as the column in which to align
680 the alignment character. If the text on a particular line
681 happens to overrun that column, a single space character,
682 or tab stop (see `align-to-tab-stop') will be added
683 between the last text character and the alignment
684 character.
686 `spacing' Alignment rules may also override the amount of spacing
687 that would normally be used by providing a `spacing'
688 attribute. This must be an integer, or a list of integers
689 corresponding to the number of parenthesis groups matched
690 by the `group' attribute. If a list of value is used, and
691 any of those values is nil, `align-default-spacing' will
692 be used for that subgroup. See `align-default-spacing'
693 for more details on spacing, tab stops, and how to
694 indicate how much spacing should be used. If TAB-STOP is
695 present, it will override the value of `align-to-tab-stop'
696 for that rule.
698 `justify' It is possible with `regexp' and `group' to identify a
699 character group that contains more than just whitespace
700 characters. By default, any non-whitespace characters in
701 that group will also be deleted while aligning the
702 alignment character. However, if the `justify' attribute
703 is set to a non-nil value, only the initial whitespace
704 characters within that group will be deleted. This has
705 the effect of right-justifying the characters that remain,
706 and can be used for outdenting or just plain old right-
707 justification.
709 `separate' Each rule can define its own section separator, which
711 within the region to be aligned. Setting the `separate'
712 attribute overrides the value of `align-region-separate'
713 (see the documentation of that variable for possible
714 values), and any separation argument passed to `align'."
715 :type align-rules-list-type
734 repeat)
745 case-fold)
785 "*A list describing text that should be excluded from alignment.
786 See the documentation for `align-rules-list' for more info."
787 :type align-exclude-rules-list-type
792 ;;; Internal Variables:
795 "Alignment rules specific to the current major mode.
801 "Alignment exclusion rules specific to the current major mode.
809 ;; Sample extension rule set, for vhdl-mode. This should properly be
810 ;; in vhdl-mode.el itself.
843 "*Alignment rules for `vhdl-mode'. See `align-rules-list' for more info."
844 :type align-rules-list-type
850 "Setup the `align-mode-rules-list' variable for `vhdl-mode'."
858 ;;; User Functions:
860 ;;;###autoload
862 "Attempt to align a region based on a set of alignment rules.
863 BEG and END mark the region. If BEG and END are specifically set to
864 nil (this can only be done programmatically), the beginning and end of
865 the current alignment section will be calculated based on the location
866 of point, and the value of `align-region-separate' (or possibly each
867 rule's `separate' attribute).
869 If SEPARATE is non-nil, it overrides the value of
870 `align-region-separate' for all rules, except those that have their
871 `separate' attribute set.
873 RULES and EXCLUDE-RULES, if either is non-nil, will replace the
874 default rule lists defined in `align-rules-list' and
875 `align-exclude-rules-list'. See `align-rules-list' for more details
876 on the format of these lists."
883 align-region-separate)
891 align-exclude-rules-list))
896 align-mode-exclude-rules-list
897 align-exclude-rules-list) nil
898 separator
908 align-exclude-rules-list)))))))
910 ;;;###autoload
912 "Align the current region using an ad-hoc rule read from the minibuffer.
913 BEG and END mark the limits of the region. This function will prompt
914 for the REGEXP to align with. If no prefix arg was specified, you
915 only need to supply the characters to be lined up and any preceding
916 whitespace is replaced. If a prefix arg was specified, the full
917 regexp with parenthesized whitespace should be supplied; it will also
918 prompt for which parenthesis GROUP within REGEXP to modify, the amount
919 of SPACING to use, and whether or not to REPEAT the rule throughout
920 the line. See `align-rules-list' for more information about these
921 options.
923 For example, let's say you had a list of phone numbers, and wanted to
924 align them so that the opening parentheses would line up:
926 Fred (123) 456-7890
927 Alice (123) 456-7890
928 Mary-Anne (123) 456-7890
929 Joe (123) 456-7890
931 There is no predefined rule to handle this, but you could easily do it
933 region, call `align-regexp' and type in that regular expression."
963 ;;;###autoload
965 "Align the selected region as if it were one alignment section.
966 BEG and END mark the extent of the region. If RULES or EXCLUDE-RULES
967 is set to a list of rules (see `align-rules-list'), it can be used to
968 override the default alignment rules that would have been used to
969 align that section."
973 ;;;###autoload
975 "Call `align' on the current alignment section.
976 This function assumes you want to align only the current section, and
977 so saves you from having to specify the region. If RULES or
978 EXCLUDE-RULES is set to a list of rules (see `align-rules-list'), it
979 can be used to override the default alignment rules that would have
980 been used to align that section."
984 ;;;###autoload
986 "Highlight the whitespace which a given rule would have modified.
987 BEG and END mark the extent of the region. TITLE identifies the rule
988 that should be highlighted. If RULES or EXCLUDE-RULES is set to a
989 list of rules (see `align-rules-list'), it can be used to override the
990 default alignment rules that would have been used to identify the text
991 to be colored."
996 "Title of rule to highlight: "
1006 align-exclude-rules-list)))
1007 face)
1010 beg end 'entire
1013 align-exclude-rules-list)
1016 align-exclude-rules-list))
1022 align-highlight-nochange-face))
1033 ;;;###autoload
1035 "Remove any highlighting that was added by `align-highlight-rule'."
1042 ;;;###autoload
1044 "A replacement function for `newline-and-indent', aligning as it goes."
1049 align-region-separate)
1060 ;;; Internal Functions:
1063 "Match REGEXP in TeX mode, counting backslashes appropriately.
1064 END denotes the end of the region to be searched, while REVERSE, if
1065 non-nil, indicates that the search should proceed backward from the
1066 current position."
1082 result))
1085 "Is there a section divider between BEG and END?
1086 SEPARATOR specifies how to look for the section divider. See the
1087 documentation for `align-region-separate' for more details."
1090 nil)
1111 yes))))
1114 "Adjust COLUMN according to the given RULE.
1115 SPACING specifies how much spacing to use.
1116 TAB-STOP specifies whether SPACING refers to tab-stop boundaries."
1120 column
1128 stops nil)
1130 column)))
1133 "Given a position in the buffer, state what column it's in.
1134 POS is the position whose column will be taken. Note that this
1135 function will change the location of point."
1140 "Align the regions specified in REGIONS, a list of cons cells.
1141 PROPS describes formatting features specific to the given regions.
1142 RULE specifies exactly how to perform the alignments.
1143 If FUNC is specified, it will be called with each region that would
1144 have been aligned, rather than modifying the text."
1152 "Given a list of AREAS and formatting PROPS, align according to RULE.
1153 AREAS should be a list of cons cells containing beginning and ending
1154 markers. This function sweeps through all of the beginning markers,
1155 finds out which one starts in the furthermost column, and then deletes
1156 and inserts text such that all of the ending markers occur in the same
1157 column.
1159 If FUNC is non-nil, it will be called for each text region that would
1160 have been aligned. No changes will be made to the buffer."
1164 column))
1168 ecol change look)
1170 ;; Determine the alignment column.
1195 ;; Make all ending positions to occur in the goal column. Since
1196 ;; the whitespace to be modified was already deleted by
1197 ;; `align-region', all we have to do here is indent.
1220 ;; FIXME: It is stated above that "...the
1221 ;; whitespace to be modified was already
1222 ;; deleted by `align-region', all we have
1223 ;; to do here is indent." However, this
1224 ;; doesn't seem to be true, so we first
1225 ;; delete the whitespace to avoid tabs
1226 ;; after spaces.
1230 ;; This code works around an oddity in the
1231 ;; FORCE argument of `move-to-column', which
1232 ;; tends to screw up markers if there is any
1233 ;; tabbing.
1255 "Align a region based on a given set of alignment rules.
1256 BEG and END specify the region to be aligned. Either may be nil, in
1257 which case the range will stop at the nearest section division (see
1258 `align-region-separate', and `align-region-heuristic' for more
1259 information').
1261 The region will be divided into separate alignment sections based on
1262 the value of SEPARATE.
1264 RULES and EXCLUDE-RULES are a pair of lists describing how to align
1265 the region, and which text areas within it should be excluded from
1266 alignment. See the `align-rules-list' for more information on the
1267 required format of these two lists.
1269 If FUNC is specified, no text will be modified. What `align-region'
1270 will do with the rules is to search for the alignment areas, as it
1271 regularly would, taking account for exclusions, and then call FUNC,
1272 first with the beginning and ending of the region to be aligned
1273 according to that rule (this can be different for each rule, if BEG
1274 and END were nil), and then with the beginning and ending of each
1275 text region that the rule would have applied to.
1277 The signature of FUNC should thus be:
1279 (defun my-align-function (beg end mode)
1281 Otherwise BEG to END will be a region of text that matches the rule's
1283 (unless (and mode (listp mode))
1286 This feature (of passing a FUNC) is used internally to locate the
1287 position of exclusion areas, but could also be used for any other
1288 purpose where you might want to know where the regions that the
1289 aligner would have dealt with are."
1303 ;; unless the `run-if' form tells us not to, look for the
1304 ;; rule..
1315 group group-c
1316 spacing spacing-c
1317 tab-stop tab-stop-c
1318 repeat repeat-c
1319 valid valid-c
1320 pos-list first
1321 regions index
1322 last-point b e
1323 save-match-data
1324 exclude-p
1325 align-props)
1327 ;; if beg and end were not given, figure out what the
1328 ;; current alignment region should be. Depending on the
1329 ;; value of `align-region-separate' it's possible for
1330 ;; each rule to have its own definition of what that
1331 ;; current alignment section is.
1347 align-region-heuristic))))
1351 terminus t))))
1354 here nil)
1366 align-region-heuristic))))
1372 here nil)
1381 ;; If we have a region to align, and `func' is set and
1382 ;; reports back that the region is ok, then align it.
1387 ;; determine first of all where the exclusions
1388 ;; lie in this region
1390 ;; guard against a problem with recursion and
1391 ;; dynamic binding vs. lexical binding, since
1392 ;; the call to `align-region' below will
1393 ;; re-enter this function, and rebind
1394 ;; `exclude-areas'
1397 nil)
1399 beg end 'entire
1400 exclude-rules nil
1412 ;; set `case-fold-search' according to the
1413 ;; (optional) `case-fold' property
1417 ;; while we can find the rule in the alignment
1418 ;; region..
1423 end-mark t)))
1425 ;; give the user some indication of where we
1426 ;; are, if it's a very large region being
1427 ;; aligned
1432 "Aligning `%s' (rule %d of %d) %d%%..."
1437 "Aligning %d%%..."
1441 ;; if the search ended us on the beginning of
1442 ;; the next line, move back to the end of the
1443 ;; previous line.
1447 ;; lookup the `group' attribute the first time
1448 ;; that we need it
1458 spacing-c t))
1467 align-to-tab-stop)))
1468 tab-stop-c t))
1470 ;; test whether we have found a match on the same
1471 ;; line as a previous match
1478 ;; lookup the `repeat' attribute the first time
1481 repeat-c t))
1483 ;; lookup the `valid' attribute the first time
1486 valid-c t))
1488 ;; remember the beginning position of this rule
1489 ;; match, and save the match-data, since either
1490 ;; the `valid' form, or the code that searches for
1491 ;; section separation, might alter it
1495 ;; unless the `valid' attribute is set, and tells
1496 ;; us that the rule is not valid at this point in
1497 ;; the code..
1500 ;; look to see if this match begins a new
1501 ;; section. If so, we should align what we've
1502 ;; collected so far, and then begin collecting
1503 ;; anew for the next alignment section
1506 thissep))
1509 rule func)
1511 regions nil
1512 align-props nil))
1515 ;; restore the match data
1518 ;; check whether the region to be aligned
1519 ;; straddles an exclusion area
1528 excls nil)
1531 ;; go through the list of parenthesis groups
1532 ;; matching whitespace text to be
1533 ;; contracted/expanded (or possibly
1534 ;; justified, if the `justify' attribute was
1535 ;; set)
1540 ;; we have to use markers, since
1541 ;; `align-areas' may modify the buffer
1546 ;; record this text region for alignment
1552 spacing)
1555 tab-stop))))
1569 ;; if any further rule matches are
1570 ;; found before `eol', then they are
1571 ;; on the same line as this one; this
1572 ;; can only happen if the `repeat'
1573 ;; attribute is non-nil
1580 ;; if `repeat' has not been set, move to
1581 ;; the next line; don't bother searching
1582 ;; anymore on this one
1586 ;; when they are no more matches for this rule,
1587 ;; align whatever was left over
1598 ;; Provide:
1604 ;;; arch-tag: ef79cccf-1db8-4888-a8a1-d7ce2d1532f7
1605 ;;; align.el ends here