;ELC ;;; Compiled by buildd@akateko.buildd on Fri Oct 25 13:48:24 2013 ;;; from file /build/buildd/emacs23-23.4+1/debian/build-x/lisp/align.el ;;; in Emacs version 23.4.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. ;;; This file does not contain utf-8 non-ASCII characters, ;;; and so can be loaded in Emacs versions earlier than 23. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (custom-declare-group 'align nil "Align text to a specific column, by regexp." :version "21.1" :group 'fill) #@55 Hook that gets run after the aligner has been loaded. (custom-declare-variable 'align-load-hook 'nil '(#$ . 644) :type 'hook :group 'align) #@58 If non-nil, indent the marked region before aligning it. (custom-declare-variable 'align-indent-before-aligning 'nil '(#$ . 790) :type 'boolean :group 'align) #@314 An integer that represents the default amount of padding to use. If `align-to-tab-stop' is non-nil, this will represent the number of tab stops to use for alignment, rather than the number of spaces. Each alignment rule can optionally override both this variable and `align-to-tab-stop'. See `align-rules-list'. (custom-declare-variable 'align-default-spacing '1 '(#$ . 956) :type 'integer :group 'align) #@112 If non-nil, alignments will always fall on a tab boundary. It may also be a symbol, whose value will be taken. (custom-declare-variable 'align-to-tab-stop ''indent-tabs-mode '(#$ . 1369) :type '(choice (const nil) symbol) :group 'align) #@438 If non-nil, used as a heuristic by `align-current'. Since each alignment rule can possibly have its own set of alignment sections (whenever `align-region-separate' is non-nil, and not a string), this heuristic is used to determine how far before and after point we should search in looking for a region separator. Larger values can mean slower performance in large files, although smaller values may cause unexpected behavior at times. (custom-declare-variable 'align-region-heuristic '500 '(#$ . 1613) :type 'integer :group 'align) #@54 The face to highlight with if changes are necessary. (custom-declare-variable 'align-highlight-change-face ''highlight '(#$ . 2153) :type 'face :group 'align) #@57 The face to highlight with if no changes are necessary. (custom-declare-variable 'align-highlight-nochange-face ''secondary-selection '(#$ . 2318) :type 'face :group 'align) #@124 If an integer, defines what constitutes a "large" region. If nil, then no messages will ever be printed to the minibuffer. (custom-declare-variable 'align-large-region '10000 '(#$ . 2499) :type 'integer :group 'align) #@47 A list of modes whose syntax resembles C/C++. (custom-declare-variable 'align-c++-modes ''(c++-mode c-mode java-mode) '(#$ . 2723) :type '(repeat symbol) :group 'align) #@50 A list of modes where Perl syntax is to be seen. (custom-declare-variable 'align-perl-modes ''(perl-mode cperl-mode) '(#$ . 2898) :type '(repeat symbol) :group 'align) #@46 A list of modes whose syntax resembles Lisp. (custom-declare-variable 'align-lisp-modes ''(emacs-lisp-mode lisp-interaction-mode lisp-mode scheme-mode) '(#$ . 3072) :type '(repeat symbol) :group 'align) #@58 A list of modes whose syntax resembles TeX (and family). (custom-declare-variable 'align-tex-modes ''(tex-mode plain-tex-mode latex-mode slitex-mode) '(#$ . 3281) :type '(repeat symbol) :group 'align) #@46 A list of modes whose content is plain text. (custom-declare-variable 'align-text-modes ''(text-mode outline-mode) '(#$ . 3488) :type '(repeat symbol) :group 'align) #@65 A list of modes where double quoted strings should be excluded. (custom-declare-variable 'align-dq-string-modes '(append align-lisp-modes align-c++-modes align-perl-modes '(python-mode)) '(#$ . 3660) :type '(repeat symbol) :group 'align) #@65 A list of modes where single quoted strings should be excluded. (custom-declare-variable 'align-sq-string-modes '(append align-perl-modes '(python-mode)) '(#$ . 3904) :type '(repeat symbol) :group 'align) #@171 A list of modes with a single-line comment syntax. These are comments as in Lisp, which have a beginning, but end with the line (i.e., `comment-end' is an empty string). (custom-declare-variable 'align-open-comment-modes '(append align-lisp-modes align-c++-modes align-perl-modes '(python-mode makefile-mode)) '(#$ . 4116) :type '(repeat symbol) :group 'align) #@3129 Select the method by which alignment sections will be separated. If this is a symbol, that symbol's value will be used. For the sake of clarification, consider the following example, which will be referred to in the descriptions below. int alpha = 1; /* one */ double beta = 2.0; long gamma; /* ten */ unsigned int delta = 1; /* one */ long double epsilon = 3.0; long long omega; /* ten */ The possible settings for `align-region-separate' are: `entire' The entire region being aligned will be considered as a single alignment section. Assuming that comments were not being aligned to a particular column, the example would become: int alpha = 1; /* one */ double beta = 2.0; long gamma; /* ten */ unsigned int delta = 1; /* one */ long double epsilon; long long chi = 10; /* ten */ `group' Each contiguous set of lines where a specific alignment occurs is considered a section for that alignment rule. Note that each rule may have any entirely different set of section divisions than another. int alpha = 1; /* one */ double beta = 2.0; long gamma; /* ten */ unsigned int delta = 1; /* one */ long double epsilon; long long chi = 10; /* ten */ `largest' When contiguous rule sets overlap, the largest section described will be taken as the alignment section for each rule touched by that section. int alpha = 1; /* one */ double beta = 2.0; long gamma; /* ten */ unsigned int delta = 1; /* one */ long double epsilon; long long chi = 10; /* ten */ NOTE: This option is not supported yet, due to algorithmic issues which haven't been satisfactorily resolved. There are ways to do it, but they're both ugly and resource consumptive. regexp A regular expression string which defines the section divider. If the mode you're in has a consistent divider between sections, the behavior will be very similar to `largest', and faster. But if the mode does not use clear separators (for example, if you collapse your braces onto the preceding statement in C or Perl), `largest' is probably the better alternative. function A function that will be passed the beginning and ending locations of the region in which to look for the section separator. At the very beginning of the attempt to align, both of these parameters will be nil, in which case the function should return non-nil if it wants each rule to define its own section, or nil if it wants the largest section found to be used as the common section for all rules that occur there. list A list of markers within the buffer that represent where the section dividers lie. Be certain to use markers! For when the aligning begins, the ensuing contract/expanding of whitespace will throw off any non-marker positions. This method is intended for use in Lisp programs, and not by the user. (custom-declare-variable 'align-region-separate '"^\\s-*[{}]?\\s-*$" '(#$ . 4485) :type '(choice (const :tag "Entire region is one section" entire) (const :tag "Align by contiguous groups" group) (regexp :tag "Regexp defines section boundaries") (function :tag "Function defines section boundaries")) :group 'align) (put 'align-region-separate 'risky-local-variable t) #@54 The `type' form for any `align-rules-list' variable. (defvar align-rules-list-type '(repeat (cons :tag "Alignment rule" (symbol :tag "Title") (cons :tag "Required attributes" (cons :tag "Regexp" (const :tag "(Regular expression to match)" regexp) (choice :value "\\(\\s-+\\)" regexp function)) (repeat :tag "Optional attributes" (choice (cons :tag "Repeat" (const :tag "(Repeat this rule throughout line)" repeat) (boolean :value t)) (cons :tag "Paren group" (const :tag "(Parenthesis group to use)" group) (choice :value 2 integer (repeat integer))) (cons :tag "Modes" (const :tag "(Modes where this rule applies)" modes) (sexp :value (text-mode))) (cons :tag "Case-fold" (const :tag "(Should case be ignored for this rule)" case-fold) (boolean :value t)) (cons :tag "To Tab Stop" (const :tag "(Should rule align to tab stops)" tab-stop) (boolean :value nil)) (cons :tag "Valid" (const :tag "(Return non-nil if rule is valid)" valid) (function :value t)) (cons :tag "Run If" (const :tag "(Return non-nil if rule should run)" run-if) (function :value t)) (cons :tag "Column" (const :tag "(Column to fix alignment at)" column) (choice :value comment-column integer symbol)) (cons :tag "Spacing" (const :tag "(Amount of spacing to use)" spacing) (integer :value 1)) (cons :tag "Justify" (const :tag "(Should text be right justified)" justify) (boolean :value t)) (cons :tag "Separate" (const :tag "(Separation to use for this rule)" separate) (choice :value "^\\s-*$" (const entire) (const group) regexp function))))))) (#$ . 7988)) #@6332 A list describing all of the available alignment rules. The format is: ((TITLE (ATTRIBUTE . VALUE) ...) ...) The following attributes are meaningful: `regexp' This required attribute must be either a string describing a regular expression, or a function (described below). For every line within the section that this regular expression matches, the given rule will be applied to that line. The exclusion rules denote which part(s) of the line should not be modified; the alignment rules cause the identified whitespace group to be contracted/expanded such that the "alignment character" (the character immediately following the identified parenthesis group), occurs in the same column for every line within the alignment section (see `align-region-separate' for a description of how the region is broken up into alignment sections). The `regexp' attribute describes how the text should be treated. Within this regexp, there must be at least one group of characters (typically whitespace) identified by the special opening and closing parens used in regexp expressions (`\\(' and `\\)') (see the Emacs manual on the syntax of regular expressions for more info). If `regexp' is a function, it will be called as a replacement for `re-search-forward'. This means that it should return nil if nothing is found to match the rule, or it should set the match data appropriately, move point to the end of the match, and return the value of point. `group' For exclusion rules, the group identifies the range of characters that should be ignored. For alignment rules, these are the characters that will be deleted/expanded for the purposes of alignment. The "alignment character" is always the first character immediately following this parenthesis group. This attribute may also be a list of integers, in which case multiple alignment characters will be aligned, with the list of integers identifying the whitespace groups which precede them. The default for this attribute is 1. `modes' The `modes' attribute, if set, should name a list of major modes -- or evaluate to such a value -- in which the rule is valid. If not set, the rule will apply to all modes. `case-fold' If `regexp' is an ordinary regular expression string containing alphabetic character, sometimes you may want the search to proceed case-insensitively (for languages that ignore case, such as Pascal for example). In that case, set `case-fold' to a non-nil value, and the regular expression search will ignore case. If `regexp' is set to a function, that function must handle the job of ignoring case by itself. `tab-stop' If the `tab-stop' attribute is set, and non-nil, the alignment character will always fall on a tab stop (whether it uses tabs to get there or not depends on the value of `indent-tabs-mode'). If the `tab-stop' attribute is set to nil, tab stops will never be used. Otherwise, the value of `align-to-tab-stop' determines whether or not to align to a tab stop. The `tab-stop' attribute may also be a list of t or nil values, corresponding to the number of parenthesis groups specified by the `group' attribute. `repeat' If the `repeat' attribute is present, and non-nil, the rule will be applied to the line continuously until no further matches are found. `valid' If the `valid' attribute is set, it will be used to determine whether the rule should be invoked. This form is evaluated after the regular expression match has been performed, so that it is possible to use the results of that match to determine whether the alignment should be performed. The buffer should not be modified during the evaluation of this form. `run-if' Like `valid', the `run-if' attribute tests whether the rule should be run at all -- even before any searches are done to determine if the rule applies to the alignment region. This can save time, since `run-if' will only be run once for each rule. If it returns nil, the rule will not be attempted. `column' For alignment rules, if the `column' attribute is set -- which must be an integer, or a symbol whose value is an integer -- it will be used as the column in which to align the alignment character. If the text on a particular line happens to overrun that column, a single space character, or tab stop (see `align-to-tab-stop') will be added between the last text character and the alignment character. `spacing' Alignment rules may also override the amount of spacing that would normally be used by providing a `spacing' attribute. This must be an integer, or a list of integers corresponding to the number of parenthesis groups matched by the `group' attribute. If a list of value is used, and any of those values is nil, `align-default-spacing' will be used for that subgroup. See `align-default-spacing' for more details on spacing, tab stops, and how to indicate how much spacing should be used. If TAB-STOP is present, it will override the value of `align-to-tab-stop' for that rule. `justify' It is possible with `regexp' and `group' to identify a character group that contains more than just whitespace characters. By default, any non-whitespace characters in that group will also be deleted while aligning the alignment character. However, if the `justify' attribute is set to a non-nil value, only the initial whitespace characters within that group will be deleted. This has the effect of right-justifying the characters that remain, and can be used for outdenting or just plain old right- justification. `separate' Each rule can define its own section separator, which describes how to identify the separation of "sections" within the region to be aligned. Setting the `separate' attribute overrides the value of `align-region-separate' (see the documentation of that variable for possible values), and any separation argument passed to `align'. (custom-declare-variable 'align-rules-list '`((lisp-second-arg (regexp . "\\(^\\s-+[^( \n]\\|(\\(\\S-+\\)\\s-+\\)\\S-+\\(\\s-+\\)") (group . 3) (modes . align-lisp-modes) (run-if \, #'(lambda nil current-prefix-arg))) (lisp-alist-dot (regexp . "\\(\\s-*\\)\\.\\(\\s-*\\)") (group 1 2) (modes . align-lisp-modes)) (open-comment (regexp \, #'(lambda (end reverse) (funcall (if reverse 're-search-backward 're-search-forward) (concat "[^ \n\\\\]" (regexp-quote comment-start) "\\(.+\\)$") end t))) (modes . align-open-comment-modes)) (c-macro-definition (regexp . "^\\s-*#\\s-*define\\s-+\\S-+\\(\\s-+\\)") (modes . align-c++-modes)) (c-variable-declaration (regexp \, (concat "[*&0-9A-Za-z_]>?[&*]*\\(\\s-+[*&]*\\)" "[A-Za-z_][0-9A-Za-z:_]*\\s-*\\(\\()\\|" "=[^=\n].*\\|(.*)\\|\\(\\[.*\\]\\)*\\)?" "\\s-*[;,]\\|)\\s-*$\\)")) (group . 1) (modes . align-c++-modes) (justify . t) (valid \, #'(lambda nil (not (or (save-excursion (goto-char (match-beginning 1)) (backward-word 1) (looking-at "\\(goto\\|return\\|new\\|delete\\|throw\\)")) (if (and (boundp 'font-lock-mode) font-lock-mode) (eq (get-text-property (point) 'face) 'font-lock-comment-face) (eq (caar (c-guess-basic-syntax)) 'c))))))) (c-assignment (regexp \, (concat "[^-=!^&*+<>/| \n]\\(\\s-*[-=!^&*+<>/|]*\\)" "=\\(\\s-*\\)\\([^= \n]\\|$\\)")) (group 1 2) (modes . align-c++-modes) (justify . t) (tab-stop)) (perl-assignment (regexp \, (concat "[^=!^&*-+<>/| \n]\\(\\s-*\\)=[~>]?" "\\(\\s-*\\)\\([^>= \n]\\|$\\)")) (group 1 2) (modes . align-perl-modes) (tab-stop)) (python-assignment (regexp \, (concat "[^=!<> \n]\\(\\s-*\\)=" "\\(\\s-*\\)\\([^>= \n]\\|$\\)")) (group 1 2) (modes quote (python-mode)) (tab-stop)) (make-assignment (regexp . "^\\s-*\\w+\\(\\s-*\\):?=\\(\\s-*\\)\\([^ \n \\\\]\\|$\\)") (group 1 2) (modes quote (makefile-mode)) (tab-stop)) (c-comma-delimiter (regexp . ",\\(\\s-*\\)[^/ \n]") (repeat . t) (modes . align-c++-modes) (run-if \, #'(lambda nil current-prefix-arg))) (basic-comma-delimiter (regexp . ",\\(\\s-*\\)[^# \n]") (repeat . t) (modes append align-perl-modes '(python-mode)) (run-if \, #'(lambda nil current-prefix-arg))) (c++-comment (regexp . "\\(\\s-*\\)\\(//.*\\|/\\*.*\\*/\\s-*\\)$") (modes . align-c++-modes) (column . comment-column) (valid \, #'(lambda nil (save-excursion (goto-char (match-beginning 1)) (not (bolp)))))) (c-chain-logic (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\\\|\\\\)") (modes . align-c++-modes) (valid \, #'(lambda nil (save-excursion (goto-char (match-end 2)) (looking-at "\\s-*\\(/[*/]\\|$\\)"))))) (perl-chain-logic (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\\\|\\\\)") (modes . align-perl-modes) (valid \, #'(lambda nil (save-excursion (goto-char (match-end 2)) (looking-at "\\s-*\\(#\\|$\\)"))))) (python-chain-logic (regexp . "\\(\\s-*\\)\\(\\\\|\\\\)") (modes quote (python-mode)) (valid \, #'(lambda nil (save-excursion (goto-char (match-end 2)) (looking-at "\\s-*\\(#\\|$\\|\\\\\\)"))))) (c-macro-line-continuation (regexp . "\\(\\s-*\\)\\\\$") (modes . align-c++-modes) (column . c-backslash-column)) (basic-line-continuation (regexp . "\\(\\s-*\\)\\\\$") (modes quote (python-mode makefile-mode))) (tex-record-separator (regexp \, #'(lambda (end reverse) (align-match-tex-pattern "&" end reverse))) (group 1 2) (modes . align-tex-modes) (repeat . t)) (tex-tabbing-separator (regexp \, #'(lambda (end reverse) (align-match-tex-pattern "\\\\[=>]" end reverse))) (group 1 2) (modes . align-tex-modes) (repeat . t) (run-if \, #'(lambda nil (eq major-mode 'latex-mode)))) (tex-record-break (regexp . "\\(\\s-*\\)\\\\\\\\") (modes . align-tex-modes)) (text-column (regexp . "\\(^\\|\\S-\\)\\([ ]+\\)\\(\\S-\\|$\\)") (group . 2) (modes . align-text-modes) (repeat . t) (run-if \, #'(lambda nil (and current-prefix-arg (not (eq '- current-prefix-arg)))))) (text-dollar-figure (regexp . "\\$?\\(\\s-+[0-9]+\\)\\.") (modes . align-text-modes) (justify . t) (run-if \, #'(lambda nil (eq '- current-prefix-arg)))) (css-declaration (regexp . "^\\s-*\\w+:\\(\\s-*\\).*;") (group 1) (modes quote (css-mode html-mode)))) '(#$ . 9527) :type align-rules-list-type :group 'align) (put 'align-rules-list 'risky-local-variable t) #@62 The `type' form for any `align-exclude-rules-list' variable. (defvar align-exclude-rules-list-type '(repeat (cons :tag "Exclusion rule" (symbol :tag "Title") (cons :tag "Required attributes" (cons :tag "Regexp" (const :tag "(Regular expression to match)" regexp) (choice :value "\\(\\s-+\\)" regexp function)) (repeat :tag "Optional attributes" (choice (cons :tag "Repeat" (const :tag "(Repeat this rule throughout line)" repeat) (boolean :value t)) (cons :tag "Paren group" (const :tag "(Parenthesis group to use)" group) (choice :value 2 integer (repeat integer))) (cons :tag "Modes" (const :tag "(Modes where this rule applies)" modes) (sexp :value (text-mode))) (cons :tag "Case-fold" (const :tag "(Should case be ignored for this rule)" case-fold) (boolean :value t))))))) (#$ . 20045)) #@124 A list describing text that should be excluded from alignment. See the documentation for `align-rules-list' for more info. (custom-declare-variable 'align-exclude-rules-list '`((exc-dq-string (regexp . "\"\\([^\"\n]+\\)\"") (repeat . t) (modes . align-dq-string-modes)) (exc-sq-string (regexp . "'\\([^'\n]+\\)'") (repeat . t) (modes . align-sq-string-modes)) (exc-open-comment (regexp \, #'(lambda (end reverse) (funcall (if reverse 're-search-backward 're-search-forward) (concat "[^ \n\\\\]" (regexp-quote comment-start) "\\(.+\\)$") end t))) (modes . align-open-comment-modes)) (exc-c-comment (regexp . "/\\*\\(.+\\)\\*/") (repeat . t) (modes . align-c++-modes)) (exc-c-func-params (regexp . "(\\([^)\n]+\\))") (repeat . t) (modes . align-c++-modes)) (exc-c-macro (regexp . "^\\s-*#\\s-*\\(if\\w*\\|endif\\)\\(.*\\)$") (group . 2) (modes . align-c++-modes))) '(#$ . 20844) :type align-exclude-rules-list-type :group 'align) (put 'align-exclude-rules-list 'risky-local-variable t) #@107 Alignment rules specific to the current major mode. See the variable `align-rules-list' for more details. (defvar align-mode-rules-list nil (#$ . 21836)) (make-variable-buffer-local 'align-mode-rules-list) #@125 Alignment exclusion rules specific to the current major mode. See the variable `align-exclude-rules-list' for more details. (defvar align-mode-exclude-rules-list nil (#$ . 22049)) (make-variable-buffer-local 'align-mode-exclude-rules-list) #@63 The current overlays highlighting the text matched by a rule. (defvar align-highlight-overlays nil (#$ . 22295)) #@73 Alignment rules for `vhdl-mode'. See `align-rules-list' for more info. (custom-declare-variable 'align-vhdl-rules-list '`((vhdl-declaration (regexp . "\\(signal\\|variable\\|constant\\)\\(\\s-+\\)\\S-") (group . 2)) (vhdl-case (regexp . "\\(others\\|[^ \n=<]\\)\\(\\s-*\\)=>\\(\\s-*\\)\\S-") (group 2 3) (valid \, #'(lambda nil (not (string= (downcase (match-string 1)) "others"))))) (vhdl-colon (regexp . "[^ \n:]\\(\\s-*\\):\\(\\s-*\\)[^=\n]") (group 1 2)) (direction (regexp . ":\\s-*\\(in\\|out\\|inout\\|buffer\\)\\(\\s-*\\)") (group . 2)) (sig-assign (regexp . "[^ \n=<]\\(\\s-*\\)<=\\(\\s-*\\)\\S-") (group 1 2)) (var-assign (regexp . "[^ \n:]\\(\\s-*\\):=")) (use-entity (regexp . "\\(\\s-+\\)use\\s-+entity"))) '(#$ . 22414) :type align-rules-list-type :group 'align) (put 'align-vhdl-rules-list 'risky-local-variable t) #@61 Setup the `align-mode-rules-list' variable for `vhdl-mode'. (defalias 'align-set-vhdl-rules #[nil "\211\207" [align-vhdl-rules-list align-mode-rules-list] 2 (#$ . 23255)]) (byte-code "\300\301\302\"\210\303\304\305\"\210\303\306\305\"\207" [add-hook vhdl-mode-hook align-set-vhdl-rules add-to-list align-dq-string-modes vhdl-mode align-open-comment-modes] 3) #@734 Attempt to align a region based on a set of alignment rules. BEG and END mark the region. If BEG and END are specifically set to nil (this can only be done programmatically), the beginning and end of the current alignment section will be calculated based on the location of point, and the value of `align-region-separate' (or possibly each rule's `separate' attribute). If SEPARATE is non-nil, it overrides the value of `align-region-separate' for all rules, except those that have their `separate' attribute set. RULES and EXCLUDE-RULES, if either is non-nil, will replace the default rule lists defined in `align-rules-list' and `align-exclude-rules-list'. See `align-rules-list' for more details on the format of these lists. (defalias 'align #[(beg end &optional separate rules exclude-rules) "\206 9\203\306 !\203 J\202 \206\307\310\n!\203'\n\311\211\"\203F\312 \f\n \2066\f\2066 \206B\206B%\202\210\f \312 \f\206[\206[\311\n\313&\210W\205\207\312\307 \206z\f\206z \206\206\206\206%*)\207" [separate align-region-separate separator beg end rules boundp entire functionp nil align-region #[(b e mode) "\205<\205 \n^ \f]\211\207" [mode sec-first b sec-last e] 2] align-mode-rules-list align-rules-list exclude-rules align-mode-exclude-rules-list align-exclude-rules-list sec-last sec-first] 7 (#$ . 23623) "r"]) #@1062 Align the current region using an ad-hoc rule read from the minibuffer. BEG and END mark the limits of the region. This function will prompt for the REGEXP to align with. If no prefix arg was specified, you only need to supply the characters to be lined up and any preceding whitespace is replaced. If a prefix arg was specified, the full regexp with parenthesized whitespace should be supplied; it will also prompt for which parenthesis GROUP within REGEXP to modify, the amount of SPACING to use, and whether or not to REPEAT the rule throughout the line. See `align-rules-list' for more information about these options. For example, let's say you had a list of phone numbers, and wanted to align them so that the opening parentheses would line up: Fred (123) 456-7890 Alice (123) 456-7890 Mary-Anne (123) 456-7890 Joe (123) 456-7890 There is no predefined rule to handle this, but you could easily do it using a REGEXP like "(". All you would have to do is to mark the region, call `align-regexp' and type in that regular expression. (defalias 'align-regexp #[(beg end regexp &optional group spacing repeat) "\204\306 \204\f\n\307\303 B\300\310!B\311W\203!\312\313B\202$\314\307B \311Y\2030\301 B\2025\315\310 !B\304\fB\257C\316\317 \307\211&)\207" [group spacing align-default-spacing regexp repeat rule 1 nil abs 0 justify t bogus column align-region entire beg end] 7 (#$ . 25019) (byte-code "\302\303 \304 D\203#\305\306\307\"\310\305\311\312\"!\310\305\313\314 !\"!\315\316!F\202,\307\305\317!P\320 \321F\"\207" [current-prefix-arg align-default-spacing append region-beginning region-end read-string "Complex align using regexp: " "\\(\\s-*\\)" string-to-number "Parenthesis group to modify (justify if negative): " "1" "Amount of spacing (or column if negative): " number-to-string y-or-n-p "Repeat throughout line? " "Align regexp: " 1 nil] 9)]) #@290 Align the selected region as if it were one alignment section. BEG and END mark the extent of the region. If RULES or EXCLUDE-RULES is set to a list of rules (see `align-rules-list'), it can be used to override the default alignment rules that would have been used to align that section. (defalias 'align-entire #[(beg end &optional rules exclude-rules) "\304 \305\n %\207" [beg end rules exclude-rules align entire] 6 (#$ . 26929) "r"]) #@349 Call `align' on the current alignment section. This function assumes you want to align only the current section, and so saves you from having to specify the region. If RULES or EXCLUDE-RULES is set to a list of rules (see `align-rules-list'), it can be used to override the default alignment rules that would have been used to align that section. (defalias 'align-current #[(&optional rules exclude-rules) "\302\303\211\211 %\207" [rules exclude-rules align nil] 6 (#$ . 27376) nil]) #@360 Highlight the whitespace which a given rule would have modified. BEG and END mark the extent of the region. TITLE identifies the rule that should be highlighted. If RULES or EXCLUDE-RULES is set to a list of rules (see `align-rules-list'), it can be used to override the default alignment rules that would have been used to identify the text to be colored. (defalias 'align-highlight-rule #[(beg end title &optional rules exclude-rules) "\306! \206\n\236\307\310 \210\311 \f\312 \2061\f\203*\2061 \2061\n\2021\2061\f?\205@\206@ \206@\n\313&*\207" [title align-mode-exclude-rules-list align-exclude-rules-list face ex-rule beg intern nil align-unhighlight-rule align-region entire #[(b e mode) "\203<\203\306@! \232\203\n B\211\207\307\211\207\f\205>\310 \n\"\211 \fB\f\311 \304\203:\f@\202<\fA#)\207" [mode title align-highlight-change-face align-highlight-nochange-face face b symbol-name nil make-overlay overlay-put e overlay align-highlight-overlays] 5] end rules exclude-rules align-mode-rules-list align-rules-list] 7 (#$ . 27869) (list (region-beginning) (region-end) (completing-read "Title of rule to highlight: " (mapcar #'(lambda (rule) (list (symbol-name (car rule)))) (append (or align-mode-rules-list align-rules-list) (or align-mode-exclude-rules-list align-exclude-rules-list))) nil t))]) #@67 Remove any highlighting that was added by `align-highlight-rule'. (defalias 'align-unhighlight-rule #[nil "\205\301@!\210A\211\204\302\207" [align-highlight-overlays delete-overlay nil] 3 (#$ . 29227) nil]) #@71 A replacement function for `newline-and-indent', aligning as it goes. (defalias 'align-newline-and-indent #[nil "9\203\303!\203J\202\206\304`\305\306!\210\212\307y\210o\2042\310` \n#\2042\307y\210\202 \311` \"+\207" [align-region-separate end separate boundp entire call-interactively newline-and-indent -1 align-new-section-p align] 4 (#$ . 29448) nil]) #@217 Match REGEXP in TeX mode, counting backslashes appropriately. END denotes the end of the region to be searched, while REVERSE, if non-nil, indicates that the search should proceed backward from the current position. (defalias 'align-match-tex-pattern #[(regexp end &optional reverse) "\306 \203\n\307\202 \310\311\n\311Q \312#\211\203L\313\225\314\211eV\2034 Sf\315=\2034\fT S\211\202\316\f\317\"*\313=\203L \203F\313\202G\317\224b\204)\207" [result reverse regexp end count pos nil re-search-backward re-search-forward "\\(\\s-*\\)" t 1 0 92 mod 2] 5 (#$ . 29827)]) #@175 Is there a section divider between BEG and END? SEPARATOR specifies how to look for the section divider. See the documentation for `align-region-separate' for more details. (defalias 'align-new-section-p #[(beg end separator) "\203\n\306=\203\f\307\207\310=\203'\311\212\nb\210n\203\312)\313 \n\" V)\207;\2037\212 b\210\314\n\315#)\207\316!\203B \n\"\207<\205n\307\211\203l @ Y\203e @\nX\203e\315\307\211\202L A\211\204O\f*\207" [separator amount end beg yes seps entire nil group 2 1 count-lines re-search-forward t functionp] 5 (#$ . 30420)]) #@153 Adjust COLUMN according to the given RULE. SPACING specifies how much spacing to use. TAB-STOP specifies whether SPACING refers to tab-stop boundaries. (defalias 'align-adjust-col-for-rule #[(column rule spacing tab-stop) "\204 \306X\203\n\207 \204\n\\\207\f\211\203< @\nV\2035S\211\306U\2035 @\307\211\202 A\211\204)\n\207" [spacing align-default-spacing column tab-stop tab-stop-list stops 0 nil] 3 (#$ . 31002)]) #@168 Given a position in the buffer, state what column it's in. POS is the position whose column will be taken. Note that this function will change the location of point. (defalias 'align-column #[(pos) "b\210i\207" [pos] 1 (#$ . 31448)]) (put 'align-column 'byte-optimizer 'byte-compile-inline-expand) #@303 Align the regions specified in REGIONS, a list of cons cells. PROPS describes formatting features specific to the given regions. RULE specifies exactly how to perform the alignments. If FUNC is specified, it will be called with each region that would have been aligned, rather than modifying the text. (defalias 'align-regions #[(regions props rule func) "\205\212\304@ @\n $\210)A A\202\207" [regions props rule func align-areas] 5 (#$ . 31755)]) (put 'align-regions 'byte-optimizer 'byte-compile-inline-expand) #@488 Given a list of AREAS and formatting PROPS, align according to RULE. AREAS should be a list of cons cells containing beginning and ending markers. This function sweeps through all of the beginning markers, finds out which one starts in the furthermost column, and then deletes and inserts text such that all of the ending markers occur in the same column. If FUNC is non-nil, it will be called for each text region that would have been aligned. No changes will be made to the buffer. (defalias 'align-areas #[(areas props rule func) "\301\236A\2119\203 J\202 \303\236A\n\206\306\306\307\211\307\211\203\302\n\204E\f\211@@)\211b\210i)]\204i\211@A)b\210\203fiU\204i\310\202ii \203\271\211@@)b\210\311\312\211@A)\310#\203\271`\211@A)U\204\271i@\313 \211@A)B\241\210\211@A)Ab\210 iZ])A\211\204/)\n\204\324\314\f@A$ \\\204\345\205\343\fU?\204\357\205\336\205\336@\f\307\211\203\323\203@A#\210\202\323 \203\"A:\204*Ab\210\202J\211AA)b\210i\211A@)b\210\fiZZ)i\306W\204\323U\204\323W\203o\315\310!\210j\210\202\323 \203\205A:\203\205\211A@)\202\210A\211b\210i)@\211b\210i)X\203\255@b\210\202\263\316\310\"\210`\316\310\"\210`|\210\203\322\314i@A$j\210++A\211\204\364\307.\207" [rule column fixed justify col width 0 nil t re-search-forward "\\s-*" point-marker align-adjust-col-for-rule delete-horizontal-space move-to-column ecol change look areas a x pos bcol props func cur gocol area abuts endcol here] 6 (#$ . 32284)]) #@1680 Align a region based on a given set of alignment rules. BEG and END specify the region to be aligned. Either may be nil, in which case the range will stop at the nearest section division (see `align-region-separate', and `align-region-heuristic' for more information'). The region will be divided into separate alignment sections based on the value of SEPARATE. RULES and EXCLUDE-RULES are a pair of lists describing how to align the region, and which text areas within it should be excluded from alignment. See the `align-rules-list' for more information on the required format of these two lists. If FUNC is specified, no text will be modified. What `align-region' will do with the rules is to search for the alignment areas, as it regularly would, taking account for exclusions, and then call FUNC, first with the beginning and ending of the region to be aligned according to that rule (this can be different for each rule, if BEG and END were nil), and then with the beginning and ending of each text region that the rule would have applied to. The signature of FUNC should thus be: (defun my-align-function (beg end mode) "If MODE is a rule (a list), return t if BEG to END are to be searched. Otherwise BEG to END will be a region of text that matches the rule's definition, and MODE will be non-nil if any changes are necessary." (unless (and mode (listp mode)) (message "Would have aligned from %d to %d..." beg end))) This feature (of passing a FUNC) is used internally to locate the position of exclusion areas, but could also be used for any other purpose where you might want to know where the regions that the aligner would have dealt with are. (defalias 'align-region #[(beg end separate rules exclude-rules &optional func) "\205\306\307\" \n?\205 \205 \205 \205  Z Y\310\fG<=>?@A\203E?\203E@\203E\311?@\312#\210\f\203\351\f@B\313B\236 \314B\236\211\f\203hC\315\fA!>\203\335 \203t A \203\335DE\316B\236\317B\236A\320!\205\216F\321B\236\211G\203\240GA\202\242H\312I\322J\312\211K1\312\211L2\312\211M3\312\211N5\312\211O6\312\211PQ\312\211RS\312\211TU\312\211VW\312\211XY\312Z\212?\203\365 b\210\202\327H\203H\323=\203\f\324\325\326\327B\236A!\"\210\330 \210m\204\331\332!\203\312y\210\202`\211[\\[\203i]\2053`]Z^F\203CF^\307\"\202J\333^\307#)\203i\334`[H#\203b[\312\211[\202'`\211[\204*[\204q b\210\330 \210`\\b\210`\211[\203\300]\205\212`]\\^F\203\232F^\312\"\202\241\335^\307#)\203\300\334[`H#\203\271[\312\211[\202~`\211[\204\201[\204\310b\210\312y\210`\306\307\"@ b\210*\n\203\344\n B#\203\333\336\216\312_`\203\337\340!\211_\312L\210\341 \323`\312\342\343\344\345\346\347_D\350\351_EEEE&\210\352_J\353\"_\203$AD`@W\203\246`\211K\203\246F\203@F@\312\"\202G\335@\307#\203\246=\203\211B@\211a\203xa9\203x\354\355\326a!< `?Z\356_@?Z\245%\210\202\210\354\357`?Z\356_@?Z\245\"\210)n\203\227`KV\203\227\360u\210L\204\300\361B\236A\206\245\310\2111<\203\2641@R\202\2751R1C1\307LM\204\317\362B\236A2\307MN\204\370\363B\236\211b\203\344bA\202\362c9\203\360cJ\202\362c)3\307N`JV\203 \312I\212\312\210\364 )JO\204\365B\236A5\307OP\204(\366B\2366\307PR\224V\367 X6\203=6A \203$U\203\214\334UVH#\203\214SZB\nBdSS\203{\212\370S@d@B\n$\210)SASdAd\202[,\306V\307\"U\312\211SZ\202\223\306V\307\"U\371X!\210_e\312Ye\203\3311@\224e\211f@A)W\203\320\3721!@\225e\211f@@)V\203\320\307Y\312\211e\202\241eA\211e\204\244)Y\204$1\211g\203\214\306g@\224\307\"V\306g@\225\307\"WI\203TT\202\322TVWB2<\2032@\20223<\203&3@\202(3BdhTS8\203GTS\233hTS8B\240\210\202iS\203^ShCC\244\210ZdC\244\210\202ihCCSdCZ*2<\203u2A23<\203\2003A3\307IgA\211g\204\347)5\204\231n\204\231\312y\210`KU\203$\312u\210\202$S\203\332SZB\nBdSS\203\331\212\370S@d@B\n$\210)SASdAd\202\271,*.+\fA