bug#7930: 24.0.50; Indentation problem in C-mode

[Michael Welsh Duggan]

No recipe yet.  Here is a backtrace from TAB in a C-mode buffer.  I am
hoping that this is enough to figure out what is going on.  This has
been happening periodically since a bzr update from a week or so ago.  A
recent bzr pull didn't help.  If you can suggest anything to look at
next time I encounter this problem, I'd be happy to do so.

Debugger entered--Lisp error: (wrong-type-argument number-or-marker-p (13067 . 
13237))
  >(13242 (13067 . 13237))
  (progn (c-backward-syntactic-ws) (> (point) closest-lim))
  (and (eq res (quote maybe)) (progn (c-backward-syntactic-ws) (> (point) 
closest-lim)) (not (bobp)) (progn (backward-char) (looking-at 
"[]).]\\|\\w\\|\\s_")) (c-safe (forward-char) (goto-char (scan-sexps (point) 
-1))))
  (while (and (eq res (quote maybe)) (progn (c-backward-syntactic-ws) (> 
(point) closest-lim)) (not (bobp)) (progn (backward-char) (looking-at 
"[]).]\\|\\w\\|\\s_")) (c-safe (forward-char) (goto-char (scan-sexps (point) 
-1)))) (setq res (if (looking-at c-keywords-regexp) (let ((kw-sym 
(c-keyword-sym (match-string 1)))) (cond ((and block-follows (c-keyword-member 
kw-sym ...)) (and (not ...) (or ... ... ...) (cons ... ...))) 
((c-keyword-member kw-sym (quote c-inexpr-block-kwds)) (when (not passed-paren) 
(cons ... ...))) ((c-keyword-member kw-sym (quote c-lambda-kwds)) (when (or ... 
...) (cons ... ...))) ((c-keyword-member kw-sym (quote c-block-stmt-kwds)) nil) 
(t (quote maybe)))) (if (looking-at "\\s(") (if passed-paren (if (and (eq 
passed-paren 91) (eq ... 91)) (quote maybe)) (setq passed-paren (char-after)) 
(quote maybe)) (quote maybe)))))
  (let ((res (quote maybe)) passed-paren (closest-lim (or containing-sexp lim 
(point-min))) (block-follows (and (eq (char-after) 123) (point)))) (while (and 
(eq res (quote maybe)) (progn (c-backward-syntactic-ws) (> (point) 
closest-lim)) (not (bobp)) (progn (backward-char) (looking-at 
"[]).]\\|\\w\\|\\s_")) (c-safe (forward-char) (goto-char (scan-sexps (point) 
-1)))) (setq res (if (looking-at c-keywords-regexp) (let ((kw-sym 
(c-keyword-sym ...))) (cond ((and block-follows ...) (and ... ... ...)) 
((c-keyword-member kw-sym ...) (when ... ...)) ((c-keyword-member kw-sym ...) 
(when ... ...)) ((c-keyword-member kw-sym ...) nil) (t (quote maybe)))) (if 
(looking-at "\\s(") (if passed-paren (if (and ... ...) (quote maybe)) (setq 
passed-paren (char-after)) (quote maybe)) (quote maybe))))) (if (eq res (quote 
maybe)) (when (and c-recognize-paren-inexpr-blocks block-follows 
containing-sexp (eq (char-after containing-sexp) 40)) (goto-char 
containing-sexp) (if (or (save-excursion (c-backward-syntactic-ws lim) (and (> 
... ...) (c-on-identifier))) (and c-special-brace-lists 
(c-looking-at-special-brace-list))) nil (cons (quote inexpr-statement) 
(point)))) res))
  (save-excursion (let ((res (quote maybe)) passed-paren (closest-lim (or 
containing-sexp lim (point-min))) (block-follows (and (eq (char-after) 123) 
(point)))) (while (and (eq res (quote maybe)) (progn (c-backward-syntactic-ws) 
(> (point) closest-lim)) (not (bobp)) (progn (backward-char) (looking-at 
"[]).]\\|\\w\\|\\s_")) (c-safe (forward-char) (goto-char (scan-sexps (point) 
-1)))) (setq res (if (looking-at c-keywords-regexp) (let ((kw-sym ...)) (cond 
(... ...) (... ...) (... ...) (... nil) (t ...))) (if (looking-at "\\s(") (if 
passed-paren (if ... ...) (setq passed-paren ...) (quote maybe)) (quote 
maybe))))) (if (eq res (quote maybe)) (when (and 
c-recognize-paren-inexpr-blocks block-follows containing-sexp (eq (char-after 
containing-sexp) 40)) (goto-char containing-sexp) (if (or (save-excursion 
(c-backward-syntactic-ws lim) (and ... ...)) (and c-special-brace-lists 
(c-looking-at-special-brace-list))) nil (cons (quote inexpr-statement) 
(point)))) res)))
  c-looking-at-inexpr-block((13067 . 13237) (13067 . 13237))
  (if (c-looking-at-inexpr-block next-containing next-containing) (setq 
containing-sexp nil) (setq braceassignp (quote dontknow)) (c-backward-token-2 1 
t lim) (when (and c-opt-inexpr-brace-list-key (eq (char-after) 91)) (while (eq 
braceassignp (quote dontknow)) (setq braceassignp (cond ((/= 
(c-backward-token-2 1 t lim) 0) nil) ((looking-at c-opt-inexpr-brace-list-key) 
t) ((looking-at "\\sw\\|\\s_\\|[.[]") (quote dontknow)) (t nil))))) (while (eq 
braceassignp (quote dontknow)) (cond ((eq (char-after) 59) (setq braceassignp 
nil)) ((and class-key (looking-at class-key)) (setq braceassignp nil)) ((eq 
(char-after) 61) (setq braceassignp (quote maybe)) (while (and (eq braceassignp 
(quote maybe)) (zerop (c-backward-token-2 1 t lim))) (setq braceassignp (cond 
(... nil) (... nil) (... ...) (... nil) (t t)))))) (if (and (eq braceassignp 
(quote dontknow)) (/= (c-backward-token-2 1 t lim) 0)) (setq braceassignp 
nil))) (if (not braceassignp) (if (eq (char-after) 59) (setq containing-sexp 
nil) (setq containing-sexp next-containing lim nil next-containing nil)) 
(c-beginning-of-statement-1 (c-most-enclosing-brace paren-state)) (setq bufpos 
(point))))
  (while (and (not bufpos) containing-sexp) (when paren-state (if (consp (car 
paren-state)) (setq lim (cdr (car paren-state)) paren-state (cdr paren-state)) 
(setq lim (car paren-state))) (when paren-state (setq next-containing (car 
paren-state) paren-state (cdr paren-state)))) (goto-char containing-sexp) (if 
(c-looking-at-inexpr-block next-containing next-containing) (setq 
containing-sexp nil) (setq braceassignp (quote dontknow)) (c-backward-token-2 1 
t lim) (when (and c-opt-inexpr-brace-list-key (eq (char-after) 91)) (while (eq 
braceassignp (quote dontknow)) (setq braceassignp (cond ((/= ... 0) nil) 
((looking-at c-opt-inexpr-brace-list-key) t) ((looking-at "\\sw\\|\\s_\\|[.[]") 
(quote dontknow)) (t nil))))) (while (eq braceassignp (quote dontknow)) (cond 
((eq (char-after) 59) (setq braceassignp nil)) ((and class-key (looking-at 
class-key)) (setq braceassignp nil)) ((eq (char-after) 61) (setq braceassignp 
(quote maybe)) (while (and (eq braceassignp ...) (zerop ...)) (setq 
braceassignp (cond ... ... ... ... ...))))) (if (and (eq braceassignp (quote 
dontknow)) (/= (c-backward-token-2 1 t lim) 0)) (setq braceassignp nil))) (if 
(not braceassignp) (if (eq (char-after) 59) (setq containing-sexp nil) (setq 
containing-sexp next-containing lim nil next-containing nil)) 
(c-beginning-of-statement-1 (c-most-enclosing-brace paren-state)) (setq bufpos 
(point)))))
  (let ((class-key (and (c-major-mode-is (quote pike-mode)) c-decl-block-key)) 
bufpos braceassignp lim next-containing) (while (and (not bufpos) 
containing-sexp) (when paren-state (if (consp (car paren-state)) (setq lim (cdr 
(car paren-state)) paren-state (cdr paren-state)) (setq lim (car paren-state))) 
(when paren-state (setq next-containing (car paren-state) paren-state (cdr 
paren-state)))) (goto-char containing-sexp) (if (c-looking-at-inexpr-block 
next-containing next-containing) (setq containing-sexp nil) (setq braceassignp 
(quote dontknow)) (c-backward-token-2 1 t lim) (when (and 
c-opt-inexpr-brace-list-key (eq (char-after) 91)) (while (eq braceassignp 
(quote dontknow)) (setq braceassignp (cond (... nil) (... t) (... ...) (t 
nil))))) (while (eq braceassignp (quote dontknow)) (cond ((eq (char-after) 59) 
(setq braceassignp nil)) ((and class-key (looking-at class-key)) (setq 
braceassignp nil)) ((eq (char-after) 61) (setq braceassignp (quote maybe)) 
(while (and ... ...) (setq braceassignp ...)))) (if (and (eq braceassignp 
(quote dontknow)) (/= (c-backward-token-2 1 t lim) 0)) (setq braceassignp 
nil))) (if (not braceassignp) (if (eq (char-after) 59) (setq containing-sexp 
nil) (setq containing-sexp next-containing lim nil next-containing nil)) 
(c-beginning-of-statement-1 (c-most-enclosing-brace paren-state)) (setq bufpos 
(point))))) bufpos)
  (save-excursion (let ((class-key (and (c-major-mode-is (quote pike-mode)) 
c-decl-block-key)) bufpos braceassignp lim next-containing) (while (and (not 
bufpos) containing-sexp) (when paren-state (if (consp (car paren-state)) (setq 
lim (cdr (car paren-state)) paren-state (cdr paren-state)) (setq lim (car 
paren-state))) (when paren-state (setq next-containing (car paren-state) 
paren-state (cdr paren-state)))) (goto-char containing-sexp) (if 
(c-looking-at-inexpr-block next-containing next-containing) (setq 
containing-sexp nil) (setq braceassignp (quote dontknow)) (c-backward-token-2 1 
t lim) (when (and c-opt-inexpr-brace-list-key (eq (char-after) 91)) (while (eq 
braceassignp (quote dontknow)) (setq braceassignp (cond ... ... ... ...)))) 
(while (eq braceassignp (quote dontknow)) (cond ((eq ... 59) (setq braceassignp 
nil)) ((and class-key ...) (setq braceassignp nil)) ((eq ... 61) (setq 
braceassignp ...) (while ... ...))) (if (and (eq braceassignp ...) (/= ... 0)) 
(setq braceassignp nil))) (if (not braceassignp) (if (eq (char-after) 59) (setq 
containing-sexp nil) (setq containing-sexp next-containing lim nil 
next-containing nil)) (c-beginning-of-statement-1 (c-most-enclosing-brace 
paren-state)) (setq bufpos (point))))) bufpos))
  (or (c-safe (save-excursion (goto-char containing-sexp) (c-forward-sexp -1) 
(let (bracepos) (if (and (or (looking-at c-brace-list-key) (progn ... ...)) 
(setq bracepos (c-down-list-forward ...)) (not (c-crosses-statement-barrier-p 
... ...))) (point))))) (save-excursion (let ((class-key (and (c-major-mode-is 
(quote pike-mode)) c-decl-block-key)) bufpos braceassignp lim next-containing) 
(while (and (not bufpos) containing-sexp) (when paren-state (if (consp (car 
paren-state)) (setq lim (cdr ...) paren-state (cdr paren-state)) (setq lim (car 
paren-state))) (when paren-state (setq next-containing (car paren-state) 
paren-state (cdr paren-state)))) (goto-char containing-sexp) (if 
(c-looking-at-inexpr-block next-containing next-containing) (setq 
containing-sexp nil) (setq braceassignp (quote dontknow)) (c-backward-token-2 1 
t lim) (when (and c-opt-inexpr-brace-list-key (eq ... 91)) (while (eq 
braceassignp ...) (setq braceassignp ...))) (while (eq braceassignp (quote 
dontknow)) (cond (... ...) (... ...) (... ... ...)) (if (and ... ...) (setq 
braceassignp nil))) (if (not braceassignp) (if (eq ... 59) (setq 
containing-sexp nil) (setq containing-sexp next-containing lim nil 
next-containing nil)) (c-beginning-of-statement-1 (c-most-enclosing-brace 
paren-state)) (setq bufpos (point))))) bufpos)))
  c-inside-bracelist-p(13243 ((13067 . 13237) 10676 13243 (9637 . 9744) (13067 
. 13237) 10676 13199 (9637 . 9744) (13067 . 13193) 10676 13199 (9637 . 9744) 
(13067 . 13193) 10676 13199 (9637 . 9744) (13067 . 13193) 10676 13199 (13067 . 
13193) 10676 14405 14168 13990 (13739 . 13984) 13199 (13067 . 13193) 10676 
14405 14168 13990 (13739 . 13984) 13199 (13067 . 13193) 10676 14405 14168 13990 
(13739 . 13984) 13199 (13067 . 13193) 10676 (9637 . 9744) 15532 (15359 . 15395) 
15271 15187 (9212 . 15122)))
  (or (and c-special-brace-lists (save-excursion (goto-char containing-sexp) 
(c-looking-at-special-brace-list))) (c-inside-bracelist-p containing-sexp 
paren-state))
  (setq special-brace-list (or (and c-special-brace-lists (save-excursion 
(goto-char containing-sexp) (c-looking-at-special-brace-list))) 
(c-inside-bracelist-p containing-sexp paren-state)))
  (and (not (c-major-mode-is (quote awk-mode))) (setq special-brace-list (or 
(and c-special-brace-lists (save-excursion (goto-char containing-sexp) 
(c-looking-at-special-brace-list))) (c-inside-bracelist-p containing-sexp 
paren-state))))
  (cond ((eq literal (quote string)) (c-add-syntax (quote string) (c-point 
(quote bopl)))) ((and (memq literal (quote (c c++))) (setq placeholder 
(c-literal-limits lim))) (c-add-syntax literal (car placeholder))) ((and 
(save-excursion (when (c-beginning-of-macro) (setq macro-start (point)))) (/= 
macro-start (c-point (quote boi))) (progn (setq tmpsymbol (quote 
cpp-macro-cont)) (or (not c-syntactic-indentation-in-macros) (save-excursion 
(goto-char macro-start) (if (c-forward-to-cpp-define-body) (let ... ... ...) 
(setq in-macro-expr t) nil))))) (c-add-syntax tmpsymbol macro-start) (setq 
macro-start nil)) ((looking-at "else\\>[^_]") (c-beginning-of-statement-1 
containing-sexp) (c-add-stmt-syntax (quote else-clause) nil t containing-sexp 
paren-state)) ((and (looking-at "while\\>[^_]") (save-excursion (prog1 (eq 
(c-beginning-of-statement-1 containing-sexp) (quote beginning)) (setq 
placeholder (point))))) (goto-char placeholder) (c-add-stmt-syntax (quote 
do-while-closure) nil t containing-sexp paren-state)) ((save-excursion (and 
(cond ((c-major-mode-is (quote c++-mode)) (looking-at "catch\\>[^_]")) 
((c-major-mode-is (quote java-mode)) (looking-at 
"\\(catch\\|finally\\)\\>[^_]"))) (and (c-safe (c-backward-syntactic-ws) 
(c-backward-sexp) t) (eq (char-after) 123) (c-safe (c-backward-syntactic-ws) 
(c-backward-sexp) t) (if (eq (char-after) 40) (c-safe (c-backward-sexp) t) t)) 
(looking-at "\\(try\\|catch\\)\\>[^_]") (setq placeholder (point)))) (goto-char 
placeholder) (c-add-stmt-syntax (quote catch-clause) nil t containing-sexp 
paren-state)) ((save-excursion (and c-opt-block-stmt-key (not (eq 
char-before-ip 59)) (not (c-at-vsemi-p before-ws-ip)) (not (memq char-after-ip 
(quote (41 93 44)))) (or (not (eq char-before-ip 125)) 
(c-looking-at-inexpr-block-backward c-state-cache)) (> (point) (progn (setq 
placeholder (point)) (while (eq ... ...)) (if (eq step-type ...) (goto-char 
placeholder) (setq placeholder ...) (if ... ...)) placeholder)) (if (looking-at 
c-block-stmt-2-key) (and (zerop (c-forward-token-2 1 nil)) (eq (char-after) 
40)) (looking-at c-opt-block-stmt-key)))) (if (eq step-type (quote up)) (progn 
(goto-char placeholder) (cond ((eq char-after-ip 123) (c-add-stmt-syntax (quote 
substatement-open) nil nil containing-sexp paren-state)) ((save-excursion 
(goto-char indent-point) (back-to-indentation) (c-forward-label)) 
(c-add-stmt-syntax (quote substatement-label) nil nil containing-sexp 
paren-state)) (t (c-add-stmt-syntax (quote substatement) nil nil 
containing-sexp paren-state)))) (c-guess-continued-construct indent-point 
char-after-ip placeholder lim paren-state))) ((looking-at c-label-kwds-regexp) 
(if containing-sexp (progn (goto-char containing-sexp) (setq lim 
(c-most-enclosing-brace c-state-cache containing-sexp)) 
(c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote case-label) nil t 
lim paren-state)) (c-add-syntax (quote case-label) (point-min)))) 
((save-excursion (back-to-indentation) (and (not (looking-at 
c-syntactic-ws-start)) (c-forward-label))) (cond (containing-decl-open (setq 
placeholder (c-add-class-syntax (quote inclass) containing-decl-open 
containing-decl-start containing-decl-kwd paren-state)) (c-append-syntax (quote 
access-label) placeholder)) (containing-sexp (goto-char containing-sexp) (setq 
lim (c-most-enclosing-brace c-state-cache containing-sexp)) (save-excursion 
(setq tmpsymbol (if (and ... ...) (quote case-label) (quote label)))) 
(c-backward-to-block-anchor lim) (c-add-stmt-syntax tmpsymbol nil t lim 
paren-state)) (t (c-add-syntax (quote access-label) (point-min))))) ((setq 
placeholder (c-looking-at-inexpr-block (c-safe-position containing-sexp 
paren-state) containing-sexp t)) (setq tmpsymbol (assq (car placeholder) (quote 
((inexpr-class . class-open) (inexpr-statement . block-open))))) (if tmpsymbol 
(setq tmpsymbol (cdr tmpsymbol)) (setq tmpsymbol (if (eq char-after-ip 123) 
(quote inline-open) (quote lambda-intro-cont)))) (goto-char (cdr placeholder)) 
(back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace c-state-cache (point)) paren-state) (unless (eq (point) 
(cdr placeholder)) (c-add-syntax (car placeholder)))) ((or containing-decl-open 
(null containing-sexp)) (cond ((setq special-brace-list (or (and 
c-special-brace-lists (c-looking-at-special-brace-list)) (eq char-after-ip 
123))) (cond ((save-excursion (let ... ...)) (goto-char placeholder) 
(c-add-stmt-syntax (if ... ... ...) nil t containing-sexp paren-state)) 
((save-excursion (goto-char indent-point) (skip-chars-forward "     ") (and ... 
... ...)) (c-add-syntax (quote class-open) placeholder)) ((save-excursion 
(c-beginning-of-decl-1 lim) (while ... ... ...) (setq placeholder ...) (or ... 
...)) (if (and ... ... ...) (progn ... ...) (c-add-syntax ... placeholder))) 
((and containing-decl-open (not ...)) (c-add-syntax (quote inline-open)) 
(c-add-class-syntax (quote inclass) containing-decl-open containing-decl-start 
containing-decl-kwd paren-state)) (t (save-excursion (c-beginning-of-decl-1 
lim) (while ... ... ...) (c-add-syntax ... ...))))) ((save-excursion (when 
(setq placeholder (c-just-after-func-arglist-p lim)) (setq tmp-pos (point)))) 
(cond ((eq (char-after tmp-pos) 58) (if (or ... ...) (progn ... ...) (goto-char 
...) (c-forward-syntactic-ws) (c-add-syntax ... ...))) ((and c-recognize-knr-p 
(c-in-knr-argdecl lim)) (c-beginning-of-statement-1 lim) (c-add-syntax (quote 
knr-argdecl-intro) (c-point ...)) (if containing-decl-open (c-add-class-syntax 
... containing-decl-open containing-decl-start containing-decl-kwd 
paren-state))) (t (c-beginning-of-statement-1 lim) (c-add-syntax (quote 
func-decl-cont) (c-point ...))))) ((or (and (c-major-mode-is (quote c++-mode)) 
(progn (when ... ... ...) (looking-at c-opt-postfix-decl-spec-key))) (and (or 
(eq char-before-ip 58) (save-excursion ...)) (save-excursion 
(c-backward-syntactic-ws lim) (if ... ...) (back-to-indentation) (looking-at 
c-class-key))) (and (c-major-mode-is (quote java-mode)) (let (... cont done) 
(save-excursion ...) injava-inher) (not (c-crosses-statement-barrier-p ... 
...)))) (cond ((eq char-after-ip 58) (c-beginning-of-statement-1 lim) 
(c-add-syntax (quote inher-intro) (c-point ...))) ((eq char-before-ip 58) 
(c-beginning-of-statement-1 lim) (c-add-syntax (quote inher-intro) (c-point 
...)) (if containing-decl-open (c-add-class-syntax ... containing-decl-open 
containing-decl-start containing-decl-kwd paren-state))) (injava-inher (let 
(... ...) (goto-char where) (cond ... ... ...))) (t 
(c-beginning-of-inheritance-list lim) (c-add-syntax (quote inher-cont) 
(point))))) ((save-excursion (if c-recognize-<>-arglists (while (and ... ...)) 
(c-syntactic-skip-backward "^;,=" lim t)) (memq (char-before) (quote (44 61 
60)))) (cond ((and (c-major-mode-is ...) (save-excursion ...)) 
(c-with-syntax-table c++-template-syntax-table (goto-char placeholder) 
(c-beginning-of-statement-1 lim t) (if ... ... ...)) (c-add-syntax (quote 
template-args-cont) (point) placeholder)) ((and (c-major-mode-is ...) 
(save-excursion ... ... ... ...)) (goto-char placeholder) (c-add-syntax (quote 
inher-cont) (c-point ...))) (t (while (and ... ... ... ...)) (c-add-stmt-syntax 
(cond ... ... ...) nil nil containing-sexp paren-state)))) ((and (eq 
char-after-ip 125) (c-keyword-member containing-decl-kwd (quote 
c-other-block-decl-kwds))) (goto-char containing-decl-start) (c-add-stmt-syntax 
(if (string-equal (symbol-name containing-decl-kwd) "extern") (quote 
extern-lang-close) (intern (concat ... "-close"))) nil t 
(c-most-enclosing-brace paren-state (point)) paren-state)) ((and 
containing-sexp (eq char-after-ip 125) (eq containing-decl-open 
containing-sexp)) (c-add-class-syntax (quote class-close) containing-decl-open 
containing-decl-start containing-decl-kwd paren-state)) ((and c-recognize-knr-p 
(not containing-sexp) (not (eq char-before-ip 125)) (save-excursion (setq 
placeholder (cdr ...)) (and placeholder (not ...))) (< placeholder 
indent-point)) (goto-char placeholder) (c-add-syntax (quote knr-argdecl) 
(point))) ((and c-opt-method-key (looking-at c-opt-method-key)) 
(c-beginning-of-statement-1 nil t) (if (= (point) indent-point) (goto-char 
(point-min))) (c-add-syntax (quote objc-method-intro) (c-point (quote boi)))) 
((c-major-mode-is (quote awk-mode)) (setq placeholder (point)) 
(c-add-stmt-syntax (if (and (eq ... ...) (/= ... placeholder)) (quote 
topmost-intro-cont) (quote topmost-intro)) nil nil containing-sexp 
paren-state)) ((progn (c-backward-syntactic-ws lim) (and (eq (char-before) 125) 
(save-excursion (let ... ... ... ... ...)))) (goto-char placeholder) 
(c-add-stmt-syntax (quote topmost-intro-cont) nil nil containing-sexp 
paren-state)) ((and (not (and macro-start (> indent-point macro-start))) 
(save-excursion (setq placeholder (point)) (or (memq char-before-ip ...) 
(c-at-vsemi-p before-ws-ip) (when ... ... ...) (and ... ...)))) (goto-char 
placeholder) (c-add-syntax (quote topmost-intro) (c-point (quote bol))) (if 
containing-decl-open (if (c-keyword-member containing-decl-kwd (quote 
c-other-block-decl-kwds)) (progn (goto-char ...) (c-add-stmt-syntax ... nil t 
... paren-state)) (c-add-class-syntax (quote inclass) containing-decl-open 
containing-decl-start containing-decl-kwd paren-state))) (when (and 
c-syntactic-indentation-in-macros macro-start (/= macro-start (c-point ... 
indent-point))) (c-add-syntax (quote cpp-define-intro)) (setq macro-start 
nil))) ((and c-opt-method-key (save-excursion (c-beginning-of-statement-1 lim) 
(beginning-of-line) (when (looking-at c-opt-method-key) (setq placeholder 
...)))) (c-add-syntax (quote objc-method-args-cont) placeholder)) ((and 
c-recognize-<>-arglists (eq (char-before) 60) (not (and 
c-overloadable-operators-regexp (c-after-special-operator-id lim)))) 
(c-beginning-of-statement-1 (c-safe-position (point) paren-state)) 
(c-add-syntax (quote template-args-cont) (c-point (quote boi)))) (macro-start 
(c-beginning-of-statement-1 containing-sexp) (c-add-stmt-syntax (quote 
statement) nil t containing-sexp paren-state)) ((and (c-major-mode-is (quote 
java-mode)) (setq placeholder (point)) (c-beginning-of-statement-1) (progn 
(while (and ...) (c-forward-syntactic-ws)) t) (prog1 (>= (point) placeholder) 
(goto-char placeholder))) (c-add-syntax (quote annotation-top-cont) (c-point 
(quote boi)))) (t (c-beginning-of-statement-1 (c-safe-position (point) 
paren-state)) (when (c-major-mode-is (quote objc-mode)) (setq placeholder 
(point)) (while (and (c-forward-objc-directive) (< ... indent-point)) 
(c-forward-syntactic-ws) (setq placeholder (point))) (goto-char placeholder)) 
(c-add-syntax (quote topmost-intro-cont) (c-point (quote boi)))))) ((not (or 
(and c-special-brace-lists (save-excursion (goto-char containing-sexp) 
(c-looking-at-special-brace-list))) (eq (char-after containing-sexp) 123))) 
(cond ((memq char-after-ip (quote (41 93))) (goto-char containing-sexp) (setq 
placeholder (c-point (quote boi))) (if (and (c-safe (backward-up-list 1) t) (>= 
(point) placeholder)) (progn (forward-char) (skip-chars-forward "         ")) 
(goto-char placeholder)) (c-add-stmt-syntax (quote arglist-close) (list 
containing-sexp) t (c-most-enclosing-brace paren-state (point)) paren-state)) 
((and c-recognize-<>-arglists (setq containing-< (c-up-list-backward 
indent-point containing-sexp)) (eq (char-after containing-<) 60)) (setq 
placeholder (c-point (quote boi) containing-<)) (goto-char containing-sexp) (if 
(>= (point) placeholder) (progn (forward-char) (skip-chars-forward "     ")) 
(goto-char placeholder)) (c-add-stmt-syntax (quote template-args-cont) (list 
containing-<) t (c-most-enclosing-brace c-state-cache (point)) paren-state)) 
((and (eq char-after-ip 123) (progn (setq placeholder (c-inside-bracelist-p ... 
paren-state)) (if placeholder (setq tmpsymbol ...) (setq tmpsymbol ... 
placeholder ...)))) (goto-char placeholder) (back-to-indentation) 
(c-add-stmt-syntax (car tmpsymbol) nil t (c-most-enclosing-brace paren-state 
(point)) paren-state) (if (/= (point) placeholder) (c-add-syntax (cdr 
tmpsymbol)))) ((memq char-before-ip (quote (40 91))) (goto-char 
containing-sexp) (setq placeholder (c-point (quote boi))) (if (and (c-safe 
(backward-up-list 1) t) (>= (point) placeholder)) (progn (forward-char) 
(skip-chars-forward "      ")) (goto-char placeholder)) (c-add-stmt-syntax 
(quote arglist-intro) (list containing-sexp) t (c-most-enclosing-brace 
paren-state (point)) paren-state)) ((progn (goto-char containing-sexp) (and 
(c-safe (c-forward-sexp -1) t) (looking-at "\\<for\\>[^_]"))) (goto-char (1+ 
containing-sexp)) (c-forward-syntactic-ws indent-point) (if (eq char-before-ip 
59) (c-add-syntax (quote statement) (point)) (c-add-syntax (quote 
statement-cont) (point)))) ((and c-opt-method-key (eq (char-after 
containing-sexp) 91) (progn (goto-char (1- containing-sexp)) 
(c-backward-syntactic-ws (c-point ...)) (if (not ...) (c-add-syntax ... 
containing-sexp))))) ((progn (goto-char (1+ containing-sexp)) (< 
(save-excursion (c-forward-syntactic-ws) (point)) (c-point (quote bonl)))) 
(goto-char containing-sexp) (setq placeholder (c-point (quote boi))) (if (and 
(c-safe (backward-up-list 1) t) (>= (point) placeholder)) (progn (forward-char) 
(skip-chars-forward "         ")) (goto-char placeholder)) (c-add-stmt-syntax 
(quote arglist-cont-nonempty) (list containing-sexp) t (c-most-enclosing-brace 
c-state-cache (point)) paren-state)) (t (c-forward-syntactic-ws indent-point) 
(c-add-syntax (quote arglist-cont) (c-point (quote boi)))))) ((and 
(c-major-mode-is (quote c++-mode)) (save-excursion (goto-char indent-point) 
(skip-chars-forward "       ") (looking-at c-opt-postfix-decl-spec-key))) 
(goto-char indent-point) (skip-chars-forward "    ") (cond ((eq char-after-ip 
58) (c-backward-syntactic-ws lim) (c-add-syntax (quote inher-intro) (c-point 
(quote boi)))) ((eq char-before-ip 58) (c-add-syntax (quote inher-intro) 
(c-point (quote boi)))) (t (c-beginning-of-inheritance-list lim) (c-add-syntax 
(quote inher-cont) (point))))) ((and (not (c-major-mode-is (quote awk-mode))) 
(setq special-brace-list (or (and c-special-brace-lists (save-excursion 
(goto-char containing-sexp) (c-looking-at-special-brace-list))) 
(c-inside-bracelist-p containing-sexp paren-state)))) (cond ((and (consp 
special-brace-list) (save-excursion (goto-char containing-sexp) (eq 
(char-after) 40)) (eq char-after-ip (car (cdr special-brace-list)))) (goto-char 
(car (car special-brace-list))) (skip-chars-backward "      ") (if (and (bolp) 
(assoc (quote statement-cont) (setq placeholder ...))) (setq 
c-syntactic-context placeholder) (c-beginning-of-statement-1 (c-safe-position 
(1- containing-sexp) paren-state)) (c-forward-token-2 0) (while (looking-at 
c-specifier-key) (goto-char (match-end 1)) (c-forward-syntactic-ws)) 
(c-add-syntax (quote brace-list-open) (c-point (quote boi))))) ((if (consp 
special-brace-list) (progn (goto-char (car ...)) (save-excursion (goto-char 
indent-point) (back-to-indentation) (or ... ...))) (and (eq char-after-ip 125) 
(c-safe (goto-char ...) t) (= (point) containing-sexp))) (if (eq (point) 
(c-point (quote boi))) (c-add-syntax (quote brace-list-close) (point)) (setq 
lim (c-most-enclosing-brace c-state-cache (point))) (c-beginning-of-statement-1 
lim) (c-add-stmt-syntax (quote brace-list-close) nil t lim paren-state))) (t 
(if (consp special-brace-list) (progn (goto-char (car ...)) (c-forward-token-2 
1 nil indent-point)) (goto-char containing-sexp)) (forward-char) (let ((start 
(point))) (c-forward-syntactic-ws indent-point) (goto-char (max start (c-point 
...)))) (c-skip-ws-forward indent-point) (cond ((= (point) indent-point) (if 
(consp special-brace-list) (goto-char ...) (goto-char containing-sexp)) (if (eq 
... ...) (c-add-syntax ... ...) (setq lim ...) (c-beginning-of-statement-1 lim) 
(c-add-stmt-syntax ... nil t lim paren-state))) (t (if (or ... ...) 
(c-add-syntax ... ...) (c-add-syntax ... ...))))))) ((and (not (memq 
char-before-ip (quote (59 58)))) (not (c-at-vsemi-p before-ws-ip)) (or (not (eq 
char-before-ip 125)) (c-looking-at-inexpr-block-backward c-state-cache)) (> 
(point) (save-excursion (c-beginning-of-statement-1 containing-sexp) (setq 
placeholder (point)))) (/= placeholder containing-sexp)) 
(c-guess-continued-construct indent-point char-after-ip placeholder 
containing-sexp paren-state)) ((eq char-after-ip 125) (setq lim 
(c-most-enclosing-brace paren-state)) (goto-char containing-sexp) (cond 
((c-after-conditional) (c-backward-to-block-anchor lim) (c-add-stmt-syntax 
(quote block-close) nil t lim paren-state)) ((setq placeholder 
(c-looking-at-inexpr-block (c-safe-position containing-sexp paren-state) nil)) 
(setq tmpsymbol (if (eq (car placeholder) (quote inlambda)) (quote 
inline-close) (quote block-close))) (goto-char containing-sexp) 
(back-to-indentation) (if (= containing-sexp (point)) (c-add-syntax tmpsymbol 
(point)) (goto-char (cdr placeholder)) (back-to-indentation) (c-add-stmt-syntax 
tmpsymbol nil t (c-most-enclosing-brace paren-state (point)) paren-state) (if 
(/= (point) (cdr placeholder)) (c-add-syntax (car placeholder))))) 
((save-excursion (and lim (progn (goto-char lim) (c-looking-at-decl-block ... 
nil)) (setq placeholder (point)))) (c-backward-to-decl-anchor lim) 
(back-to-indentation) (if (save-excursion (goto-char placeholder) (looking-at 
c-other-decl-block-key)) (c-add-syntax (quote defun-close) (point)) 
(c-add-syntax (quote inline-close) (point)))) ((save-excursion (and (not 
(c-at-statement-start-p)) (eq (c-beginning-of-statement-1 lim nil nil t) (quote 
same)) (setq placeholder (point)) (let (...) (c-forward-decl-or-cast-1 ... nil 
nil)))) (back-to-indentation) (if (/= (point) containing-sexp) (goto-char 
placeholder)) (c-add-stmt-syntax (quote defun-close) nil t lim paren-state)) 
(lim (while (and (/= (setq placeholder ...) (c-point ...)) (eq 
(c-beginning-of-statement-1 lim) (quote label)))) (goto-char placeholder) (if 
(looking-at c-label-kwds-regexp) (c-add-syntax (quote block-close) (point)) 
(goto-char containing-sexp) (c-add-stmt-syntax (quote block-close) nil t lim 
paren-state))) (t (goto-char containing-sexp) (c-backward-to-decl-anchor lim) 
(c-add-stmt-syntax (quote defun-close) nil nil (c-most-enclosing-brace 
paren-state) paren-state)))) (t (goto-char indent-point) (while (let* 
((prev-point (point)) (last-step-type (c-beginning-of-statement-1 
containing-sexp))) (if (= (point) prev-point) (progn (setq step-type (or 
step-type last-step-type)) nil) (setq step-type last-step-type) (/= (point) 
(c-point (quote boi)))))) (cond ((and (eq step-type (quote same)) (/= (point) 
indent-point)) (c-add-stmt-syntax (quote statement-cont) nil nil 
containing-sexp paren-state)) ((progn (while (and (eq step-type ...) (not ...)) 
(setq step-type (c-beginning-of-statement-1 containing-sexp))) (eq step-type 
(quote label))) (c-add-stmt-syntax (if (eq char-after-ip 123) (quote 
statement-case-open) (quote statement-case-intro)) nil t containing-sexp 
paren-state)) ((progn (while (eq step-type (quote label)) (setq step-type 
(c-beginning-of-statement-1 containing-sexp))) (eq step-type (quote previous))) 
(c-add-stmt-syntax (quote statement) nil t containing-sexp paren-state) (if (eq 
char-after-ip 123) (c-add-syntax (quote block-open)))) ((progn (goto-char 
containing-sexp) (setq lim (c-most-enclosing-brace paren-state 
containing-sexp)) (c-after-conditional)) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax (quote statement-block-intro) nil t lim paren-state) (if (eq 
char-after-ip 123) (c-add-syntax (quote block-open)))) ((setq placeholder 
(c-looking-at-inexpr-block (c-safe-position containing-sexp paren-state) nil)) 
(setq tmpsymbol (if (eq (car placeholder) (quote inlambda)) (quote 
defun-block-intro) (quote statement-block-intro))) (back-to-indentation) (if (= 
containing-sexp (point)) (c-add-syntax tmpsymbol (point)) (goto-char (cdr 
placeholder)) (back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace c-state-cache (point)) paren-state) (if (/= (point) 
(cdr placeholder)) (c-add-syntax (car placeholder)))) (if (eq char-after-ip 
123) (c-add-syntax (quote block-open)))) ((save-excursion (or (not (setq 
placeholder ...)) (and (progn ... ...) (c-looking-at-decl-block ... nil)))) 
(c-backward-to-decl-anchor lim) (back-to-indentation) (c-add-syntax (quote 
defun-block-intro) (point))) ((save-excursion (and (not 
(c-at-statement-start-p)) (eq (c-beginning-of-statement-1 lim nil nil t) (quote 
same)) (setq placeholder (point)) (let (...) (c-forward-decl-or-cast-1 ... nil 
nil)))) (back-to-indentation) (if (/= (point) containing-sexp) (goto-char 
placeholder)) (c-add-stmt-syntax (quote defun-block-intro) nil t lim 
paren-state)) (t (while (and (/= (setq placeholder ...) (c-point ...)) (eq 
(c-beginning-of-statement-1 lim) (quote label)))) (goto-char placeholder) (if 
(looking-at c-label-kwds-regexp) (c-add-syntax (quote statement-block-intro) 
(point)) (goto-char containing-sexp) (c-add-stmt-syntax (quote 
statement-block-intro) nil t lim paren-state)) (if (eq char-after-ip 123) 
(c-add-syntax (quote block-open)))))))
  (progn (when (and (setq containing-sexp (c-most-enclosing-brace paren-state)) 
(progn (goto-char containing-sexp) (eq (char-after) 123)) (setq placeholder 
(c-looking-at-decl-block (c-most-enclosing-brace paren-state containing-sexp) 
t))) (setq containing-decl-open containing-sexp containing-decl-start (point) 
containing-sexp nil) (goto-char placeholder) (setq containing-decl-kwd (and 
(looking-at c-keywords-regexp) (c-keyword-sym (match-string 1))))) (if 
c-state-cache (progn (setq containing-sexp (car paren-state) paren-state (cdr 
paren-state)) (if (consp containing-sexp) (progn (setq lim (cdr 
containing-sexp)) (if (cdr c-state-cache) (setq containing-sexp (car ...) 
paren-state (cdr paren-state)) (setq paren-state (cons containing-sexp 
paren-state) containing-sexp nil))) (setq lim (1+ containing-sexp)))) (setq lim 
(point-min))) (when (and containing-sexp (eq (char-after containing-sexp) 40)) 
(setq c-stmt-delim-chars c-stmt-delim-chars-with-comma)) (goto-char 
indent-point) (c-backward-syntactic-ws lim) (setq before-ws-ip (point) 
char-before-ip (char-before)) (goto-char indent-point) (skip-chars-forward "    
    ") (setq char-after-ip (char-after)) (setq literal (c-in-literal lim)) 
(cond ((eq literal (quote string)) (c-add-syntax (quote string) (c-point (quote 
bopl)))) ((and (memq literal (quote (c c++))) (setq placeholder 
(c-literal-limits lim))) (c-add-syntax literal (car placeholder))) ((and 
(save-excursion (when (c-beginning-of-macro) (setq macro-start (point)))) (/= 
macro-start (c-point (quote boi))) (progn (setq tmpsymbol (quote 
cpp-macro-cont)) (or (not c-syntactic-indentation-in-macros) (save-excursion 
(goto-char macro-start) (if ... ... ... nil))))) (c-add-syntax tmpsymbol 
macro-start) (setq macro-start nil)) ((looking-at "else\\>[^_]") 
(c-beginning-of-statement-1 containing-sexp) (c-add-stmt-syntax (quote 
else-clause) nil t containing-sexp paren-state)) ((and (looking-at 
"while\\>[^_]") (save-excursion (prog1 (eq (c-beginning-of-statement-1 
containing-sexp) (quote beginning)) (setq placeholder (point))))) (goto-char 
placeholder) (c-add-stmt-syntax (quote do-while-closure) nil t containing-sexp 
paren-state)) ((save-excursion (and (cond ((c-major-mode-is ...) (looking-at 
"catch\\>[^_]")) ((c-major-mode-is ...) (looking-at 
"\\(catch\\|finally\\)\\>[^_]"))) (and (c-safe (c-backward-syntactic-ws) 
(c-backward-sexp) t) (eq (char-after) 123) (c-safe (c-backward-syntactic-ws) 
(c-backward-sexp) t) (if (eq ... 40) (c-safe ... t) t)) (looking-at 
"\\(try\\|catch\\)\\>[^_]") (setq placeholder (point)))) (goto-char 
placeholder) (c-add-stmt-syntax (quote catch-clause) nil t containing-sexp 
paren-state)) ((save-excursion (and c-opt-block-stmt-key (not (eq 
char-before-ip 59)) (not (c-at-vsemi-p before-ws-ip)) (not (memq char-after-ip 
(quote ...))) (or (not (eq char-before-ip 125)) 
(c-looking-at-inexpr-block-backward c-state-cache)) (> (point) (progn (setq 
placeholder ...) (while ...) (if ... ... ... ...) placeholder)) (if (looking-at 
c-block-stmt-2-key) (and (zerop ...) (eq ... 40)) (looking-at 
c-opt-block-stmt-key)))) (if (eq step-type (quote up)) (progn (goto-char 
placeholder) (cond ((eq char-after-ip 123) (c-add-stmt-syntax ... nil nil 
containing-sexp paren-state)) ((save-excursion ... ... ...) (c-add-stmt-syntax 
... nil nil containing-sexp paren-state)) (t (c-add-stmt-syntax ... nil nil 
containing-sexp paren-state)))) (c-guess-continued-construct indent-point 
char-after-ip placeholder lim paren-state))) ((looking-at c-label-kwds-regexp) 
(if containing-sexp (progn (goto-char containing-sexp) (setq lim 
(c-most-enclosing-brace c-state-cache containing-sexp)) 
(c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote case-label) nil t 
lim paren-state)) (c-add-syntax (quote case-label) (point-min)))) 
((save-excursion (back-to-indentation) (and (not (looking-at 
c-syntactic-ws-start)) (c-forward-label))) (cond (containing-decl-open (setq 
placeholder (c-add-class-syntax (quote inclass) containing-decl-open 
containing-decl-start containing-decl-kwd paren-state)) (c-append-syntax (quote 
access-label) placeholder)) (containing-sexp (goto-char containing-sexp) (setq 
lim (c-most-enclosing-brace c-state-cache containing-sexp)) (save-excursion 
(setq tmpsymbol (if ... ... ...))) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax tmpsymbol nil t lim paren-state)) (t (c-add-syntax (quote 
access-label) (point-min))))) ((setq placeholder (c-looking-at-inexpr-block 
(c-safe-position containing-sexp paren-state) containing-sexp t)) (setq 
tmpsymbol (assq (car placeholder) (quote ((inexpr-class . class-open) 
(inexpr-statement . block-open))))) (if tmpsymbol (setq tmpsymbol (cdr 
tmpsymbol)) (setq tmpsymbol (if (eq char-after-ip 123) (quote inline-open) 
(quote lambda-intro-cont)))) (goto-char (cdr placeholder)) 
(back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace c-state-cache (point)) paren-state) (unless (eq (point) 
(cdr placeholder)) (c-add-syntax (car placeholder)))) ((or containing-decl-open 
(null containing-sexp)) (cond ((setq special-brace-list (or (and 
c-special-brace-lists ...) (eq char-after-ip 123))) (cond ((save-excursion ...) 
(goto-char placeholder) (c-add-stmt-syntax ... nil t containing-sexp 
paren-state)) ((save-excursion ... ... ...) (c-add-syntax ... placeholder)) 
((save-excursion ... ... ... ...) (if ... ... ...)) ((and containing-decl-open 
...) (c-add-syntax ...) (c-add-class-syntax ... containing-decl-open 
containing-decl-start containing-decl-kwd paren-state)) (t (save-excursion ... 
... ...)))) ((save-excursion (when (setq placeholder ...) (setq tmp-pos ...))) 
(cond ((eq ... 58) (if ... ... ... ... ...)) ((and c-recognize-knr-p ...) 
(c-beginning-of-statement-1 lim) (c-add-syntax ... ...) (if 
containing-decl-open ...)) (t (c-beginning-of-statement-1 lim) (c-add-syntax 
... ...)))) ((or (and (c-major-mode-is ...) (progn ... ...)) (and (or ... ...) 
(save-excursion ... ... ... ...)) (and (c-major-mode-is ...) (let ... ... 
injava-inher) (not ...))) (cond ((eq char-after-ip 58) 
(c-beginning-of-statement-1 lim) (c-add-syntax ... ...)) ((eq char-before-ip 
58) (c-beginning-of-statement-1 lim) (c-add-syntax ... ...) (if 
containing-decl-open ...)) (injava-inher (let ... ... ...)) (t 
(c-beginning-of-inheritance-list lim) (c-add-syntax ... ...)))) 
((save-excursion (if c-recognize-<>-arglists (while ...) 
(c-syntactic-skip-backward "^;,=" lim t)) (memq (char-before) (quote ...))) 
(cond ((and ... ...) (c-with-syntax-table c++-template-syntax-table ... ... 
...) (c-add-syntax ... ... placeholder)) ((and ... ...) (goto-char placeholder) 
(c-add-syntax ... ...)) (t (while ...) (c-add-stmt-syntax ... nil nil 
containing-sexp paren-state)))) ((and (eq char-after-ip 125) (c-keyword-member 
containing-decl-kwd (quote c-other-block-decl-kwds))) (goto-char 
containing-decl-start) (c-add-stmt-syntax (if (string-equal ... "extern") 
(quote extern-lang-close) (intern ...)) nil t (c-most-enclosing-brace 
paren-state (point)) paren-state)) ((and containing-sexp (eq char-after-ip 125) 
(eq containing-decl-open containing-sexp)) (c-add-class-syntax (quote 
class-close) containing-decl-open containing-decl-start containing-decl-kwd 
paren-state)) ((and c-recognize-knr-p (not containing-sexp) (not (eq 
char-before-ip 125)) (save-excursion (setq placeholder ...) (and placeholder 
...)) (< placeholder indent-point)) (goto-char placeholder) (c-add-syntax 
(quote knr-argdecl) (point))) ((and c-opt-method-key (looking-at 
c-opt-method-key)) (c-beginning-of-statement-1 nil t) (if (= (point) 
indent-point) (goto-char (point-min))) (c-add-syntax (quote objc-method-intro) 
(c-point (quote boi)))) ((c-major-mode-is (quote awk-mode)) (setq placeholder 
(point)) (c-add-stmt-syntax (if (and ... ...) (quote topmost-intro-cont) (quote 
topmost-intro)) nil nil containing-sexp paren-state)) ((progn 
(c-backward-syntactic-ws lim) (and (eq ... 125) (save-excursion ...))) 
(goto-char placeholder) (c-add-stmt-syntax (quote topmost-intro-cont) nil nil 
containing-sexp paren-state)) ((and (not (and macro-start ...)) (save-excursion 
(setq placeholder ...) (or ... ... ... ...))) (goto-char placeholder) 
(c-add-syntax (quote topmost-intro) (c-point (quote bol))) (if 
containing-decl-open (if (c-keyword-member containing-decl-kwd ...) (progn ... 
...) (c-add-class-syntax ... containing-decl-open containing-decl-start 
containing-decl-kwd paren-state))) (when (and c-syntactic-indentation-in-macros 
macro-start (/= macro-start ...)) (c-add-syntax (quote cpp-define-intro)) (setq 
macro-start nil))) ((and c-opt-method-key (save-excursion 
(c-beginning-of-statement-1 lim) (beginning-of-line) (when ... ...))) 
(c-add-syntax (quote objc-method-args-cont) placeholder)) ((and 
c-recognize-<>-arglists (eq (char-before) 60) (not (and 
c-overloadable-operators-regexp ...))) (c-beginning-of-statement-1 
(c-safe-position (point) paren-state)) (c-add-syntax (quote template-args-cont) 
(c-point (quote boi)))) (macro-start (c-beginning-of-statement-1 
containing-sexp) (c-add-stmt-syntax (quote statement) nil t containing-sexp 
paren-state)) ((and (c-major-mode-is (quote java-mode)) (setq placeholder 
(point)) (c-beginning-of-statement-1) (progn (while ... ...) t) (prog1 (>= ... 
placeholder) (goto-char placeholder))) (c-add-syntax (quote 
annotation-top-cont) (c-point (quote boi)))) (t (c-beginning-of-statement-1 
(c-safe-position (point) paren-state)) (when (c-major-mode-is (quote 
objc-mode)) (setq placeholder (point)) (while (and ... ...) 
(c-forward-syntactic-ws) (setq placeholder ...)) (goto-char placeholder)) 
(c-add-syntax (quote topmost-intro-cont) (c-point (quote boi)))))) ((not (or 
(and c-special-brace-lists (save-excursion (goto-char containing-sexp) 
(c-looking-at-special-brace-list))) (eq (char-after containing-sexp) 123))) 
(cond ((memq char-after-ip (quote (41 93))) (goto-char containing-sexp) (setq 
placeholder (c-point (quote boi))) (if (and (c-safe ... t) (>= ... 
placeholder)) (progn (forward-char) (skip-chars-forward "      ")) (goto-char 
placeholder)) (c-add-stmt-syntax (quote arglist-close) (list containing-sexp) t 
(c-most-enclosing-brace paren-state (point)) paren-state)) ((and 
c-recognize-<>-arglists (setq containing-< (c-up-list-backward indent-point 
containing-sexp)) (eq (char-after containing-<) 60)) (setq placeholder (c-point 
(quote boi) containing-<)) (goto-char containing-sexp) (if (>= (point) 
placeholder) (progn (forward-char) (skip-chars-forward "     ")) (goto-char 
placeholder)) (c-add-stmt-syntax (quote template-args-cont) (list containing-<) 
t (c-most-enclosing-brace c-state-cache (point)) paren-state)) ((and (eq 
char-after-ip 123) (progn (setq placeholder ...) (if placeholder ... ...))) 
(goto-char placeholder) (back-to-indentation) (c-add-stmt-syntax (car 
tmpsymbol) nil t (c-most-enclosing-brace paren-state (point)) paren-state) (if 
(/= (point) placeholder) (c-add-syntax (cdr tmpsymbol)))) ((memq char-before-ip 
(quote (40 91))) (goto-char containing-sexp) (setq placeholder (c-point (quote 
boi))) (if (and (c-safe ... t) (>= ... placeholder)) (progn (forward-char) 
(skip-chars-forward "        ")) (goto-char placeholder)) (c-add-stmt-syntax 
(quote arglist-intro) (list containing-sexp) t (c-most-enclosing-brace 
paren-state (point)) paren-state)) ((progn (goto-char containing-sexp) (and 
(c-safe ... t) (looking-at "\\<for\\>[^_]"))) (goto-char (1+ containing-sexp)) 
(c-forward-syntactic-ws indent-point) (if (eq char-before-ip 59) (c-add-syntax 
(quote statement) (point)) (c-add-syntax (quote statement-cont) (point)))) 
((and c-opt-method-key (eq (char-after containing-sexp) 91) (progn (goto-char 
...) (c-backward-syntactic-ws ...) (if ... ...)))) ((progn (goto-char (1+ 
containing-sexp)) (< (save-excursion ... ...) (c-point ...))) (goto-char 
containing-sexp) (setq placeholder (c-point (quote boi))) (if (and (c-safe ... 
t) (>= ... placeholder)) (progn (forward-char) (skip-chars-forward "        ")) 
(goto-char placeholder)) (c-add-stmt-syntax (quote arglist-cont-nonempty) (list 
containing-sexp) t (c-most-enclosing-brace c-state-cache (point)) paren-state)) 
(t (c-forward-syntactic-ws indent-point) (c-add-syntax (quote arglist-cont) 
(c-point (quote boi)))))) ((and (c-major-mode-is (quote c++-mode)) 
(save-excursion (goto-char indent-point) (skip-chars-forward "       ") 
(looking-at c-opt-postfix-decl-spec-key))) (goto-char indent-point) 
(skip-chars-forward "    ") (cond ((eq char-after-ip 58) 
(c-backward-syntactic-ws lim) (c-add-syntax (quote inher-intro) (c-point (quote 
boi)))) ((eq char-before-ip 58) (c-add-syntax (quote inher-intro) (c-point 
(quote boi)))) (t (c-beginning-of-inheritance-list lim) (c-add-syntax (quote 
inher-cont) (point))))) ((and (not (c-major-mode-is (quote awk-mode))) (setq 
special-brace-list (or (and c-special-brace-lists (save-excursion ... ...)) 
(c-inside-bracelist-p containing-sexp paren-state)))) (cond ((and (consp 
special-brace-list) (save-excursion (goto-char containing-sexp) (eq ... 40)) 
(eq char-after-ip (car ...))) (goto-char (car (car special-brace-list))) 
(skip-chars-backward "  ") (if (and (bolp) (assoc ... ...)) (setq 
c-syntactic-context placeholder) (c-beginning-of-statement-1 (c-safe-position 
... paren-state)) (c-forward-token-2 0) (while (looking-at c-specifier-key) 
(goto-char ...) (c-forward-syntactic-ws)) (c-add-syntax (quote brace-list-open) 
(c-point ...)))) ((if (consp special-brace-list) (progn (goto-char ...) 
(save-excursion ... ... ...)) (and (eq char-after-ip 125) (c-safe ... t) (= ... 
containing-sexp))) (if (eq (point) (c-point ...)) (c-add-syntax (quote 
brace-list-close) (point)) (setq lim (c-most-enclosing-brace c-state-cache 
...)) (c-beginning-of-statement-1 lim) (c-add-stmt-syntax (quote 
brace-list-close) nil t lim paren-state))) (t (if (consp special-brace-list) 
(progn (goto-char ...) (c-forward-token-2 1 nil indent-point)) (goto-char 
containing-sexp)) (forward-char) (let ((start ...)) (c-forward-syntactic-ws 
indent-point) (goto-char (max start ...))) (c-skip-ws-forward indent-point) 
(cond ((= ... indent-point) (if ... ... ...) (if ... ... ... ... ...)) (t (if 
... ... ...)))))) ((and (not (memq char-before-ip (quote (59 58)))) (not 
(c-at-vsemi-p before-ws-ip)) (or (not (eq char-before-ip 125)) 
(c-looking-at-inexpr-block-backward c-state-cache)) (> (point) (save-excursion 
(c-beginning-of-statement-1 containing-sexp) (setq placeholder (point)))) (/= 
placeholder containing-sexp)) (c-guess-continued-construct indent-point 
char-after-ip placeholder containing-sexp paren-state)) ((eq char-after-ip 125) 
(setq lim (c-most-enclosing-brace paren-state)) (goto-char containing-sexp) 
(cond ((c-after-conditional) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax (quote block-close) nil t lim paren-state)) ((setq 
placeholder (c-looking-at-inexpr-block (c-safe-position containing-sexp 
paren-state) nil)) (setq tmpsymbol (if (eq ... ...) (quote inline-close) (quote 
block-close))) (goto-char containing-sexp) (back-to-indentation) (if (= 
containing-sexp (point)) (c-add-syntax tmpsymbol (point)) (goto-char (cdr 
placeholder)) (back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace paren-state ...) paren-state) (if (/= ... ...) 
(c-add-syntax ...)))) ((save-excursion (and lim (progn ... ...) (setq 
placeholder ...))) (c-backward-to-decl-anchor lim) (back-to-indentation) (if 
(save-excursion (goto-char placeholder) (looking-at c-other-decl-block-key)) 
(c-add-syntax (quote defun-close) (point)) (c-add-syntax (quote inline-close) 
(point)))) ((save-excursion (and (not ...) (eq ... ...) (setq placeholder ...) 
(let ... ...))) (back-to-indentation) (if (/= (point) containing-sexp) 
(goto-char placeholder)) (c-add-stmt-syntax (quote defun-close) nil t lim 
paren-state)) (lim (while (and (/= ... ...) (eq ... ...))) (goto-char 
placeholder) (if (looking-at c-label-kwds-regexp) (c-add-syntax (quote 
block-close) (point)) (goto-char containing-sexp) (c-add-stmt-syntax (quote 
block-close) nil t lim paren-state))) (t (goto-char containing-sexp) 
(c-backward-to-decl-anchor lim) (c-add-stmt-syntax (quote defun-close) nil nil 
(c-most-enclosing-brace paren-state) paren-state)))) (t (goto-char 
indent-point) (while (let* ((prev-point (point)) (last-step-type 
(c-beginning-of-statement-1 containing-sexp))) (if (= (point) prev-point) 
(progn (setq step-type ...) nil) (setq step-type last-step-type) (/= (point) 
(c-point ...))))) (cond ((and (eq step-type (quote same)) (/= (point) 
indent-point)) (c-add-stmt-syntax (quote statement-cont) nil nil 
containing-sexp paren-state)) ((progn (while (and ... ...) (setq step-type 
...)) (eq step-type (quote label))) (c-add-stmt-syntax (if (eq char-after-ip 
123) (quote statement-case-open) (quote statement-case-intro)) nil t 
containing-sexp paren-state)) ((progn (while (eq step-type ...) (setq step-type 
...)) (eq step-type (quote previous))) (c-add-stmt-syntax (quote statement) nil 
t containing-sexp paren-state) (if (eq char-after-ip 123) (c-add-syntax (quote 
block-open)))) ((progn (goto-char containing-sexp) (setq lim 
(c-most-enclosing-brace paren-state containing-sexp)) (c-after-conditional)) 
(c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote 
statement-block-intro) nil t lim paren-state) (if (eq char-after-ip 123) 
(c-add-syntax (quote block-open)))) ((setq placeholder 
(c-looking-at-inexpr-block (c-safe-position containing-sexp paren-state) nil)) 
(setq tmpsymbol (if (eq ... ...) (quote defun-block-intro) (quote 
statement-block-intro))) (back-to-indentation) (if (= containing-sexp (point)) 
(c-add-syntax tmpsymbol (point)) (goto-char (cdr placeholder)) 
(back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace c-state-cache ...) paren-state) (if (/= ... ...) 
(c-add-syntax ...))) (if (eq char-after-ip 123) (c-add-syntax (quote 
block-open)))) ((save-excursion (or (not ...) (and ... ...))) 
(c-backward-to-decl-anchor lim) (back-to-indentation) (c-add-syntax (quote 
defun-block-intro) (point))) ((save-excursion (and (not ...) (eq ... ...) (setq 
placeholder ...) (let ... ...))) (back-to-indentation) (if (/= (point) 
containing-sexp) (goto-char placeholder)) (c-add-stmt-syntax (quote 
defun-block-intro) nil t lim paren-state)) (t (while (and (/= ... ...) (eq ... 
...))) (goto-char placeholder) (if (looking-at c-label-kwds-regexp) 
(c-add-syntax (quote statement-block-intro) (point)) (goto-char 
containing-sexp) (c-add-stmt-syntax (quote statement-block-intro) nil t lim 
paren-state)) (if (eq char-after-ip 123) (c-add-syntax (quote block-open))))))) 
(goto-char indent-point) (skip-chars-forward "  ") (when (and (looking-at 
c-comment-start-regexp) (/= (c-forward-token-2 0 nil (c-point (quote eol))) 0)) 
(c-append-syntax (quote comment-intro))) (when (and c-opt-friend-key 
(looking-at c-opt-friend-key)) (c-append-syntax (quote friend))) (let ((p 
c-syntactic-context)) (while (and p (if (integerp (c-langelem-pos (car p))) 
(progn (setq syntactic-relpos (c-langelem-pos ...)) nil) t)) (setq p (cdr p)))) 
(if (and macro-start (eq macro-start (c-point (quote boi))) (not (and 
(c-major-mode-is (quote pike-mode)) (eq (char-after (1+ macro-start)) 34)))) 
(c-append-syntax (quote cpp-macro)) (when (and 
c-syntactic-indentation-in-macros macro-start) (if in-macro-expr (when (or (< 
syntactic-relpos macro-start) (not (or ... ... ... ...))) (setq 
c-syntactic-context nil) (c-add-syntax (quote cpp-macro-cont) macro-start)) 
(when (and (eq macro-start syntactic-relpos) (not (assq ... 
c-syntactic-context)) (save-excursion (goto-char macro-start) (or ... ...))) 
(c-add-syntax (quote cpp-define-intro)))))) c-syntactic-context)
  (unwind-protect (progn (when (and (setq containing-sexp 
(c-most-enclosing-brace paren-state)) (progn (goto-char containing-sexp) (eq 
(char-after) 123)) (setq placeholder (c-looking-at-decl-block 
(c-most-enclosing-brace paren-state containing-sexp) t))) (setq 
containing-decl-open containing-sexp containing-decl-start (point) 
containing-sexp nil) (goto-char placeholder) (setq containing-decl-kwd (and 
(looking-at c-keywords-regexp) (c-keyword-sym (match-string 1))))) (if 
c-state-cache (progn (setq containing-sexp (car paren-state) paren-state (cdr 
paren-state)) (if (consp containing-sexp) (progn (setq lim (cdr 
containing-sexp)) (if (cdr c-state-cache) (setq containing-sexp ... paren-state 
...) (setq paren-state ... containing-sexp nil))) (setq lim (1+ 
containing-sexp)))) (setq lim (point-min))) (when (and containing-sexp (eq 
(char-after containing-sexp) 40)) (setq c-stmt-delim-chars 
c-stmt-delim-chars-with-comma)) (goto-char indent-point) 
(c-backward-syntactic-ws lim) (setq before-ws-ip (point) char-before-ip 
(char-before)) (goto-char indent-point) (skip-chars-forward "   ") (setq 
char-after-ip (char-after)) (setq literal (c-in-literal lim)) (cond ((eq 
literal (quote string)) (c-add-syntax (quote string) (c-point (quote bopl)))) 
((and (memq literal (quote (c c++))) (setq placeholder (c-literal-limits lim))) 
(c-add-syntax literal (car placeholder))) ((and (save-excursion (when 
(c-beginning-of-macro) (setq macro-start ...))) (/= macro-start (c-point (quote 
boi))) (progn (setq tmpsymbol (quote cpp-macro-cont)) (or (not 
c-syntactic-indentation-in-macros) (save-excursion ... ...)))) (c-add-syntax 
tmpsymbol macro-start) (setq macro-start nil)) ((looking-at "else\\>[^_]") 
(c-beginning-of-statement-1 containing-sexp) (c-add-stmt-syntax (quote 
else-clause) nil t containing-sexp paren-state)) ((and (looking-at 
"while\\>[^_]") (save-excursion (prog1 (eq ... ...) (setq placeholder ...)))) 
(goto-char placeholder) (c-add-stmt-syntax (quote do-while-closure) nil t 
containing-sexp paren-state)) ((save-excursion (and (cond (... ...) (... ...)) 
(and (c-safe ... ... t) (eq ... 123) (c-safe ... ... t) (if ... ... t)) 
(looking-at "\\(try\\|catch\\)\\>[^_]") (setq placeholder (point)))) (goto-char 
placeholder) (c-add-stmt-syntax (quote catch-clause) nil t containing-sexp 
paren-state)) ((save-excursion (and c-opt-block-stmt-key (not (eq 
char-before-ip 59)) (not (c-at-vsemi-p before-ws-ip)) (not (memq char-after-ip 
...)) (or (not ...) (c-looking-at-inexpr-block-backward c-state-cache)) (> 
(point) (progn ... ... ... placeholder)) (if (looking-at c-block-stmt-2-key) 
(and ... ...) (looking-at c-opt-block-stmt-key)))) (if (eq step-type (quote 
up)) (progn (goto-char placeholder) (cond (... ...) (... ...) (t ...))) 
(c-guess-continued-construct indent-point char-after-ip placeholder lim 
paren-state))) ((looking-at c-label-kwds-regexp) (if containing-sexp (progn 
(goto-char containing-sexp) (setq lim (c-most-enclosing-brace c-state-cache 
containing-sexp)) (c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote 
case-label) nil t lim paren-state)) (c-add-syntax (quote case-label) 
(point-min)))) ((save-excursion (back-to-indentation) (and (not (looking-at 
c-syntactic-ws-start)) (c-forward-label))) (cond (containing-decl-open (setq 
placeholder (c-add-class-syntax ... containing-decl-open containing-decl-start 
containing-decl-kwd paren-state)) (c-append-syntax (quote access-label) 
placeholder)) (containing-sexp (goto-char containing-sexp) (setq lim 
(c-most-enclosing-brace c-state-cache containing-sexp)) (save-excursion (setq 
tmpsymbol ...)) (c-backward-to-block-anchor lim) (c-add-stmt-syntax tmpsymbol 
nil t lim paren-state)) (t (c-add-syntax (quote access-label) (point-min))))) 
((setq placeholder (c-looking-at-inexpr-block (c-safe-position containing-sexp 
paren-state) containing-sexp t)) (setq tmpsymbol (assq (car placeholder) (quote 
(... ...)))) (if tmpsymbol (setq tmpsymbol (cdr tmpsymbol)) (setq tmpsymbol (if 
(eq char-after-ip 123) (quote inline-open) (quote lambda-intro-cont)))) 
(goto-char (cdr placeholder)) (back-to-indentation) (c-add-stmt-syntax 
tmpsymbol nil t (c-most-enclosing-brace c-state-cache (point)) paren-state) 
(unless (eq (point) (cdr placeholder)) (c-add-syntax (car placeholder)))) ((or 
containing-decl-open (null containing-sexp)) (cond ((setq special-brace-list 
(or ... ...)) (cond (... ... ...) (... ...) (... ...) (... ... ...) (t ...))) 
((save-excursion (when ... ...)) (cond (... ...) (... ... ... ...) (t ... 
...))) ((or (and ... ...) (and ... ...) (and ... ... ...)) (cond (... ... ...) 
(... ... ... ...) (injava-inher ...) (t ... ...))) ((save-excursion (if 
c-recognize-<>-arglists ... ...) (memq ... ...)) (cond (... ... ...) (... ... 
...) (t ... ...))) ((and (eq char-after-ip 125) (c-keyword-member 
containing-decl-kwd ...)) (goto-char containing-decl-start) (c-add-stmt-syntax 
(if ... ... ...) nil t (c-most-enclosing-brace paren-state ...) paren-state)) 
((and containing-sexp (eq char-after-ip 125) (eq containing-decl-open 
containing-sexp)) (c-add-class-syntax (quote class-close) containing-decl-open 
containing-decl-start containing-decl-kwd paren-state)) ((and c-recognize-knr-p 
(not containing-sexp) (not ...) (save-excursion ... ...) (< placeholder 
indent-point)) (goto-char placeholder) (c-add-syntax (quote knr-argdecl) 
(point))) ((and c-opt-method-key (looking-at c-opt-method-key)) 
(c-beginning-of-statement-1 nil t) (if (= ... indent-point) (goto-char ...)) 
(c-add-syntax (quote objc-method-intro) (c-point ...))) ((c-major-mode-is 
(quote awk-mode)) (setq placeholder (point)) (c-add-stmt-syntax (if ... ... 
...) nil nil containing-sexp paren-state)) ((progn (c-backward-syntactic-ws 
lim) (and ... ...)) (goto-char placeholder) (c-add-stmt-syntax (quote 
topmost-intro-cont) nil nil containing-sexp paren-state)) ((and (not ...) 
(save-excursion ... ...)) (goto-char placeholder) (c-add-syntax (quote 
topmost-intro) (c-point ...)) (if containing-decl-open (if ... ... ...)) (when 
(and c-syntactic-indentation-in-macros macro-start ...) (c-add-syntax ...) 
(setq macro-start nil))) ((and c-opt-method-key (save-excursion ... ... ...)) 
(c-add-syntax (quote objc-method-args-cont) placeholder)) ((and 
c-recognize-<>-arglists (eq ... 60) (not ...)) (c-beginning-of-statement-1 
(c-safe-position ... paren-state)) (c-add-syntax (quote template-args-cont) 
(c-point ...))) (macro-start (c-beginning-of-statement-1 containing-sexp) 
(c-add-stmt-syntax (quote statement) nil t containing-sexp paren-state)) ((and 
(c-major-mode-is ...) (setq placeholder ...) (c-beginning-of-statement-1) 
(progn ... t) (prog1 ... ...)) (c-add-syntax (quote annotation-top-cont) 
(c-point ...))) (t (c-beginning-of-statement-1 (c-safe-position ... 
paren-state)) (when (c-major-mode-is ...) (setq placeholder ...) (while ... ... 
...) (goto-char placeholder)) (c-add-syntax (quote topmost-intro-cont) (c-point 
...))))) ((not (or (and c-special-brace-lists (save-excursion ... ...)) (eq 
(char-after containing-sexp) 123))) (cond ((memq char-after-ip (quote ...)) 
(goto-char containing-sexp) (setq placeholder (c-point ...)) (if (and ... ...) 
(progn ... ...) (goto-char placeholder)) (c-add-stmt-syntax (quote 
arglist-close) (list containing-sexp) t (c-most-enclosing-brace paren-state 
...) paren-state)) ((and c-recognize-<>-arglists (setq containing-< ...) (eq 
... 60)) (setq placeholder (c-point ... containing-<)) (goto-char 
containing-sexp) (if (>= ... placeholder) (progn ... ...) (goto-char 
placeholder)) (c-add-stmt-syntax (quote template-args-cont) (list containing-<) 
t (c-most-enclosing-brace c-state-cache ...) paren-state)) ((and (eq 
char-after-ip 123) (progn ... ...)) (goto-char placeholder) 
(back-to-indentation) (c-add-stmt-syntax (car tmpsymbol) nil t 
(c-most-enclosing-brace paren-state ...) paren-state) (if (/= ... placeholder) 
(c-add-syntax ...))) ((memq char-before-ip (quote ...)) (goto-char 
containing-sexp) (setq placeholder (c-point ...)) (if (and ... ...) (progn ... 
...) (goto-char placeholder)) (c-add-stmt-syntax (quote arglist-intro) (list 
containing-sexp) t (c-most-enclosing-brace paren-state ...) paren-state)) 
((progn (goto-char containing-sexp) (and ... ...)) (goto-char (1+ 
containing-sexp)) (c-forward-syntactic-ws indent-point) (if (eq char-before-ip 
59) (c-add-syntax ... ...) (c-add-syntax ... ...))) ((and c-opt-method-key (eq 
... 91) (progn ... ... ...))) ((progn (goto-char ...) (< ... ...)) (goto-char 
containing-sexp) (setq placeholder (c-point ...)) (if (and ... ...) (progn ... 
...) (goto-char placeholder)) (c-add-stmt-syntax (quote arglist-cont-nonempty) 
(list containing-sexp) t (c-most-enclosing-brace c-state-cache ...) 
paren-state)) (t (c-forward-syntactic-ws indent-point) (c-add-syntax (quote 
arglist-cont) (c-point ...))))) ((and (c-major-mode-is (quote c++-mode)) 
(save-excursion (goto-char indent-point) (skip-chars-forward "       ") 
(looking-at c-opt-postfix-decl-spec-key))) (goto-char indent-point) 
(skip-chars-forward "    ") (cond ((eq char-after-ip 58) 
(c-backward-syntactic-ws lim) (c-add-syntax (quote inher-intro) (c-point ...))) 
((eq char-before-ip 58) (c-add-syntax (quote inher-intro) (c-point ...))) (t 
(c-beginning-of-inheritance-list lim) (c-add-syntax (quote inher-cont) 
(point))))) ((and (not (c-major-mode-is (quote awk-mode))) (setq 
special-brace-list (or (and c-special-brace-lists ...) (c-inside-bracelist-p 
containing-sexp paren-state)))) (cond ((and (consp special-brace-list) 
(save-excursion ... ...) (eq char-after-ip ...)) (goto-char (car ...)) 
(skip-chars-backward "  ") (if (and ... ...) (setq c-syntactic-context 
placeholder) (c-beginning-of-statement-1 ...) (c-forward-token-2 0) (while ... 
... ...) (c-add-syntax ... ...))) ((if (consp special-brace-list) (progn ... 
...) (and ... ... ...)) (if (eq ... ...) (c-add-syntax ... ...) (setq lim ...) 
(c-beginning-of-statement-1 lim) (c-add-stmt-syntax ... nil t lim 
paren-state))) (t (if (consp special-brace-list) (progn ... ...) (goto-char 
containing-sexp)) (forward-char) (let (...) (c-forward-syntactic-ws 
indent-point) (goto-char ...)) (c-skip-ws-forward indent-point) (cond (... ... 
...) (t ...))))) ((and (not (memq char-before-ip (quote ...))) (not 
(c-at-vsemi-p before-ws-ip)) (or (not (eq char-before-ip 125)) 
(c-looking-at-inexpr-block-backward c-state-cache)) (> (point) (save-excursion 
(c-beginning-of-statement-1 containing-sexp) (setq placeholder ...))) (/= 
placeholder containing-sexp)) (c-guess-continued-construct indent-point 
char-after-ip placeholder containing-sexp paren-state)) ((eq char-after-ip 125) 
(setq lim (c-most-enclosing-brace paren-state)) (goto-char containing-sexp) 
(cond ((c-after-conditional) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax (quote block-close) nil t lim paren-state)) ((setq 
placeholder (c-looking-at-inexpr-block ... nil)) (setq tmpsymbol (if ... ... 
...)) (goto-char containing-sexp) (back-to-indentation) (if (= containing-sexp 
...) (c-add-syntax tmpsymbol ...) (goto-char ...) (back-to-indentation) 
(c-add-stmt-syntax tmpsymbol nil t ... paren-state) (if ... ...))) 
((save-excursion (and lim ... ...)) (c-backward-to-decl-anchor lim) 
(back-to-indentation) (if (save-excursion ... ...) (c-add-syntax ... ...) 
(c-add-syntax ... ...))) ((save-excursion (and ... ... ... ...)) 
(back-to-indentation) (if (/= ... containing-sexp) (goto-char placeholder)) 
(c-add-stmt-syntax (quote defun-close) nil t lim paren-state)) (lim (while (and 
... ...)) (goto-char placeholder) (if (looking-at c-label-kwds-regexp) 
(c-add-syntax ... ...) (goto-char containing-sexp) (c-add-stmt-syntax ... nil t 
lim paren-state))) (t (goto-char containing-sexp) (c-backward-to-decl-anchor 
lim) (c-add-stmt-syntax (quote defun-close) nil nil (c-most-enclosing-brace 
paren-state) paren-state)))) (t (goto-char indent-point) (while (let* 
((prev-point ...) (last-step-type ...)) (if (= ... prev-point) (progn ... nil) 
(setq step-type last-step-type) (/= ... ...)))) (cond ((and (eq step-type ...) 
(/= ... indent-point)) (c-add-stmt-syntax (quote statement-cont) nil nil 
containing-sexp paren-state)) ((progn (while ... ...) (eq step-type ...)) 
(c-add-stmt-syntax (if ... ... ...) nil t containing-sexp paren-state)) ((progn 
(while ... ...) (eq step-type ...)) (c-add-stmt-syntax (quote statement) nil t 
containing-sexp paren-state) (if (eq char-after-ip 123) (c-add-syntax ...))) 
((progn (goto-char containing-sexp) (setq lim ...) (c-after-conditional)) 
(c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote 
statement-block-intro) nil t lim paren-state) (if (eq char-after-ip 123) 
(c-add-syntax ...))) ((setq placeholder (c-looking-at-inexpr-block ... nil)) 
(setq tmpsymbol (if ... ... ...)) (back-to-indentation) (if (= containing-sexp 
...) (c-add-syntax tmpsymbol ...) (goto-char ...) (back-to-indentation) 
(c-add-stmt-syntax tmpsymbol nil t ... paren-state) (if ... ...)) (if (eq 
char-after-ip 123) (c-add-syntax ...))) ((save-excursion (or ... ...)) 
(c-backward-to-decl-anchor lim) (back-to-indentation) (c-add-syntax (quote 
defun-block-intro) (point))) ((save-excursion (and ... ... ... ...)) 
(back-to-indentation) (if (/= ... containing-sexp) (goto-char placeholder)) 
(c-add-stmt-syntax (quote defun-block-intro) nil t lim paren-state)) (t (while 
(and ... ...)) (goto-char placeholder) (if (looking-at c-label-kwds-regexp) 
(c-add-syntax ... ...) (goto-char containing-sexp) (c-add-stmt-syntax ... nil t 
lim paren-state)) (if (eq char-after-ip 123) (c-add-syntax ...)))))) (goto-char 
indent-point) (skip-chars-forward "       ") (when (and (looking-at 
c-comment-start-regexp) (/= (c-forward-token-2 0 nil (c-point (quote eol))) 0)) 
(c-append-syntax (quote comment-intro))) (when (and c-opt-friend-key 
(looking-at c-opt-friend-key)) (c-append-syntax (quote friend))) (let ((p 
c-syntactic-context)) (while (and p (if (integerp (c-langelem-pos ...)) (progn 
(setq syntactic-relpos ...) nil) t)) (setq p (cdr p)))) (if (and macro-start 
(eq macro-start (c-point (quote boi))) (not (and (c-major-mode-is (quote 
pike-mode)) (eq (char-after ...) 34)))) (c-append-syntax (quote cpp-macro)) 
(when (and c-syntactic-indentation-in-macros macro-start) (if in-macro-expr 
(when (or (< syntactic-relpos macro-start) (not ...)) (setq c-syntactic-context 
nil) (c-add-syntax (quote cpp-macro-cont) macro-start)) (when (and (eq 
macro-start syntactic-relpos) (not ...) (save-excursion ... ...)) (c-add-syntax 
(quote cpp-define-intro)))))) c-syntactic-context) (and (not modified) 
(buffer-modified-p) (set-buffer-modified-p nil)))
  (let* ((modified (buffer-modified-p)) (buffer-undo-list t) (inhibit-read-only 
t) (inhibit-point-motion-hooks t) before-change-functions 
after-change-functions deactivate-mark buffer-file-name buffer-file-truename 
(indent-point (point)) (case-fold-search nil) literal char-before-ip 
before-ws-ip char-after-ip macro-start in-macro-expr c-syntactic-context 
placeholder c-in-literal-cache step-type tmpsymbol keyword injava-inher 
special-brace-list tmp-pos containing-< containing-decl-open 
containing-decl-start containing-decl-kwd containing-sexp lim (paren-state 
(c-parse-state)) syntactic-relpos (c-stmt-delim-chars c-stmt-delim-chars)) 
(unwind-protect (progn (when (and (setq containing-sexp (c-most-enclosing-brace 
paren-state)) (progn (goto-char containing-sexp) (eq (char-after) 123)) (setq 
placeholder (c-looking-at-decl-block (c-most-enclosing-brace paren-state 
containing-sexp) t))) (setq containing-decl-open containing-sexp 
containing-decl-start (point) containing-sexp nil) (goto-char placeholder) 
(setq containing-decl-kwd (and (looking-at c-keywords-regexp) (c-keyword-sym 
(match-string 1))))) (if c-state-cache (progn (setq containing-sexp (car 
paren-state) paren-state (cdr paren-state)) (if (consp containing-sexp) (progn 
(setq lim ...) (if ... ... ...)) (setq lim (1+ containing-sexp)))) (setq lim 
(point-min))) (when (and containing-sexp (eq (char-after containing-sexp) 40)) 
(setq c-stmt-delim-chars c-stmt-delim-chars-with-comma)) (goto-char 
indent-point) (c-backward-syntactic-ws lim) (setq before-ws-ip (point) 
char-before-ip (char-before)) (goto-char indent-point) (skip-chars-forward "    
 ") (setq char-after-ip (char-after)) (setq literal (c-in-literal lim)) (cond 
((eq literal (quote string)) (c-add-syntax (quote string) (c-point (quote 
bopl)))) ((and (memq literal (quote ...)) (setq placeholder (c-literal-limits 
lim))) (c-add-syntax literal (car placeholder))) ((and (save-excursion (when 
... ...)) (/= macro-start (c-point ...)) (progn (setq tmpsymbol ...) (or ... 
...))) (c-add-syntax tmpsymbol macro-start) (setq macro-start nil)) 
((looking-at "else\\>[^_]") (c-beginning-of-statement-1 containing-sexp) 
(c-add-stmt-syntax (quote else-clause) nil t containing-sexp paren-state)) 
((and (looking-at "while\\>[^_]") (save-excursion (prog1 ... ...))) (goto-char 
placeholder) (c-add-stmt-syntax (quote do-while-closure) nil t containing-sexp 
paren-state)) ((save-excursion (and (cond ... ...) (and ... ... ... ...) 
(looking-at "\\(try\\|catch\\)\\>[^_]") (setq placeholder ...))) (goto-char 
placeholder) (c-add-stmt-syntax (quote catch-clause) nil t containing-sexp 
paren-state)) ((save-excursion (and c-opt-block-stmt-key (not ...) (not ...) 
(not ...) (or ... ...) (> ... ...) (if ... ... ...))) (if (eq step-type (quote 
up)) (progn (goto-char placeholder) (cond ... ... ...)) 
(c-guess-continued-construct indent-point char-after-ip placeholder lim 
paren-state))) ((looking-at c-label-kwds-regexp) (if containing-sexp (progn 
(goto-char containing-sexp) (setq lim ...) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax ... nil t lim paren-state)) (c-add-syntax (quote case-label) 
(point-min)))) ((save-excursion (back-to-indentation) (and (not ...) 
(c-forward-label))) (cond (containing-decl-open (setq placeholder ...) 
(c-append-syntax ... placeholder)) (containing-sexp (goto-char containing-sexp) 
(setq lim ...) (save-excursion ...) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax tmpsymbol nil t lim paren-state)) (t (c-add-syntax ... 
...)))) ((setq placeholder (c-looking-at-inexpr-block (c-safe-position 
containing-sexp paren-state) containing-sexp t)) (setq tmpsymbol (assq (car 
placeholder) (quote ...))) (if tmpsymbol (setq tmpsymbol (cdr tmpsymbol)) (setq 
tmpsymbol (if ... ... ...))) (goto-char (cdr placeholder)) 
(back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace c-state-cache (point)) paren-state) (unless (eq (point) 
(cdr placeholder)) (c-add-syntax (car placeholder)))) ((or containing-decl-open 
(null containing-sexp)) (cond ((setq special-brace-list ...) (cond ... ... ... 
... ...)) ((save-excursion ...) (cond ... ... ...)) ((or ... ... ...) (cond ... 
... ... ...)) ((save-excursion ... ...) (cond ... ... ...)) ((and ... ...) 
(goto-char containing-decl-start) (c-add-stmt-syntax ... nil t ... 
paren-state)) ((and containing-sexp ... ...) (c-add-class-syntax ... 
containing-decl-open containing-decl-start containing-decl-kwd paren-state)) 
((and c-recognize-knr-p ... ... ... ...) (goto-char placeholder) (c-add-syntax 
... ...)) ((and c-opt-method-key ...) (c-beginning-of-statement-1 nil t) (if 
... ...) (c-add-syntax ... ...)) ((c-major-mode-is ...) (setq placeholder ...) 
(c-add-stmt-syntax ... nil nil containing-sexp paren-state)) ((progn ... ...) 
(goto-char placeholder) (c-add-stmt-syntax ... nil nil containing-sexp 
paren-state)) ((and ... ...) (goto-char placeholder) (c-add-syntax ... ...) (if 
containing-decl-open ...) (when ... ... ...)) ((and c-opt-method-key ...) 
(c-add-syntax ... placeholder)) ((and c-recognize-<>-arglists ... ...) 
(c-beginning-of-statement-1 ...) (c-add-syntax ... ...)) (macro-start 
(c-beginning-of-statement-1 containing-sexp) (c-add-stmt-syntax ... nil t 
containing-sexp paren-state)) ((and ... ... ... ... ...) (c-add-syntax ... 
...)) (t (c-beginning-of-statement-1 ...) (when ... ... ... ...) (c-add-syntax 
... ...)))) ((not (or (and c-special-brace-lists ...) (eq ... 123))) (cond 
((memq char-after-ip ...) (goto-char containing-sexp) (setq placeholder ...) 
(if ... ... ...) (c-add-stmt-syntax ... ... t ... paren-state)) ((and 
c-recognize-<>-arglists ... ...) (setq placeholder ...) (goto-char 
containing-sexp) (if ... ... ...) (c-add-stmt-syntax ... ... t ... 
paren-state)) ((and ... ...) (goto-char placeholder) (back-to-indentation) 
(c-add-stmt-syntax ... nil t ... paren-state) (if ... ...)) ((memq 
char-before-ip ...) (goto-char containing-sexp) (setq placeholder ...) (if ... 
... ...) (c-add-stmt-syntax ... ... t ... paren-state)) ((progn ... ...) 
(goto-char ...) (c-forward-syntactic-ws indent-point) (if ... ... ...)) ((and 
c-opt-method-key ... ...)) ((progn ... ...) (goto-char containing-sexp) (setq 
placeholder ...) (if ... ... ...) (c-add-stmt-syntax ... ... t ... 
paren-state)) (t (c-forward-syntactic-ws indent-point) (c-add-syntax ... 
...)))) ((and (c-major-mode-is (quote c++-mode)) (save-excursion (goto-char 
indent-point) (skip-chars-forward "  ") (looking-at 
c-opt-postfix-decl-spec-key))) (goto-char indent-point) (skip-chars-forward "   
 ") (cond ((eq char-after-ip 58) (c-backward-syntactic-ws lim) (c-add-syntax 
... ...)) ((eq char-before-ip 58) (c-add-syntax ... ...)) (t 
(c-beginning-of-inheritance-list lim) (c-add-syntax ... ...)))) ((and (not 
(c-major-mode-is ...)) (setq special-brace-list (or ... ...))) (cond ((and ... 
... ...) (goto-char ...) (skip-chars-backward "      ") (if ... ... ... ... ... 
...)) ((if ... ... ...) (if ... ... ... ... ...)) (t (if ... ... ...) 
(forward-char) (let ... ... ...) (c-skip-ws-forward indent-point) (cond ... 
...)))) ((and (not (memq char-before-ip ...)) (not (c-at-vsemi-p before-ws-ip)) 
(or (not ...) (c-looking-at-inexpr-block-backward c-state-cache)) (> (point) 
(save-excursion ... ...)) (/= placeholder containing-sexp)) 
(c-guess-continued-construct indent-point char-after-ip placeholder 
containing-sexp paren-state)) ((eq char-after-ip 125) (setq lim 
(c-most-enclosing-brace paren-state)) (goto-char containing-sexp) (cond 
((c-after-conditional) (c-backward-to-block-anchor lim) (c-add-stmt-syntax ... 
nil t lim paren-state)) ((setq placeholder ...) (setq tmpsymbol ...) (goto-char 
containing-sexp) (back-to-indentation) (if ... ... ... ... ... ...)) 
((save-excursion ...) (c-backward-to-decl-anchor lim) (back-to-indentation) (if 
... ... ...)) ((save-excursion ...) (back-to-indentation) (if ... ...) 
(c-add-stmt-syntax ... nil t lim paren-state)) (lim (while ...) (goto-char 
placeholder) (if ... ... ... ...)) (t (goto-char containing-sexp) 
(c-backward-to-decl-anchor lim) (c-add-stmt-syntax ... nil nil ... 
paren-state)))) (t (goto-char indent-point) (while (let* (... ...) (if ... ... 
... ...))) (cond ((and ... ...) (c-add-stmt-syntax ... nil nil containing-sexp 
paren-state)) ((progn ... ...) (c-add-stmt-syntax ... nil t containing-sexp 
paren-state)) ((progn ... ...) (c-add-stmt-syntax ... nil t containing-sexp 
paren-state) (if ... ...)) ((progn ... ... ...) (c-backward-to-block-anchor 
lim) (c-add-stmt-syntax ... nil t lim paren-state) (if ... ...)) ((setq 
placeholder ...) (setq tmpsymbol ...) (back-to-indentation) (if ... ... ... ... 
... ...) (if ... ...)) ((save-excursion ...) (c-backward-to-decl-anchor lim) 
(back-to-indentation) (c-add-syntax ... ...)) ((save-excursion ...) 
(back-to-indentation) (if ... ...) (c-add-stmt-syntax ... nil t lim 
paren-state)) (t (while ...) (goto-char placeholder) (if ... ... ... ...) (if 
... ...))))) (goto-char indent-point) (skip-chars-forward "   ") (when (and 
(looking-at c-comment-start-regexp) (/= (c-forward-token-2 0 nil (c-point ...)) 
0)) (c-append-syntax (quote comment-intro))) (when (and c-opt-friend-key 
(looking-at c-opt-friend-key)) (c-append-syntax (quote friend))) (let ((p 
c-syntactic-context)) (while (and p (if (integerp ...) (progn ... nil) t)) 
(setq p (cdr p)))) (if (and macro-start (eq macro-start (c-point (quote boi))) 
(not (and (c-major-mode-is ...) (eq ... 34)))) (c-append-syntax (quote 
cpp-macro)) (when (and c-syntactic-indentation-in-macros macro-start) (if 
in-macro-expr (when (or ... ...) (setq c-syntactic-context nil) (c-add-syntax 
... macro-start)) (when (and ... ... ...) (c-add-syntax ...))))) 
c-syntactic-context) (and (not modified) (buffer-modified-p) 
(set-buffer-modified-p nil))))
  (c-save-buffer-state ((indent-point (point)) (case-fold-search nil) literal 
char-before-ip before-ws-ip char-after-ip macro-start in-macro-expr 
c-syntactic-context placeholder c-in-literal-cache step-type tmpsymbol keyword 
injava-inher special-brace-list tmp-pos containing-< containing-decl-open 
containing-decl-start containing-decl-kwd containing-sexp lim (paren-state 
(c-parse-state)) syntactic-relpos (c-stmt-delim-chars c-stmt-delim-chars)) 
(when (and (setq containing-sexp (c-most-enclosing-brace paren-state)) (progn 
(goto-char containing-sexp) (eq (char-after) 123)) (setq placeholder 
(c-looking-at-decl-block (c-most-enclosing-brace paren-state containing-sexp) 
t))) (setq containing-decl-open containing-sexp containing-decl-start (point) 
containing-sexp nil) (goto-char placeholder) (setq containing-decl-kwd (and 
(looking-at c-keywords-regexp) (c-keyword-sym (match-string 1))))) (if 
c-state-cache (progn (setq containing-sexp (car paren-state) paren-state (cdr 
paren-state)) (if (consp containing-sexp) (progn (setq lim (cdr 
containing-sexp)) (if (cdr c-state-cache) (setq containing-sexp (car ...) 
paren-state (cdr paren-state)) (setq paren-state (cons containing-sexp 
paren-state) containing-sexp nil))) (setq lim (1+ containing-sexp)))) (setq lim 
(point-min))) (when (and containing-sexp (eq (char-after containing-sexp) 40)) 
(setq c-stmt-delim-chars c-stmt-delim-chars-with-comma)) (goto-char 
indent-point) (c-backward-syntactic-ws lim) (setq before-ws-ip (point) 
char-before-ip (char-before)) (goto-char indent-point) (skip-chars-forward "    
    ") (setq char-after-ip (char-after)) (setq literal (c-in-literal lim)) 
(cond ((eq literal (quote string)) (c-add-syntax (quote string) (c-point (quote 
bopl)))) ((and (memq literal (quote (c c++))) (setq placeholder 
(c-literal-limits lim))) (c-add-syntax literal (car placeholder))) ((and 
(save-excursion (when (c-beginning-of-macro) (setq macro-start (point)))) (/= 
macro-start (c-point (quote boi))) (progn (setq tmpsymbol (quote 
cpp-macro-cont)) (or (not c-syntactic-indentation-in-macros) (save-excursion 
(goto-char macro-start) (if ... ... ... nil))))) (c-add-syntax tmpsymbol 
macro-start) (setq macro-start nil)) ((looking-at "else\\>[^_]") 
(c-beginning-of-statement-1 containing-sexp) (c-add-stmt-syntax (quote 
else-clause) nil t containing-sexp paren-state)) ((and (looking-at 
"while\\>[^_]") (save-excursion (prog1 (eq (c-beginning-of-statement-1 
containing-sexp) (quote beginning)) (setq placeholder (point))))) (goto-char 
placeholder) (c-add-stmt-syntax (quote do-while-closure) nil t containing-sexp 
paren-state)) ((save-excursion (and (cond ((c-major-mode-is ...) (looking-at 
"catch\\>[^_]")) ((c-major-mode-is ...) (looking-at 
"\\(catch\\|finally\\)\\>[^_]"))) (and (c-safe (c-backward-syntactic-ws) 
(c-backward-sexp) t) (eq (char-after) 123) (c-safe (c-backward-syntactic-ws) 
(c-backward-sexp) t) (if (eq ... 40) (c-safe ... t) t)) (looking-at 
"\\(try\\|catch\\)\\>[^_]") (setq placeholder (point)))) (goto-char 
placeholder) (c-add-stmt-syntax (quote catch-clause) nil t containing-sexp 
paren-state)) ((save-excursion (and c-opt-block-stmt-key (not (eq 
char-before-ip 59)) (not (c-at-vsemi-p before-ws-ip)) (not (memq char-after-ip 
(quote ...))) (or (not (eq char-before-ip 125)) 
(c-looking-at-inexpr-block-backward c-state-cache)) (> (point) (progn (setq 
placeholder ...) (while ...) (if ... ... ... ...) placeholder)) (if (looking-at 
c-block-stmt-2-key) (and (zerop ...) (eq ... 40)) (looking-at 
c-opt-block-stmt-key)))) (if (eq step-type (quote up)) (progn (goto-char 
placeholder) (cond ((eq char-after-ip 123) (c-add-stmt-syntax ... nil nil 
containing-sexp paren-state)) ((save-excursion ... ... ...) (c-add-stmt-syntax 
... nil nil containing-sexp paren-state)) (t (c-add-stmt-syntax ... nil nil 
containing-sexp paren-state)))) (c-guess-continued-construct indent-point 
char-after-ip placeholder lim paren-state))) ((looking-at c-label-kwds-regexp) 
(if containing-sexp (progn (goto-char containing-sexp) (setq lim 
(c-most-enclosing-brace c-state-cache containing-sexp)) 
(c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote case-label) nil t 
lim paren-state)) (c-add-syntax (quote case-label) (point-min)))) 
((save-excursion (back-to-indentation) (and (not (looking-at 
c-syntactic-ws-start)) (c-forward-label))) (cond (containing-decl-open (setq 
placeholder (c-add-class-syntax (quote inclass) containing-decl-open 
containing-decl-start containing-decl-kwd paren-state)) (c-append-syntax (quote 
access-label) placeholder)) (containing-sexp (goto-char containing-sexp) (setq 
lim (c-most-enclosing-brace c-state-cache containing-sexp)) (save-excursion 
(setq tmpsymbol (if ... ... ...))) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax tmpsymbol nil t lim paren-state)) (t (c-add-syntax (quote 
access-label) (point-min))))) ((setq placeholder (c-looking-at-inexpr-block 
(c-safe-position containing-sexp paren-state) containing-sexp t)) (setq 
tmpsymbol (assq (car placeholder) (quote ((inexpr-class . class-open) 
(inexpr-statement . block-open))))) (if tmpsymbol (setq tmpsymbol (cdr 
tmpsymbol)) (setq tmpsymbol (if (eq char-after-ip 123) (quote inline-open) 
(quote lambda-intro-cont)))) (goto-char (cdr placeholder)) 
(back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace c-state-cache (point)) paren-state) (unless (eq (point) 
(cdr placeholder)) (c-add-syntax (car placeholder)))) ((or containing-decl-open 
(null containing-sexp)) (cond ((setq special-brace-list (or (and 
c-special-brace-lists ...) (eq char-after-ip 123))) (cond ((save-excursion ...) 
(goto-char placeholder) (c-add-stmt-syntax ... nil t containing-sexp 
paren-state)) ((save-excursion ... ... ...) (c-add-syntax ... placeholder)) 
((save-excursion ... ... ... ...) (if ... ... ...)) ((and containing-decl-open 
...) (c-add-syntax ...) (c-add-class-syntax ... containing-decl-open 
containing-decl-start containing-decl-kwd paren-state)) (t (save-excursion ... 
... ...)))) ((save-excursion (when (setq placeholder ...) (setq tmp-pos ...))) 
(cond ((eq ... 58) (if ... ... ... ... ...)) ((and c-recognize-knr-p ...) 
(c-beginning-of-statement-1 lim) (c-add-syntax ... ...) (if 
containing-decl-open ...)) (t (c-beginning-of-statement-1 lim) (c-add-syntax 
... ...)))) ((or (and (c-major-mode-is ...) (progn ... ...)) (and (or ... ...) 
(save-excursion ... ... ... ...)) (and (c-major-mode-is ...) (let ... ... 
injava-inher) (not ...))) (cond ((eq char-after-ip 58) 
(c-beginning-of-statement-1 lim) (c-add-syntax ... ...)) ((eq char-before-ip 
58) (c-beginning-of-statement-1 lim) (c-add-syntax ... ...) (if 
containing-decl-open ...)) (injava-inher (let ... ... ...)) (t 
(c-beginning-of-inheritance-list lim) (c-add-syntax ... ...)))) 
((save-excursion (if c-recognize-<>-arglists (while ...) 
(c-syntactic-skip-backward "^;,=" lim t)) (memq (char-before) (quote ...))) 
(cond ((and ... ...) (c-with-syntax-table c++-template-syntax-table ... ... 
...) (c-add-syntax ... ... placeholder)) ((and ... ...) (goto-char placeholder) 
(c-add-syntax ... ...)) (t (while ...) (c-add-stmt-syntax ... nil nil 
containing-sexp paren-state)))) ((and (eq char-after-ip 125) (c-keyword-member 
containing-decl-kwd (quote c-other-block-decl-kwds))) (goto-char 
containing-decl-start) (c-add-stmt-syntax (if (string-equal ... "extern") 
(quote extern-lang-close) (intern ...)) nil t (c-most-enclosing-brace 
paren-state (point)) paren-state)) ((and containing-sexp (eq char-after-ip 125) 
(eq containing-decl-open containing-sexp)) (c-add-class-syntax (quote 
class-close) containing-decl-open containing-decl-start containing-decl-kwd 
paren-state)) ((and c-recognize-knr-p (not containing-sexp) (not (eq 
char-before-ip 125)) (save-excursion (setq placeholder ...) (and placeholder 
...)) (< placeholder indent-point)) (goto-char placeholder) (c-add-syntax 
(quote knr-argdecl) (point))) ((and c-opt-method-key (looking-at 
c-opt-method-key)) (c-beginning-of-statement-1 nil t) (if (= (point) 
indent-point) (goto-char (point-min))) (c-add-syntax (quote objc-method-intro) 
(c-point (quote boi)))) ((c-major-mode-is (quote awk-mode)) (setq placeholder 
(point)) (c-add-stmt-syntax (if (and ... ...) (quote topmost-intro-cont) (quote 
topmost-intro)) nil nil containing-sexp paren-state)) ((progn 
(c-backward-syntactic-ws lim) (and (eq ... 125) (save-excursion ...))) 
(goto-char placeholder) (c-add-stmt-syntax (quote topmost-intro-cont) nil nil 
containing-sexp paren-state)) ((and (not (and macro-start ...)) (save-excursion 
(setq placeholder ...) (or ... ... ... ...))) (goto-char placeholder) 
(c-add-syntax (quote topmost-intro) (c-point (quote bol))) (if 
containing-decl-open (if (c-keyword-member containing-decl-kwd ...) (progn ... 
...) (c-add-class-syntax ... containing-decl-open containing-decl-start 
containing-decl-kwd paren-state))) (when (and c-syntactic-indentation-in-macros 
macro-start (/= macro-start ...)) (c-add-syntax (quote cpp-define-intro)) (setq 
macro-start nil))) ((and c-opt-method-key (save-excursion 
(c-beginning-of-statement-1 lim) (beginning-of-line) (when ... ...))) 
(c-add-syntax (quote objc-method-args-cont) placeholder)) ((and 
c-recognize-<>-arglists (eq (char-before) 60) (not (and 
c-overloadable-operators-regexp ...))) (c-beginning-of-statement-1 
(c-safe-position (point) paren-state)) (c-add-syntax (quote template-args-cont) 
(c-point (quote boi)))) (macro-start (c-beginning-of-statement-1 
containing-sexp) (c-add-stmt-syntax (quote statement) nil t containing-sexp 
paren-state)) ((and (c-major-mode-is (quote java-mode)) (setq placeholder 
(point)) (c-beginning-of-statement-1) (progn (while ... ...) t) (prog1 (>= ... 
placeholder) (goto-char placeholder))) (c-add-syntax (quote 
annotation-top-cont) (c-point (quote boi)))) (t (c-beginning-of-statement-1 
(c-safe-position (point) paren-state)) (when (c-major-mode-is (quote 
objc-mode)) (setq placeholder (point)) (while (and ... ...) 
(c-forward-syntactic-ws) (setq placeholder ...)) (goto-char placeholder)) 
(c-add-syntax (quote topmost-intro-cont) (c-point (quote boi)))))) ((not (or 
(and c-special-brace-lists (save-excursion (goto-char containing-sexp) 
(c-looking-at-special-brace-list))) (eq (char-after containing-sexp) 123))) 
(cond ((memq char-after-ip (quote (41 93))) (goto-char containing-sexp) (setq 
placeholder (c-point (quote boi))) (if (and (c-safe ... t) (>= ... 
placeholder)) (progn (forward-char) (skip-chars-forward "      ")) (goto-char 
placeholder)) (c-add-stmt-syntax (quote arglist-close) (list containing-sexp) t 
(c-most-enclosing-brace paren-state (point)) paren-state)) ((and 
c-recognize-<>-arglists (setq containing-< (c-up-list-backward indent-point 
containing-sexp)) (eq (char-after containing-<) 60)) (setq placeholder (c-point 
(quote boi) containing-<)) (goto-char containing-sexp) (if (>= (point) 
placeholder) (progn (forward-char) (skip-chars-forward "     ")) (goto-char 
placeholder)) (c-add-stmt-syntax (quote template-args-cont) (list containing-<) 
t (c-most-enclosing-brace c-state-cache (point)) paren-state)) ((and (eq 
char-after-ip 123) (progn (setq placeholder ...) (if placeholder ... ...))) 
(goto-char placeholder) (back-to-indentation) (c-add-stmt-syntax (car 
tmpsymbol) nil t (c-most-enclosing-brace paren-state (point)) paren-state) (if 
(/= (point) placeholder) (c-add-syntax (cdr tmpsymbol)))) ((memq char-before-ip 
(quote (40 91))) (goto-char containing-sexp) (setq placeholder (c-point (quote 
boi))) (if (and (c-safe ... t) (>= ... placeholder)) (progn (forward-char) 
(skip-chars-forward "        ")) (goto-char placeholder)) (c-add-stmt-syntax 
(quote arglist-intro) (list containing-sexp) t (c-most-enclosing-brace 
paren-state (point)) paren-state)) ((progn (goto-char containing-sexp) (and 
(c-safe ... t) (looking-at "\\<for\\>[^_]"))) (goto-char (1+ containing-sexp)) 
(c-forward-syntactic-ws indent-point) (if (eq char-before-ip 59) (c-add-syntax 
(quote statement) (point)) (c-add-syntax (quote statement-cont) (point)))) 
((and c-opt-method-key (eq (char-after containing-sexp) 91) (progn (goto-char 
...) (c-backward-syntactic-ws ...) (if ... ...)))) ((progn (goto-char (1+ 
containing-sexp)) (< (save-excursion ... ...) (c-point ...))) (goto-char 
containing-sexp) (setq placeholder (c-point (quote boi))) (if (and (c-safe ... 
t) (>= ... placeholder)) (progn (forward-char) (skip-chars-forward "        ")) 
(goto-char placeholder)) (c-add-stmt-syntax (quote arglist-cont-nonempty) (list 
containing-sexp) t (c-most-enclosing-brace c-state-cache (point)) paren-state)) 
(t (c-forward-syntactic-ws indent-point) (c-add-syntax (quote arglist-cont) 
(c-point (quote boi)))))) ((and (c-major-mode-is (quote c++-mode)) 
(save-excursion (goto-char indent-point) (skip-chars-forward "       ") 
(looking-at c-opt-postfix-decl-spec-key))) (goto-char indent-point) 
(skip-chars-forward "    ") (cond ((eq char-after-ip 58) 
(c-backward-syntactic-ws lim) (c-add-syntax (quote inher-intro) (c-point (quote 
boi)))) ((eq char-before-ip 58) (c-add-syntax (quote inher-intro) (c-point 
(quote boi)))) (t (c-beginning-of-inheritance-list lim) (c-add-syntax (quote 
inher-cont) (point))))) ((and (not (c-major-mode-is (quote awk-mode))) (setq 
special-brace-list (or (and c-special-brace-lists (save-excursion ... ...)) 
(c-inside-bracelist-p containing-sexp paren-state)))) (cond ((and (consp 
special-brace-list) (save-excursion (goto-char containing-sexp) (eq ... 40)) 
(eq char-after-ip (car ...))) (goto-char (car (car special-brace-list))) 
(skip-chars-backward "  ") (if (and (bolp) (assoc ... ...)) (setq 
c-syntactic-context placeholder) (c-beginning-of-statement-1 (c-safe-position 
... paren-state)) (c-forward-token-2 0) (while (looking-at c-specifier-key) 
(goto-char ...) (c-forward-syntactic-ws)) (c-add-syntax (quote brace-list-open) 
(c-point ...)))) ((if (consp special-brace-list) (progn (goto-char ...) 
(save-excursion ... ... ...)) (and (eq char-after-ip 125) (c-safe ... t) (= ... 
containing-sexp))) (if (eq (point) (c-point ...)) (c-add-syntax (quote 
brace-list-close) (point)) (setq lim (c-most-enclosing-brace c-state-cache 
...)) (c-beginning-of-statement-1 lim) (c-add-stmt-syntax (quote 
brace-list-close) nil t lim paren-state))) (t (if (consp special-brace-list) 
(progn (goto-char ...) (c-forward-token-2 1 nil indent-point)) (goto-char 
containing-sexp)) (forward-char) (let ((start ...)) (c-forward-syntactic-ws 
indent-point) (goto-char (max start ...))) (c-skip-ws-forward indent-point) 
(cond ((= ... indent-point) (if ... ... ...) (if ... ... ... ... ...)) (t (if 
... ... ...)))))) ((and (not (memq char-before-ip (quote (59 58)))) (not 
(c-at-vsemi-p before-ws-ip)) (or (not (eq char-before-ip 125)) 
(c-looking-at-inexpr-block-backward c-state-cache)) (> (point) (save-excursion 
(c-beginning-of-statement-1 containing-sexp) (setq placeholder (point)))) (/= 
placeholder containing-sexp)) (c-guess-continued-construct indent-point 
char-after-ip placeholder containing-sexp paren-state)) ((eq char-after-ip 125) 
(setq lim (c-most-enclosing-brace paren-state)) (goto-char containing-sexp) 
(cond ((c-after-conditional) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax (quote block-close) nil t lim paren-state)) ((setq 
placeholder (c-looking-at-inexpr-block (c-safe-position containing-sexp 
paren-state) nil)) (setq tmpsymbol (if (eq ... ...) (quote inline-close) (quote 
block-close))) (goto-char containing-sexp) (back-to-indentation) (if (= 
containing-sexp (point)) (c-add-syntax tmpsymbol (point)) (goto-char (cdr 
placeholder)) (back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace paren-state ...) paren-state) (if (/= ... ...) 
(c-add-syntax ...)))) ((save-excursion (and lim (progn ... ...) (setq 
placeholder ...))) (c-backward-to-decl-anchor lim) (back-to-indentation) (if 
(save-excursion (goto-char placeholder) (looking-at c-other-decl-block-key)) 
(c-add-syntax (quote defun-close) (point)) (c-add-syntax (quote inline-close) 
(point)))) ((save-excursion (and (not ...) (eq ... ...) (setq placeholder ...) 
(let ... ...))) (back-to-indentation) (if (/= (point) containing-sexp) 
(goto-char placeholder)) (c-add-stmt-syntax (quote defun-close) nil t lim 
paren-state)) (lim (while (and (/= ... ...) (eq ... ...))) (goto-char 
placeholder) (if (looking-at c-label-kwds-regexp) (c-add-syntax (quote 
block-close) (point)) (goto-char containing-sexp) (c-add-stmt-syntax (quote 
block-close) nil t lim paren-state))) (t (goto-char containing-sexp) 
(c-backward-to-decl-anchor lim) (c-add-stmt-syntax (quote defun-close) nil nil 
(c-most-enclosing-brace paren-state) paren-state)))) (t (goto-char 
indent-point) (while (let* ((prev-point (point)) (last-step-type 
(c-beginning-of-statement-1 containing-sexp))) (if (= (point) prev-point) 
(progn (setq step-type ...) nil) (setq step-type last-step-type) (/= (point) 
(c-point ...))))) (cond ((and (eq step-type (quote same)) (/= (point) 
indent-point)) (c-add-stmt-syntax (quote statement-cont) nil nil 
containing-sexp paren-state)) ((progn (while (and ... ...) (setq step-type 
...)) (eq step-type (quote label))) (c-add-stmt-syntax (if (eq char-after-ip 
123) (quote statement-case-open) (quote statement-case-intro)) nil t 
containing-sexp paren-state)) ((progn (while (eq step-type ...) (setq step-type 
...)) (eq step-type (quote previous))) (c-add-stmt-syntax (quote statement) nil 
t containing-sexp paren-state) (if (eq char-after-ip 123) (c-add-syntax (quote 
block-open)))) ((progn (goto-char containing-sexp) (setq lim 
(c-most-enclosing-brace paren-state containing-sexp)) (c-after-conditional)) 
(c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote 
statement-block-intro) nil t lim paren-state) (if (eq char-after-ip 123) 
(c-add-syntax (quote block-open)))) ((setq placeholder 
(c-looking-at-inexpr-block (c-safe-position containing-sexp paren-state) nil)) 
(setq tmpsymbol (if (eq ... ...) (quote defun-block-intro) (quote 
statement-block-intro))) (back-to-indentation) (if (= containing-sexp (point)) 
(c-add-syntax tmpsymbol (point)) (goto-char (cdr placeholder)) 
(back-to-indentation) (c-add-stmt-syntax tmpsymbol nil t 
(c-most-enclosing-brace c-state-cache ...) paren-state) (if (/= ... ...) 
(c-add-syntax ...))) (if (eq char-after-ip 123) (c-add-syntax (quote 
block-open)))) ((save-excursion (or (not ...) (and ... ...))) 
(c-backward-to-decl-anchor lim) (back-to-indentation) (c-add-syntax (quote 
defun-block-intro) (point))) ((save-excursion (and (not ...) (eq ... ...) (setq 
placeholder ...) (let ... ...))) (back-to-indentation) (if (/= (point) 
containing-sexp) (goto-char placeholder)) (c-add-stmt-syntax (quote 
defun-block-intro) nil t lim paren-state)) (t (while (and (/= ... ...) (eq ... 
...))) (goto-char placeholder) (if (looking-at c-label-kwds-regexp) 
(c-add-syntax (quote statement-block-intro) (point)) (goto-char 
containing-sexp) (c-add-stmt-syntax (quote statement-block-intro) nil t lim 
paren-state)) (if (eq char-after-ip 123) (c-add-syntax (quote block-open))))))) 
(goto-char indent-point) (skip-chars-forward "  ") (when (and (looking-at 
c-comment-start-regexp) (/= (c-forward-token-2 0 nil (c-point (quote eol))) 0)) 
(c-append-syntax (quote comment-intro))) (when (and c-opt-friend-key 
(looking-at c-opt-friend-key)) (c-append-syntax (quote friend))) (let ((p 
c-syntactic-context)) (while (and p (if (integerp (c-langelem-pos (car p))) 
(progn (setq syntactic-relpos (c-langelem-pos ...)) nil) t)) (setq p (cdr p)))) 
(if (and macro-start (eq macro-start (c-point (quote boi))) (not (and 
(c-major-mode-is (quote pike-mode)) (eq (char-after (1+ macro-start)) 34)))) 
(c-append-syntax (quote cpp-macro)) (when (and 
c-syntactic-indentation-in-macros macro-start) (if in-macro-expr (when (or (< 
syntactic-relpos macro-start) (not (or ... ... ... ...))) (setq 
c-syntactic-context nil) (c-add-syntax (quote cpp-macro-cont) macro-start)) 
(when (and (eq macro-start syntactic-relpos) (not (assq ... 
c-syntactic-context)) (save-excursion (goto-char macro-start) (or ... ...))) 
(c-add-syntax (quote cpp-define-intro)))))) c-syntactic-context)
  (save-excursion (beginning-of-line) (c-save-buffer-state ((indent-point 
(point)) (case-fold-search nil) literal char-before-ip before-ws-ip 
char-after-ip macro-start in-macro-expr c-syntactic-context placeholder 
c-in-literal-cache step-type tmpsymbol keyword injava-inher special-brace-list 
tmp-pos containing-< containing-decl-open containing-decl-start 
containing-decl-kwd containing-sexp lim (paren-state (c-parse-state)) 
syntactic-relpos (c-stmt-delim-chars c-stmt-delim-chars)) (when (and (setq 
containing-sexp (c-most-enclosing-brace paren-state)) (progn (goto-char 
containing-sexp) (eq (char-after) 123)) (setq placeholder 
(c-looking-at-decl-block (c-most-enclosing-brace paren-state containing-sexp) 
t))) (setq containing-decl-open containing-sexp containing-decl-start (point) 
containing-sexp nil) (goto-char placeholder) (setq containing-decl-kwd (and 
(looking-at c-keywords-regexp) (c-keyword-sym (match-string 1))))) (if 
c-state-cache (progn (setq containing-sexp (car paren-state) paren-state (cdr 
paren-state)) (if (consp containing-sexp) (progn (setq lim (cdr 
containing-sexp)) (if (cdr c-state-cache) (setq containing-sexp ... paren-state 
...) (setq paren-state ... containing-sexp nil))) (setq lim (1+ 
containing-sexp)))) (setq lim (point-min))) (when (and containing-sexp (eq 
(char-after containing-sexp) 40)) (setq c-stmt-delim-chars 
c-stmt-delim-chars-with-comma)) (goto-char indent-point) 
(c-backward-syntactic-ws lim) (setq before-ws-ip (point) char-before-ip 
(char-before)) (goto-char indent-point) (skip-chars-forward "       ") (setq 
char-after-ip (char-after)) (setq literal (c-in-literal lim)) (cond ((eq 
literal (quote string)) (c-add-syntax (quote string) (c-point (quote bopl)))) 
((and (memq literal (quote (c c++))) (setq placeholder (c-literal-limits lim))) 
(c-add-syntax literal (car placeholder))) ((and (save-excursion (when 
(c-beginning-of-macro) (setq macro-start ...))) (/= macro-start (c-point (quote 
boi))) (progn (setq tmpsymbol (quote cpp-macro-cont)) (or (not 
c-syntactic-indentation-in-macros) (save-excursion ... ...)))) (c-add-syntax 
tmpsymbol macro-start) (setq macro-start nil)) ((looking-at "else\\>[^_]") 
(c-beginning-of-statement-1 containing-sexp) (c-add-stmt-syntax (quote 
else-clause) nil t containing-sexp paren-state)) ((and (looking-at 
"while\\>[^_]") (save-excursion (prog1 (eq ... ...) (setq placeholder ...)))) 
(goto-char placeholder) (c-add-stmt-syntax (quote do-while-closure) nil t 
containing-sexp paren-state)) ((save-excursion (and (cond (... ...) (... ...)) 
(and (c-safe ... ... t) (eq ... 123) (c-safe ... ... t) (if ... ... t)) 
(looking-at "\\(try\\|catch\\)\\>[^_]") (setq placeholder (point)))) (goto-char 
placeholder) (c-add-stmt-syntax (quote catch-clause) nil t containing-sexp 
paren-state)) ((save-excursion (and c-opt-block-stmt-key (not (eq 
char-before-ip 59)) (not (c-at-vsemi-p before-ws-ip)) (not (memq char-after-ip 
...)) (or (not ...) (c-looking-at-inexpr-block-backward c-state-cache)) (> 
(point) (progn ... ... ... placeholder)) (if (looking-at c-block-stmt-2-key) 
(and ... ...) (looking-at c-opt-block-stmt-key)))) (if (eq step-type (quote 
up)) (progn (goto-char placeholder) (cond (... ...) (... ...) (t ...))) 
(c-guess-continued-construct indent-point char-after-ip placeholder lim 
paren-state))) ((looking-at c-label-kwds-regexp) (if containing-sexp (progn 
(goto-char containing-sexp) (setq lim (c-most-enclosing-brace c-state-cache 
containing-sexp)) (c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote 
case-label) nil t lim paren-state)) (c-add-syntax (quote case-label) 
(point-min)))) ((save-excursion (back-to-indentation) (and (not (looking-at 
c-syntactic-ws-start)) (c-forward-label))) (cond (containing-decl-open (setq 
placeholder (c-add-class-syntax ... containing-decl-open containing-decl-start 
containing-decl-kwd paren-state)) (c-append-syntax (quote access-label) 
placeholder)) (containing-sexp (goto-char containing-sexp) (setq lim 
(c-most-enclosing-brace c-state-cache containing-sexp)) (save-excursion (setq 
tmpsymbol ...)) (c-backward-to-block-anchor lim) (c-add-stmt-syntax tmpsymbol 
nil t lim paren-state)) (t (c-add-syntax (quote access-label) (point-min))))) 
((setq placeholder (c-looking-at-inexpr-block (c-safe-position containing-sexp 
paren-state) containing-sexp t)) (setq tmpsymbol (assq (car placeholder) (quote 
(... ...)))) (if tmpsymbol (setq tmpsymbol (cdr tmpsymbol)) (setq tmpsymbol (if 
(eq char-after-ip 123) (quote inline-open) (quote lambda-intro-cont)))) 
(goto-char (cdr placeholder)) (back-to-indentation) (c-add-stmt-syntax 
tmpsymbol nil t (c-most-enclosing-brace c-state-cache (point)) paren-state) 
(unless (eq (point) (cdr placeholder)) (c-add-syntax (car placeholder)))) ((or 
containing-decl-open (null containing-sexp)) (cond ((setq special-brace-list 
(or ... ...)) (cond (... ... ...) (... ...) (... ...) (... ... ...) (t ...))) 
((save-excursion (when ... ...)) (cond (... ...) (... ... ... ...) (t ... 
...))) ((or (and ... ...) (and ... ...) (and ... ... ...)) (cond (... ... ...) 
(... ... ... ...) (injava-inher ...) (t ... ...))) ((save-excursion (if 
c-recognize-<>-arglists ... ...) (memq ... ...)) (cond (... ... ...) (... ... 
...) (t ... ...))) ((and (eq char-after-ip 125) (c-keyword-member 
containing-decl-kwd ...)) (goto-char containing-decl-start) (c-add-stmt-syntax 
(if ... ... ...) nil t (c-most-enclosing-brace paren-state ...) paren-state)) 
((and containing-sexp (eq char-after-ip 125) (eq containing-decl-open 
containing-sexp)) (c-add-class-syntax (quote class-close) containing-decl-open 
containing-decl-start containing-decl-kwd paren-state)) ((and c-recognize-knr-p 
(not containing-sexp) (not ...) (save-excursion ... ...) (< placeholder 
indent-point)) (goto-char placeholder) (c-add-syntax (quote knr-argdecl) 
(point))) ((and c-opt-method-key (looking-at c-opt-method-key)) 
(c-beginning-of-statement-1 nil t) (if (= ... indent-point) (goto-char ...)) 
(c-add-syntax (quote objc-method-intro) (c-point ...))) ((c-major-mode-is 
(quote awk-mode)) (setq placeholder (point)) (c-add-stmt-syntax (if ... ... 
...) nil nil containing-sexp paren-state)) ((progn (c-backward-syntactic-ws 
lim) (and ... ...)) (goto-char placeholder) (c-add-stmt-syntax (quote 
topmost-intro-cont) nil nil containing-sexp paren-state)) ((and (not ...) 
(save-excursion ... ...)) (goto-char placeholder) (c-add-syntax (quote 
topmost-intro) (c-point ...)) (if containing-decl-open (if ... ... ...)) (when 
(and c-syntactic-indentation-in-macros macro-start ...) (c-add-syntax ...) 
(setq macro-start nil))) ((and c-opt-method-key (save-excursion ... ... ...)) 
(c-add-syntax (quote objc-method-args-cont) placeholder)) ((and 
c-recognize-<>-arglists (eq ... 60) (not ...)) (c-beginning-of-statement-1 
(c-safe-position ... paren-state)) (c-add-syntax (quote template-args-cont) 
(c-point ...))) (macro-start (c-beginning-of-statement-1 containing-sexp) 
(c-add-stmt-syntax (quote statement) nil t containing-sexp paren-state)) ((and 
(c-major-mode-is ...) (setq placeholder ...) (c-beginning-of-statement-1) 
(progn ... t) (prog1 ... ...)) (c-add-syntax (quote annotation-top-cont) 
(c-point ...))) (t (c-beginning-of-statement-1 (c-safe-position ... 
paren-state)) (when (c-major-mode-is ...) (setq placeholder ...) (while ... ... 
...) (goto-char placeholder)) (c-add-syntax (quote topmost-intro-cont) (c-point 
...))))) ((not (or (and c-special-brace-lists (save-excursion ... ...)) (eq 
(char-after containing-sexp) 123))) (cond ((memq char-after-ip (quote ...)) 
(goto-char containing-sexp) (setq placeholder (c-point ...)) (if (and ... ...) 
(progn ... ...) (goto-char placeholder)) (c-add-stmt-syntax (quote 
arglist-close) (list containing-sexp) t (c-most-enclosing-brace paren-state 
...) paren-state)) ((and c-recognize-<>-arglists (setq containing-< ...) (eq 
... 60)) (setq placeholder (c-point ... containing-<)) (goto-char 
containing-sexp) (if (>= ... placeholder) (progn ... ...) (goto-char 
placeholder)) (c-add-stmt-syntax (quote template-args-cont) (list containing-<) 
t (c-most-enclosing-brace c-state-cache ...) paren-state)) ((and (eq 
char-after-ip 123) (progn ... ...)) (goto-char placeholder) 
(back-to-indentation) (c-add-stmt-syntax (car tmpsymbol) nil t 
(c-most-enclosing-brace paren-state ...) paren-state) (if (/= ... placeholder) 
(c-add-syntax ...))) ((memq char-before-ip (quote ...)) (goto-char 
containing-sexp) (setq placeholder (c-point ...)) (if (and ... ...) (progn ... 
...) (goto-char placeholder)) (c-add-stmt-syntax (quote arglist-intro) (list 
containing-sexp) t (c-most-enclosing-brace paren-state ...) paren-state)) 
((progn (goto-char containing-sexp) (and ... ...)) (goto-char (1+ 
containing-sexp)) (c-forward-syntactic-ws indent-point) (if (eq char-before-ip 
59) (c-add-syntax ... ...) (c-add-syntax ... ...))) ((and c-opt-method-key (eq 
... 91) (progn ... ... ...))) ((progn (goto-char ...) (< ... ...)) (goto-char 
containing-sexp) (setq placeholder (c-point ...)) (if (and ... ...) (progn ... 
...) (goto-char placeholder)) (c-add-stmt-syntax (quote arglist-cont-nonempty) 
(list containing-sexp) t (c-most-enclosing-brace c-state-cache ...) 
paren-state)) (t (c-forward-syntactic-ws indent-point) (c-add-syntax (quote 
arglist-cont) (c-point ...))))) ((and (c-major-mode-is (quote c++-mode)) 
(save-excursion (goto-char indent-point) (skip-chars-forward "       ") 
(looking-at c-opt-postfix-decl-spec-key))) (goto-char indent-point) 
(skip-chars-forward "    ") (cond ((eq char-after-ip 58) 
(c-backward-syntactic-ws lim) (c-add-syntax (quote inher-intro) (c-point ...))) 
((eq char-before-ip 58) (c-add-syntax (quote inher-intro) (c-point ...))) (t 
(c-beginning-of-inheritance-list lim) (c-add-syntax (quote inher-cont) 
(point))))) ((and (not (c-major-mode-is (quote awk-mode))) (setq 
special-brace-list (or (and c-special-brace-lists ...) (c-inside-bracelist-p 
containing-sexp paren-state)))) (cond ((and (consp special-brace-list) 
(save-excursion ... ...) (eq char-after-ip ...)) (goto-char (car ...)) 
(skip-chars-backward "  ") (if (and ... ...) (setq c-syntactic-context 
placeholder) (c-beginning-of-statement-1 ...) (c-forward-token-2 0) (while ... 
... ...) (c-add-syntax ... ...))) ((if (consp special-brace-list) (progn ... 
...) (and ... ... ...)) (if (eq ... ...) (c-add-syntax ... ...) (setq lim ...) 
(c-beginning-of-statement-1 lim) (c-add-stmt-syntax ... nil t lim 
paren-state))) (t (if (consp special-brace-list) (progn ... ...) (goto-char 
containing-sexp)) (forward-char) (let (...) (c-forward-syntactic-ws 
indent-point) (goto-char ...)) (c-skip-ws-forward indent-point) (cond (... ... 
...) (t ...))))) ((and (not (memq char-before-ip (quote ...))) (not 
(c-at-vsemi-p before-ws-ip)) (or (not (eq char-before-ip 125)) 
(c-looking-at-inexpr-block-backward c-state-cache)) (> (point) (save-excursion 
(c-beginning-of-statement-1 containing-sexp) (setq placeholder ...))) (/= 
placeholder containing-sexp)) (c-guess-continued-construct indent-point 
char-after-ip placeholder containing-sexp paren-state)) ((eq char-after-ip 125) 
(setq lim (c-most-enclosing-brace paren-state)) (goto-char containing-sexp) 
(cond ((c-after-conditional) (c-backward-to-block-anchor lim) 
(c-add-stmt-syntax (quote block-close) nil t lim paren-state)) ((setq 
placeholder (c-looking-at-inexpr-block ... nil)) (setq tmpsymbol (if ... ... 
...)) (goto-char containing-sexp) (back-to-indentation) (if (= containing-sexp 
...) (c-add-syntax tmpsymbol ...) (goto-char ...) (back-to-indentation) 
(c-add-stmt-syntax tmpsymbol nil t ... paren-state) (if ... ...))) 
((save-excursion (and lim ... ...)) (c-backward-to-decl-anchor lim) 
(back-to-indentation) (if (save-excursion ... ...) (c-add-syntax ... ...) 
(c-add-syntax ... ...))) ((save-excursion (and ... ... ... ...)) 
(back-to-indentation) (if (/= ... containing-sexp) (goto-char placeholder)) 
(c-add-stmt-syntax (quote defun-close) nil t lim paren-state)) (lim (while (and 
... ...)) (goto-char placeholder) (if (looking-at c-label-kwds-regexp) 
(c-add-syntax ... ...) (goto-char containing-sexp) (c-add-stmt-syntax ... nil t 
lim paren-state))) (t (goto-char containing-sexp) (c-backward-to-decl-anchor 
lim) (c-add-stmt-syntax (quote defun-close) nil nil (c-most-enclosing-brace 
paren-state) paren-state)))) (t (goto-char indent-point) (while (let* 
((prev-point ...) (last-step-type ...)) (if (= ... prev-point) (progn ... nil) 
(setq step-type last-step-type) (/= ... ...)))) (cond ((and (eq step-type ...) 
(/= ... indent-point)) (c-add-stmt-syntax (quote statement-cont) nil nil 
containing-sexp paren-state)) ((progn (while ... ...) (eq step-type ...)) 
(c-add-stmt-syntax (if ... ... ...) nil t containing-sexp paren-state)) ((progn 
(while ... ...) (eq step-type ...)) (c-add-stmt-syntax (quote statement) nil t 
containing-sexp paren-state) (if (eq char-after-ip 123) (c-add-syntax ...))) 
((progn (goto-char containing-sexp) (setq lim ...) (c-after-conditional)) 
(c-backward-to-block-anchor lim) (c-add-stmt-syntax (quote 
statement-block-intro) nil t lim paren-state) (if (eq char-after-ip 123) 
(c-add-syntax ...))) ((setq placeholder (c-looking-at-inexpr-block ... nil)) 
(setq tmpsymbol (if ... ... ...)) (back-to-indentation) (if (= containing-sexp 
...) (c-add-syntax tmpsymbol ...) (goto-char ...) (back-to-indentation) 
(c-add-stmt-syntax tmpsymbol nil t ... paren-state) (if ... ...)) (if (eq 
char-after-ip 123) (c-add-syntax ...))) ((save-excursion (or ... ...)) 
(c-backward-to-decl-anchor lim) (back-to-indentation) (c-add-syntax (quote 
defun-block-intro) (point))) ((save-excursion (and ... ... ... ...)) 
(back-to-indentation) (if (/= ... containing-sexp) (goto-char placeholder)) 
(c-add-stmt-syntax (quote defun-block-intro) nil t lim paren-state)) (t (while 
(and ... ...)) (goto-char placeholder) (if (looking-at c-label-kwds-regexp) 
(c-add-syntax ... ...) (goto-char containing-sexp) (c-add-stmt-syntax ... nil t 
lim paren-state)) (if (eq char-after-ip 123) (c-add-syntax ...)))))) (goto-char 
indent-point) (skip-chars-forward "       ") (when (and (looking-at 
c-comment-start-regexp) (/= (c-forward-token-2 0 nil (c-point (quote eol))) 0)) 
(c-append-syntax (quote comment-intro))) (when (and c-opt-friend-key 
(looking-at c-opt-friend-key)) (c-append-syntax (quote friend))) (let ((p 
c-syntactic-context)) (while (and p (if (integerp (c-langelem-pos ...)) (progn 
(setq syntactic-relpos ...) nil) t)) (setq p (cdr p)))) (if (and macro-start 
(eq macro-start (c-point (quote boi))) (not (and (c-major-mode-is (quote 
pike-mode)) (eq (char-after ...) 34)))) (c-append-syntax (quote cpp-macro)) 
(when (and c-syntactic-indentation-in-macros macro-start) (if in-macro-expr 
(when (or (< syntactic-relpos macro-start) (not ...)) (setq c-syntactic-context 
nil) (c-add-syntax (quote cpp-macro-cont) macro-start)) (when (and (eq 
macro-start syntactic-relpos) (not ...) (save-excursion ... ...)) (c-add-syntax 
(quote cpp-define-intro)))))) c-syntactic-context))
  c-guess-basic-syntax()
  c-indent-line()
  #[nil "\302\303 !\210\304>\203.\212\305 \210\306\307x\210\305 \210\310 
)i\310 X\203'\311     !\202,\212\311  !))\207 \207" [indent-line-function 
column syntax-propertize line-end-position (indent-relative 
indent-relative-maybe) beginning-of-line "\n   " nil current-indentation 
indent-line-to] 2 1929070 nil]()
  c-indent-command(nil)
  c-indent-line-or-region(nil nil)
  call-interactively(c-indent-line-or-region nil nil)


