root/trunk/lisp/align.el

;;; align.el --- align text to a specific column, by regexp

;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004,
;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.

;; Author: John Wiegley <johnw@gnu.org> 
;; Maintainer: FSF
;; Keywords: convenience languages lisp

;; This file is part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; Commentary:

;; This mode allows you to align regions in a context-sensitive fashion.
;; The classic use is to align assignments:
;;
;;    int a = 1;
;;    short foo = 2;
;;    double blah = 4;
;;
;; becomes
;;
;;    int    a    = 1;
;;    short  foo  = 2;
;;    double blah = 4;

;;; Usage:

;; There are several variables which define how certain "categories"
;; of syntax are to be treated.  These variables go by the name
;; `align-CATEGORY-modes'.  For example, "c++" is such a category.
;; There are several rules which apply to c++, but since several other
;; languages have a syntax similar to c++ (e.g., c, java, etc), these
;; modes are treated as belonging to the same category.
;;
;; If you want to add a new mode under a certain category, just
;; customize that list, or add the new mode manually.  For example, to
;; make jde-mode a c++ category mode, use this code in your .emacs
;; file:
;;
;;    (setq align-c++-modes (cons 'jde-mode align-c++-modes))

;; In some programming modes, it's useful to have the aligner run only
;; after indentation is performed.  To achieve this, customize or set
;; the variable `align-indent-before-aligning' to t.

;;; Module Authors:

;; In order to incorporate align's functionality into your own
;; modules, there are only a few steps you have to follow.

;;  1. Require or load in the align.el library.
;;
;;  2. Define your alignment and exclusion rules lists, either
;;     customizable or not.
;;
;;  3. In your mode function, set the variables
;;     `align-mode-rules-list' and `align-mode-exclude-rules-list'
;;     to your own rules lists.

