;;; align.el --- align text to a specific column, by regexp
-;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004,
-;; 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1999-2012 Free Software Foundation, Inc.
;; Author: John Wiegley <johnw@gnu.org>
;; Maintainer: FSF
;; 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
"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)
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-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 nil, then no messages will ever be printed to the minibuffer."
:type 'integer
:group 'align)
: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)
(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
+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)
`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
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
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)
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
;; 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)
(run-hooks 'align-load-hook)
-;; arch-tag: ef79cccf-1db8-4888-a8a1-d7ce2d1532f7
;;; align.el ends here