Current File : //usr/local/share/emacs/27.2/lisp/align.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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\312\313\314DD\315\316\317\306\301&\210\310\320\312\313\321DD\322\316\323\306\301&\210\310\324\312\313\325DD\326\316\327\306\301&\210\310\330\312\313\331DD\332\316\333\306\301&\210\310\334\312\313\335DD\336\316\327\306\301&\210\310\337\312\313\340DD\341\316\342\306\301&\210\310\343\312\313\344DD\345\316\342\306\301&\210\310\346\312\313\347DD\350\316\327\306\301&\210\310\351\312\313\352DD\353\316\354\306\301&\210\310\355\312\313\356DD\357\316\360\306\301&\210\310\361\312\313\362DD\363\316\364\306\301&\210\310\365\312\313\366DD\367\316\370\306\301&\210\310\371\312\313\372DD\373\316\374\306\301&\210\310\375\312\313\376DD\377\316\201@ \306\301&\210\310\201A \312\313\201B DD\201C \316\201D \306\301&\210\310\201E \312\313\201F DD\201G \316\201H \306\301&\210\310\201I \312\313\201J DD\201K \316\201L \306\301&\210\201M \201I \201N \201O #\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 funcall function #[0 "\300\207" [nil] 1] "Hook that gets run after the aligner has been loaded." :type hook align-indent-before-aligning #[0 "\300\207" [nil] 1] "If non-nil, indent the marked region before aligning it." boolean align-default-spacing #[0 "\300\207" [1] 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 #[0 "\300\207" [indent-tabs-mode] 1] "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 #[0 "\300\207" [500] 1] "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 #[0 "\300\207" [highlight] 1] "The face to highlight with if changes are necessary." face align-highlight-nochange-face #[0 "\300\207" [secondary-selection] 1] "The face to highlight with if no changes are necessary." align-large-region #[0 "\300\207" [10000] 1] "If an integer, defines what constitutes a \"large\" region.\nIf nil, then no messages will ever be printed to the minibuffer." align-c++-modes #[0 "\300\207" [(c++-mode c-mode java-mode)] 1] "A list of modes whose syntax resembles C/C++." (repeat symbol) align-perl-modes #[0 "\300\207" [(perl-mode cperl-mode)] 1] "A list of modes where Perl syntax is to be seen." (repeat symbol) align-lisp-modes #[0 "\300\207" [(emacs-lisp-mode lisp-interaction-mode lisp-mode scheme-mode)] 1] "A list of modes whose syntax resembles Lisp." (repeat symbol) align-tex-modes #[0 "\300\207" [(tex-mode plain-tex-mode latex-mode slitex-mode)] 1] "A list of modes whose syntax resembles TeX (and family)." (repeat symbol) align-text-modes #[0 "\300\207" [(text-mode outline-mode)] 1] "A list of modes whose content is plain text." (repeat symbol) align-dq-string-modes #[0 "\303 \n\304$\207" [align-lisp-modes align-c++-modes align-perl-modes append (python-mode vhdl-mode)] 5] "A list of modes where double quoted strings should be excluded." (repeat symbol) align-sq-string-modes #[0 "\301\302\"\207" [align-perl-modes append (python-mode)] 3] "A list of modes where single quoted strings should be excluded." (repeat symbol) align-open-comment-modes #[0 "\303 \n\304$\207" [align-lisp-modes align-c++-modes align-perl-modes append (python-mode makefile-mode vhdl-mode)] 5] "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 #[0 "\300\207" [#1="^\\s-*[{}]?\\s-*$"] 1 #1#] "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 from 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))))))) (#$ . 8132))
(byte-code "\301\302\303\304\305DD\306\307\310\311&\210\312\302\313\314#\207" [align-rules-list-type custom-declare-variable align-rules-list funcall function #[0 "\300\301\302\303\304\305B\257\306\307\310\311B\312BB\313\314\310\315B\316\317\320\321\322B\257\323\310\324B\325BB\326\310\327B\330BB\331\310\332B\333BB\334\335\336\337\340\304\341B\257\342\343\344\345\304\346B\257\347\350\351\352\321\353B\257\354\355\356\321\357BF\360\361\362\321\363BF\364\365\366\321\367BF\370\371\372\310\373B\374BB\375\310\376B\377\201@ \201A \304\201B B\257\201C \201D \201E \201F \201G \201H \304\201I B\257\201J \201K \201L \201M \304\201N B\257\201O BBBBBBBBBBBBBBBBBBBBBB\207" [lisp-second-arg (regexp . "\\(^\\s-+[^( \n]\\|(\\(\\S-+\\)\\s-+\\)\\S-+\\(\\s-+\\)") (group . 3) (modes . align-lisp-modes) run-if #[0 "\207" [current-prefix-arg] 1] (lisp-alist-dot (regexp . "\\(\\s-*\\)\\.\\(\\s-*\\)") (group 1 2) (modes . align-lisp-modes)) open-comment regexp #[514 "\211\203 \301\202 \302\303\304!\305Q\306#\207" [comment-start re-search-backward re-search-forward "[^ \n\\]" regexp-quote "\\(.+\\)$" t] 6 "\n\n(fn END REVERSE)"] ((modes . align-open-comment-modes)) (c-macro-definition (regexp . "^\\s-*#\\s-*define\\s-+\\S-+\\(\\s-+\\)") (modes . align-c++-modes)) c-variable-declaration "[*&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 #[0 "\212\301\224b\210\302v\210\303\304!)\206( \305\300!\203\" \203\" \306`\307\"\310=\202( \311 @@\312=?\207" [font-lock-mode 1 -1 looking-at "\\(goto\\|return\\|new\\|delete\\|throw\\)" boundp get-text-property face font-lock-comment-face c-guess-basic-syntax c] 3] c-assignment "[^-=!^&*+<>/| \n]\\(\\s-*[-=!^&*+<>/|]*\\)=\\(\\s-*\\)\\([^= \n]\\|$\\)" ((group 1 2) (modes . align-c++-modes) (justify . t) (tab-stop)) perl-assignment "[^=!^&*+<>/| \n-]\\(\\s-*\\)=[~>]?\\(\\s-*\\)\\([^>= \n]\\|$\\)" ((group 1 2) (modes . align-perl-modes) (tab-stop)) python-assignment "[^=!<> \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) #[0 "\207" [current-prefix-arg] 1] basic-comma-delimiter (regexp . ",\\(\\s-*\\)[^# \n]") (repeat . t) (modes append align-perl-modes '(python-mode)) #[0 "\207" [current-prefix-arg] 1] c++-comment (regexp . "\\(\\s-*\\)\\(//.*\\|/\\*.*\\*/\\s-*\\)$") (modes . align-c++-modes) (column . comment-column) #[0 "\212\300\224b\210n)?\207" [1] 1] c-chain-logic (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)") (modes . align-c++-modes) #[0 "\212\300\225b\210\301\302!)\207" [2 looking-at "\\s-*\\(/[*/]\\|$\\)"] 2] perl-chain-logic (regexp . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)") (modes . align-perl-modes) #[0 "\212\300\225b\210\301\302!)\207" [2 looking-at "\\s-*\\(#\\|$\\)"] 2] python-chain-logic (regexp . "\\(\\s-*\\)\\(\\<and\\>\\|\\<or\\>\\)") (modes quote (python-mode)) #[0 "\212\300\225b\210\301\302!)\207" [2 looking-at "\\s-*\\(#\\|$\\|\\\\\\)"] 2] (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 #[514 "\300\301#\207" [align-match-tex-pattern "&"] 6 "\n\n(fn END REVERSE)"] ((group 1 2) (modes . align-tex-modes) (repeat . t)) tex-tabbing-separator #[514 "\300\301#\207" [align-match-tex-pattern "\\\\[=>]"] 6 "\n\n(fn END REVERSE)"] (group 1 2) (modes . align-tex-modes) (repeat . t) #[0 "\301=\207" [major-mode latex-mode] 2] (tex-record-break (regexp . "\\(\\s-*\\)\\\\\\\\") (modes . align-tex-modes)) text-column (regexp . "\\(^\\|\\S-\\)\\([ ]+\\)\\(\\S-\\|$\\)") (group . 2) (modes . align-text-modes) (repeat . t) #[0 "\205 \301=?\207" [current-prefix-arg -] 2] text-dollar-figure (regexp . "\\$?\\(\\s-+[0-9]+\\)\\.") (modes . align-text-modes) (justify . t) #[0 "\301=\207" [current-prefix-arg -] 2] ((css-declaration (regexp . "^\\s-*\\(?:\\w-?\\)+:\\(\\s-*\\).*;") (group 1) (modes quote (css-mode html-mode))))] 27] "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))))))) (#$ . 20557))
(byte-code "\301\302\303\304\305DD\306\307\310\311&\210\312\302\313\314#\207" [align-exclude-rules-list-type custom-declare-variable align-exclude-rules-list funcall function #[0 "\300\301\302\303\304B\305BB\306BBB\207" [(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 #[514 "\211\203 \301\202 \302\303\304!\305Q\306#\207" [comment-start re-search-backward re-search-forward "[^ \n\\]" regexp-quote "\\(.+\\)$" t] 6 "\n\n(fn END REVERSE)"] ((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)))] 5] "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 (#$ . 22461))
(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 (#$ . 22674))
(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 (#$ . 22920))
#@65 Input history for the full user-entered regex in `align-regexp'
(defvar align-regexp-history nil (#$ . 23039))
(byte-code "\301\302\303\304\305DD\306\307\310\311&\210\312\302\313\314#\210\315\302\316\317#\207" [align-rules-list-type custom-declare-variable align-vhdl-rules-list funcall function #[0 "\300\301\302\303\304\305BF\306BB\207" [(vhdl-declaration (regexp . "\\(signal\\|variable\\|constant\\)\\(\\s-+\\)\\S-") (group . 2)) vhdl-case (regexp . "\\(others\\|[^ \n=<]\\)\\(\\s-*\\)=>\\(\\s-*\\)\\S-") (group 2 3) valid #[0 "\300\301!\227\302\230?\207" [match-string 1 "others"] 2] ((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")))] 6] "Alignment rules for `vhdl-mode'. See `align-rules-list' for more info." :type :group align put risky-local-variable t make-obsolete-variable "no longer used." "27.1"] 8)
#@61 Setup the `align-mode-rules-list' variable for `vhdl-mode'.
(defalias 'align-set-vhdl-rules #[0 "\211\207" [align-vhdl-rules-list align-mode-rules-list] 2 (#$ . 24153)])
(make-obsolete 'align-set-vhdl-rules nil "27.1")
#@787 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.
(fn BEG END &optional SEPARATE RULES EXCLUDE-RULES)
(defalias 'align #[1282 "\206 9\203 \305!\203 J\202 \206 \306\307!\203& \211\310\211\"\203D \311\2066 \2066 \n\206@ \206@ \f%\202\221 CC\311\310\206Z \206Z \f\312\313\314\315\316\f\f\"\317\"\320\321%&\210\242\242W\205\217 \311\242\242\306\206\204 \206\204 \n\206\216 \206\216 \f%\266\202\207" [align-region-separate align-mode-rules-list align-rules-list align-mode-exclude-rules-list align-exclude-rules-list boundp entire functionp nil align-region make-byte-code 771 "\211:\205 \300\211\242^\240\210\301\211\242]\240\207" vconcat vector [] 6 "\n\n(fn B E MODE)"] 21 (#$ . 24381) "r"])
#@1747 Align the current region using an ad-hoc rule read from the minibuffer.
BEG and END mark the limits of the region. Interactively, this function
prompts for the regular expression REGEXP to align with.
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 "(". Interactively, all you would have to do is
to mark the region, call `align-regexp' and enter that regular expression.
REGEXP must contain at least one parenthesized subexpression, typically
whitespace of the form "\\(\\s-*\\)". In normal interactive use,
this is automatically added to the start of your regular expression after
you enter it. You only need to supply the characters to be lined up, and
any preceding whitespace is replaced.
If you specify a prefix argument (or use this function non-interactively),
you must enter the full regular expression, including the subexpression.
The function also then prompts for which subexpression parenthesis GROUP
(default 1) within REGEXP to modify, the amount of SPACING (default
`align-default-spacing') to use, and whether or not to REPEAT the rule
throughout the line.
See `align-rules-list' for more information about these options.
The non-interactive form of the previous example would look something like:
(align-regexp (point-min) (point-max) "\\(\\s-*\\)(")
This function is a nothing more than a small wrapper that helps you
construct a rule to pass to `align-region', which does the real work.
(fn BEG END REGEXP &optional GROUP SPACING REPEAT)
(defalias 'align-regexp #[1539 "\204 \301\262\204 \262\302\303B\304\305!B\306W\203$ \307\310B\202' \311\302B\306Y\2034 \312B\202: \313\305!B\314B\257C\315\316\302\211&\207" [align-default-spacing 1 nil regexp group abs 0 justify t bogus spacing column repeat align-region entire] 14 (#$ . 25812) (byte-code "\302\303 \304 D\203$ \305\306\307\310#\311\305\312\313\"!\311\305\314\315 !\"!\316\317!F\202- \307\305\320!P\321 \322F\"\207" [current-prefix-arg align-default-spacing append region-beginning region-end read-string "Complex align using regexp: " "\\(\\s-*\\)" align-regexp-history 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)])
#@334 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.
(fn BEG END &optional RULES EXCLUDE-RULES)
(defalias 'align-entire #[1026 "\300\301%\207" [align entire] 10 (#$ . 28383) "r"])
#@385 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.
(fn &optional RULES EXCLUDE-RULES)
(defalias 'align-current #[512 "\300\301\211\211%\207" [align nil] 8 (#$ . 28811) nil])
#@410 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.
(fn BEG END TITLE &optional RULES EXCLUDE-RULES)
(defalias 'align-highlight-rule #[1283 "\304!\206 \236\305C\306 \210\307\310\206/ \203* \206/ \206/ \202/ \n\206/ ?\205? \206? \206? \311\312\313\314\315\f\"\316\"\317\320%&\207" [align-mode-exclude-rules-list align-exclude-rules-list align-mode-rules-list align-rules-list intern nil align-unhighlight-rule align-region entire make-byte-code 771 "\211\203 \211<\203 \305@!\300\232\203 \301\n B\240\207\301\306\240\207\301\242\205< \307\"\211\fB\310\311\2036 \301\242@\2029 \301\242A#\262\207" vconcat vector [align-highlight-change-face align-highlight-nochange-face align-highlight-overlays symbol-name nil make-overlay overlay-put face] 8 "\n\n(fn B E MODE)"] 20 (#$ . 29292) (byte-code "\304 \305 \306\307\310\311\312\206 \n\206 \"\"\313\314$E\207" [align-mode-rules-list align-rules-list align-mode-exclude-rules-list align-exclude-rules-list region-beginning region-end completing-read "Title of rule to highlight: " mapcar #[257 "\300@!C\207" [symbol-name] 3 "\n\n(fn RULE)"] append nil t] 9)])
#@67 Remove any highlighting that was added by `align-highlight-rule'.
(defalias 'align-unhighlight-rule #[0 "\205 \301@!\210A\211\204 \302\207" [align-highlight-overlays delete-overlay nil] 3 (#$ . 30751) nil])
#@145 A replacement function for `newline-and-indent', aligning as it goes.
The alignment is done by calling `align' on the region that was
indented.
(defalias 'align-newline-and-indent #[0 "9\203 \301!\203 J\202 \206 \302`\303\304!\210\212\305y\210o\2040 \306`#\2040 \305y\210\202 \307`\")\207" [align-region-separate boundp entire call-interactively newline-and-indent -1 align-new-section-p align] 6 (#$ . 30971) nil])
#@252 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.
(fn REGEXP END &optional REVERSE)
(defalias 'align-match-tex-pattern #[770 "\300\203 \301\202\n \302\303\303Q\304#\211\262\203P \305\225\306eV\2037 \206% `Sf\307=\2037 \211T\262S\262\202 \310\311\"\305=\266\202\203P \203J \305\202K \311\224b\204 \211\207" [nil re-search-backward re-search-forward "\\(\\s-*\\)" t 1 0 92 mod 2] 9 (#$ . 31406)])
#@199 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.
(fn BEG END SEPARATOR)
(defalias 'align-new-section-p #[771 "\211\203\n \211\300=\203\f \301\207\211\302=\203& \303\212b\210n\203 \304\262)\305\"V\207\211;\2036 \212b\210\306\307#)\207\310!\203A \211\"\207\211<\205l \211\301\203j @Y\203c @X\203c \307\262\301\262\202H A\262\202H \262\207" [entire nil group 2 1 count-lines re-search-forward t functionp] 7 (#$ . 31989)])
#@188 Adjust COLUMN according to the given RULE.
SPACING specifies how much spacing to use.
TAB-STOP specifies whether SPACING refers to tab-stop boundaries.
(fn COLUMN RULE SPACING TAB-STOP)
(defalias 'align-adjust-col-for-rule #[1028 "\204 \262\301X\203 \207\211\204 \\\207\301\211W\203. \211\302!\262\210\211T\262\202 \266\207" [align-default-spacing 0 indent-next-tab-stop] 9 (#$ . 32564)])
#@178 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.
(fn POS)
(defalias 'align-column #[257 "\211b\210i\207" [] 2 (#$ . 32980)])
(put 'align-column 'byte-optimizer 'byte-compile-inline-expand)
#@333 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.
(fn REGIONS PROPS RULE FUNC)
(defalias 'align-regions #[1028 "\205 \212\300@@$\210)A\262A\262\202 \207" [align-areas] 9 (#$ . 33295)])
(put 'align-regions 'byte-optimizer 'byte-compile-inline-expand)
#@516 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.
(fn AREAS PROPS RULE FUNC)
(defalias 'align-areas #[1028 "\300\236A\2119\203 \211J\202 \211\301\236A\206 \302\302\303\211\n\211\203\212 \2043 @@\211b\210i\262]\262\204O \211@Ab\210\203L iU\204O \304\262\202O i\262\203\203 \211@@b\210\305\306@A\304#\203\203 `@AU\204\203 i@\307 @AB\241\210@AAb\210iZ]\262\210\211A\262\202 \210\204\236 \310\n\f@
A$\\\262\211\204\254 \205\252 U?\262\204\265 \211\205\211\n\205\211\n@\303\203\n\203\352 \n\311@!\311\n\203\340 A:\203\340 A@\202\342 A!#\210\202\203\365 A:\204\374 Ab\210\202AAb\210iA@b\210iZZ\262\210i\262\302W\204\211U\204\211W\203/\312\304!\210j\210\202\203@A:\203@A@\202BA\211b\210i\262@\211b\210i\262X\211\203]@b\210\202b\313\304\"\210`\313\304\"\210\211`|\210\203}\310i@A$j\210\266\266\nA\262 \202\265 \207" [column justify 0 nil t re-search-forward "\\s-*" point-marker align-adjust-col-for-rule marker-position delete-horizontal-space move-to-column] 22 (#$ . 33816)])
#@153 If MARKER-VAR is a marker, move it to position POS.
Otherwise, create a new marker at position POS, with type TYPE.
(fn MARKER-VAR POS &optional TYPE)
(defalias 'align--set-marker '(macro . #[770 "\300\301D\302E\303\304EEF\207" [if markerp move-marker setq copy-marker] 11 (#$ . 35345)]))
#@1738 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.
(fn BEG END SEPARATE RULES EXCLUDE-RULES &optional FUNC)
(defalias 'align-region #[1541 "\205 \305\306\"?\205$ \205$ \205$ \205$ ZY\307G\310 \203< \203< \203< \311\310#\210\203j@\312\236\313\236\211\203X \314\315\316A!\"\203\\\203b A \203\\\n\317\236\320\236A\321!\205r \211\322\236\211\203 \211A\202\201 \310\323\310\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\212 \203\242 'b\210\202\203\203\256 \324=\203\271 \325\326\327\330 \236A!\"\210\331 \210m\204\314 \332\333!\203\314 \310y\210\202\274 `\211\203 \205\331 ` Z\203\346 \306\"\202\354 \334\306#\262\203 \335`#\203\262*\310\262\202\316 `\262\202\316 \204)b\210\331 \210`\262*\211b\210`\262\203X \205(` \\\2035\310\"\202;\336\306#\262\203X\335`#\203R\262)\310\262\202 `\262\202 \204`(b\210\310y\210`\262)\337$!\203w#)\310\223\210\202~\305)\306\"\262$)b\266\"\203\224\"(( #\203Y\310\211C%\203\276\340**\324)\310\341\342\343\344\345 !\346\"\347\350%&\210\211\351\242\352\"\237\240\210\203\307A`$W\203/`\211\262\203/\203\343$\310\"\202\352\336%\306#\203/!\203+ @\211\203\2119\203\353\354\327!$$\355`*Z\356_++Z\"%\210\202*\353\357\355`'Z\360_((Z\"\"\210\210n\2039`V\2039\361u\210\204Y\362 \236A\206G\307\262<\204TC\262@\262 \204h\363 \236A\262\306\262
\204\214\364 \236\211\203z\211A\202\205\f9\203\204\fJ\202\205\f\262\262\306\262`V\203\256\310\262\337!\203\247\365 \310\223\210\202\256\305\365 \310\"\262 \204\275\366 \236A\262
\306\262\f \204\313\367 \236\262 \306\262\n\224\262\370 \262\204\336\325\371\n\"\210\n\203\352\nA \203\307\203!\335#\203! '\205\212\372@@$\210)A\262A\262\202\377\266\310\262\310\262\337!\2030\310\223\210\2026\305\306\"\262\373!\210\211\242\310\262\211\203k@\224@AW\203d\374!@\225@@V\203d\306\262\310\262\202?\211A\262\202?\210\204\307\211\203\211@\305\224\306\"\305\225\306\"B<\203\221@\202\223<\203\237@\202\241B%B\262%%B\262%\203\271\fT\202\272\323\262
\f8\203\325\f\2338B\240\210\202\363
\203\352
CC\244\210C\244\210\202\363CC\262\211C\262 \266<\203 A\262<\203 A\262\306\262A\266\202\202r\210\f\204\"n\204\"\310y\210`U\203\307\310u\210\202\307\203W '\205U\212\372@@$\210)A\262A\262\202;\266\266*\266\266A\262 T\262\202< \203s\310\211\223\210\211\211\203\206\211@\211\310\211\223\210A\266\202\202t\210\205\216\353\375!\207" [align-large-region align-indent-before-aligning case-fold-search align-region-heuristic align-to-tab-stop copy-marker t 1 nil indent-region run-if modes apply derived-mode-p 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 align-region make-byte-code 771 "\211\203 \211<\206 \300B\300\242B\240\207" vconcat vector [] 6 "\n\n(fn B E MODE)" sort car-less-than-car message "Aligning `%s' (rule %d of %d) %d%%..." floor 100.0 "Aligning %d%%..." 100.0 -1 group spacing tab-stop line-end-position repeat valid match-data "No match for subexpression %s" align-areas set-match-data last "Aligning...done"] 54 (#$ . 35652)])
(byte-code "\300\301!\210\302\303!\207" [provide align run-hooks align-load-hook] 2)
Mini Shell