;; If there is any need to add your mode name to one of the
;; align-?-modes variables (for example, `align-dq-string-modes'), use
;; `add-to-list', or some similar function which checks first to see
;; if the value is already there.  Since the user may customize that
;; mode list, and then write your mode name into their .emacs file,
;; causing the symbol already to be present the next time they load
;; your package.

;; Example:
;;
;;   (require 'align)
;;
;;   (defcustom my-align-rules-list
;;     '((my-rule
;;        (regexp . "Sample")))
;;     :type align-rules-list-type
;;     :group 'my-package)
;;
;;   (put 'my-align-rules-list 'risky-local-variable t)
;;
;;   (add-to-list 'align-dq-string-modes 'my-package-mode)
;;   (add-to-list 'align-open-comment-modes 'my-package-mode)
;;
;;   (defun my-mode ()
;;      ...
;;      (setq align-mode-rules-list my-align-rules-list))
;;
;; Note that if you need to install your own exclusion rules, then you
;; will also need to reproduce any double-quoted string, or open
;; comment exclusion rules that are defined in the standard
;; `align-exclude-rules-list'.  At the moment there is no convenient
;; way to mix both mode-local and global rules lists.

;;; History:

;; Version 1.0 was created in the earlier part of 1996, using a very
;; simple algorithm that understand only basic regular expressions.
;; Parts of the code were broken up and included in vhdl-mode.el
;; around this time.  After several comments from users, and a need to
;; find a more robust, performant algorithm, 2.0 was born in late
;; 1998.  Many different approaches were taken (mostly due to the
;; complexity of TeX tables), but finally a scheme was discovered
;; which worked fairly well for most common usage cases.  Development
;; beyond version 2.8 is not planned, except for problems that users
;; might encounter.

;;; Code:

(defgroup align nil
  "Align text to a specific column, by regexp."
  :version "21.1"
  :group 'fill)

;;; User Variables:

(defcustom align-load-hook nil
  "*Hook that gets run after the aligner has been loaded."
  :type 'hook
  :group 'align)

(defcustom align-indent-before-aligning nil
  "*If non-nil, indent the marked region before aligning it."
  :type 'boolean
  :group 'align)

(defcustom align-default-spacing 1
  "*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.  See
`align-mode-alist'."
  :type 'integer
  :group 'align)

(defcustom align-to-tab-stop 'indent-tabs-mode
  "*If non-nil, alignments will always fall on a tab boundary.
It may also be a symbol, whose value will be taken."
  :type '(choice (const nil) symbol)
  :group 'align)

(defcustom align-region-heuristic 500
  "*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 perform in large files, although smaller values
may cause unexpected behavior at times."
  :type 'integer
  :group 'align)

(defcustom align-highlight-change-face 'highlight
  "*The face to highlight with if changes are necessary."
  :type 'face
  :group 'align)

(defcustom align-highlight-nochange-face 'secondary-selection
  "*The face to highlight with if no changes are necessary."
  :type 'face
  :group 'align)

(defcustom align-large-region 10000
  "*If an integer, defines what constitutes a \"large\" region.
If nil,then no messages will ever be printed to the minibuffer."
  :type 'integer
  :group 'align)

(defcustom align-c++-modes '(c++-mode c-mode java-mode)
  "*A list of modes whose syntax resembles C/C++."
  :type '(repeat symbol)
  :group 'align)

(defcustom align-perl-modes '(perl-mode cperl-mode)
  "*A list of modes where perl syntax is to be seen."
  :type '(repeat symbol)
  :group 'align)

(defcustom align-lisp-modes
  '(emacs-lisp-mode lisp-interaction-mode lisp-mode scheme-mode)
  "*A list of modes whose syntax resembles Lisp."
  :type '(repeat symbol)
  :group 'align)

(defcustom align-tex-modes
  '(tex-mode plain-tex-mode latex-mode slitex-mode)
  "*A list of modes whose syntax resembles TeX (and family)."
  :type '(repeat symbol)
  :group 'align)

(defcustom align-text-modes '(text-mode outline-mode)
  "*A list of modes whose content is plain text."
  :type '(repeat symbol)
  :group 'align)

(defcustom 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."
  :type '(repeat symbol)
  :group 'align)

(defcustom align-sq-string-modes
  (append align-perl-modes '(python-mode))
  "*A list of modes where single quoted strings should be excluded."
  :type '(repeat symbol)
  :group 'align)

(defcustom 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.
These are comments as in Lisp, which have a beginning but, end with
the line (i.e., `comment-end' is an empty string)."
  :type '(repeat symbol)
  :group 'align)

(defcustom align-region-separate "^\\s-*[{}]?\\s-*$"
  "*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 will 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."
  :type '(choice
          (const :tag "Entire region is one section" entire)
          (const :tag "Align by contiguous groups" group)
;         (const largest)
          (regexp :tag "Regexp defines section boundaries")
          (function :tag "Function defines section boundaries"))
  :group 'align)

(put 'align-region-separate 'risky-local-variable t)

(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))
             ;; make sure this stays up-to-date with any changes
             ;; in `align-region-separate'
             (cons :tag "Separate"
                   (const :tag "(Separation to use for this rule)"
                          separate)
                   (choice :value "^\\s-*$"
                           (const entire)
                           (const group)
;                          (const largest)
                           regexp function)))))))
  "The `type' form for any `align-rules-list' variable.")

(defcustom align-rules-list
  `((lisp-second-arg
     (regexp   . "\\(^\\s-+[^( \t\n]\\|(\\(\\S-+\\)\\s-+\\)\\S-+\\(\\s-+\\)")
     (group    . 3)
     (modes    . align-lisp-modes)
     (run-if   . ,(function (lambda () current-prefix-arg))))

    (lisp-alist-dot
     (regexp   . "\\(\\s-*\\)\\.\\(\\s-*\\)")
     (group    . (1 2))
     (modes    . align-lisp-modes))

    (open-comment
     (regexp   . ,(function
                   (lambda (end reverse)
                     (funcall (if reverse 're-search-backward
                                're-search-forward)
                              (concat "[^ \t\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
      . ,(function
          (lambda ()
            (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 "[^-=!^&*+<>/| \t\n]\\(\\s-*[-=!^&*+<>/|]*\\)"
                          "=\\(\\s-*\\)\\([^= \t\n]\\|$\\)"))
     (group    . (1 2))
     (modes    . align-c++-modes)
     (justify  . t)
     (tab-stop . nil))

    (perl-assignment
     (regexp   . ,(concat "[^=!^&*-+<>/| \t\n]\\(\\s-*\\)=[~>]?"
                          "\\(\\s-*\\)\\([^>= \t\n]\\|$\\)"))
     (group    . (1 2))
     (modes    . align-perl-modes)
     (tab-stop . nil))

    (python-assignment
     (regexp   . ,(concat "[^=!<> \t\n]\\(\\s-*\\)="
                          "\\(\\s-*\\)\\([^>= \t\n]\\|$\\)"))
     (group    . (1 2))
     (modes    . '(python-mode))
     (tab-stop . nil))

    (make-assignment
     (regexp   . "^\\s-*\\w+\\(\\s-*\\):?=\\(\\s-*\\)\\([^\t\n \\\\]\\|$\\)")
     (group    . (1 2))
     (modes    . '(makefile-mode))
     (tab-stop . nil))

    (c-comma-delimiter
     (regexp   . ",\\(\\s-*\\)[^/ \t\n]")
     (repeat   . t)
     (modes    . align-c++-modes)
     (run-if   . ,(function (lambda () current-prefix-arg))))
                                        ;      (valid
                                        ;       . ,(function
                                        ;         (lambda ()
                                        ;           (memq (caar (c-guess-basic-syntax))
                                        ;                 '(brace-list-intro
                                        ;                   brace-list-entry
                                        ;                   brace-entry-open))))))

    ;; With a prefix argument, comma delimiter will be aligned.  Since
    ;; perl-mode doesn't give us enough syntactic information (and we
    ;; don't do our own parsing yet), this rule is too destructive to
    ;; run normally.
    (basic-comma-delimiter
     (regexp   . ",\\(\\s-*\\)[^# \t\n]")
     (repeat   . t)
     (modes    . (append align-perl-modes '(python-mode)))
     (run-if   . ,(function (lambda () current-prefix-arg))))

    (c++-comment
     (regexp   . "\\(\\s-*\\)\\(//.*\\|/\\*.*\\*/\\s-*\\)$")
     (modes    . align-c++-modes)
     (column   . comment-column)
     (valid    . ,(function
                   (lambda ()
                     (save-excursion
                       (goto-char (match-beginning 1))
                       (not (bolp)))))))

    (c-chain-logic
     (regexp   . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)")
     (modes    . align-c++-modes)
     (valid    . ,(function
                   (lambda ()
                     (save-excursion
                       (goto-char (match-end 2))
                       (looking-at "\\s-*\\(/[*/]\\|$\\)"))))))

    (perl-chain-logic
     (regexp   . "\\(\\s-*\\)\\(&&\\|||\\|\\<and\\>\\|\\<or\\>\\)")
     (modes    . align-perl-modes)
     (valid    . ,(function
                   (lambda ()
                     (save-excursion
                       (goto-char (match-end 2))
                       (looking-at "\\s-*\\(#\\|$\\)"))))))

    (python-chain-logic
     (regexp   . "\\(\\s-*\\)\\(\\<and\\>\\|\\<or\\>\\)")
     (modes    . '(python-mode))
     (valid    . ,(function
                   (lambda ()
                     (save-excursion
                       (goto-char (match-end 2))
                       (looking-at "\\s-*\\(#\\|$\\|\\\\\\)"))))))

    (c-macro-line-continuation
     (regexp   . "\\(\\s-*\\)\\\\$")
     (modes    . align-c++-modes)
     (column   . c-backslash-column))
                                        ;      (valid
                                        ;       . ,(function
                                        ;         (lambda ()
                                        ;           (memq (caar (c-guess-basic-syntax))
                                        ;                 '(cpp-macro cpp-macro-cont))))))

    (basic-line-continuation
     (regexp   . "\\(\\s-*\\)\\\\$")
     (modes    . '(python-mode makefile-mode)))

    (tex-record-separator
     (regexp . ,(function
                 (lambda (end reverse)
                   (align-match-tex-pattern "&" end reverse))))
     (group    . (1 2))
     (modes    . align-tex-modes)
     (repeat   . t))

    (tex-tabbing-separator
     (regexp   . ,(function
                   (lambda (end reverse)
                     (align-match-tex-pattern "\\\\[=>]" end reverse))))
     (group    . (1 2))
     (modes    . align-tex-modes)
     (repeat   . t)
     (run-if   . ,(function
                   (lambda ()
                     (eq major-mode 'latex-mode)))))

    (tex-record-break
     (regexp   . "\\(\\s-*\\)\\\\\\\\")
     (modes    . align-tex-modes))

    ;; With a numeric prefix argument, or C-u, space delimited text
    ;; tables will be aligned.
    (text-column
     (regexp   . "\\(^\\|\\S-\\)\\([ \t]+\\)\\(\\S-\\|$\\)")
     (group    . 2)
     (modes    . align-text-modes)
     (repeat   . t)
     (run-if   . ,(function
                   (lambda ()
                     (and current-prefix-arg
                          (not (eq '- current-prefix-arg)))))))

    ;; With a negative prefix argument, lists of dollar figures will
    ;; be aligned.
    (text-dollar-figure
     (regexp   . "\\$?\\(\\s-+[0-9]+\\)\\.")
     (modes    . align-text-modes)
     (justify  . t)
     (run-if   . ,(function
                   (lambda ()
                     (eq '- current-prefix-arg)))))

    (css-declaration
     (regexp . "^\\s-*\\w+:\\(\\s-*\\).*;")
     (group . (1))
     (modes . '(css-mode html-mode))))
  "*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
            integer, in which case multiple alignment characters will
            be aligned, with the list of integer 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'."
  :type align-rules-list-type
  :group 'align)

(put 'align-rules-list 'risky-local-variable t)

(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)))))))
  "The `type' form for any `align-exclude-rules-list' variable.")

(defcustom 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
      . ,(function
          (lambda (end reverse)
            (funcall (