[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to emacs/lisp/progmodes/cc-align.el
|
From: |
Martin Stjernholm |
|
Subject: |
[Emacs-diffs] Changes to emacs/lisp/progmodes/cc-align.el |
|
Date: |
Sun, 21 Apr 2002 20:35:36 -0400 |
Index: emacs/lisp/progmodes/cc-align.el
diff -c emacs/lisp/progmodes/cc-align.el:1.17
emacs/lisp/progmodes/cc-align.el:1.18
*** emacs/lisp/progmodes/cc-align.el:1.17 Mon Jul 16 03:46:48 2001
--- emacs/lisp/progmodes/cc-align.el Sun Apr 21 20:35:36 2002
***************
*** 25,31 ****
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
! ;; along with this program; see the file COPYING. If not, write to
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
--- 25,31 ----
;; 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., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
***************
*** 49,95 ****
;; Standard indentation line-ups
(defun c-lineup-arglist (langelem)
"Line up the current argument line under the first argument.
! Works with: arglist-cont-nonempty."
(save-excursion
! (let* ((containing-sexp
! (save-excursion
! ;; arglist-cont-nonempty gives relpos ==
! ;; to boi of containing-sexp paren. This
! ;; is good when offset is +, but bad
! ;; when it is c-lineup-arglist, so we
! ;; have to special case a kludge here.
! (if (memq (car langelem) '(arglist-intro arglist-cont-nonempty))
! (progn
! (beginning-of-line)
! (backward-up-list 1)
! (skip-chars-forward " \t" (c-point 'eol)))
! (goto-char (cdr langelem)))
! (point)))
! (langelem-col (c-langelem-col langelem t)))
! (if (save-excursion
! (beginning-of-line)
! (looking-at "[ \t]*)"))
! (progn (goto-char (match-end 0))
! (c-forward-sexp -1)
! (forward-char 1)
! (c-forward-syntactic-ws)
! (- (current-column) langelem-col))
! (goto-char containing-sexp)
! (or (eolp)
! (not (memq (char-after) '(?{ ?\( ?\[)))
! (let ((eol (c-point 'eol))
! (here (progn
! (forward-char 1)
! (skip-chars-forward " \t")
! (point))))
! (c-forward-syntactic-ws)
! (if (< (point) eol)
! (goto-char here))))
! (- (current-column) langelem-col)
! ))))
(defun c-lineup-arglist-intro-after-paren (langelem)
"Line up a line just after the open paren of the surrounding paren or
--- 49,155 ----
;; Standard indentation line-ups
+ (defun c-lineup-topmost-intro-cont (langelem)
+ "Line up declaration continuation lines zero or one indentation step.
+ For lines in the \"header\" of a definition, zero is used. For other
+ lines, `c-basic-offset' is added to the indentation. E.g:
+
+ int
+ neg (int i) <- c-lineup-topmost-intro-cont
+ {
+ return -i;
+ }
+
+ struct
+ larch <- c-lineup-topmost-intro-cont
+ {
+ double height;
+ }
+ the_larch, <- c-lineup-topmost-intro-cont
+ another_larch; <- c-lineup-topmost-intro-cont
+ <--> c-basic-offset
+
+ struct larch
+ the_larch, <- c-lineup-topmost-intro-cont
+ another_larch; <- c-lineup-topmost-intro-cont
+
+ \(This function is mainly provided to mimic the behavior of CC Mode
+ 5.28 and earlier where this case wasn't handled consistently so that
+ these lines could be analyzed as either topmost-intro-cont or
+ statement-cont.)
+
+ Works with: topmost-intro-cont."
+ (save-excursion
+ (beginning-of-line)
+ (c-backward-syntactic-ws (cdr langelem))
+ (if (memq (char-before) '(?} ?,))
+ c-basic-offset)))
+
(defun c-lineup-arglist (langelem)
"Line up the current argument line under the first argument.
! Works with: arglist-cont-nonempty, arglist-close."
(save-excursion
! (beginning-of-line)
! (let ((containing-sexp (c-most-enclosing-brace (c-parse-state))))
! (goto-char (1+ containing-sexp))
! (let ((eol (c-point 'eol)))
! (c-forward-syntactic-ws)
! (when (< (point) eol)
! (goto-char (1+ containing-sexp))
! (skip-chars-forward " \t")))
! (vector (current-column)))))
!
! ;; Contributed by Kevin Ryde <address@hidden>.
! (defun c-lineup-argcont (elem)
! "Line up a continued argument.
!
! foo (xyz, aaa + bbb + ccc
! + ddd + eee + fff); <- c-lineup-argcont
!
! Only continuation lines like this are touched, `nil' is returned on lines
! which are the start of an argument.
!
! Within a gcc asm block, \":\" is recognised as an argument separator,
! but of course only between operand specifications, not in the expressions
! for the operands.
!
! Works with: arglist-cont, arglist-cont-nonempty."
!
! (save-excursion
! (beginning-of-line)
! (let ((bol (point)))
!
! ;; Previous line ending in a comma means we're the start of an
! ;; argument. This should quickly catch most cases not for us.
! (c-backward-syntactic-ws)
! (let ((c (char-before)))
! (unless (eq c ?,)
!
! ;; In a gcc asm, ":" on the previous line means the start of an
! ;; argument. And lines starting with ":" are not for us, don't
! ;; want them to indent to the preceding operand.
! (let ((gcc-asm (save-excursion
! (goto-char bol)
! (c-in-gcc-asm-p))))
! (unless (and gcc-asm
! (or (eq c ?:)
! (save-excursion
! (goto-char bol)
! (looking-at "[ \t]*:"))))
!
! (c-lineup-argcont-scan (if gcc-asm ?:))
! (vector (current-column)))))))))
!
! (defun c-lineup-argcont-scan (&optional other-match)
! ;; Find the start of an argument, for `c-lineup-argcont'.
! (when (eq 0 (c-backward-token-1 1 t))
! (let ((c (char-after)))
! (if (or (eq c ?,) (eq c other-match))
! (progn
! (forward-char)
! (c-forward-syntactic-ws))
! (c-lineup-argcont-scan other-match)))))
(defun c-lineup-arglist-intro-after-paren (langelem)
"Line up a line just after the open paren of the surrounding paren or
***************
*** 98,110 ****
Works with: defun-block-intro, brace-list-intro,
statement-block-intro, statement-case-intro, arglist-intro."
(save-excursion
! (let ((langelem-col (c-langelem-col langelem t))
! (ce-curcol (save-excursion
! (beginning-of-line)
! (backward-up-list 1)
! (skip-chars-forward " \t" (c-point 'eol))
! (current-column))))
! (- ce-curcol langelem-col -1))))
(defun c-lineup-arglist-close-under-paren (langelem)
"Line up a closing paren line under the corresponding open paren.
--- 158,167 ----
Works with: defun-block-intro, brace-list-intro,
statement-block-intro, statement-case-intro, arglist-intro."
(save-excursion
! (beginning-of-line)
! (backward-up-list 1)
! (skip-chars-forward " \t" (c-point 'eol))
! (vector (1+ (current-column)))))
(defun c-lineup-arglist-close-under-paren (langelem)
"Line up a closing paren line under the corresponding open paren.
***************
*** 114,125 ****
\(for most of these, a zero offset will normally produce the same
result, though)."
(save-excursion
! (let ((langelem-col (c-langelem-col langelem t))
! (ce-curcol (save-excursion
! (beginning-of-line)
! (backward-up-list 1)
! (current-column))))
! (- ce-curcol langelem-col))))
(defun c-lineup-close-paren (langelem)
"Line up the closing paren under its corresponding open paren if the
--- 171,179 ----
\(for most of these, a zero offset will normally produce the same
result, though)."
(save-excursion
! (beginning-of-line)
! (backward-up-list 1)
! (vector (current-column))))
(defun c-lineup-close-paren (langelem)
"Line up the closing paren under its corresponding open paren if the
***************
*** 147,153 ****
(c-forward-syntactic-ws (c-point 'eol))
(if (eolp)
0
! (- opencol (c-langelem-col langelem t))))
(error nil))))
(defun c-lineup-streamop (langelem)
--- 201,207 ----
(c-forward-syntactic-ws (c-point 'eol))
(if (eolp)
0
! (vector opencol)))
(error nil))))
(defun c-lineup-streamop (langelem)
***************
*** 155,164 ****
Works with: stream-op."
(save-excursion
! (let ((langelem-col (c-langelem-col langelem)))
! (re-search-forward "<<\\|>>" (c-point 'eol) 'move)
! (goto-char (match-beginning 0))
! (- (current-column) langelem-col))))
(defun c-lineup-multi-inher (langelem)
"Line up the classes in C++ multiple inheritance clauses and member
--- 209,218 ----
Works with: stream-op."
(save-excursion
! (goto-char (cdr langelem))
! (re-search-forward "<<\\|>>" (c-point 'eol) 'move)
! (goto-char (match-beginning 0))
! (vector (current-column))))
(defun c-lineup-multi-inher (langelem)
"Line up the classes in C++ multiple inheritance clauses and member
***************
*** 182,189 ****
(here (point))
(char-after-ip (progn
(skip-chars-forward " \t")
! (char-after)))
! (langelem-col (c-langelem-col langelem)))
;; This kludge is necessary to support both inher-cont and
;; member-init-cont, since they have different anchor positions.
--- 236,243 ----
(here (point))
(char-after-ip (progn
(skip-chars-forward " \t")
! (char-after))))
! (if (cdr langelem) (goto-char (cdr langelem)))
;; This kludge is necessary to support both inher-cont and
;; member-init-cont, since they have different anchor positions.
***************
*** 199,205 ****
(if (or (eolp)
(looking-at c-comment-start-regexp))
(c-forward-syntactic-ws here))
! (- (current-column) langelem-col)
)))
(defun c-lineup-java-inher (langelem)
--- 253,259 ----
(if (or (eolp)
(looking-at c-comment-start-regexp))
(c-forward-syntactic-ws here))
! (vector (current-column))
)))
(defun c-lineup-java-inher (langelem)
***************
*** 216,227 ****
Works with: inher-cont."
(save-excursion
! (let ((langelem-col (c-langelem-col langelem)))
! (forward-word 1)
! (if (looking-at "[ \t]*$")
! c-basic-offset
! (c-forward-syntactic-ws)
! (- (current-column) langelem-col)))))
(defun c-lineup-java-throws (langelem)
"Line up Java throws declarations.
--- 270,281 ----
Works with: inher-cont."
(save-excursion
! (goto-char (cdr langelem))
! (forward-word 1)
! (if (looking-at "[ \t]*$")
! c-basic-offset
! (c-forward-syntactic-ws)
! (vector (current-column)))))
(defun c-lineup-java-throws (langelem)
"Line up Java throws declarations.
***************
*** 246,255 ****
(throw 'done t))))))
(if throws
(if (zerop (c-forward-token-1 1 nil (c-point 'eol)))
! (- (current-column) (c-langelem-col langelem))
(back-to-indentation)
! (+ (- (current-column) (c-langelem-col langelem))
! c-basic-offset))
c-basic-offset))))
(defun c-indent-one-line-block (langelem)
--- 300,308 ----
(throw 'done t))))))
(if throws
(if (zerop (c-forward-token-1 1 nil (c-point 'eol)))
! (vector (current-column))
(back-to-indentation)
! (vector (+ (current-column) c-basic-offset)))
c-basic-offset))))
(defun c-indent-one-line-block (langelem)
***************
*** 332,352 ****
(if (looking-at c-current-comment-prefix)
(- (match-end 0) (point))
0)))
! (starterlen (save-excursion
! (goto-char (cdr langelem))
! (looking-at comment-start-skip)
! (- (save-excursion
! (goto-char (match-end 0))
! (skip-chars-backward " \t")
! (point))
! (or (match-end 1) (point))
! 1))) ; Don't count the first '/'.
! (langelem-col (save-excursion (c-langelem-col langelem))))
(if (and (> starterlen 10) (zerop prefixlen))
;; The comment has a long starter and the line doesn't have
;; a nonempty comment prefix. Treat it as free form text
;; and don't change the indentation.
! (- (current-column) langelem-col)
(forward-line -1)
(back-to-indentation)
(if (>= (cdr langelem) (point))
--- 385,417 ----
(if (looking-at c-current-comment-prefix)
(- (match-end 0) (point))
0)))
! (starterlen
! ;; Get the length of the comment starter, not including
! ;; the first '/'. We check if the comment prefix matched
! ;; on the current line matches the starter or if it
! ;; matches comment-start-skip, and choose whichever is
! ;; longest.
! (max (save-excursion
! (goto-char (1+ (cdr langelem)))
! (if (and (match-string 0)
! (looking-at (regexp-quote (match-string 0))))
! (- (match-end 0) (match-beginning 0))
! 0))
! (save-excursion
! (goto-char (cdr langelem))
! (looking-at comment-start-skip)
! (- (or (match-end 1)
! (save-excursion
! (goto-char (match-end 0))
! (skip-chars-backward " \t")
! (point)))
! (point)
! 1)))))
(if (and (> starterlen 10) (zerop prefixlen))
;; The comment has a long starter and the line doesn't have
;; a nonempty comment prefix. Treat it as free form text
;; and don't change the indentation.
! (vector (current-column))
(forward-line -1)
(back-to-indentation)
(if (>= (cdr langelem) (point))
***************
*** 356,366 ****
;; starter.
(progn
(goto-char (match-end 0))
! (if (looking-at "\\([ \t]+\\).+$")
! ;; Align with the text that hangs after the
! ;; comment starter.
! (goto-char (match-end 1)))
! (- (current-column) langelem-col))
;; How long is the comment starter? if greater than the
;; length of the comment prefix, align left. if less
;; than or equal, align right. this should also pick up
--- 421,434 ----
;; starter.
(progn
(goto-char (match-end 0))
! ;; The following should not be necessary, since
! ;; comment-start-skip should match everything (i.e.
! ;; typically whitespace) that leads up to the text.
! ;;(if (looking-at "\\([ \t]+\\).+$")
! ;; ;; Align with the text that hangs after the
! ;; ;; comment starter.
! ;; (goto-char (match-end 1)))
! (vector (current-column)))
;; How long is the comment starter? if greater than the
;; length of the comment prefix, align left. if less
;; than or equal, align right. this should also pick up
***************
*** 368,377 ****
(if (> starterlen prefixlen)
(progn
(goto-char (cdr langelem))
! (- (current-column) -1 langelem-col))
! (goto-char (match-end 0))
! (skip-chars-backward " \t")
! (- (current-column) prefixlen langelem-col)))
;; Not on the second line in the comment. If the previous
;; line has a nonempty comment prefix, align with it.
;; Otherwise, align with the previous nonempty line, but
--- 436,444 ----
(if (> starterlen prefixlen)
(progn
(goto-char (cdr langelem))
! (vector (1+ (current-column))))
! (goto-char (+ (cdr langelem) starterlen 1))
! (vector (- (current-column) prefixlen))))
;; Not on the second line in the comment. If the previous
;; line has a nonempty comment prefix, align with it.
;; Otherwise, align with the previous nonempty line, but
***************
*** 389,395 ****
;; Align with the comment starter rather than
;; with the code before it.
(goto-char (cdr langelem)))))
! (- (current-column) langelem-col))))))
(defun c-lineup-comment (langelem)
"Line up a comment start according to `c-comment-only-line-offset'.
--- 456,462 ----
;; Align with the comment starter rather than
;; with the code before it.
(goto-char (cdr langelem)))))
! (vector (current-column)))))))
(defun c-lineup-comment (langelem)
"Line up a comment start according to `c-comment-only-line-offset'.
***************
*** 416,421 ****
--- 483,512 ----
-1000)) ;jam it against the left side
))))
+ (defun c-lineup-knr-region-comment (langelem)
+ "Line up a comment in the \"K&R region\" with the declaration.
+ That is the region between the function or class header and the
+ beginning of the block. E.g:
+
+ int main()
+ /* This is the main function. */ <- c-lineup-knr-region-comment
+ {
+ return 0;
+ }
+
+ Return nil if called in any other situation, to be useful in list
+ expressions.
+
+ Works with: comment-intro."
+ (when (or (assq 'topmost-intro-cont c-syntactic-context)
+ (assq 'func-decl-cont c-syntactic-context)
+ (assq 'knr-argdecl-intro c-syntactic-context)
+ (assq 'lambda-intro-cont c-syntactic-context))
+ (save-excursion
+ (beginning-of-line)
+ (c-beginning-of-statement-1)
+ (vector (current-column)))))
+
(defun c-lineup-runin-statements (langelem)
"Line up statements when the first statement is on the same line as
the block opening brace. E.g:
***************
*** 431,441 ****
Works with: The `statement' syntactic symbol."
(if (eq (char-after (cdr langelem)) ?{)
(save-excursion
! (let ((langelem-col (c-langelem-col langelem)))
! (forward-char 1)
! (skip-chars-forward " \t")
! (unless (eolp)
! (- (current-column) langelem-col))))))
(defun c-lineup-math (langelem)
"Line up the current line after the equal sign on the first line in
--- 522,532 ----
Works with: The `statement' syntactic symbol."
(if (eq (char-after (cdr langelem)) ?{)
(save-excursion
! (if (cdr langelem) (goto-char (cdr langelem)))
! (forward-char 1)
! (skip-chars-forward " \t")
! (unless (eolp)
! (vector (current-column))))))
(defun c-lineup-math (langelem)
"Line up the current line after the equal sign on the first line in
***************
*** 443,449 ****
the current line contains an equal sign too, try to align it with the
first one.
! Works with: statement-cont."
(save-excursion
(let ((equalp (save-excursion
(goto-char (c-point 'boi))
--- 534,540 ----
the current line contains an equal sign too, try to align it with the
first one.
! Works with: statement-cont, arglist-cont, arglist-cont-nonempty."
(save-excursion
(let ((equalp (save-excursion
(goto-char (c-point 'boi))
***************
*** 453,460 ****
(= (c-forward-token-1 1 t eol) 0))))
(and (eq (char-after) ?=)
(- (point) (c-point 'boi)))))
- (langelem-col (c-langelem-col langelem))
donep)
(while (and (not donep)
(< (point) (c-point 'eol)))
(skip-chars-forward "^=" (c-point 'eol))
--- 544,551 ----
(= (c-forward-token-1 1 t eol) 0))))
(and (eq (char-after) ?=)
(- (point) (c-point 'boi)))))
donep)
+ (if (cdr langelem) (goto-char (cdr langelem)))
(while (and (not donep)
(< (point) (c-point 'eol)))
(skip-chars-forward "^=" (c-point 'eol))
***************
*** 475,483 ****
(forward-char 1)
(skip-chars-forward " \t")
(setq equalp 0)))
! (- (current-column) equalp langelem-col))
)))
(defun c-lineup-template-args (langelem)
"Line up template argument lines under the first argument.
To allow this function to be used in a list expression, nil is
--- 566,604 ----
(forward-char 1)
(skip-chars-forward " \t")
(setq equalp 0)))
! (vector (- (current-column) equalp)))
)))
+ (defun c-lineup-cascaded-calls (langelem)
+ "Line up \"cascaded calls\" under each other.
+ If the line begins with \"->\" and the preceding line ends with one or
+ more function calls preceded by \"->\", then the arrow is lined up with
+ the first of those \"->\". E.g:
+
+ result = proc->add(17)->add(18)
+ ->add(19) + <- c-lineup-cascaded-calls
+ offset; <- c-lineup-cascaded-calls (inactive)
+
+ In any other situation nil is returned to allow use in list
+ expressions.
+
+ Works with: statement-cont, arglist-cont, arglist-cont-nonempty."
+ (save-excursion
+ (let ((bopl (c-point 'bopl)) col)
+ (back-to-indentation)
+ (when (and (looking-at "->")
+ (= (c-backward-token-1 1 t bopl) 0)
+ (eq (char-after) ?\()
+ (= (c-backward-token-1 3 t bopl) 0)
+ (looking-at "->"))
+ (setq col (current-column))
+ (while (and (= (c-backward-token-1 1 t bopl) 0)
+ (eq (char-after) ?\()
+ (= (c-backward-token-1 3 t bopl) 0)
+ (looking-at "->"))
+ (setq col (current-column)))
+ (vector col)))))
+
(defun c-lineup-template-args (langelem)
"Line up template argument lines under the first argument.
To allow this function to be used in a list expression, nil is
***************
*** 490,496 ****
(backward-up-list 1)
(if (and (eq (char-after) ?<)
(zerop (c-forward-token-1 1 nil (c-point 'eol))))
! (- (current-column) (c-langelem-col langelem))))))
(defun c-lineup-ObjC-method-call (langelem)
"Line up selector args as elisp-mode does with function args:
--- 611,617 ----
(backward-up-list 1)
(if (and (eq (char-after) ?<)
(zerop (c-forward-token-1 1 nil (c-point 'eol))))
! (vector (current-column))))))
(defun c-lineup-ObjC-method-call (langelem)
"Line up selector args as elisp-mode does with function args:
***************
*** 579,588 ****
Works with: inlambda, inexpr-statement, inexpr-class."
(save-excursion
(back-to-indentation)
! (let ((res (or (c-looking-at-inexpr-block)
! (if (c-safe (backward-up-list 1)
! (eq (char-after) ?{))
! (c-looking-at-inexpr-block)))))
(when res
(goto-char (cdr res))
(- (current-column)
--- 700,719 ----
Works with: inlambda, inexpr-statement, inexpr-class."
(save-excursion
(back-to-indentation)
! (let* ((paren-state (c-parse-state))
! (containing-sexp (c-most-enclosing-brace paren-state))
! (res (or (c-looking-at-inexpr-block
! (c-safe-position containing-sexp paren-state)
! containing-sexp)
! (and containing-sexp
! (progn (goto-char containing-sexp)
! (eq (char-after) ?{))
! (progn (setq containing-sexp
! (c-most-enclosing-brace paren-state
! (point)))
! (c-looking-at-inexpr-block
! (c-safe-position containing-sexp paren-state)
! containing-sexp))))))
(when res
(goto-char (cdr res))
(- (current-column)
***************
*** 614,619 ****
--- 745,878 ----
0
c-basic-offset)))
+ (defun c-lineup-cpp-define (langelem)
+ "Line up macro continuation lines according to the indentation of
+ the construct preceding the macro. E.g:
+
+ v beg of preceding constr v beg of preceding constr
+ int dribble() {
+ const char msg[] = if (!running)
+ \"Some text.\"; error(\"Not running!\");
+
+ #define X(A, B) \ #define X(A, B) \
+ do { \ <-> do { \ <- c-lineup-cpp-define
+ printf (A, B); \ printf (A, B); \
+ } while (0) } while (0)
+
+ If `c-syntactic-indentation-in-macros' is non-nil, the function
+ returns the relative indentation to the macro start line to allow
+ accumulation with other offsets. E.g. in the following cases,
+ cpp-define-intro is combined with the statement-block-intro that comes
+ from the \"do {\" that hangs on the \"#define\" line:
+
+ int dribble() {
+ const char msg[] = if (!running)
+ \"Some text.\"; error(\"Not running!\");
+
+ #define X(A, B) do { \ #define X(A, B) do { \
+ printf (A, B); \ <-> printf (A, B); \ <- c-lineup-cpp-define
+ this->refs++; \ this->refs++; \
+ } while (0) <-> } while (0) <- c-lineup-cpp-define
+
+ The relative indentation returned by `c-lineup-cpp-define' is zero and
+ two, respectively, in these two examples. They are then added to the
+ two column indentation that statement-block-intro gives in both cases
+ here.
+
+ If the relative indentation is zero, then nil is returned instead.
+ This useful in a list expression to specify the default indentation on
+ the top level.
+
+ If `c-syntactic-indentation-in-macros' is nil then this function keeps
+ the current indentation, except for empty lines \(ignoring the ending
+ backslash) where it takes the indentation from the closest preceding
+ nonempty line in the macro. If there's no such line in the macro then
+ the indentation is taken from the construct preceding it, as described
+ above.
+
+ Works with: cpp-define-intro."
+ (let (offset)
+ (if c-syntactic-indentation-in-macros
+ ;; Go to the macro start and do a syntactic analysis of it.
+ ;; Then remove the cpp-macro element it should contain and
+ ;; calculate the indentation it then would get.
+ (save-excursion
+ (c-beginning-of-macro)
+ (setq offset (- (c-get-syntactic-indentation
+ (delete '(cpp-macro) (c-guess-basic-syntax)))
+ (save-excursion
+ (back-to-indentation)
+ (current-column))))
+ (if (zerop offset)
+ nil
+ offset))
+ ;; Do not indent syntactically inside the macro.
+ (save-excursion
+ (let ((macro-start-line (save-excursion
+ (goto-char (c-query-macro-start))
+ (beginning-of-line)
+ (point))))
+ (beginning-of-line)
+ ;; Check every line while inside the macro.
+ (while (and (> (point) macro-start-line)
+ (looking-at "[ \t]*\\\\?$")
+ (= (forward-line -1) 0)))
+ (if (<= (point) macro-start-line)
+ ;; If we've stepped out of the macro we take the
+ ;; syntactic offset.
+ (setq offset (c-get-syntactic-indentation
+ (delete '(cpp-macro) (c-guess-basic-syntax))))
+ (setq offset (current-indentation)))
+ (if (zerop offset)
+ nil
+ (vector offset)))))))
+
+ ;; Contributed by Kevin Ryde <address@hidden>.
+ (defun c-lineup-gcc-asm-reg (elem)
+ "Line up a gcc asm register under one on a previous line.
+
+ asm (\"foo %1, %0\\n\"
+ \"bar %0, %1\"
+ : \"=r\" (w),
+ \"=r\" (x)
+ : \"0\" (y),
+ \"1\" (z));
+
+ The \"x\" line is aligned to the text after the \":\" on the \"w\" line, and
+ similarly \"z\" under \"y\".
+
+ This is done only in an \"asm\" or \"__asm__\" block, and only to those
+ lines mentioned. Anywhere else `nil' is returned. The usual arrangement is
+ to have this routine as an extra feature at the start of arglist lineups, e.g.
+
+ (c-lineup-gcc-asm-reg c-lineup-arglist)
+
+ Works with: arglist-cont, arglist-cont-nonempty."
+
+ (let ((orig-pos (point))
+ alignto)
+ (save-excursion
+ (and
+ c-opt-asm-stmt-key
+
+ ;; Find the ":" to align to. Look for this first so as to quickly
+ ;; eliminate pretty much all cases which are not for us.
+ (re-search-backward "^[ \t]*:[ \t]*\\(.\\)?" (cdr elem) t)
+
+ ;; Must have something after the ":".
+ (setq alignto (match-beginning 1))
+
+ ;; Don't touch ":" lines themselves.
+ (progn (goto-char orig-pos)
+ (beginning-of-line)
+ (not (looking-at "^[ \t]*:")))
+
+ ;; Only operate in an asm statement.
+ (progn (goto-char orig-pos)
+ (c-in-gcc-asm-p))
+
+ (vector (progn (goto-char alignto) (current-column)))))))
+
(defun c-lineup-dont-change (langelem)
"Do not change the indentation of the current line.
***************
*** 663,669 ****
(setq syntax nil)
(back-to-indentation)
(if (zerop (current-column))
! (insert (make-string c-label-minimum-indentation 32)))
))
))))
--- 922,928 ----
(setq syntax nil)
(back-to-indentation)
(if (zerop (current-column))
! (insert-char ?\ c-label-minimum-indentation t))
))
))))
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] Changes to emacs/lisp/progmodes/cc-align.el,
Martin Stjernholm <=