;;; 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.
+;; Copyright (C) 1999-2012 Free Software Foundation, Inc.
-;; Author: John Wiegley <johnw@gnu.org>
+;; Author: John Wiegley <johnw@gnu.org>
;; Maintainer: FSF
;; Keywords: convenience languages lisp
;; 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
+;; find a more robust, higher performing 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
;;; User Variables:
(defcustom align-load-hook nil
- "*Hook that gets run after the aligner has been loaded."
+ "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."
+ "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.
+ "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'."
+Each alignment rule can optionally override both this variable and
+`align-to-tab-stop'. See `align-rules-list'."
:type 'integer
:group 'align)
(defcustom align-to-tab-stop 'indent-tabs-mode
- "*If non-nil, alignments will always fall on a tab boundary.
+ "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'.
+ "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."
+values can mean slower performance 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."
+ "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."
+ "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."
+ "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++."
+ "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."
+ "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."
+ "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)."
+ "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."
+ "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."
+ "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."
+ "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
+ "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.
+ "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
`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.
+ Note that each rule may have any entirely different set
+ of section divisions than another.
int alpha = 1; /* one */
double beta = 2.0;
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
+ the preceding statement in C or Perl), `largest' is
probably the better alternative.
function A function that will be passed the beginning and ending
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.
+ 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
(regexp . "^\\s-*\\w+:\\(\\s-*\\).*;")
(group . (1))
(modes . '(css-mode html-mode))))
- "*A list describing all of the available alignment rules.
+ "A list describing all of the available alignment rules.
The format is:
((TITLE
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
+ integers, in which case multiple alignment characters will
+ be aligned, with the list of integers identifying the
whitespace groups which precede them. The default for
this attribute is 1.
`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
+ 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
(regexp . "^\\s-*#\\s-*\\(if\\w*\\|endif\\)\\(.*\\)$")
(group . 2)
(modes . align-c++-modes)))
- "*A list describing text that should be excluded from alignment.
+ "A list describing text that should be excluded from alignment.
See the documentation for `align-rules-list' for more info."
:type align-exclude-rules-list-type
:group 'align)
(use-entity
(regexp . "\\(\\s-+\\)use\\s-+entity")))
- "*Alignment rules for `vhdl-mode'. See `align-rules-list' for more info."
+ "Alignment rules for `vhdl-mode'. See `align-rules-list' for more info."
:type align-rules-list-type
:group 'align)
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
+using a REGEXP like \"(\". All you would have to do is to mark the
region, call `align-regexp' and type in that regular expression."
(interactive
(append
(list (concat "\\(\\s-*\\)"
(read-string "Align regexp: "))
1 align-default-spacing nil))))
+ (or group (setq group 1))
+ (or spacing (setq spacing align-default-spacing))
(let ((rule
(list (list nil (cons 'regexp regexp)
(cons 'group (abs group))
(setq seps (cdr seps))))
yes))))
-(defun align-adjust-col-for-rule (column rule spacing tab-stop)
+(defun align-adjust-col-for-rule (column _rule spacing tab-stop)
"Adjust COLUMN according to the given RULE.
SPACING specifies how much spacing to use.
TAB-STOP specifies whether SPACING refers to tab-stop boundaries."
(justify (cdr (assq 'justify rule)))
(col (or fixed 0))
(width 0)
- ecol change look)
+ ecol change)
;; Determine the alignment column.
(let ((a areas))
(car props) (cdr props)))))))))))
(setq areas (cdr areas))))))
+(defmacro align--set-marker (marker-var pos &optional type)
+ "If MARKER-VAR is a marker, move it to position POS.
+Otherwise, create a new marker at position POS, with type TYPE."
+ `(if (markerp ,marker-var)
+ (move-marker ,marker-var ,pos)
+ (setq ,marker-var (copy-marker ,pos ,type))))
+
(defun align-region (beg end separate rules exclude-rules
&optional func)
"Align a region based on a given set of alignment rules.
aligner would have dealt with are."
(let ((end-mark (and end (copy-marker end t)))
(real-beg beg)
- (real-end end)
(report (and (not func) align-large-region beg end
(>= (- end beg) align-large-region)))
(rule-index 1)
(rulesep (assq 'separate rule))
(thissep (if rulesep (cdr rulesep) separate))
same (eol 0)
+ search-start
group group-c
spacing spacing-c
tab-stop tab-stop-c
repeat repeat-c
valid valid-c
- pos-list first
+ first
regions index
last-point b e
save-match-data
(if (not here)
(goto-char end))
(forward-line)
- (setq end (point)
- end-mark (copy-marker end t))
+ (setq end (point))
+ (align--set-marker end-mark end t)
(goto-char beg)))
;; If we have a region to align, and `func' is set and
;; while we can find the rule in the alignment
;; region..
(while (and (< (point) end-mark)
+ (setq search-start (point))
(if regfunc
(funcall regfunc end-mark nil)
(re-search-forward regexp
;; if the search ended us on the beginning of
;; the next line, move back to the end of the
;; previous line.
- (if (bolp)
+ (if (and (bolp) (> (point) search-start))
(forward-char -1))
;; lookup the `group' attribute the first time
;; test whether we have found a match on the same
;; line as a previous match
(if (> (point) eol)
- (setq same nil
- eol (save-excursion
- (end-of-line)
- (point-marker))))
+ (progn
+ (setq same nil)
+ (align--set-marker eol (line-end-position))))
;; lookup the `repeat' attribute the first time
(or repeat-c
(progn
(align-regions regions align-props
rule func)
- (setq last-point (copy-marker b t)
- regions nil
- align-props nil))
- (setq last-point (copy-marker b t)))
+ (setq regions nil)
+ (setq align-props nil)))
+ (align--set-marker last-point b t)
;; restore the match data
(set-match-data save-match-data)
;; the next line; don't bother searching
;; anymore on this one
(if (and (not repeat) (not (bolp)))
- (forward-line)))))
+ (forward-line))
+
+ ;; if the search did not change point,
+ ;; move forward to avoid an infinite loop
+ (if (= (point) search-start)
+ (forward-char)))))
;; when they are no more matches for this rule,
;; align whatever was left over
(run-hooks 'align-load-hook)
-;; arch-tag: ef79cccf-1db8-4888-a8a1-d7ce2d1532f7
;;; align.el ends here
HCoop / bpt / emacs.git / blobdiff