C variables are:

(setq
 c-basic-offset 4
 c-comment-only-line-offset '(0 . 0)
 c-indent-comment-alist '((anchored-comment column . 0) (end-block space . 1)
                          (cpp-end-block space . 2))
 c-indent-comments-syntactically-p nil
 c-block-comment-prefix "* "
 c-comment-prefix-regexp '((pike-mode . "//+!?\\|\\**") (awk-mode . "#+")
                           (other . "//+\\|\\**"))
 c-doc-comment-style '((java-mode . javadoc) (pike-mode . autodoc)
                       (c-mode . gtkdoc))
 c-cleanup-list '(scope-operator)
 c-hanging-braces-alist '((substatement-open before after)
                          (arglist-cont-nonempty))
 c-hanging-colons-alist nil
 c-hanging-semi&comma-criteria '(c-semi&comma-inside-parenlist)
 c-backslash-column 48
 c-backslash-max-column 72
 c-special-indent-hook '(c-gnu-impose-minimum)
 c-label-minimum-indentation 1
 c-offsets-alist '((inexpr-class . +)
                   (inexpr-statement . +)
                   (lambda-intro-cont . +)
                   (inlambda . c-lineup-inexpr-block)
                   (template-args-cont c-lineup-template-args +)
                   (incomposition . +)
                   (inmodule . +)
                   (innamespace . +)
                   (inextern-lang . +)
                   (composition-close . 0)
                   (module-close . 0)
                   (namespace-close . 0)
                   (extern-lang-close . 0)
                   (composition-open . 0)
                   (module-open . 0)
                   (namespace-open . 0)
                   (extern-lang-open . 0)
                   (objc-method-call-cont
                    c-lineup-ObjC-method-call-colons
                    c-lineup-ObjC-method-call
                    +
                    )
                   (objc-method-args-cont . c-lineup-ObjC-method-args)
                   (objc-method-intro . [0])
                   (friend . 0)
                   (cpp-define-intro c-lineup-cpp-define +)
                   (cpp-macro-cont . +)
                   (cpp-macro . [0])
                   (inclass . +)
                   (stream-op . c-lineup-streamop)
                   (arglist-cont-nonempty
                    c-lineup-gcc-asm-reg
                    c-lineup-arglist
                    )
                   (arglist-cont c-lineup-gcc-asm-reg 0)
                   (comment-intro
                    c-lineup-knr-region-comment
                    c-lineup-comment
                    )
                   (catch-clause . 0)
                   (else-clause . 0)
                   (do-while-closure . 0)
                   (access-label . -)
                   (case-label . *)
                   (substatement . +)
                   (statement-case-intro . *)
                   (statement . 0)
                   (brace-entry-open . 0)
                   (brace-list-entry . 0)
                   (brace-list-intro . +)
                   (brace-list-close . 0)
                   (block-close . 0)
                   (block-open . 0)
                   (inher-cont . c-lineup-multi-inher)
                   (inher-intro . +)
                   (member-init-cont . c-lineup-multi-inher)
                   (member-init-intro . +)
                   (annotation-var-cont . +)
                   (annotation-top-cont . 0)
                   (topmost-intro . 0)
                   (knr-argdecl . 0)
                   (func-decl-cont . +)
                   (inline-close . 0)
                   (class-close . 0)
                   (class-open . 0)
                   (defun-block-intro . +)
                   (defun-close . 0)
                   (defun-open . 0)
                   (c . c-lineup-C-comments)
                   (string . c-lineup-dont-change)
                   (topmost-intro-cont
                    first
                    c-lineup-topmost-intro-cont
                    c-lineup-gnu-DEFUN-intro-cont
                    )
                   (brace-list-open . +)
                   (inline-open . 0)
                   (arglist-close . c-lineup-arglist)
                   (arglist-intro . +)
                   (statement-cont . c-lineup-math)
                   (statement-case-open . *)
                   (label . *)
                   (substatement-label . 0)
                   (substatement-open . 0)
                   (knr-argdecl-intro . 5)
                   (statement-block-intro . +)
                   )
 c-buffer-is-cc-mode 'c-mode
 c-tab-always-indent t
 c-syntactic-indentation t
 c-syntactic-indentation-in-macros t
 c-ignore-auto-fill '(string cpp code)
 c-auto-align-backslashes t
 c-backspace-function 'backward-delete-char-untabify
 c-delete-function 'delete-char
 c-electric-pound-behavior nil
 c-default-style '((java-mode . "java") (awk-mode . "awk") (other . "gnu"))
 c-enable-xemacs-performance-kludge-p nil
 c-old-style-variable-behavior nil
 defun-prompt-regexp nil
 tab-width 8
 comment-column 32
 parse-sexp-ignore-comments t
 parse-sexp-lookup-properties t
 auto-fill-function nil
 comment-multi-line t
 comment-start-skip "\\(//+\\|/\\*+\\)\\s *"
 fill-prefix nil
 fill-column 70
 paragraph-start "[     ]*\\(//+\\|\\**\\)[     ]*$\\|^\f"
 adaptive-fill-mode t
 adaptive-fill-regexp "[        ]*\\(//+\\|\\**\\)[     ]*\\([  
]*\\([-!|#%;>*·•‣⁃◦]+[  ]*\\)*\\)"
 )



In GNU Emacs 24.0.50.1 (i686-pc-linux-gnu, GTK+ Version 2.10.4)
 of 2011-01-26 on waterbuck.yellow.cert.org
Windowing system distributor `The X.Org Foundation', version 11.0.70101000
configured using `configure  '--prefix=/home/mwd' 
'--without-toolkit-scroll-bars' '--with-gif=no''

Important settings:
  value of $LC_ALL: nil
  value of $LC_COLLATE: nil
  value of $LC_CTYPE: nil
  value of $LC_MESSAGES: nil
  value of $LC_MONETARY: nil
  value of $LC_NUMERIC: nil
  value of $LC_TIME: nil
  value of $LANG: en_US.UTF-8
  value of $XMODIFIERS: @im=none
  locale-coding-system: utf-8-unix
  default enable-multibyte-characters: t

Major mode: Group

Minor modes in effect:
  gnus-undo-mode: t
  display-time-mode: t
  diff-auto-refine-mode: t
  tooltip-mode: t
  mouse-wheel-mode: t
  tool-bar-mode: t
  menu-bar-mode: t
  file-name-shadow-mode: t
  global-font-lock-mode: t
  font-lock-mode: t
  auto-composition-mode: t
  auto-encryption-mode: t
  auto-compression-mode: t
  line-number-mode: t

Recent input:
C-b C-f C-M-b C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n 
C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n 
C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n 
C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n C-n 
C-n C-n C-n C-n C-n C-_ C-_ C-n C-p C-y C-p C-e <return> 
} SPC e l s e SPC { C-n C-a C-k C-n C-n C-n C-e C-b 
C-M-f C-n C-b C-b C-b C-k C-k C-k C-k C-k C-k C-k C-k 
C-k C-M-b C-n C-p C-d C-d <escape> SPC C-n <tab> <tab> 
C-p C-e C-b C-b C-M-b C-M-f <tab> C-n <tab> <tab> M-b 
M-b M-b M-b M-b M-b C-n C-p C-a C-SPC C-n C-n C-M-\ 
C-n C-p C-p C-d C-d C-d C-d C-n <tab> C-d C-d C-d C-d 
C-n <tab> C-d C-d C-d C-d C-e C-b C-M-f C-n C-a C-k 
C-k C-SPC C-M-b C-M-\ C-n C-n C-n C-n C-n C-n C-n C-n 
C-n C-n C-n C-n C-p C-p C-p C-p C-p C-p C-p C-p C-p 
C-p C-p C-p C-e <return> <return> C-p C-p C-p C-p C-e 
M-b M-b M-b M-b M-b T h i s SPC p a c k e t SPC i s 
SPC i n SPC s e q u e n c e . SPC SPC M-q C-n C-n C-n 
C-n C-n C-p C-k <tab> M-; C-d <return> <return> C-p 
C-p <tab> M-x d e b u g - o n <tab> <M-backspace> e 
<tab> M-b M-b M-b C-k M-x t C-h o g g l e - <backspace> 
<backspace> <backspace> <backspace> <backspace> o g 
g l e - d e <tab> e <tab> <return> <tab> C-x h M-w 
<help-echo> <switch-frame> M-x r e p o r t - e m <tab> 
<return>

Recent messages:
c-inside-bracelist-p: Wrong type argument: number-or-marker-p, (13067 . 13205) 
[2 times]
c-inside-bracelist-p: Wrong type argument: number-or-marker-p, (13067 . 13201)
Mark set
Indenting region... done
syntax: ((c 13081)), indent: 13
c-inside-bracelist-p: Wrong type argument: number-or-marker-p, (13067 . 13237) 
[3 times]
read-extended-command: Command attempted to use minibuffer while in minibuffer
Debug on Error enabled globally
Entering debugger...
Mark set [2 times]

Load-path shadows:
/afs/cert.org/usr/mwd/src/elisp/emacs-svn/psvn hides 
/afs/cert.org/usr/mwd/src/elisp/psvn
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnir hides 
/afs/cert.org/usr/mwd/src/elisp/nnir
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/password-cache hides 
/home/mwd/share/emacs/24.0.50/lisp/password-cache
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/format-spec hides 
/home/mwd/share/emacs/24.0.50/lisp/format-spec
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/md4 hides 
/home/mwd/share/emacs/24.0.50/lisp/md4
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/hex-util hides 
/home/mwd/share/emacs/24.0.50/lisp/hex-util
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/sha1 hides 
/home/mwd/share/emacs/24.0.50/lisp/sha1
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/color hides 
/home/mwd/share/emacs/24.0.50/lisp/color
/afs/cert.org/usr/mwd/src/elisp/emacs-svn/vc-svn hides 
/home/mwd/share/emacs/24.0.50/lisp/vc/vc-svn
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/dns-mode hides 
/home/mwd/share/emacs/24.0.50/lisp/textmodes/dns-mode
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/hmac-md5 hides 
/home/mwd/share/emacs/24.0.50/lisp/net/hmac-md5
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/dns hides 
/home/mwd/share/emacs/24.0.50/lisp/net/dns
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/ntlm hides 
/home/mwd/share/emacs/24.0.50/lisp/net/ntlm
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/tls hides 
/home/mwd/share/emacs/24.0.50/lisp/net/tls
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/hmac-def hides 
/home/mwd/share/emacs/24.0.50/lisp/net/hmac-def
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/sasl hides 
/home/mwd/share/emacs/24.0.50/lisp/net/sasl
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/dig hides 
/home/mwd/share/emacs/24.0.50/lisp/net/dig
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/sasl-cram hides 
/home/mwd/share/emacs/24.0.50/lisp/net/sasl-cram
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/sasl-digest hides 
/home/mwd/share/emacs/24.0.50/lisp/net/sasl-digest
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/sasl-ntlm hides 
/home/mwd/share/emacs/24.0.50/lisp/net/sasl-ntlm
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/imap hides 
/home/mwd/share/emacs/24.0.50/lisp/net/imap
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/netrc hides 
/home/mwd/share/emacs/24.0.50/lisp/net/netrc
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/binhex hides 
/home/mwd/share/emacs/24.0.50/lisp/mail/binhex
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/uudecode hides 
/home/mwd/share/emacs/24.0.50/lisp/mail/uudecode
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/hashcash hides 
/home/mwd/share/emacs/24.0.50/lisp/mail/hashcash
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-mlspl hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-mlspl
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/qp hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/qp
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-range hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-range
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/html2text hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/html2text
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-util hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-util
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-picon hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-picon
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-mh hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-mh
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnimap hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnimap
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnoo hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnoo
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mail-prsvr hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mail-prsvr
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/proto-stream hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/proto-stream
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mml-sec hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mml-sec
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-registry hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-registry
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnmbox hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnmbox
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-topic hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-topic
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-group hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-group
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-score hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-score
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-cite hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-cite
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-cus hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-cus
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nndir hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nndir
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/spam-stat hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/spam-stat
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/deuglify hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/deuglify
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mml2015 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mml2015
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/pop3 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/pop3
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-ml hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-ml
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-partial hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-partial
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/rtree hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/rtree
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnregistry hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnregistry
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-extern hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-extern
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnvirtual hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnvirtual
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnbabyl hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnbabyl
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-start hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-start
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnrss hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnrss
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-dired hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-dired
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-uu hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-uu
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-url hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-url
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-cache hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-cache
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-draft hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-draft
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-async hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-async
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-setup hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-setup
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-srvr hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-srvr
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nndiary hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nndiary
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/sieve hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/sieve
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnmairix hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnmairix
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/messcompat hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/messcompat
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-bookmark hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-bookmark
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-bcklg hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-bcklg
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnml hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnml
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnir hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnir
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/ietf-drums hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/ietf-drums
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/yenc hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/yenc
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nngateway hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nngateway
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mml1991 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mml1991
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-win hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-win
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-eform hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-eform
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/shr-color hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/shr-color
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-html hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-html
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-fun hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-fun
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-delay hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-delay
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gravatar hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gravatar
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-demon hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-demon
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nndraft hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nndraft
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnmh hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnmh
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnweb hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnweb
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nntp hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nntp
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/score-mode hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/score-mode
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/rfc2231 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/rfc2231
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-dup hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-dup
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/smiley hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/smiley
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnagent hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnagent
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/rfc2047 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/rfc2047
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-int hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-int
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/rfc2045 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/rfc2045
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnfolder hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnfolder
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/compface hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/compface
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-encode hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-encode
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-art hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-art
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/sieve-manage hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/sieve-manage
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/rfc2104 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/rfc2104
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/spam hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/spam
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnspool hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnspool
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/ecomplete hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/ecomplete
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-vm hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-vm
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-undo hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-undo
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/spam-report hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/spam-report
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mml-smime hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mml-smime
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-util hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-util
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nndoc hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nndoc
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/starttls hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/starttls
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-bodies hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-bodies
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnmaildir hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnmaildir
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/message hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/message
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-kill hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-kill
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-sync hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-sync
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-decode hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-decode
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mail-parse hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mail-parse
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/legacy-gnus-agent hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/legacy-gnus-agent
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/smime hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/smime
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-salt hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-salt
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-gravatar hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-gravatar
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/utf7 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/utf7
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mailcap hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mailcap
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-msg hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-msg
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mail-source hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mail-source
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mml hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mml
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/canlock hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/canlock
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-ems hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-ems
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-sum hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-sum
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nneething hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nneething
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/rfc1843 hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/rfc1843
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-sieve hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-sieve
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-diary hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-diary
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/sieve-mode hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/sieve-mode
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnmail hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnmail
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/shr hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/shr
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/spam-wash hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/spam-wash
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/auth-source hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/auth-source
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-agent hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-agent
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-logic hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-logic
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnheader hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnheader
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gmm-utils hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gmm-utils
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/.dir-locals hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/.dir-locals
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/flow-fill hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/flow-fill
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/mm-view hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/mm-view
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-uu hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-uu
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/gnus-spec hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/gnus-spec
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/nnnil hides 
/home/mwd/share/emacs/24.0.50/lisp/gnus/nnnil
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/time-date hides 
/home/mwd/share/emacs/24.0.50/lisp/calendar/time-date
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/parse-time hides 
/home/mwd/share/emacs/24.0.50/lisp/calendar/parse-time
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/pgg-def hides 
/home/mwd/share/emacs/24.0.50/lisp/obsolete/pgg-def
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/pgg hides 
/home/mwd/share/emacs/24.0.50/lisp/obsolete/pgg
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/pgg-pgp5 hides 
/home/mwd/share/emacs/24.0.50/lisp/obsolete/pgg-pgp5
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/pgg-parse hides 
/home/mwd/share/emacs/24.0.50/lisp/obsolete/pgg-parse
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/pgg-pgp hides 
/home/mwd/share/emacs/24.0.50/lisp/obsolete/pgg-pgp
/afs/cert.org/usr/mwd/src/elisp/gnus/lisp/pgg-gpg hides 
/home/mwd/share/emacs/24.0.50/lisp/obsolete/pgg-gpg

Features:
(shadow emacsbug debug cus-start cus-load compile help-mode view
time-stamp tabify whitespace calc-misc calc-menu calc calc-loaddefs
calc-macs dabbrev multi-isearch vc-svn cc-mode cc-fonts cc-menus cc-cmds
cc-styles cc-align cc-engine cc-vars cc-defs browse-url flow-fill
copyright newcomment flyspell ispell mule-util sort ansi-color gnus-cite
qp mail-extr gnus-async gnus-bcklg gnus-ml disp-table byte-opt bytecomp
byte-compile nndraft nnmh nnml utf-7 nnimap parse-time utf7 gnus-agent
gnus-srvr gnus-score score-mode nnvirtual gnus-msg gnus-art mm-uu
mml2015 epg-config mm-view mml-smime mailcap gnus-cache edmacro kmacro
nnir gnus-sum macroexp gnus-demon nntp gnus-group gnus-undo nnmail
mail-source proto-stream starttls tls nnoo gnus-start gnus-spec gnus-int
gnus-range gnus-win gnus-load woman man assoc uniquify tramp
tramp-compat auth-source netrc format-spec tramp-loaddefs time smime
password-cache dig comint server psvn advice help-fns advice-preload cl
log-edit ring pcvs-util add-log diff-mode easy-mmode time-date pgg
pgg-parse pgg-def message sendmail rfc822 mml easymenu mml-sec mm-decode
mm-bodies mm-encode mail-parse rfc2231 rfc2047 rfc2045 ietf-drums
mailabbrev gmm-utils mailheader gnus gnus-ems nnheader gnus-util
mail-utils mm-util mail-prsvr wid-edit generic-x dired-x dired-aux dired
regexp-opt tooltip ediff-hook vc-hooks lisp-float-type mwheel x-win
x-dnd tool-bar dnd fontset image fringe lisp-mode register page menu-bar
rfn-eshadow timer select scroll-bar mouse jit-lock font-lock syntax
facemenu font-core frame cham georgian utf-8-lang misc-lang vietnamese
tibetan thai tai-viet lao korean japanese hebrew greek romanian slovak
czech european ethiopic indian cyrillic chinese case-table epa-hook
jka-cmpr-hook help simple abbrev loaddefs button minibuffer faces
cus-face files text-properties overlay md5 base64 format env code-pages
mule custom widget hashtable-print-readable backquote
make-network-process dbusbind dynamic-setting system-font-setting
font-render-setting move-toolbar gtk x-toolkit x multi-tty emacs)

-- 
Michael Welsh Duggan
(mwd@cert.org)