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

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\b\304>\203.\212\305 \210\306\307x\210\305 \210\310 )i\310 X\203'\311	!\202,\212\311	!))\207\b \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)

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

[Michael Welsh Duggan]

I now can recreate this problem, although not minimally.

Using the included file pdusource.c:

emacs -Q pdusource.c
M-g g 549 RET
TAB

This will cause the wrong-type-argument error.  A bisection shows that
this error was introduced in commit 191882,
acm@muc.de-20101009195828-ajo6zapkxu8oluwz:

Enhance fontification of declarators to take account of the
presence/absence of "typedef".

cc-engine.el (c-forward-type): New &optional param "brace-block-too".
(c-forward-decl-or-cast-1): cdr of return value now indicates the
presence of either or both of a "struct"-like keyword and "typedef".

cc-fonts.el (c-complex-decl-matchers): Remove the heuristic fontification
of declarators which follow a "}".
(c-font-lock-declarations): Fontify declarators according to the
presence/absence of "typedef".

cc-langs.el (c-typedef-kwds c-typedef-key): New lang variable for
"typedef".
(c-typedef-decl-key): New lang variable built from c-typedef-decl-kwds.

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

bug#7930: Forgot to include the file

[Michael Welsh Duggan]

[-- Attachment #1: Type: text/plain, Size: 26 bytes --]

Included is pdusource.c:


[-- Attachment #2: pdusource.c --]
[-- Type: text/plain, Size: 23290 bytes --]

/*
** Copyright (C) 2004-2011 by Carnegie Mellon University.
**
** @OPENSOURCE_HEADER_START@
**
** Use of the SILK system and related source code is subject to the terms
** of the following licenses:
**
** GNU Public License (GPL) Rights pursuant to Version 2, June 1991
** Government Purpose License Rights (GPLR) pursuant to DFARS 252.227.7013
**
** NO WARRANTY
**
** ANY INFORMATION, MATERIALS, SERVICES, INTELLECTUAL PROPERTY OR OTHER
** PROPERTY OR RIGHTS GRANTED OR PROVIDED BY CARNEGIE MELLON UNIVERSITY
** PURSUANT TO THIS LICENSE (HEREINAFTER THE "DELIVERABLES") ARE ON AN
** "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY
** KIND, EITHER EXPRESS OR IMPLIED AS TO ANY MATTER INCLUDING, BUT NOT
** LIMITED TO, WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE,
** MERCHANTABILITY, INFORMATIONAL CONTENT, NONINFRINGEMENT, OR ERROR-FREE
** OPERATION. CARNEGIE MELLON UNIVERSITY SHALL NOT BE LIABLE FOR INDIRECT,
** SPECIAL OR CONSEQUENTIAL DAMAGES, SUCH AS LOSS OF PROFITS OR INABILITY
** TO USE SAID INTELLECTUAL PROPERTY, UNDER THIS LICENSE, REGARDLESS OF
** WHETHER SUCH PARTY WAS AWARE OF THE POSSIBILITY OF SUCH DAMAGES.
** LICENSEE AGREES THAT IT WILL NOT MAKE ANY WARRANTY ON BEHALF OF
** CARNEGIE MELLON UNIVERSITY, EXPRESS OR IMPLIED, TO ANY PERSON
** CONCERNING THE APPLICATION OF OR THE RESULTS TO BE OBTAINED WITH THE
** DELIVERABLES UNDER THIS LICENSE.
**
** Licensee hereby agrees to defend, indemnify, and hold harmless Carnegie
** Mellon University, its trustees, officers, employees, and agents from
** all claims or demands made against them (and any related losses,
** expenses, or attorney's fees) arising out of, or relating to Licensee's
** and/or its sub licensees' negligent use or willful misuse of or
** negligent conduct or willful misconduct regarding the Software,
** facilities, or other rights or assistance granted by Carnegie Mellon
** University under this License, including, but not limited to, any
** claims of product liability, personal injury, death, damage to
** property, or violation of any laws or regulations.
**
** Carnegie Mellon University Software Engineering Institute authored
** documents are sponsored by the U.S. Department of Defense under
** Contract F19628-00-C-0003. Carnegie Mellon University retains
** copyrights in all material produced under this contract. The U.S.
** Government retains a non-exclusive, royalty-free license to publish or
** reproduce these documents, or allow others to do so, for U.S.
** Government purposes only pursuant to the copyright license under the
** contract clause at 252.227.7013.
**
** @OPENSOURCE_HEADER_END@
*/

/*
**  Interface to pull a single flow from a NetFlow v5 PDU
**
*/


#include <silk/silk.h>

RCSIDENT("$Id: pdusource.c 16619 2011-01-11 21:07:54Z mthomas $");

#include <silk/utils.h>
#include "v5pdu.h"
#include "udpsource.h"
#include <silk/libflowsource.h>
#include <silk/sklog.h>


/* Number of milliseconds the calculated router boot time for a PDU
 * packet must be beyond the last packet in order to consider the
 * router to have rebooted. */
#define ROUTER_BOOT_FUZZ 1e3

/* Encapsulate timing information from a NetFlow v5 PDU header. */
typedef struct cflowdTimeInfo_st {
    /* router boot time as milliseconds since the UNIX epoch */
    intmax_t router_boot;
    /* milliseconds since the router booted */
    intmax_t sysUptime;
} cflowdTimeInfo_t;


typedef struct pdu_source_st {
    flowsource_stats_t  statistics;
    pthread_mutex_t     stats_mutex;

    udpSource_t        *source;

    cflowdTimeInfo_t    ti;
    intmax_t            last_router_boot;

    uint8_t             count;  /* Number of recs left in pdu */
    v5PDU              *pdu;    /* Current pdu */

    uint32_t            flowSeqNumbers[0xffff];
    BITMAP_DECLARE(     engineMasks, 0xffff);

    uint8_t             logopt;

    unsigned            file    : 1; /* File-based source */
    unsigned            stopped : 1;
} pdu_source_t;
/* typedef struct pdu_source_st *pduSource_t;   // libflowsource.h */


#define COUNT_BAD_PACKET(source, pdu)                   \
    {                                                   \
        pthread_mutex_lock(&((source)->stats_mutex));   \
        (source)->statistics.badPkts++;                 \
        pthread_mutex_unlock(&((source)->stats_mutex)); \
    }

#define COUNT_BAD_RECORD(source, pdu)                   \
    {                                                   \
        pthread_mutex_lock(&((source)->stats_mutex));   \
        (source)->statistics.badRecs++;                 \
        pthread_mutex_unlock(&((source)->stats_mutex)); \
    }


/*
 *  TIME VALUES IN THE NETFLOW V5 PDU
 *
 *  The naive ordering of events with respect to time in the router
 *  would be to collect the flows and generate the PDU.  Thus, one
 *  would expect:
 *
 *      flow.Start  <  flow.End  <  hdr.sysUptime
 *
 *  where all values are given as milliseconds since the router's
 *  interface was booted, and hdr.sysUptime is advertised as the
 *  "current" time.
 *
 *  However, since values are given as 32bit numbers, the values will
 *  roll-over after about 49.7 days.  If the values roll-over in the
 *  middle of writing the PDU, we will see one of these two
 *  conditions:
 *
 *      hdr.sysUptime  <<  flow.Start  <  flow.End
 *
 *      flow.End  <  hdr.sysUptime  <<  flow.Start
 *
 *  Thus, if flow.End less than flow.Start, we need to account for the
 *  roll-over when computing the flow's duration.
 *
 *  In practice, the PDU's header gets filled in before flows are
 *  added, making the hdr.sysUptime not have any true time ordering
 *  with respect to the flow.Start and flow.End, and we have seen
 *  cases in real NetFlow data where hdr.sysUptime is slightly less
 *  than flow.End:
 *
 *      flow.Start  <  hdr.sysUptime  <  flow.End
 *
 *  Moreover, some naive NetFlow PDU generators simply pin the
 *  hdr.sysUptime to zero, and don't account for rollover at all.
 *  This can make hdr.sysUptime much less than flow.Start.
 *
 *  In order to make the determination whether the flow.Start or
 *  hdr.sysUptime values have overflown their values and rolled-over,
 *  we look at the difference between them.  If the absolute value of
 *  the difference is greater than some very large maximum defined in
 *  maximumFlowTimeDeviation (currently 45 days), we assume that one
 *  of the two has rolled over, and adjust based on that assumption.
 */
static const intmax_t maximumFlowTimeDeviation =
    (intmax_t)45 * 24 * 3600 * 1000; /* 45 days */

static const intmax_t maximumSequenceDeviation =
    (intmax_t)3600 * 1000; /* 1 hour of flows at 1k flows/sec */

#define ROLLOVER32 ((intmax_t)UINT32_MAX + 1)


/* FUNCTION PROTOTYPES */

static void cflowdTimeInfoSetup(
    const v5Header     *hdr,
    cflowdTimeInfo_t   *ti);


/* FUNCTION DEFINITIONS */

pduSource_t pduSourceCreate(
    const sk_sockaddr_array_t *from_address,
    const sk_sockaddr_array_t *listen_address,
    uint32_t                   max_pkts)
{
    int rv;
    udpSource_t *udpsource;
    pduSource_t source;

    rv = udpSourceNetworkCreate(&udpsource, from_address, listen_address,
                                V5PDU_LEN, max_pkts);
    if (rv != 0) {
        return NULL;
    }

    source = (pduSource_t)calloc(1, sizeof(*source));
    if (source == NULL) {
        udpSourceDestroy(udpsource);
        return NULL;
    }

    source->source = udpsource;
    pthread_mutex_init(&source->stats_mutex, NULL);
    source->logopt = SOURCE_LOG_ALL;

    return source;
}

pduSource_t pduFileSourceCreate(
    const char *path)
{
    udpSource_t *udpsource;
    pduSource_t source;
    int rv;

    rv = udpFileSourceCreate(&udpsource, path, V5PDU_LEN);
    if (rv != 0) {
        return NULL;
    }

    source = (pduSource_t)calloc(1, sizeof(*source));
    if (source == NULL) {
        udpSourceDestroy(udpsource);
        return NULL;
    }

    source->file = 1;
    source->source = udpsource;

    return source;
}


void pduSourceStop(pduSource_t source)
{
    source->stopped = 1;
    udpSourceStop(source->source);
}


void pduSourceDestroy(pduSource_t source)
{
    if (!source->stopped) {
        pduSourceStop(source);
    }
    udpSourceDestroy(source->source);
    pthread_mutex_destroy(&source->stats_mutex);
    free(source);
}


/*
 *  cflowdTimeInfoSetup(hdr, ti);
 *
 *    Given the NetFlow v5 header 'hdr', initialize the time info
 *    structure 'ti' with the boot time of the router.
 */
static void cflowdTimeInfoSetup(
    const v5Header     *hdr,
    cflowdTimeInfo_t   *ti)
{
    intmax_t now;

    /* get the sysUptime, which is the current time in milliseconds
     * since the export device booted */
    ti->sysUptime = ntohl(hdr->SysUptime);

    /* use the PDU header to get the "current" time as milliseconds
     * since the UNIX epoch; round nanoseconds by adding 5e5 before
     * dividing. */
    now = ((intmax_t)1000 * ntohl(hdr->unix_secs)
           + ((ntohl(hdr->unix_nsecs) + 5e5L) / 1e6L));

    /* subtract sysUpTime from current-time to get router boot time as
     * milliseconds since UNIX epoch */
    ti->router_boot = now - ti->sysUptime;
}


static v5PDU *pduNext(pduSource_t source)
{
    /* keep this array and the enum in sync.  we use these and the
     * macro to count the number of invalid PDUs we saw consecutively,
     * and we print a log message for the bad PDUs as a group.  */
    static const char *err_msgs[] = {
        "No Error",
        "not marked as version 5",
        "reporting more than " V5PDU_MAX_RECS_STR " records",
        "reporting zero records"
    };
    enum err_status_en {
        PDU_OK = 0,
        PDU_BAD_VERSION,
        PDU_ZERO_RECORDS,
        PDU_OVERFLOW_RECORDS
    } err_status = PDU_OK;
    uint32_t err_count = 0;

#define LOG_BAD_PDUS(new_err_status)                            \
    if (new_err_status == err_status) {                         \
        ++err_count;                                            \
    } else {                                                    \
        if (err_count) {                                        \
            assert(PDU_OK != err_status);                       \
            NOTICEMSG(("Rejected %" PRIu32 " PDU record%s %s"), \
                      err_count, ((err_count == 1) ? "" : "s"), \
                      err_msgs[err_status]);                    \
        }                                                       \
        err_count = 1;                                          \
        err_status = new_err_status;                            \
    }

    assert (source != NULL);

    /* Infloop; exit by return only */
    for (;;) {
        v5PDU *pdu;
        uint16_t count;
        uint16_t engine;
        uint32_t flow_sequence;

        pdu = (v5PDU *)udpNext(source->source);
        if (pdu == NULL) {
            /* if we saw any bad PDUs, print message before returning */
            LOG_BAD_PDUS(PDU_OK);
            return NULL;
        }

        pthread_mutex_lock(&source->stats_mutex);
        source->statistics.procPkts++;
        pthread_mutex_unlock(&source->stats_mutex);

        if (ntohs(pdu->hdr.version) != 5) {
            /* reject packet */
            LOG_BAD_PDUS(PDU_BAD_VERSION);
            COUNT_BAD_PACKET(source, pdu);
            continue;
        }

        count = ntohs(pdu->hdr.count);

        if (count > V5PDU_MAX_RECS) {
            /* reject packet */
            LOG_BAD_PDUS(PDU_OVERFLOW_RECORDS);
            COUNT_BAD_PACKET(source, pdu);
            continue;
        }

        if (count == 0) {
            /* reject packet */
            LOG_BAD_PDUS(PDU_ZERO_RECORDS);
            COUNT_BAD_PACKET(source, pdu);
            continue;
        }

        /* at this point we are guaranteed to return from this
         * function.  Use the PDU_OK "error" to log about any bad PDUs
         * we saw previously */
        LOG_BAD_PDUS(PDU_OK);

        /* Calculate the offset from which times in the records are
         * calculated */
        cflowdTimeInfoSetup(&pdu->hdr, &source->ti);

        /* Handle router reboots by resetting the engine masks */
        if (((source->ti.router_boot > source->last_router_boot)
             && ((source->ti.router_boot - source->last_router_boot)
                 > ROUTER_BOOT_FUZZ))
            || ((source->last_router_boot - source->ti.router_boot)
                > ROUTER_BOOT_FUZZ))
        {
            DEBUGMSG("Router reboot noticed");
            BITMAP_INIT(source->engineMasks);
        }
        source->last_router_boot = source->ti.router_boot;

        /* handle seq numbers here */
        flow_sequence = ntohl(pdu->hdr.flow_sequence);
        engine = (pdu->hdr.engine_type << 8) | pdu->hdr.engine_id;

        if (!BITMAP_GETBIT(source->engineMasks, engine)) {
            /* A new engine. Mark and record */
            BITMAP_SETBIT(source->engineMasks, engine);
            source->flowSeqNumbers[engine] = flow_sequence + count;
        } else if (flow_sequence == source->flowSeqNumbers[engine]) {
            /* This packet is in sequence.  Update the next expected
             * seq */
            source->flowSeqNumbers[engine] = flow_sequence + count;
        } else {
            intmax_t expected;
            intmax_t actual;

            pthread_mutex_lock(&source->stats_mutex);

            actual = flow_sequence;
            expected = source->flowSeqNumbers[engine];

            if (actual > expected) {
                if ((actual - expected) > maximumSequenceDeviation) {
                    expected += ROLLOVER32;
                }
            } else if ((expected - actual) > maximumSequenceDeviation) {
                actual += ROLLOVER32;
            }

            if (actual < expected) {
                /*
                ** Out of sequence packet.  Reduce missing flow count.
                ** However, do not change the expected seq num.
                */
                source->statistics.missingRecs -= count;
            } else {
                /* Increase missing flow count */
                source->statistics.missingRecs += actual - expected;
                if (source->logopt & SOURCE_LOG_MISSING) {
                    uint64_t allrecs = source->statistics.goodRecs +
                                       source->statistics.badRecs +
                                       source->statistics.missingRecs;
                    INFOMSG(("Missing netflow records: "
                             "%" PRId64 "/%" PRIu64 " == %7.4g%%"),
                            source->statistics.missingRecs,
                            allrecs,
                            ((float)source->statistics.missingRecs /
                             (float)allrecs * 100.0));
                }
                /* Update the next expected seq */
                source->flowSeqNumbers[engine] = flow_sequence + count;
            }

            pthread_mutex_unlock(&source->stats_mutex);
        }

        return pdu;
    }
 }

static v5Record *pduSourceGetNextRec(
    pduSource_t source)
{
    assert (source != NULL);

    /* Infloop; exit by return only */
    for (;;) {
        v5Record *v5RPtr;
        intmax_t  difference;

        if (source->stopped) {
            return NULL;
        }

        /* If we need a pdu, get a new one, otherwise we are not finished
           with the last. */
        if (source->count == 0) {
            source->pdu = pduNext(source);
            if (source->pdu == NULL) {
                return NULL;
            }
            source->count = ntohs(source->pdu->hdr.count);
        }

        /* Get next record, and decrement counter*/
        v5RPtr = &source->pdu->data[ntohs(source->pdu->hdr.count)
                                    - source->count--];

        /* Check for zero packets or bytes.  No need for byteswapping
           when checking zero. */
        if (v5RPtr->dPkts == 0 || v5RPtr->dOctets == 0) {
            if (source->logopt & SOURCE_LOG_BAD) {
                NOTICEMSG("Netflow record has zero packets or bytes.");
            }
            COUNT_BAD_RECORD(source, source->pdu);
            continue;
        }

        /* Check to see if more packets them bytes. */
        if (ntohl(v5RPtr->dPkts) > ntohl(v5RPtr->dOctets)) {
            if (source->logopt & SOURCE_LOG_BAD) {
                NOTICEMSG("Netflow record has more packets them bytes.");
            }
            COUNT_BAD_RECORD(source, source->pdu);
            continue;
        }

        /* Check to see if the First and Last timestamps for the flow
         * record are reasonable, accounting for rollover.  If the
         * absolute value of the difference is greater than
         * maximumFlowTimeDeviation, we assume it has rolled over. */
        difference = (intmax_t)ntohl(v5RPtr->Last) - ntohl(v5RPtr->First);
        if ((difference > maximumFlowTimeDeviation)
            || ((difference < 0)
                && (difference > (-maximumFlowTimeDeviation))))
        {
            if (source->logopt & SOURCE_LOG_BAD) {
                NOTICEMSG(("Netflow record has earlier end time"
                           " than start time."));
            }
            COUNT_BAD_RECORD(source, source->pdu);
            continue;
        }

        /* Check for bogosities in how the ICMP type/code are set.  It
           should be in dest port, but sometimes it is backwards in src
           port. */
        if (v5RPtr->prot == 1 &&  /* ICMP */
            v5RPtr->dstport == 0) /* No byteswapping for check against 0 */
        {
            uint32_t *ports = (uint32_t *)&v5RPtr->srcport;
            *ports = BSWAP32(*ports); /* This will swap src into dest,
                                         while byteswapping. */
        }

        pthread_mutex_lock(&source->stats_mutex);
        source->statistics.goodRecs++;
        pthread_mutex_unlock(&source->stats_mutex);

        return v5RPtr;
    }
}


int pduSourceGetGeneric(
    pduSource_t     source,
    rwRec          *rwrec)
{
    const v5Record *v5RPtr;
    intmax_t v5_first, v5_last;
    intmax_t sTime;
    intmax_t difference;

    v5RPtr = pduSourceGetNextRec(source);
    if (v5RPtr == NULL) {
        return -1;
    }
    /* Setup start and duration */
    v5_first = ntohl(v5RPtr->First);
    v5_last = ntohl(v5RPtr->Last);
    if (v5_first > v5_last) {
        /* End has rolled over, while start has not.  Adjust end by
         * 2^32 msecs in order to allow us to subtract start from end
         * and get a correct value for the duration. */
        v5_last += ROLLOVER32;
    }

    /* v5_first is milliseconds since the router booted.  To get UNIX
     * epoch milliseconds, add the router's boot time. */
    sTime = v5_first + source->ti.router_boot;

                        /* Check to see if the difference between the 32bit start time and
                         * the sysUptime is overly large.  If it is, one of the two has
                         * more than likely rolled over.  We need to adjust based on
                         * this. */
                        difference = source->ti.sysUptime - v5_first;
                        if (difference > maximumFlowTimeDeviation) {
                            /* sTime rollover */
                            sTime += ROLLOVER32;
                        } else if (difference < (-maximumFlowTimeDeviation)) {
                            /* sysUptime rollover */
                            sTime -= ROLLOVER32;
                        }

                        RWREC_CLEAR(rwrec);

                        /* Convert NetFlow v5 to SiLK */
                        rwRecSetSIPv4(rwrec, ntohl(v5RPtr->srcaddr));
                        rwRecSetDIPv4(rwrec, ntohl(v5RPtr->dstaddr));
                        rwRecSetSPort(rwrec, ntohs(v5RPtr->srcport));
                        rwRecSetDPort(rwrec, ntohs(v5RPtr->dstport));
                        rwRecSetProto(rwrec, v5RPtr->prot);
                        rwRecSetFlags(rwrec, v5RPtr->tcp_flags);
                        rwRecSetInput(rwrec, ntohs(v5RPtr->input));
                        rwRecSetOutput(rwrec, ntohs(v5RPtr->output));
                        rwRecSetNhIPv4(rwrec, ntohl(v5RPtr->nexthop));
                        rwRecSetStartTime(rwrec, (sktime_t)sTime);
                        rwRecSetPkts(rwrec, ntohl(v5RPtr->dPkts));
                        rwRecSetBytes(rwrec, ntohl(v5RPtr->dOctets));
                        rwRecSetElapsed(rwrec, (uint32_t)(v5_last - v5_first));
                        rwRecSetRestFlags(rwrec, 0);
                        rwRecSetTcpState(rwrec, SK_TCPSTATE_NO_INFO);

#if SK_ENABLE_TOS_APPLICATION_HACK
                        rwRecSetApplication(rwrec, v5RPtr->tos);
#else
                        rwRecSetApplication(rwrec, 0);
#endif

                        return 0;
                    }


                    pduSource_t pduSourceCreateFromProbeDef(
                        const skpc_probe_t *probe,
                        uint32_t            max_pkts)
                    {
                        const sk_sockaddr_array_t *paddr;
                        const sk_sockaddr_array_t *haddr;
                        pduSource_t source;
                        int rv;
                        uint8_t flags;

                        assert(probe);

                        flags = skpcProbeGetLogFlags(probe);

                        rv = skpcProbeGetListenOnSockaddr(probe, &paddr);
                        if (rv == -1) {
                            return NULL;
                        }
                        rv = skpcProbeGetAcceptFromHost(probe, &haddr);
                        if (rv == -1) {
                            haddr = NULL;
                        }

                        source = pduSourceCreate(haddr, paddr, max_pkts);
                        if (source == NULL) {
                            return NULL;
                        }
                        pduSourceSetLogopt(source, flags);

                        return source;
                    }


                    /* Get statistics associated with a pdu source. */
                    void pduSourceGetStats(pduSource_t source, flowStats_t stats)
                    {
                        pthread_mutex_lock(&source->stats_mutex);
                        *stats = source->statistics;
                        pthread_mutex_unlock(&source->stats_mutex);
                    }


                    /* Clear out current statistics */
                    void pduSourceClearStats(pduSource_t source)
                    {
                        pthread_mutex_lock(&source->stats_mutex);
                        memset(&source->statistics, 0, sizeof(source->statistics));
                        pthread_mutex_unlock(&source->stats_mutex);
                    }


                    /* Set logging options */
                    void pduSourceSetLogopt(pduSource_t source, uint8_t opt)
                    {
                        source->logopt = opt;
                    }


                    /*
                    ** Local Variables:
                    ** mode:c
                    ** indent-tabs-mode:nil
                    ** c-basic-offset:4
                    ** End:
                    */

[-- Attachment #3: Type: text/plain, Size: 41 bytes --]


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

bug#7930: Forgot to include the file

[Alan Mackenzie]

Hi, Michael.

Here's a patch for the bug.  Would you please try it out and let me know
it's OK.

Thanks a lot for taking the trouble to pin this one down, and for
reporting it in such a high quality fashion.  It was a nasty little bug
caused by a mistaken tacit assumption in an internal CC Mode cache.

The cache in question maintains a list of "safe" positions every ~10,000
characters, and in your file position 10,001 was in the middle of a
macro.  It transpires that inside a macro is NOT a safe position ;-(.

Here's the patch (don't worry that the line numbers don't match
exactly):


*** orig/cc-engine.el	2011-02-06 15:53:22.000000000 +0000
--- cc-engine.el	2011-02-18 20:59:13.854308264 +0000
***************
*** 2026,2034 ****
  
  (defvar c-state-nonlit-pos-cache nil)
  (make-variable-buffer-local 'c-state-nonlit-pos-cache)
! ;; A list of buffer positions which are known not to be in a literal.  This is
! ;; ordered with higher positions at the front of the list.  Only those which
! ;; are less than `c-state-nonlit-pos-cache-limit' are valid.
  
  (defvar c-state-nonlit-pos-cache-limit 1)
  (make-variable-buffer-local 'c-state-nonlit-pos-cache-limit)
--- 2026,2034 ----
  
  (defvar c-state-nonlit-pos-cache nil)
  (make-variable-buffer-local 'c-state-nonlit-pos-cache)
! ;; A list of buffer positions which are known not to be in a literal or a cpp
! ;; construct.  This is ordered with higher positions at the front of the list.
! ;; Only those which are less than `c-state-nonlit-pos-cache-limit' are valid.
  
  (defvar c-state-nonlit-pos-cache-limit 1)
  (make-variable-buffer-local 'c-state-nonlit-pos-cache-limit)
***************
*** 2059,2064 ****
--- 2059,2070 ----
    ;; This function is almost the same as `c-literal-limits'.  It differs in
    ;; that it is a lower level function, and that it rigourously follows the
    ;; syntax from BOB, whereas `c-literal-limits' uses a "local" safe position.
+   ;;
+   ;; NOTE: This function manipulates `c-state-nonlit-pos-cache'.  This cache
+   ;; MAY NOT contain any positions within macros, since macros are frequently
+   ;; turned into comments by use of the `c-cpp-delimiter' category properties.
+   ;; We cannot rely on this mechanism whilst determining a cache pos since
+   ;; this function is also called from outwith `c-parse-state'.
    (save-restriction
      (widen)
      (save-excursion
***************
*** 2077,2082 ****
--- 2083,2093 ----
  		   here)
  	  (setq lit (c-state-pp-to-literal pos npos))
  	  (setq pos (or (cdr lit) npos)) ; end of literal containing npos.
+ 	  (goto-char pos)
+ 	  (when (and (c-beginning-of-macro) (/= (point) pos))
+ 	    (c-syntactic-end-of-macro)
+ 	    (or (eobp) (forward-char))
+ 	    (setq pos (point)))
  	  (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
  
  	(if (> pos c-state-nonlit-pos-cache-limit)
***************
*** 2161,2167 ****
  ;; of fruitless backward scans.
  (defvar c-state-brace-pair-desert nil)
  (make-variable-buffer-local 'c-state-brace-pair-desert)
! ;; Used only in `c-append-lower-brace-pair-to-state-cache'.  It is set when an
  ;; that defun has searched backwards for a brace pair and not found one.  Its
  ;; value is either nil or a cons (PA . FROM), where PA is the position of the
  ;; enclosing opening paren/brace/bracket which bounds the backwards search (or
--- 2172,2178 ----
  ;; of fruitless backward scans.
  (defvar c-state-brace-pair-desert nil)
  (make-variable-buffer-local 'c-state-brace-pair-desert)
! ;; Used only in `c-append-lower-brace-pair-to-state-cache'.  It is set when
  ;; that defun has searched backwards for a brace pair and not found one.  Its
  ;; value is either nil or a cons (PA . FROM), where PA is the position of the
  ;; enclosing opening paren/brace/bracket which bounds the backwards search (or
***************
*** 2846,2851 ****
--- 2857,2885 ----
  	c-state-old-cpp-end nil)
    (c-state-mark-point-min-literal))
  
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;; Debugging routines to dump `c-state-cache' in a "replayable" form.
+ ;; (defmacro c-sc-de (elt) 		; "c-state-cache-dump-element"
+ ;;   `(format ,(concat "(setq " (symbol-name elt) " %s)    ") ,elt))
+ ;; (defmacro c-sc-qde (elt)		; "c-state-cache-quote-dump-element"
+ ;;   `(format ,(concat "(setq " (symbol-name elt) " '%s)    ") ,elt))
+ ;; (defun c-state-dump ()
+ ;;   ;; For debugging.
+ ;;   ;(message
+ ;;   (concat
+ ;;    (c-sc-qde c-state-cache)
+ ;;    (c-sc-de c-state-cache-good-pos)
+ ;;    (c-sc-qde c-state-nonlit-pos-cache)
+ ;;    (c-sc-de c-state-nonlit-pos-cache-limit)
+ ;;    (c-sc-qde c-state-brace-pair-desert)
+ ;;    (c-sc-de c-state-point-min)
+ ;;    (c-sc-de c-state-point-min-lit-type)
+ ;;    (c-sc-de c-state-point-min-lit-start)
+ ;;    (c-sc-de c-state-min-scan-pos)
+ ;;    (c-sc-de c-state-old-cpp-beg)
+ ;;    (c-sc-de c-state-old-cpp-end)))
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ 
  (defun c-invalidate-state-cache-1 (here)
    ;; Invalidate all info on `c-state-cache' that applies to the buffer at HERE
    ;; or higher and set `c-state-cache-good-pos' accordingly.  The cache is




On Thu, Jan 27, 2011 at 03:26:57PM -0500, Michael Welsh Duggan wrote:
> Included is pdusource.c:
> 

> /*
> ** Copyright (C) 2004-2011 by Carnegie Mellon University.
> **
> ** @OPENSOURCE_HEADER_START@

[ .... ]

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

-- 
Alan Mackenzie (Nuremberg, Germany).

bug#7930: Forgot to include the file

[Michael Welsh Duggan]

Alan Mackenzie <acm@muc.de> writes:

> Here's a patch for the bug.  Would you please try it out and let me know
> it's OK.
>
> Thanks a lot for taking the trouble to pin this one down, and for
> reporting it in such a high quality fashion.  It was a nasty little bug
> caused by a mistaken tacit assumption in an internal CC Mode cache.
>
> The cache in question maintains a list of "safe" positions every ~10,000
> characters, and in your file position 10,001 was in the middle of a
> macro.  It transpires that inside a macro is NOT a safe position ;-(.

Yes, those five lines seem to do the trick.  Thank you very much for
tracking this down.  It seems like it was a fairly brutal piece of
debugging.

-- 
Michael Welsh Duggan
(md5i@md5i.com)

bug#7930: Bug #7930 fixed

[Alan Mackenzie]

Fixed by modifying c-state-literal-at (cc-engine.el) so that positions
within macros can't find their way into c-state-nonlit-pos-cache.  Fixed
in revision 103377.