| Current Path : /usr/share/emacs/24.3/lisp/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : //usr/share/emacs/24.3/lisp/align.elc |
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:06:10 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/align.el
;;; in Emacs version 24.3.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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\303\304\305\306\307&\210\310\311\302\312\313\314\306\301&\210\310\315\302\316\313\317\306\301&\210\310\320\321\322\313\323\306\301&\210\310\324\325\326\313\327\306\301&\210\310\330\331\332\313\323\306\301&\210\310\333\334\335\313\336\306\301&\210\310\337\340\341\313\336\306\301&\210\310\342\343\344\313\323\306\301&\210\310\345\346\347\313\350\306\301&\210\310\351\352\353\313\354\306\301&\210\310\355\356\357\313\360\306\301&\210\310\361\362\363\313\364\306\301&\210\310\365\366\367\313\370\306\301&\210\310\371\372\373\313\374\306\301&\210\310\375\376\377\313\201@ \306\301&\210\310\201A \201B \201C \313\201D \306\301&\210\310\201E \201F \201G \313\201H \306\301&\210\201I \201E \201J \201K #\207" [custom-declare-group align nil "Align text to a specific column, by regexp." :version "21.1" :group fill custom-declare-variable align-load-hook "Hook that gets run after the aligner has been loaded." :type hook align-indent-before-aligning "If non-nil, indent the marked region before aligning it." boolean align-default-spacing 1 "An integer that represents the default amount of padding to use.\nIf `align-to-tab-stop' is non-nil, this will represent the number of\ntab stops to use for alignment, rather than the number of spaces.\nEach alignment rule can optionally override both this variable and\n`align-to-tab-stop'. See `align-rules-list'." integer align-to-tab-stop 'indent-tabs-mode "If non-nil, alignments will always fall on a tab boundary.\nIt may also be a symbol, whose value will be taken." (choice (const nil) symbol) align-region-heuristic 500 "If non-nil, used as a heuristic by `align-current'.\nSince each alignment rule can possibly have its own set of alignment\nsections (whenever `align-region-separate' is non-nil, and not a\nstring), this heuristic is used to determine how far before and after\npoint we should search in looking for a region separator. Larger\nvalues can mean slower performance in large files, although smaller\nvalues may cause unexpected behavior at times." align-highlight-change-face 'highlight "The face to highlight with if changes are necessary." face align-highlight-nochange-face 'secondary-selection "The face to highlight with if no changes are necessary." align-large-region 10000 "If an integer, defines what constitutes a \"large\" region.\nIf nil, then no messages will ever be printed to the minibuffer." align-c++-modes '(c++-mode c-mode java-mode) "A list of modes whose syntax resembles C/C++." (repeat symbol) align-perl-modes '(perl-mode cperl-mode) "A list of modes where Perl syntax is to be seen." (repeat symbol) align-lisp-modes '(emacs-lisp-mode lisp-interaction-mode lisp-mode scheme-mode) "A list of modes whose syntax resembles Lisp." (repeat symbol) align-tex-modes '(tex-mode plain-tex-mode latex-mode slitex-mode) "A list of modes whose syntax resembles TeX (and family)." (repeat symbol) align-text-modes '(text-mode outline-mode) "A list of modes whose content is plain text." (repeat symbol) align-dq-string-modes (append align-lisp-modes align-c++-modes align-perl-modes '(python-mode)) "A list of modes where double quoted strings should be excluded." (repeat symbol) align-sq-string-modes (append align-perl-modes '(python-mode)) "A list of modes where single quoted strings should be excluded." (repeat symbol) align-open-comment-modes (append align-lisp-modes align-c++-modes align-perl-modes '(python-mode makefile-mode)) "A list of modes with a single-line comment syntax.\nThese are comments as in Lisp, which have a beginning, but end with\nthe line (i.e., `comment-end' is an empty string)." (repeat symbol) align-region-separate "^\\s-*[{}]?\\s-*$" "Select the method by which alignment sections will be separated.\nIf this is a symbol, that symbol's value will be used.\n\nFor the sake of clarification, consider the following example, which\nwill be referred to in the descriptions below.\n\n int alpha = 1; /* one */\n double beta = 2.0;\n long gamma; /* ten */\n\n unsigned int delta = 1; /* one */\n long double epsilon = 3.0;\n long long omega; /* ten */\n\nThe possible settings for `align-region-separate' are:\n\n `entire' The entire region being aligned will be considered as a\n single alignment section. Assuming that comments were not\n being aligned to a particular column, the example would\n become:\n\n int alpha = 1; /* one */\n double beta = 2.0;\n long gamma; /* ten */\n\n unsigned int delta = 1; /* one */\n long double epsilon;\n long long chi = 10; /* ten */\n\n `group' Each contiguous set of lines where a specific alignment\n occurs is considered a section for that alignment rule.\n Note that each rule may have any entirely different set\n of section divisions than another.\n\n int alpha = 1; /* one */\n double beta = 2.0;\n long gamma; /* ten */\n\n unsigned int delta = 1; /* one */\n long double epsilon;\n long long chi = 10; /* ten */\n\n `largest' When contiguous rule sets overlap, the largest section\n described will be taken as the alignment section for each\n rule touched by that section.\n\n int alpha = 1; /* one */\n double beta = 2.0;\n long gamma; /* ten */\n\n unsigned int delta = 1; /* one */\n long double epsilon;\n long long chi = 10; /* ten */\n\n NOTE: This option is not supported yet, due to algorithmic\n issues which haven't been satisfactorily resolved. There\n are ways to do it, but they're both ugly and resource\n consumptive.\n\n regexp A regular expression string which defines the section\n divider. If the mode you're in has a consistent divider\n between sections, the behavior will be very similar to\n `largest', and faster. But if the mode does not use clear\n separators (for example, if you collapse your braces onto\n the preceding statement in C or Perl), `largest' is\n probably the better alternative.\n\n function A function that will be passed the beginning and ending\n locations of the region in which to look for the section\n separator. At the very beginning of the attempt to align,\n both of these parameters will be nil, in which case the\n function should return non-nil if it wants each rule to\n define its own section, or nil if it wants the largest\n section found to be used as the common section for all\n rules that occur there.\n\n list A list of markers within the buffer that represent where\n the section dividers lie. Be certain to use markers! For\n when the aligning begins, the ensuing contract/expanding of\n whitespace will throw off any non-marker positions.\n\n This method is intended for use in Lisp programs, and not\n by the user." (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")) put risky-local-variable t] 8)
#@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))))))) (#$ . 7694))
(byte-code "\301\302\303\304\305\306\307&\210\310\302\311\312#\207" [align-rules-list-type 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-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)") (modes . align-c++-modes) (valid \, #'(lambda nil (save-excursion (goto-char (match-end 2)) (looking-at "\\s-*\\(/[*/]\\|$\\)"))))) (perl-chain-logic (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)") (modes . align-perl-modes) (valid \, #'(lambda nil (save-excursion (goto-char (match-end 2)) (looking-at "\\s-*\\(#\\|$\\)"))))) (python-chain-logic (regexp . "\\(\\s-*\\)\\(\\<and\\>\\|\\<or\\>\\)") (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)))) "A list describing all of the available alignment rules.\nThe format is:\n\n ((TITLE\n (ATTRIBUTE . VALUE) ...)\n ...)\n\nThe following attributes are meaningful:\n\n`regexp' This required attribute must be either a string describing\n a regular expression, or a function (described below).\n For every line within the section that this regular\n expression matches, the given rule will be applied to that\n line. The exclusion rules denote which part(s) of the\n line should not be modified; the alignment rules cause the\n identified whitespace group to be contracted/expanded such\n that the \"alignment character\" (the character\n immediately following the identified parenthesis group),\n occurs in the same column for every line within the\n alignment section (see `align-region-separate' for a\n description of how the region is broken up into alignment\n sections).\n\n The `regexp' attribute describes how the text should be\n treated. Within this regexp, there must be at least one\n group of characters (typically whitespace) identified by\n the special opening and closing parens used in regexp\n expressions (`\\\\(' and `\\\\)') (see the Emacs manual on\n the syntax of regular expressions for more info).\n\n If `regexp' is a function, it will be called as a\n replacement for `re-search-forward'. This means that it\n should return nil if nothing is found to match the rule,\n or it should set the match data appropriately, move point\n to the end of the match, and return the value of point.\n\n`group' For exclusion rules, the group identifies the range of\n characters that should be ignored. For alignment rules,\n these are the characters that will be deleted/expanded for\n the purposes of alignment. The \"alignment character\" is\n always the first character immediately following this\n parenthesis group. This attribute may also be a list of\n integers, in which case multiple alignment characters will\n be aligned, with the list of integers identifying the\n whitespace groups which precede them. The default for\n this attribute is 1.\n\n`modes' The `modes' attribute, if set, should name a list of\n major modes -- or evaluate to such a value -- in which the\n rule is valid. If not set, the rule will apply to all\n modes.\n\n`case-fold' If `regexp' is an ordinary regular expression string\n containing alphabetic character, sometimes you may want\n the search to proceed case-insensitively (for languages\n that ignore case, such as Pascal for example). In that\n case, set `case-fold' to a non-nil value, and the regular\n expression search will ignore case. If `regexp' is set to\n a function, that function must handle the job of ignoring\n case by itself.\n\n`tab-stop' If the `tab-stop' attribute is set, and non-nil, the\n alignment character will always fall on a tab stop\n (whether it uses tabs to get there or not depends on the\n value of `indent-tabs-mode'). If the `tab-stop' attribute\n is set to nil, tab stops will never be used. Otherwise,\n the value of `align-to-tab-stop' determines whether or not\n to align to a tab stop. The `tab-stop' attribute may also\n be a list of t or nil values, corresponding to the number\n of parenthesis groups specified by the `group' attribute.\n\n`repeat' If the `repeat' attribute is present, and non-nil, the\n rule will be applied to the line continuously until no\n further matches are found.\n\n`valid' If the `valid' attribute is set, it will be used to\n determine whether the rule should be invoked. This form\n is evaluated after the regular expression match has been\n performed, so that it is possible to use the results of\n that match to determine whether the alignment should be\n performed. The buffer should not be modified during the\n evaluation of this form.\n\n`run-if' Like `valid', the `run-if' attribute tests whether the\n rule should be run at all -- even before any searches are\n done to determine if the rule applies to the alignment\n region. This can save time, since `run-if' will only be\n run once for each rule. If it returns nil, the rule will\n not be attempted.\n\n`column' For alignment rules, if the `column' attribute is set --\n which must be an integer, or a symbol whose value is an\n integer -- it will be used as the column in which to align\n the alignment character. If the text on a particular line\n happens to overrun that column, a single space character,\n or tab stop (see `align-to-tab-stop') will be added\n between the last text character and the alignment\n character.\n\n`spacing' Alignment rules may also override the amount of spacing\n that would normally be used by providing a `spacing'\n attribute. This must be an integer, or a list of integers\n corresponding to the number of parenthesis groups matched\n by the `group' attribute. If a list of value is used, and\n any of those values is nil, `align-default-spacing' will\n be used for that subgroup. See `align-default-spacing'\n for more details on spacing, tab stops, and how to\n indicate how much spacing should be used. If TAB-STOP is\n present, it will override the value of `align-to-tab-stop'\n for that rule.\n\n`justify' It is possible with `regexp' and `group' to identify a\n character group that contains more than just whitespace\n characters. By default, any non-whitespace characters in\n that group will also be deleted while aligning the\n alignment character. However, if the `justify' attribute\n is set to a non-nil value, only the initial whitespace\n characters within that group will be deleted. This has\n the effect of right-justifying the characters that remain,\n and can be used for outdenting or just plain old right-\n justification.\n\n`separate' Each rule can define its own section separator, which\n describes how to identify the separation of \"sections\"\n within the region to be aligned. Setting the `separate'\n attribute overrides the value of `align-region-separate'\n (see the documentation of that variable for possible\n values), and any separation argument passed to `align'." :type :group align put risky-local-variable t] 8)
#@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))))))) (#$ . 19918))
(byte-code "\301\302\303\304\305\306\307&\210\310\302\311\312#\207" [align-exclude-rules-list-type 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))) "A list describing text that should be excluded from alignment.\nSee the documentation for `align-rules-list' for more info." :type :group align put risky-local-variable t] 8)
#@107 Alignment rules specific to the current major mode.
See the variable `align-rules-list' for more details.
(defvar align-mode-rules-list nil (#$ . 21732))
(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 (#$ . 21945))
(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 (#$ . 22191))
(byte-code "\301\302\303\304\305\306\307&\210\310\302\311\312#\207" [align-rules-list-type 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"))) "Alignment rules for `vhdl-mode'. See `align-rules-list' for more info." :type :group align put risky-local-variable t] 8)
#@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 (#$ . 23177)])
(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 (#$ . 23545) "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 (#$ . 24941) (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 (#$ . 26851) "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 (#$ . 27298) 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 (#$ . 27791) (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 (#$ . 29149) nil])
#@71 A replacement function for `newline-and-indent', aligning as it goes.
(defalias 'align-newline-and-indent #[nil "9\203 \303!\203 J\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 (#$ . 29370) 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 \211 eV\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 (#$ . 29749)])
#@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 (#$ . 30342)])
#@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\2035 S\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 (#$ . 30924)])
#@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 (#$ . 31371)])
(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 (#$ . 31678)])
(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 \211 \203\277 \n\204B \f\211 @@)\211 b\210i)]\204f \211 @A)b\210\203c iU\204f \310\202f i \203\266 \211 @@)b\210\311\312\211 @A)\310#\203\266 `\211 @A)U\204\266 i @\313 \211 @A)B\241\210\211 @A)Ab\210
iZ])A\211\204, )\n\204\321 \314\f@A$
\\\204\342 \205\340 \fU?\204\354 \205\337\205\337@\f\307 \211 \203\324\203\315@!\315A!#\210\202\324 \203#A:\204+Ab\210\202K\211 AA)b\210i \211 A@)b\210\fiZZ)i\306W\204\324U\204\324W\203p\316\310!\210j\210\202\324 \203\206A:\203\206\211 A@)\202\211A\211 b\210i)@\211 b\210i)X \203\256@b\210\202\264\317\310\"\210` \317 \310\"\210 `|\210 \203\323\314i@A$j\210++A\211\204\361 \307.\207" [rule column fixed justify col width 0 nil t re-search-forward "\\s-*" point-marker align-adjust-col-for-rule marker-position delete-horizontal-space move-to-column ecol change areas a x pos bcol props func cur gocol area abuts endcol here] 6 (#$ . 32207)])
#@117 If MARKER-VAR is a marker, move it to position POS.
Otherwise, create a new marker at position POS, with type TYPE.
(defalias 'align--set-marker '(macro . #[(marker-var pos &optional type) "\303\304D\305 E\306\307 \nEEF\207" [marker-var pos type if markerp move-marker setq copy-marker] 8 (#$ . 33870)]))
#@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\311 = > ? @ AB\203E @\203E A\203E \312@A\311#\210\f\203\f@ C\313C\236 \314C\236\211 \f\203h D\315\fA!>\203 \203t A \203E F\316C\236 \317C\236A \320!\205\216 G\321C\236\211 H\203\240 HA\202\242 I\311 J\322 K\311\211 L M\311\211 N 3\311\211 O 4\311\211 P 6\311\211 Q 7\311\211 R S\311\211 T U\311\211 V W\311\211 X Y\212@\203\354 b\210\202\336I\203\370 I\323=\203\324\325\326\327C\236A!\"\210\330 \210m\204\331\332!\203\311y\210\202`\211 Z [Z\203`\\\205*`\\Z ]G\203:G]\307\"\202A\333]\307#)\203`\334`ZI#\203YZ\311\211Z\202 `\211Z\204!Z\204h b\210\330 \210`[b\210`\211Z\203\267\\\205\201`\\\\ ]G\203\221G]\311\"\202\230\335]\307#)\203\267\334Z`I#\203\260Z\311\211Z\202u`\211Z\204xZ\204\277b\210\311y\210`\336A!\203\324A\311\223\210\202\332\306\307\"A b\210*\n\203\353\n C#\203\337\216\311\211 ^ _`\203$\340\341!\211^\311L\210\342 \323`\311\343\344\345\346\347\350^D\351\352^EEEE&\210\353^J\354\"^\203.AE`AW\203\315`\211L\203\315G\203JGA\311\"\202Q\335A\307#\203\315?\203\224C@\211 a\203\203a9\203\203\355\356\326a!>=`@Z\357_A@Z\245%\210\202\223\355\360`@Z\357_A@Z\245\"\210)n\203\242`LV\203\242\361u\210N\204\301\362C\236A\206\260\310\211M<\204\274MCMM@SO\204\320\363C\236A3\307OP\204\371\364C\236\211 b\203\345bA\202\363c9\203\361cJ\202\363c)4\307P`KV\203\311J\336K!\203K\365 \311\223\210\202\306\365 \311\"KQ\204*\366C\236A6\307QR\2048\367C\2367\307RS\224_\370 W7\203M7A \203.V\203\223\334V_I#\203\223TYC\n C d TT\205\213\212\371T@d@C\n$\210)TATdAd\202k,\210\311\211TY\336V!\203\244V_\311\223\210\202\253\306_\307\"V\372W!\210^ e\311Xe\203\361M@\224e\211 f@A)W\203\350\373M!@\225e\211 f@@)V\203\350\307X\311\211e\202\271eA\211e\204\274)X\204.M\311 g\211 h\203\263h@g\306g\224\307\" i\306g\225\307\" jijB k3<\203*3@\202,34<\20384@\202:4B di
Bj
BJ\203RUT\202S\322\211UT8\203nUT\233kUT8B\240\210\202\220T\203\205TkCC\244\210YdC\244\210\202\220kCCTdCY,3<\203\2343A34<\203\2474A4\307JhA\211h\204*6\204\300n\204\300\311y\210`LU\203.\311u\210\202.T\203TYC\n C d TT\205 \212\371T@d@C\n$\210)TATdAd\202\340,\210+.+\fA>T>\202E A\311\211\223\210
\311 l\211 h\2034h@\211l\311\211\223\210hA\211h\204!*?\205=\355\374!.\207" [end beg func align-large-region rules markers copy-marker t 1 nil indent-region run-if modes eval case-fold regexp functionp separate 0 entire error "Cannot determine alignment region for '%s'" symbol-name title beginning-of-line looking-at "^\\s-*$" re-search-backward align-new-section-p re-search-forward markerp ((byte-code "\302\207" [current-case-fold case-fold-search nil] 1)) make-symbol "align-exclude-areas" align-region lambda (b e mode) or (and mode (listp mode)) set quote cons (cons b e) sort #[(l r) "@ @Y\207" [l r] 2] message "Aligning `%s' (rule %d of %d) %d%%..." 100 "Aligning %d%%..." -1 group spacing tab-stop line-end-position repeat valid match-data align-areas set-match-data last "Aligning...done" rule-count rule-index report real-beg end-mark align-indent-before-aligning rule major-mode case-fold-search current-case-fold regfunc rulesep thissep same eol search-start groups group-c spacing-c tab-stop-c repeat-c valid-c first regions index last-point save-match-data exclude-p align-props here start align-region-heuristic terminus exclude-areas rule-beg exclude-rules symbol rule-ts align-to-tab-stop props excls x g --dolist-tail-- group-beg group-end region m] 16 (#$ . 34186)])
(byte-code "\300\301!\210\302\303!\207" [provide align run-hooks align-load-hook] 2)