%PDF-
%PDF-
Mini Shell
Mini Shell
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
(< (aref emacs-version (1- (length emacs-version))) ?A)
(string-lessp emacs-version "23")
(error "`%s' was compiled for Emacs 23 or later" #$))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301!\210\300\302!\207" [require cc-defs cc-vars] 2)
(defalias 'c-declare-lang-variables '(macro . #[nil "\301\302\303A\"B\207" [c-lang-variable-inits progn mapcan #[(init) "\301\234\203 \302@\303\301\234F\202 \302@\304BB\305\306@DDD\207" [init 2 defvar nil (nil) make-variable-buffer-local quote] 5]] 4]))
(defvar c-no-parens-syntax-table nil)
(make-variable-buffer-local 'c-no-parens-syntax-table)
#@351 A list that describes the modifications that should be done to the
mode syntax table to get a syntax table that matches all identifiers
and keywords as words.
The list is just like the one used in `font-lock-defaults': Each
element is a cons where the car is the character to modify and the cdr
the new syntax, as accepted by `modify-syntax-entry'.
(defvar c-identifier-syntax-modifications nil (#$ . 833))
(make-variable-buffer-local 'c-identifier-syntax-modifications)
#@181 Syntax table built on the mode syntax table but additionally
classifies symbol constituents like `_' and `$' as word constituents,
so that all identifiers are recognized as words.
(defvar c-identifier-syntax-table nil (#$ . 1312))
(make-variable-buffer-local 'c-identifier-syntax-table)
#@719 If non-nil, a list of functions called from c-before-change-hook.
Typically these will record enough state to allow
`c-before-font-lock-functions' to extend the region to fontify,
and may do such things as removing text-properties which must be
recalculated.
These functions will be run in the order given. Each of them
takes 2 parameters, the BEG and END supplied to every
before-change function; on entry, the buffer will have been
widened and match-data will have been saved; point is undefined
on both entry and exit; the return value is ignored.
The functions are called even when font locking isn't enabled.
When the mode is initialized, the functions are called with
parameters (point-min) and (point-max).
(defvar c-get-state-before-change-functions nil (#$ . 1606))
(make-variable-buffer-local 'c-get-state-before-change-functions)
#@796 If non-nil, a list of functions called just before font locking.
Typically they will extend the region about to be fontified (see
below) and will set `syntax-table' text properties on the region.
These functions will be run in the order given. Each of them
takes 3 parameters, the BEG, END, and OLD-LEN supplied to every
after-change function; point is undefined on both entry and exit;
on entry, the buffer will have been widened and match-data will
have been saved; the return value is ignored.
The functions may extend the region to be fontified by setting the
buffer local variables c-new-BEG and c-new-END.
The functions are called even when font locking is disabled.
When the mode is initialized, these functions are called with
parameters (point-min), (point-max) and <buffer size>.
(defvar c-before-font-lock-functions nil (#$ . 2458))
(make-variable-buffer-local 'c-before-font-lock-functions)
#@473 If non-nil, a list of functions called just before context (or
other non-change) fontification is done. Typically they will
extend the region.
These functions will be run in the order given. Each of them
takes 2 parameters, the BEG and END of the region to be
fontified. Point is undefined on both entry and exit. On entry,
the buffer will have been widened and match-data will have been
saved; the return value is a cons of the adjusted
region, (NEW-BEG . NEW-END).
(defvar c-before-context-fontification-functions nil (#$ . 3373))
(make-variable-buffer-local 'c-before-context-fontification-functions)
#@264 Contains a function "Is there a virtual semicolon at POS or point?".
Such a function takes one optional parameter, a buffer position (defaults to
point), and returns nil or t. This variable contains nil for languages which
don't have EOL terminated statements.
(defvar c-at-vsemi-p-fn nil (#$ . 3989))
(make-variable-buffer-local 'c-at-vsemi-p-fn)
#@426 Contains a function "are we unsure whether there is a virtual semicolon on this line?".
The (admittedly kludgy) purpose of such a function is to prevent an infinite
recursion in c-beginning-of-statement-1 when point starts at a `while' token.
The function MUST NOT UNDER ANY CIRCUMSTANCES call c-beginning-of-statement-1,
even indirectly. This variable contains nil for languages which don't have
EOL terminated statements.
(defvar c-vsemi-status-unknown-p-fn nil (#$ . 4346))
(make-variable-buffer-local 'c-vsemi-status-unknown-p-fn)
#@49 Whether the language has bitfield declarations.
(defvar c-has-bitfields nil (#$ . 4888))
(make-variable-buffer-local 'c-has-bitfields)
#@466 Whether the language uses single quotes for multi-char strings.
Note that to set up a language to use this, additionally:
(i) the syntax of "'" must be "string quote" (7);
(ii) the language's value of `c-has-quoted-numbers' must be nil;
(iii) the language's value of `c-get-state-before-change-functions' may not
contain `c-parse-quotes-before-change';
(iv) the language's value of `c-before-font-lock-functions' may not contain
`c-parse-quotes-after-change'.
(defvar c-single-quotes-quote-strings nil (#$ . 5030))
(make-variable-buffer-local 'c-single-quotes-quote-strings)
(defvar c-string-delims nil)
(make-variable-buffer-local 'c-string-delims)
#@61 Whether the language has numbers quoted like 4'294'967'295.
(defvar c-has-quoted-numbers nil (#$ . 5691))
(make-variable-buffer-local 'c-has-quoted-numbers)
#@76 Whether literal initializers {...} are used other than in initializations.
(defvar c-has-compound-literals nil (#$ . 5854))
(make-variable-buffer-local 'c-has-compound-literals)
#@222 Regexp that matches a “modified” constant literal such as "L\='a\='",
a “long character”. In particular, this recognizes forms of constant
which `c-backward-sexp' needs to be called twice to move backwards over.
(defvar c-modified-constant nil (#$ . 6039))
(make-variable-buffer-local 'c-modified-constant)
#@164 Regexp that matches the start of a symbol, i.e. any identifier or
keyword. It's unspecified how far it matches. Does not contain a \|
operator at the top level.
(defvar c-symbol-start nil (#$ . 6362))
(make-variable-buffer-local 'c-symbol-start)
#@103 Set of characters that can be part of a symbol.
This is of the form that fits inside [ ] in a regexp.
(defvar c-symbol-chars nil (#$ . 6617))
(make-variable-buffer-local 'c-symbol-chars)
#@66 Regexp matching a sequence of at least one identifier character.
(defvar c-symbol-char-key nil (#$ . 6810))
(make-variable-buffer-local 'c-symbol-char-key)
#@129 Regexp matching identifiers and keywords (with submatch 0). Assumed
to match if `c-symbol-start' matches on the same position.
(defvar c-symbol-key nil (#$ . 6973))
(make-variable-buffer-local 'c-symbol-key)
#@97 This is the set of chars that can't be part of a symbol, i.e. the
negation of `c-symbol-chars'.
(defvar c-nonsymbol-chars nil (#$ . 7188))
(make-variable-buffer-local 'c-nonsymbol-chars)
(defvar c-opt-identifier-concat-key nil)
(make-variable-buffer-local 'c-opt-identifier-concat-key)
#@145 Regexp that matches the start of an (optionally qualified) identifier.
It should also match all keywords. It's unspecified how far it
matches.
(defvar c-identifier-start nil (#$ . 7481))
(make-variable-buffer-local 'c-identifier-start)
#@332 Regexp matching a fully qualified identifier, like "A::B::c" in
C++. It does not recognize the full range of syntactic whitespace
between the tokens; `c-forward-name' has to be used for that. It
should also not match identifiers containing parenthesis groupings,
e.g. identifiers with template arguments such as "A<X,Y>" in C++.
(defvar c-identifier-key nil (#$ . 7725))
(make-variable-buffer-local 'c-identifier-key)
#@80 Set if the language support backslash escaped newlines inside string
literals.
(defvar c-string-escaped-newlines nil (#$ . 8151))
(make-variable-buffer-local 'c-string-escaped-newlines)
#@231 Set if the language supports multiline string literals without escaped
newlines. If t, all string literals are multiline. If a character,
only literals where the open quote is immediately preceded by that
literal are multiline.
(defvar c-multiline-string-start-char nil (#$ . 8344))
(make-variable-buffer-local 'c-multiline-string-start-char)
(defvar c-string-innards-re-alist nil)
(make-variable-buffer-local 'c-string-innards-re-alist)
#@69 The symbol which starts preprocessor constructs when in the margin.
(defvar c-opt-cpp-symbol nil (#$ . 8790))
(make-variable-buffer-local 'c-opt-cpp-symbol)
#@188 Regexp matching the prefix of a cpp directive in the languages that
normally use that macro preprocessor. Tested at bol or at boi.
Assumed to not contain any submatches or \| operators.
(defvar c-opt-cpp-prefix nil (#$ . 8954))
(make-variable-buffer-local 'c-opt-cpp-prefix)
#@113 Regexp matching the prefix of a cpp directive anchored to BOL,
in the languages that have a macro preprocessor.
(defvar c-anchored-cpp-prefix nil (#$ . 9237))
(make-variable-buffer-local 'c-anchored-cpp-prefix)
#@177 Regexp matching the prefix of a cpp directive including the directive
name, or nil in languages without preprocessor support. The first
submatch surrounds the directive name.
(defvar c-opt-cpp-start nil (#$ . 9455))
(make-variable-buffer-local 'c-opt-cpp-start)
(defvar c-cpp-include-key nil)
(make-variable-buffer-local 'c-cpp-include-key)
#@117 Cpp directive (without the prefix) that is followed by a macro
definition, or nil if the language doesn't have any.
(defvar c-opt-cpp-macro-define nil (#$ . 9804))
(make-variable-buffer-local 'c-opt-cpp-macro-define)
(defvar c-opt-cpp-macro-define-start nil)
(make-variable-buffer-local 'c-opt-cpp-macro-define-start)
(defvar c-opt-cpp-macro-define-id nil)
(make-variable-buffer-local 'c-opt-cpp-macro-define-id)
#@125 Regexp which matches the start of a CPP directive which contains an
expression, or nil if there aren't any in the language.
(defvar c-cpp-expr-intro-re nil (#$ . 10224))
(make-variable-buffer-local 'c-cpp-expr-intro-re)
(defvar c-cpp-expr-functions-key nil)
(make-variable-buffer-local 'c-cpp-expr-functions-key)
(defvar c-operator-re nil)
(make-variable-buffer-local 'c-operator-re)
(defvar c-non-after-{}-ops-re nil)
(make-variable-buffer-local 'c-non-after-{}-ops-re)
(defvar c-overloadable-operators-regexp nil)
(make-variable-buffer-local 'c-overloadable-operators-regexp)
#@432 Regexp matching the token before the ones in
`c-overloadable-operators' when operators are specified in their
"identifier form". This typically matches "operator" in C++ where
operator functions are specified as e.g. "operator +". It's nil in
languages without operator functions or where the complete operator
identifier is listed in `c-overloadable-operators'.
This regexp is assumed to not match any non-operator identifier.
(defvar c-opt-op-identifier-prefix nil (#$ . 10809))
(make-variable-buffer-local 'c-opt-op-identifier-prefix)
(defvar c-ambiguous-overloadable-or-identifier-prefix-re nil)
(make-variable-buffer-local 'c-ambiguous-overloadable-or-identifier-prefix-re)
(defvar c-nonsymbol-token-regexp nil)
(make-variable-buffer-local 'c-nonsymbol-token-regexp)
(defvar c-assignment-op-regexp nil)
(make-variable-buffer-local 'c-assignment-op-regexp)
(defvar c-arithmetic-op-regexp nil)
(make-variable-buffer-local 'c-arithmetic-op-regexp)
(defvar c-:$-multichar-token-regexp nil)
(make-variable-buffer-local 'c-:$-multichar-token-regexp)
(defvar c-<>-multichar-token-regexp nil)
(make-variable-buffer-local 'c-<>-multichar-token-regexp)
(defvar c-<-op-cont-regexp nil)
(make-variable-buffer-local 'c-<-op-cont-regexp)
#@184 Regexp matching the continuation of a pseudo digraph starting "<".
This is used only in C++ Mode, where "<::" is handled as a
template opener followed by the "::" operator - usually.
(defvar c-<-pseudo-digraph-cont-regexp nil (#$ . 12048))
(make-variable-buffer-local 'c-<-pseudo-digraph-cont-regexp)
#@148 The maximum length of the main bit of a `c-<-pseudo-digraph-cont-regexp' match.
This doesn't count the merely contextual bits of the regexp match.
(defvar c-<-pseudo-digraph-cont-len nil (#$ . 12356))
(make-variable-buffer-local 'c-<-pseudo-digraph-cont-len)
(defvar c->-op-cont-regexp nil)
(make-variable-buffer-local 'c->-op-cont-regexp)
(defvar c->-op-without->-cont-regexp nil)
(make-variable-buffer-local 'c->-op-without->-cont-regexp)
(defvar c-multichar->-op-not->>->>>-regexp nil)
(make-variable-buffer-local 'c-multichar->-op-not->>->>>-regexp)
(defvar c-:-op-cont-regexp nil)
(make-variable-buffer-local 'c-:-op-cont-regexp)
(defvar c-stmt-delim-chars nil)
(make-variable-buffer-local 'c-stmt-delim-chars)
(defvar c-stmt-boundary-skip-chars nil)
(make-variable-buffer-local 'c-stmt-boundary-skip-chars)
(defvar c-stmt-boundary-skip-list nil)
(make-variable-buffer-local 'c-stmt-boundary-skip-list)
(defvar c-stmt-delim-chars-with-comma nil)
(make-variable-buffer-local 'c-stmt-delim-chars-with-comma)
(defvar c-stmt-boundary-skip-chars-with-comma nil)
(make-variable-buffer-local 'c-stmt-boundary-skip-chars-with-comma)
(defvar c-stmt-boundary-skip-list-with-comma nil)
(make-variable-buffer-local 'c-stmt-boundary-skip-list-with-comma)
(defvar c-pack-key nil)
(make-variable-buffer-local 'c-pack-key)
(defvar c-auto-ops-re nil)
(make-variable-buffer-local 'c-auto-ops-re)
(defvar c-haskell-op-re nil)
(make-variable-buffer-local 'c-haskell-op-re)
#@169 List of operators following which an apparent declaration (e.g.
"t1 *fn (t2 *b);") is most likely to be an actual declaration
(as opposed to an arithmetic expression).
(defvar c-pre-start-tokens nil (#$ . 13821))
(make-variable-buffer-local 'c-pre-start-tokens)
(defvar c-pre-lambda-tokens-re nil)
(make-variable-buffer-local 'c-pre-lambda-tokens-re)
#@336 String that starts line comments, or nil if such don't exist.
Line comments are always terminated by newlines. At least one of
`c-block-comment-starter' and this one is assumed to be set.
Note that it's currently not enough to set this to support a new
comment style. Other stuff like the syntax table must also be set up
properly.
(defvar c-line-comment-starter nil (#$ . 14179))
(make-variable-buffer-local 'c-line-comment-starter)
#@379 String that starts block comments, or nil if such don't exist.
Block comments are ended by `c-block-comment-ender', which is assumed
to be set if this is. At least one of `c-line-comment-starter' and
this one is assumed to be set.
Note that it's currently not enough to set this to support a new
comment style. Other stuff like the syntax table must also be set up
properly.
(defvar c-block-comment-starter nil (#$ . 14623))
(make-variable-buffer-local 'c-block-comment-starter)
#@208 String that ends block comments, or nil if such don't exist.
Note that it's currently not enough to set this to support a new
comment style. Other stuff like the syntax table must also be set up
properly.
(defvar c-block-comment-ender nil (#$ . 15112))
(make-variable-buffer-local 'c-block-comment-ender)
(defvar c-block-comment-ender-regexp nil)
(make-variable-buffer-local 'c-block-comment-ender-regexp)
#@146 List of characters which, inside a block comment, could be the first
character of a double character construct. This doesn't include
backslash.
(defvar c-block-comment-awkward-chars nil (#$ . 15527))
(make-variable-buffer-local 'c-block-comment-awkward-chars)
(defvar c-comment-start-regexp nil)
(make-variable-buffer-local 'c-comment-start-regexp)
(defvar c-block-comment-start-regexp nil)
(make-variable-buffer-local 'c-block-comment-start-regexp)
(defvar c-line-comment-start-regexp nil)
(make-variable-buffer-local 'c-line-comment-start-regexp)
#@193 Regexp which matches the last block comment ender on the
current line, if any, or nil in those languages without block
comments. When a match is found, submatch 1 contains the comment
ender.
(defvar c-last-c-comment-end-on-line-re nil (#$ . 16084))
(make-variable-buffer-local 'c-last-c-comment-end-on-line-re)
(defvar c-literal-start-regexp nil)
(make-variable-buffer-local 'c-literal-start-regexp)
#@54 Regexp to match the start of documentation comments.
(defvar c-doc-comment-start-regexp nil (#$ . 16491))
(make-variable-buffer-local 'c-doc-comment-start-regexp)
#@58 Non-nil when the default comment style is block comment.
(defvar c-block-comment-is-default nil (#$ . 16660))
(make-variable-buffer-local 'c-block-comment-is-default)
(defvar c-syntactic-ws-start nil)
(make-variable-buffer-local 'c-syntactic-ws-start)
(defvar c-syntactic-ws-end nil)
(make-variable-buffer-local 'c-syntactic-ws-end)
(defvar c-syntactic-eol nil)
(make-variable-buffer-local 'c-syntactic-eol)
#@40 Regexp to append to `paragraph-start'.
(defvar c-paragraph-start nil (#$ . 17074))
(make-variable-buffer-local 'c-paragraph-start)
#@43 Regexp to append to `paragraph-separate'.
(defvar c-paragraph-separate nil (#$ . 17211))
(make-variable-buffer-local 'c-paragraph-separate)
(defvar c-return-key nil)
(make-variable-buffer-local 'c-return-key)
(defvar c-primitive-type-key nil)
(make-variable-buffer-local 'c-primitive-type-key)
(defvar c-typedef-key nil)
(make-variable-buffer-local 'c-typedef-key)
(defvar c-typeof-key nil)
(make-variable-buffer-local 'c-typeof-key)
(defvar c-template-typename-key nil)
(make-variable-buffer-local 'c-template-typename-key)
(defvar c-type-prefix-key nil)
(make-variable-buffer-local 'c-type-prefix-key)
(defvar c-opt-type-modifier-prefix-key nil)
(make-variable-buffer-local 'c-opt-type-modifier-prefix-key)
(defvar c-opt-type-modifier-key nil)
(make-variable-buffer-local 'c-opt-type-modifier-key)
(defvar c-opt-type-component-key nil)
(make-variable-buffer-local 'c-opt-type-component-key)
(defvar c-type-decl-suffix-ws-ids-key nil)
(make-variable-buffer-local 'c-type-decl-suffix-ws-ids-key)
(defvar c-class-id-suffix-ws-ids-key nil)
(make-variable-buffer-local 'c-class-id-suffix-ws-ids-key)
(defvar c-class-key nil)
(make-variable-buffer-local 'c-class-key)
(defvar c-brace-list-key nil)
(make-variable-buffer-local 'c-brace-list-key)
(defvar c-after-brace-list-key nil)
(make-variable-buffer-local 'c-after-brace-list-key)
#@101 Set to t when we recognize a colon and then a type after an enum,
e.g., enum foo : int { A, B, C };
(defvar c-recognize-post-brace-list-type-p nil (#$ . 18548))
(make-variable-buffer-local 'c-recognize-post-brace-list-type-p)
(defvar c-other-decl-block-key nil)
(make-variable-buffer-local 'c-other-decl-block-key)
#@104 Alist associating keywords in c-other-decl-block-decl-kwds with
their matching "in" syntactic symbols.
(defvar c-other-decl-block-key-in-symbols-alist nil (#$ . 18870))
(make-variable-buffer-local 'c-other-decl-block-key-in-symbols-alist)
(defvar c-defun-type-name-decl-key nil)
(make-variable-buffer-local 'c-defun-type-name-decl-key)
(defvar c-typedef-decl-key nil)
(make-variable-buffer-local 'c-typedef-decl-key)
(defvar c-equals-type-clause-key nil)
(make-variable-buffer-local 'c-equals-type-clause-key)
(defvar c-decl-hangon-key nil)
(make-variable-buffer-local 'c-decl-hangon-key)
(defvar c-prefix-spec-kwds-re nil)
(make-variable-buffer-local 'c-prefix-spec-kwds-re)
(defvar c-specifier-key nil)
(make-variable-buffer-local 'c-specifier-key)
(defvar c-not-decl-init-keywords nil)
(make-variable-buffer-local 'c-not-decl-init-keywords)
(defvar c-not-primitive-type-keywords-regexp nil)
(make-variable-buffer-local 'c-not-primitive-type-keywords-regexp)
(defvar c-protection-key nil)
(make-variable-buffer-local 'c-protection-key)
#@122 The token which (may) follow a protection keyword,
e.g. the ":" in C++ Mode's "public:". nil if there is no such token.
(defvar c-post-protection-token nil (#$ . 19915))
(make-variable-buffer-local 'c-post-protection-token)
(defvar c-opt-block-decls-with-vars-key nil)
(make-variable-buffer-local 'c-opt-block-decls-with-vars-key)
(defvar c-postfix-decl-spec-key nil)
(make-variable-buffer-local 'c-postfix-decl-spec-key)
(defvar c-make-top-level-key nil)
(make-variable-buffer-local 'c-make-top-level-key)
#@250 Regexp matched after the keywords in `c-colon-type-list-kwds' to skip
forward to the colon. The end of the match is assumed to be directly
after the colon, so the regexp should end with ":". Must be a
regexp if `c-colon-type-list-kwds' isn't nil.
(defvar c-colon-type-list-re nil (#$ . 20430))
(make-variable-buffer-local 'c-colon-type-list-re)
(defvar c-paren-nontype-key nil)
(make-variable-buffer-local 'c-paren-nontype-key)
(defvar c-opt-<>-sexp-key nil)
(make-variable-buffer-local 'c-opt-<>-sexp-key)
(defvar c-inside-<>-type-key nil)
(make-variable-buffer-local 'c-inside-<>-type-key)
(defvar c-block-stmt-1-key nil)
(make-variable-buffer-local 'c-block-stmt-1-key)
(defvar c-block-stmt-1-2-key nil)
(make-variable-buffer-local 'c-block-stmt-1-2-key)
(defvar c-block-stmt-2-key nil)
(make-variable-buffer-local 'c-block-stmt-2-key)
(defvar c-block-stmt-hangon-key nil)
(make-variable-buffer-local 'c-block-stmt-hangon-key)
(defvar c-opt-block-stmt-key nil)
(make-variable-buffer-local 'c-opt-block-stmt-key)
(defvar c-simple-stmt-key nil)
(make-variable-buffer-local 'c-simple-stmt-key)
(defvar c-paren-stmt-key nil)
(make-variable-buffer-local 'c-paren-stmt-key)
(defvar c-opt-asm-stmt-key nil)
(make-variable-buffer-local 'c-opt-asm-stmt-key)
(defvar c-case-kwds-regexp nil)
(make-variable-buffer-local 'c-case-kwds-regexp)
(defvar c-label-kwds-regexp nil)
(make-variable-buffer-local 'c-label-kwds-regexp)
(defvar c-opt-inexpr-brace-list-key nil)
(make-variable-buffer-local 'c-opt-inexpr-brace-list-key)
(defvar c-brace-stack-thing-key nil)
(make-variable-buffer-local 'c-brace-stack-thing-key)
(defvar c-brace-stack-no-semi-key nil)
(make-variable-buffer-local 'c-brace-stack-no-semi-key)
(defvar c-decl-block-key nil)
(make-variable-buffer-local 'c-decl-block-key)
(defvar c-opt-bitfield-key nil)
(make-variable-buffer-local 'c-opt-bitfield-key)
(defvar c-keywords-regexp nil)
(make-variable-buffer-local 'c-keywords-regexp)
(defvar c-keywords-obarray nil)
(make-variable-buffer-local 'c-keywords-obarray)
(defvar c-regular-keywords-regexp nil)
(make-variable-buffer-local 'c-regular-keywords-regexp)
(defvar c-primary-expr-regexp nil)
(make-variable-buffer-local 'c-primary-expr-regexp)
#@136 Regexp matching a keyword that is followed by a colon, where
the whole construct can precede a declaration.
E.g. "public:" in C++.
(defvar c-decl-start-colon-kwd-re nil (#$ . 22640))
(make-variable-buffer-local 'c-decl-start-colon-kwd-re)
(defvar c-decl-prefix-re nil)
(make-variable-buffer-local 'c-decl-prefix-re)
#@276 Regexp matching the start of any declaration, cast or label.
It's used on the token after the one `c-decl-prefix-re' matched. This
regexp should not try to match those constructs accurately as it's
only used as a sieve to avoid spending more time checking other
constructs.
(defvar c-decl-start-re nil (#$ . 22967))
(make-variable-buffer-local 'c-decl-start-re)
(defvar c-decl-prefix-or-start-re nil)
(make-variable-buffer-local 'c-decl-prefix-or-start-re)
(defvar c-dposr-cpp-macro-depth nil)
(make-variable-buffer-local 'c-dposr-cpp-macro-depth)
(defvar c-cast-parens nil)
(make-variable-buffer-local 'c-cast-parens)
(defvar c-block-prefix-charset nil)
(make-variable-buffer-local 'c-block-prefix-charset)
(defvar c-type-decl-prefix-key nil)
(make-variable-buffer-local 'c-type-decl-prefix-key)
#@302 Regexp matching any declarator operator which isn't a keyword,
that might precede the identifier in a declaration, e.g. the
"*" in "char *argv". The end of the first submatch is taken
as the end of the operator. Identifier syntax is in effect when
this is matched (see `c-identifier-syntax-table').
(defvar c-type-decl-operator-prefix-key nil (#$ . 23772))
(make-variable-buffer-local 'c-type-decl-operator-prefix-key)
(defvar c-type-decl-suffix-key nil)
(make-variable-buffer-local 'c-type-decl-suffix-key)
(defvar c-after-suffixed-type-decl-key nil)
(make-variable-buffer-local 'c-after-suffixed-type-decl-key)
(defvar c-after-suffixed-type-maybe-decl-key nil)
(make-variable-buffer-local 'c-after-suffixed-type-maybe-decl-key)
(defvar c-opt-type-concat-key nil)
(make-variable-buffer-local 'c-opt-type-concat-key)
#@369 Regexp matching operators that might follow after a type, or nil in
languages that don't have such operators. The end of the first
submatch is taken as the end of the operator. This should not match
things like C++ template arglists if `c-recognize-<>-arglists' is set.
It's undefined whether identifier syntax (see `c-identifier-syntax-table')
is in effect or not.
(defvar c-opt-type-suffix-key nil (#$ . 24598))
(make-variable-buffer-local 'c-opt-type-suffix-key)
(defvar c-known-type-key nil)
(make-variable-buffer-local 'c-known-type-key)
#@142 List of open- and close-chars that makes up a pike-style brace list,
i.e., for a ([ ]) list there should be a cons (?\[ . ?\]) in this
list.
(defvar c-special-brace-lists nil (#$ . 25150))
(make-variable-buffer-local 'c-special-brace-lists)
#@58 Non-nil means K&R style argument declarations are valid.
(defvar c-recognize-knr-p nil (#$ . 25397))
(make-variable-buffer-local 'c-recognize-knr-p)
#@80 A regexp matching tokens which, preceding an identifier, signify a bracelist.
(defvar c-pre-id-bracelist-key nil (#$ . 25552))
(make-variable-buffer-local 'c-pre-id-bracelist-key)
#@332 Non-nil means function declarations without return type should be
recognized. That can introduce an ambiguity with parenthesized macro
calls before a brace block. This setting does not affect declarations
that are preceded by a declaration starting keyword, so
e.g. `c-typeless-decl-kwds' may still be used when it's set to nil.
(defvar c-recognize-typeless-decls nil (#$ . 25740))
(make-variable-buffer-local 'c-recognize-typeless-decls)
#@360 Non-nil means C++ style template arglists should be handled. More
specifically, this means a comma separated list of types or
expressions surrounded by "<" and ">". It's always preceded by an
identifier or one of the keywords on `c-<>-type-kwds' or
`c-<>-arglist-kwds'. If there's an identifier before then the whole
expression is considered to be a type.
(defvar c-recognize-<>-arglists nil (#$ . 26188))
(make-variable-buffer-local 'c-recognize-<>-arglists)
#@551 A regexp matching any single character notable inside a <...> construct.
This must include "<" and ">", and should include ",", and
any character which cannot be valid inside such a construct.
This is used in `c-forward-<>-arglist-recur' to try to detect
sequences of tokens which cannot be a template/generic construct.
When "(" is present, that defun will attempt to parse a
parenthesized expression inside the template. When ")" is
present it will treat an unbalanced closing paren as a sign of
the invalidity of the putative template construct.
(defvar c-<>-notable-chars-re nil (#$ . 26658))
(make-variable-buffer-local 'c-<>-notable-chars-re)
(defvar c-enum-clause-introduction-re nil)
(make-variable-buffer-local 'c-enum-clause-introduction-re)
#@64 Non-nil means that an enum structure can contain declarations.
(defvar c-enums-contain-decls nil (#$ . 27417))
(make-variable-buffer-local 'c-enums-contain-decls)
#@144 Non-nil means that parenthesis style initializers exist,
i.e. constructs like
Foo bar (gnu);
in addition to the more classic
Foo bar = gnu;
(defvar c-recognize-paren-inits nil (#$ . 27587))
(make-variable-buffer-local 'c-recognize-paren-inits)
#@158 Non-nil means that brace initializers without "=" exist,
i.e. constructs like
int foo[] {1, 2, 3};
in addition to the more classic
int foo[] = {1, 2, 3};
(defvar c-recognize-bare-brace-inits nil (#$ . 27841))
(make-variable-buffer-local 'c-recognize-bare-brace-inits)
#@125 Non-nil to recognize gcc style in-expression blocks,
i.e. compound statements surrounded by parentheses inside expressions.
(defvar c-recognize-paren-inexpr-blocks nil (#$ . 28119))
(make-variable-buffer-local 'c-recognize-paren-inexpr-blocks)
(defvar c-opt-<>-arglist-start nil)
(make-variable-buffer-local 'c-opt-<>-arglist-start)
(defvar c-opt-<>-arglist-start-in-paren nil)
(make-variable-buffer-local 'c-opt-<>-arglist-start-in-paren)
(defvar c-opt-postfix-decl-spec-key nil)
(make-variable-buffer-local 'c-opt-postfix-decl-spec-key)
#@211 Non-nil if generic labels ending with ":" should be recognized.
That includes labels in code and access keys in classes. This does
not apply to labels recognized by `c-label-kwds' and
`c-opt-extra-label-key'.
(defvar c-recognize-colon-labels nil (#$ . 28665))
(make-variable-buffer-local 'c-recognize-colon-labels)
#@143 Regexp like `c-decl-prefix-re' that matches any token that can precede
a generic colon label. Not used if `c-recognize-colon-labels' is
nil.
(defvar c-label-prefix-re nil (#$ . 28988))
(make-variable-buffer-local 'c-label-prefix-re)
#@260 Regexp matching things that can't occur in generic colon labels,
neither in a statement nor in a declaration context. The regexp is
tested at the beginning of every sexp in a suspected label,
i.e. before ":". Only used if `c-recognize-colon-labels' is set.
(defvar c-nonlabel-token-key nil (#$ . 29229))
(make-variable-buffer-local 'c-nonlabel-token-key)
#@302 Regexp matching things that can't occur in generic colon labels,
neither in a statement nor in a declaration context, with the
exception of an open parenthesis. The regexp is tested at the
beginning of every sexp in a suspected label, i.e. before ":".
Only used if `c-recognize-colon-labels' is set.
(defvar c-nonlabel-nonparen-token-key nil (#$ . 29593))
(make-variable-buffer-local 'c-nonlabel-nonparen-token-key)
#@200 Regexp matching things that can't occur two symbols before a colon in
a label construct. This catches C++'s inheritance construct "class foo
: bar". Only used if `c-recognize-colon-labels' is set.
(defvar c-nonlabel-token-2-key nil (#$ . 30017))
(make-variable-buffer-local 'c-nonlabel-token-2-key)
#@242 Optional regexp matching labels.
Normally, labels are detected according to `c-nonlabel-token-key',
`c-decl-prefix-re' and `c-nonlabel-decl-prefix-re'. This regexp can
be used if there are additional labels that aren't recognized that
way.
(defvar c-opt-extra-label-key nil (#$ . 30325))
(make-variable-buffer-local 'c-opt-extra-label-key)
(defvar c-opt-friend-key nil)
(make-variable-buffer-local 'c-opt-friend-key)
(defvar c-opt-method-key nil)
(make-variable-buffer-local 'c-opt-method-key)
(defvar c-type-decl-end-used nil)
(make-variable-buffer-local 'c-type-decl-end-used)
#@236 List of faces that might be put at the start of a type when
`c-font-lock-declarations' runs. This must be evaluated (with `eval') at
runtime to get the actual list of faces. This ensures that face name
aliases in Emacs are resolved.
(defvar c-maybe-decl-faces nil (#$ . 30912))
(make-variable-buffer-local 'c-maybe-decl-faces)
(defvar c-hungry-delete-key nil)
(make-variable-buffer-local 'c-hungry-delete-key)
(defvar c-electric-flag t)
(make-variable-buffer-local 'c-electric-flag)
(defvar c-auto-newline nil)
(make-variable-buffer-local 'c-auto-newline)
(defalias 'c-calculate-state #[(arg prevstate) "\203 \302!\211\303U\203 ?\207\303V\207" [arg prevstate prefix-numeric-value 0] 2])
(defvar c-macro-start 'unknown)
(defalias 'c-query-and-set-macro-start #[nil "9\203 \212\305 \306\211\306 \307\216\310 \205 `.\211\207\207" [c-macro-start #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-beginning-of-macro] 3])
(put 'c-query-and-set-macro-start 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-query-macro-start #[nil "9\203 \212\305 \306\211\306 \307\216\310 \205 `.\207\207" [c-macro-start #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-beginning-of-macro] 2])
(put 'c-query-macro-start 'byte-optimizer 'byte-compile-inline-expand)
(defvar c-macro-cache nil)
(make-variable-buffer-local 'c-macro-cache)
(defvar c-macro-cache-start-pos nil)
(make-variable-buffer-local 'c-macro-cache-start-pos)
(defvar c-macro-cache-syntactic nil)
(make-variable-buffer-local 'c-macro-cache-syntactic)
(defvar c-macro-cache-no-comment nil)
(make-variable-buffer-local 'c-macro-cache-no-comment)
(defalias 'c-invalidate-macro-cache #[(beg _end) "?\206? @X\203 \305\211\305\211\211\207A\203. AW\203. \305\241\210 \305\211\211\207\n\205? \nW\205? \305\211\211\207" [c-macro-cache beg c-macro-cache-start-pos c-macro-cache-syntactic c-macro-cache-no-comment nil] 3])
(defalias 'c-macro-is-genuine-p #[nil "`\302 \210`e=\203% `\303U\204% \214~\210\302 \210\304 !\205! \303\224=)\202& \305b\210)\207" [here c-anchored-cpp-prefix beginning-of-line 1 looking-at t] 2])
#@286 Go to the beginning of a preprocessor directive.
Leave point at the beginning of the directive and return t if in one,
otherwise return nil and leave point unchanged.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-beginning-of-macro #[(&optional lim) "`\306 \n\205\324 @\203E ` @Y\203E A\203! ` AX\204' `\fX\203E @
\206. eW?\205\324
\2068 e @]b\210\f ]\307\202\324 \310\211\310\211\214
\203X
d}\210\311 \210
\203e
Y\203\246 \312 \313\216`S\206q `Sf\314=\203~ \315y\210\202k \203\245 \316\307#\203\245 \317\225b\210\320 \203\236 \311 \210`\211\202\242 b\210\310\204k *\321 \210` X\203\317 \312 \322\216\323!*\203\317 \324 \203\317 `\310B \310\307\202\323 b\210\310)*\207" [pause here c-opt-cpp-prefix c-macro-cache c-macro-cache-start-pos lim line-end-position t nil beginning-of-line match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] 92 -1 re-search-forward 1 c-backward-single-comment back-to-indentation #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] looking-at c-macro-is-genuine-p c-macro-cache-syntactic c-macro-cache-no-comment save-match-data-internal c-last-c-comment-end-on-line-re c-opt-cpp-start] 5 (#$ . 33265)])
#@544 Go to the end of a preprocessor directive.
More accurately, move the point to the end of the closest following
line that doesn't end with a line continuation backslash - no check is
done that the point is inside a cpp directive to begin with, although
it is assumed that point isn't inside a comment or string.
If LIM is provided, it is a limit position at which point is left
if the end of the macro doesn't occur earlier.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-end-of-macro #[(&optional lim) "\214\203 e}\210 A\203\" ` AX\203\" ` @Y\203\" Ab\202\244 @\2034 `\nX\2034 ` @Y\204< \306\211\306\211\307 \310\216` \306\210`Sf\311=\203Y m\204Y \306u\210\202D \312`\" \3138\205~ \3148?\205~ \312`d\306\211\315&\210`\211)\204D @\205\243 ` @V\205\243 `S\206\224 `Sf\311=?\205\243 `\241\210\306\211+)\207" [lim c-macro-cache c-macro-cache-start-pos c-macro-cache-syntactic c-macro-cache-no-comment save-match-data-internal nil match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] 92 parse-partial-sexp 4 7 syntax-table safe-pos s] 8 (#$ . 34587)])
(defalias 'c-syntactic-end-of-macro #[nil "`\304 \210`\305 \203 b\210\202A \306 \"\307\n8\204, \310\n8\203? \311\n8\312=\204? V\203? \313\n8S\306 \"\202 ``+\207" [here there s c-macro-cache-syntactic c-end-of-macro nil parse-partial-sexp 3 4 7 syntax-table 8] 3])
(defalias 'c-no-comment-end-of-macro #[nil "`\304 \210`\305 \203 b\210\202F \306 \"\307\n8\2031 V\2031 \310\n8T\306 \"\202 \311\n8\203D \312\n8\313=\204D \310\n8b\210``+\207" [here there s c-macro-cache-no-comment c-end-of-macro nil parse-partial-sexp 3 8 4 7 syntax-table] 3])
(defalias 'c-forward-over-cpp-define-id #[nil "\205
\301!\205
\302\225b\207" [c-opt-cpp-macro-define-id looking-at 0] 2])
(defalias 'c-forward-to-cpp-define-body #[nil "\205 \301!\205 \302\225\303 U?\205 \302\225b\207" [c-opt-cpp-macro-define-start looking-at 0 line-end-position] 2])
(defalias 'c-delq-from-dotted-list #[(elt dlist) "\304\211:\203+ \n@ =\203\" \203 \nA\241\210\202$ A\202$ \n\nA\211\202 *\207" [dlist prev tail elt nil] 3])
(defalias 'c-syntactic-content #[(from to paren-level) "\212\214 }\210b\210\306C\211\306\211 \307 \310#\203\233 \311\224\211b\210\312 \210`\fU\2030 \306u\210\202 \203B \212\313\f\314#@\314U`)\fV\203p ` W\203p \315\316!\203p \212\fSb\210\315\316!)\203p \317\f\"\320D\241\210 AA\202{ \317\f\"C\241\210 A
\203\226 \313\f \321#@\321U\203\226 \317`S`\"C\241\210 A`\202 \317 \"C\241\210\322\323\nA\".\207" [from to parts tail pos in-paren nil re-search-forward t 0 c-forward-sws parse-partial-sexp 1 looking-at "\\w\\|\\s_" buffer-substring-no-properties " " -1 apply concat c-syntactic-ws-start paren-level] 5])
(defalias 'c-shift-line-indentation #[(shift-amt) "d`Z\306 \307U\204d 9\203. \212\310 \311\211 \311 \312\216\313 \205' `.\211\202/ \203J \314\315!\203J \212\316\306x\210n)\203J \317c\210\320u\210\311\321\216\322 \323 \212\324 \210`)|\210\325 \210 \\j\210*`\212\324 \210`)W\203x \204x \324 \202\204 d\nZ`V\205\204 d\nZb+\207" [c-macro-start tmp-char-inserted pos shift-amt #1=#:modified buffer-undo-list nil 0 buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-beginning-of-macro looking-at "[ ]*\\\\$" " " 120 -1 #[nil "\205 \301\302!\207" [tmp-char-inserted delete-char 1] 2] current-indentation line-beginning-position back-to-indentation beginning-of-line inhibit-read-only inhibit-modification-hooks col] 3])
(defalias 'c-keyword-sym #[(keyword) "\302 \"\207" [keyword c-keywords-obarray intern-soft] 3])
(put 'c-keyword-sym 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-keyword-member #[(keyword-sym lang-constant) " N\207" [keyword-sym lang-constant] 2])
(put 'c-keyword-member 'byte-optimizer 'byte-compile-inline-expand)
(defconst c-string-syntax (byte-code "\301>\203 \302\207\303\207" [c-emacs-features gen-string-delim "\"|" "\""] 2))
(defconst c-string-limit-regexp (byte-code "\301>\203 \302\207\303\207" [c-emacs-features gen-string-delim "\\s\"\\|\\s|" "\\s\""] 2))
(defconst c-ws*-string-limit-regexp (concat "[ ]*\\(" c-string-limit-regexp "\\)"))
(defvar c-parsing-error nil)
(make-variable-buffer-local 'c-parsing-error)
(defalias 'c-echo-parsing-error #[(&optional quiet) "\203 \203 \n\204 \303\304 \"\210\305 \210 \207" [c-report-syntactic-errors c-parsing-error quiet message "%s" ding] 3])
(defvar c-literal-faces (byte-code "\300\301\302\303!\205 \304\"\207" [append (font-lock-comment-face font-lock-string-face) facep font-lock-comment-delimiter-face (font-lock-comment-delimiter-face)] 4))
(defalias 'c-put-c-type-property #[(pos value) "\303 \211T\304\n$)\207" [pos -pos- value put-text-property c-type] 5])
(put 'c-put-c-type-property 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-clear-c-type-property #[(from to value) "\212b\210\304`\305\" =\203 `\306\n\211T\307#\210)\310`\305\311 $b\210` W\205( \202 )\207" [from value pos to get-text-property c-type remove-text-properties (c-type nil) next-single-property-change nil] 5])
(defalias 'c-debug-add-face #[(beg end face) "\306 \307\211\307\310\216\311\f
\" \312 \203D @A\313\314\"\f=\203 \f\315!^
\316!]\317!\210\202 \320\321\f
\"\314\f#.\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks beg end buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] overlays-in nil overlay-get face overlay-start overlay-end delete-overlay overlay-put make-overlay overlays overlay] 5])
(defalias 'c-debug-remove-face #[(beg end face) "\306 \307\211\307\310\216\311\f
\" \312 \f
\203N @A\313\314\"\f=\203 \315!^\316!]\317!\210\202 \fW\203` \320\321\f\"\314\f#\210
V\205q \320\321
\"\314\f#. \207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks beg end buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] overlays-in nil overlay-get face overlay-start overlay-end delete-overlay overlay-put make-overlay overlays overlay ol-beg ol-end] 5])
(defalias 'c-looking-at-c++-attribute '(macro . #[nil "\300\207" [(and (c-major-mode-is 'c++-mode) (looking-at "\\[\\[") (save-excursion (and (c-go-list-forward) (eq (char-before) 93) (eq (char-before (1- (point))) 93) (point))))] 1]))
(defvar c-commas-bound-stmts nil)
(defalias 'c-bos-push-state '(macro . #[nil "\300\207" [(setq stack (cons (cons state saved-pos) stack))] 1]))
(defalias 'c-bos-pop-state '(macro . #[(&optional do-if-done) "\301\302\303\304BBBB\207" [do-if-done if (setq state (car (car stack)) saved-pos (cdr (car stack)) stack (cdr stack)) t ((setq pre-stmt-found t) (throw 'loop nil))] 5]))
(defalias 'c-bos-pop-state-and-retry '(macro . #[nil "\300\207" [(throw 'loop (setq state (car (car stack)) saved-pos (cdr (car stack)) pre-stmt-found (not (cdr stack)) stack (cdr stack)))] 1]))
(defalias 'c-bos-save-pos '(macro . #[nil "\300\207" [(setq saved-pos (vector pos tok ptok pptok))] 1]))
(defalias 'c-bos-restore-pos '(macro . #[nil "\300\207" [(unless (eq (elt saved-pos 0) start) (setq pos (elt saved-pos 0) tok (elt saved-pos 1) ptok (elt saved-pos 2) pptok (elt saved-pos 3)) (goto-char pos) (setq sym nil))] 1]))
(defalias 'c-bos-save-error-info '(macro . #[(missing got) "\302\303\304\305 FE\207" [missing got setq saved-pos vector pos] 6]))
(defalias 'c-bos-report-error '(macro . #[nil "\300\207" [(unless noerror (setq c-parsing-error (format-message "No matching `%s' found for `%s' on line %d" (elt saved-pos 1) (elt saved-pos 2) (1+ (count-lines (point-min) (c-point 'bol (elt saved-pos 0)))))))] 1]))
#@2517 Move to the start of the current statement or declaration, or to
the previous one if already at the beginning of one. Only
statements/declarations on the same level are considered, i.e. don't
move into or out of sexps (not even normal expression parentheses).
If point is already at the earliest statement within braces or parens,
this function doesn't move back into any whitespace preceding it; it
returns `same' in this case.
Stop at statement continuation tokens like "else", "catch",
"finally" and the "while" in "do ... while" if the start point
is within the continuation. If starting at such a token, move to the
corresponding statement start. If at the beginning of a statement,
move to the closest containing statement if there is any. This might
also stop at a continuation clause.
Labels are treated as part of the following statements if
IGNORE-LABELS is non-nil. (FIXME: Doesn't work if we stop at a known
statement start keyword.) Otherwise, each label is treated as a
separate statement.
Macros are ignored (i.e. skipped over) unless point is within one, in
which case the content of the macro is treated as normal code. Aside
from any normal statement starts found in it, stop at the first token
of the content in the macro, i.e. the expression of an "#if" or the
start of the definition in a "#define". Also stop at start of
macros before leaving them.
Return:
`label' if stopped at a label or "case...:" or "default:";
`same' if stopped at the beginning of the current statement;
`up' if stepped to a containing statement;
`previous' if stepped to a preceding statement;
`beginning' if stepped from a statement continuation clause to
its start clause;
`macro' if stepped to a macro start; or
nil if HIT-LIM is non-nil, and we hit the limit.
Note that `same' and not `label' is returned if stopped at the same
label without crossing the colon character.
LIM may be given to limit the search. If the search hits the limit,
point will be left at the closest following token, or at the start
position if that is less. If HIT-LIM is non-nil, nil is returned in
this case, otherwise `same'.
NOERROR turns off error logging to `c-parsing-error'.
Normally only `;' and virtual semicolons are considered to delimit
statements, but if COMMA-DELIM is non-nil then `,' is treated
as a delimiter too.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-beginning-of-statement-1 #[(&optional lim ignore-labels noerror comma-delim hit-lim) "\306`\306\203 \307\202\f \310 \206 \306\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\n\206& \311\306\211\211 @ A B C D E F G H I J K L M N O P Q R S T U V\214W\203h We]\202i eW~\210\212\312 \205x `UU?)\203 `T`O\313 \210X\203\220 X \204\230 \314\306x\315U\203 `SfS>\203\331 \316u\210`P\313 \210`SfS>\204\317 `Sf\317>\204\317 `Sfz\320=\204\317 X\203\331 X \203\331 \321APO\202hUb\210\322\323!\203\347 U@\3242E\212T\205!\325\306x\210`Sf\326=\205!`SP\327 \210`S\206\n`Sf\330=?\205!\322Y!\205!\325\306w\210`P=)\203aPb\210\331 \203L\214eU\2066d}\210\332 \210)`UW\203L`O\333Z\202VPO\334A\333Z\333M\335\324\306\"\210\202tF\204x\322B!\203t\336\337\340!!\211F\203tOUW\203\215C\204\215\333M\335\324\306\"\210E\341\267\202\276F\342=\203\242\343\211E\202\277[\204\304\344\345D\340\234D\346\234\347e\212D\315\234b\210\327 \210`)\"T$\\\335\324C@@EC@ADCA?MCA\211C\"\202\277F\350\267\202\302C@@EC@ADCA\211C\204f\351A\333M\335\324\306\"\202\277[\204-\344\345D\340\234D\346\234\347e\212D\315\234b\210\327 \210`)\"T$\\C@@EC@ADCA\211C\204f\333M\335\324\306\"\202\277\202\302F\342=\203lL\204l\352O@
\f$D\353\211E\202\277\335\324C@@EC@ADCA?MCA\211C\"\202\277F\354\267\202\302C@@EC@ADCA\211C\204f\351A\333M\335\324\306\"\202\277D\315\234U=\204\332D\315\234OD\340\234@D\346\234D\355\234Ob\210\306FC@@EC@ADCA\211C\204f\333M\335\324\306\"\202\277\202\302F\342=\203\n\356\211E\202\277[\204,\344\345D\340\234D\346\234\347e\212D\315\234b\210\327 \210`)\"T$\\\335\324C@@EC@ADCA?MCA\211C\"\202\277F\357\267\202\302C@@EC@ADCA\211C\204f\351A\333M\335\324\306\"\202\277\360\211E\202\277[\204\234\344\345D\340\234D\346\234\347e\212D\315\234b\210\327 \210`)\"T$\\C@@EC@ADCA\211C\204f\333M\335\324\306\"\202\277\202\302\306\204fF\361\267\202fOUY\203\336EDBCBC\202fC@@EC@ADCA\211C\204f\333M\335\324\306\"\210\202fEDBCBC\352O\362\363#D\363E\202f\f\203@\ffS>\204@`U=\2034]\2034] \204@X\203fX\f!\203fEDBCBC\364E\202fEDBCBC\352O\365F#D\360ER\203t\306\211LK\306RF\342=\203\210`WY\203\373\321A\202\373\313 \210`O\306 ^ _ `?\205\237`Sf\366=^\3671\260\370`\316\"b\210\3330\202\262\210\306\204\275\333M\335\324\306\"\210T\204\343\312 \203\343\212\313 \210``)\212\371 \210\372`_\")\204\351`\211_\202\346\322\373!\204\225T\204a\203\322a!\203\212\371 \210\372`_\")\202\343\306f\374=\203\265^\204\265\375W\306\333#\204\265\212\376\340\333\306#\210\322\377!)\204\265b\203_\212\376\340\333\306#\210\322c!\203J\322d!\204J\376\340\333\306#\210\322b!?\205[\206[\306f\366=?)\203\265\212\201v 1q\201w `\340\315#0\202s\210\306\211 e\205eb\210e)\205\245\332 \210\322f!?\206\245\315\225\315\224Z g\322h!\205\244\315\225\315\224ZgV))\203\265\212\370`\340\"b\210`)\202\343\322\201x !\203\336\212\201y 1\320\201w `\316\211#0\202\322\210\306Tb\210\372`_\")\202\343\372`_\"\211N\203\372
@N@\342F\335\324\333\"\210+`WW\203\335\324\306\"\210i\203%\201z \211P\203%PO\333\211MZ\335\324\306\"\210j\203\225R\247\203gG\204g\212@\206=Ub\210\322d!)\204g\322d!\204g\201{ `R\"\204g@\206_UG`H\202\225H\203\225I\204\225\322k!\203\217\322l!\204\217\201{ `@\"\204\217`I\202\225\306\211GHZ\333=\2045R\247\203 @\206\251UQ\322m!\204\365\212\201| 1\304\370`\316\"b\210\3330\202\311\210\306\202\320\205\320\322n!)\204\365o\201} =\203\373\306f\320=\203\373\212\376\346!\315U\205\361\322p!)\204\373\306R\202 L\203K\204@\206\fUK\202@\206UL\333R\306JJ\2045\322q!\2035@\2063UJ\306F
@`\211@\211O0\204\347 r\203eM\203bOWW\204bOUY\203e\306AC\203\254\201~ D!\203\235DG\355=\203\235[\204\235\344\345D\340\234D\346\234\347e\212D\315\234b\210\327 \210`)\"T$\\C@ADCA\211C\204jA\311=\203\374F\201 >\204\374\322s!\203\316
f\320=\203\316\f\202\332\322t!\203\331
\202\332\f\211P\203\374UPV\203\357PO\202\374UPU\203\374\201\200 AZ\204hR\333=\203hA\351=\204hL\203hI\204hJ\203CJOX\204CK\2038KUW\2038K\202:Ob\210\322u!\203hLUW\203RLO\202h\201\201 AK\203hKUW\203hKOOb\210Q\203\227A\351=\204\227\322p!\203\227QUW\203\213QOA\311=\203\227\201\201 A\313 \210X\203\246X`!\204\266\201\202 \306x\315U\204\266`O\202\227Ob\210A.\207" [comma-delim c-commas-bound-stmts c-opt-block-stmt-key regexp-unmatchable pptok ptok nil (59 44) (59) same c-beginning-of-macro c-backward-sws "-+!*&~@`#" 0 -1 (58 nil) 40 previous looking-at "\\<\\|\\W" loop " " 35 beginning-of-line 92 c-forward-to-cpp-define-body c-forward-sws t macro throw intern match-string 1 #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (else 404 else-boundary 482 while 591 while-boundary 650 catch 764 catch-boundary 842)) boundary else-boundary format-message "No matching `%s' found for `%s' on line %d" 2 count-lines #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (if 489 boundary 523)) beginning vector while-boundary #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (do 657 boundary 691)) 3 catch-boundary #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (try 849 catch 883 boundary 890)) catch #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (boundary 969 else 1022 while 1046 catch 1104 finally 1104)) if else while try 44 (error) scan-sexps c-end-of-macro c-crosses-statement-barrier-p "\\\\$" 123 c-looking-at-inexpr-block c-backward-token-2 "=\\([^=]\\|$\\)" tok ret cond-key stack saved-pos state sym bitfield-size-pos bitfield-id-pos bitfield-type-pos label-good-pos last-label-pos after-labels-pos pre-stmt-found boundary-pos pos saved after-case:-pos c-maybe-labelp delims macro-start start case-fold-search lim c-at-vsemi-p-fn c-opt-cpp-start ignore-labels noerror c-parsing-error c-vsemi-status-unknown-p-fn comma-delimited maybe-after-boundary-pos before-sws-pos c-opt-cpp-prefix c-opt-block-decls-with-vars-key c-symbol-start c-keywords-regexp dest c-non-after-{}-ops-re bad-op-len c-operator-re c-opt-method-key c-has-bitfields c-symbol-key c-not-primitive-type-keywords-regexp c-nonlabel-nonparen-token-key c-nonlabel-token-2-key c-buffer-is-cc-mode c-case-kwds-regexp c-nonlabel-token-key hit-lim c-block-stmt-1-2-key c-block-stmt-1-key c-label-kwds-regexp (error) scan-lists "\\s(" (error) c-in-method-def-p c-punctuation-in (error) c++-mode vectorp (boundary ignore nil) up label "-.+!*&~@`#"] 27 (#$ . 42426)])
#@202 Return non-nil if there is a non-comment non-macro punctuation character
between FROM and TO. FROM must not be in a string or comment. The returned
value is the position of the first such character.
(defalias 'c-punctuation-in #[(from to) "\212b\210`\n w\210\214e \206 d}\210\304 \210)` V\203\" `\202 )` W\205* `)\207" [from pos c-symbol-chars to c-forward-sws] 2 (#$ . 51807)])
#@776 Return non-nil if buffer positions FROM to TO cross one or more
statement or declaration boundaries. The returned value is actually
the position of the earliest boundary char. FROM must not be within
a string or comment.
The variable `c-maybe-labelp' is set to the position of the first `:' that
might start a label (i.e. not part of `::' and not preceded by `?'). If a
single `?' is found, then `c-maybe-labelp' is cleared.
For AWK, a statement which is terminated by an EOL (not a ; or a }) is
regarded as having a "virtual semicolon" immediately after the last token on
the line. If this virtual semicolon is _at_ from, the function recognizes it.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-crosses-statement-barrier-p #[(from to) "\203 \202 \n\203 \f\202
\306\211 ! \"\306\211 # $\214~\210\212\3072\272%b\210 &\310\311!^w\210`&W\203\215n\203w \212\312%!\211\"\203P \"b\210\214\310\313!\206X ed}\210\314 \210)`#'\205j ' )\203w \315\307#\"\210\202- \214e&\206 d}\210\316 \210)`&Y\203\224 \315\307\306\"\210\202- \317%!\211!\203\246 !Ab\210\202- \306f\320=\203(\321=\205\361 \322\323!\205\361 \212\3241\310 \325`\326\313#0\202\312 \210\306\211 )\205\326 )b\210))\205\360 `Sf\327=\205\360 `S\206\350 `Sf\327=\205\360 `)\211$\203\376 $b\210\202- \306u\210\202- \306f\330=\203)\306u\210\306f\330=\203\"`&W\203\"\306u\210\202- `S*\202- \306f\331=\203G\306*\332\203=+\202?,\313\333#\211\202. -\203}\322-!\203}\212\334\306x\210n\205ko\206k`S\206f`Sf\335=?)\203u\336 \210\202- -\306w\210\202- \306f >\203- \315\307`\"\210\202- \214%\206\224ed}\210\314 \210)n\203\246o\204\246\337u\210`&W\205\271'\205\271' \205\271`0.\207" [c-commas-bound-stmts c-stmt-boundary-skip-chars-with-comma c-stmt-boundary-skip-chars skip-chars c-stmt-boundary-skip-list-with-comma c-stmt-boundary-skip-list nil done line-beginning-position 2 c-literal-start 0 c-backward-sws throw c-forward-sws c-literal-limits 91 c++-mode looking-at "\\[\\[" (error) scan-lists 1 93 58 63 substring -2 " " 92 c-end-of-macro -1 non-skip-list lit-range lit-start vsemi-pos attr-end from to c-at-vsemi-p-fn c-buffer-is-cc-mode dest c-maybe-labelp c-stmt-delim-chars-with-comma c-stmt-delim-chars c-opt-cpp-symbol] 5 (#$ . 52200)])
#@411 Return non-nil if the point is at the first token in a statement
or somewhere in the syntactic whitespace before it.
A "statement" here is not restricted to those inside code blocks.
Any kind of declaration-like construct that occur outside function
bodies is also considered a "statement".
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-at-statement-start-p #[nil "\212`\306\307\310\n\203 \202 \f\311\"\306\312#\210o\206; `Sf\313=\206; `Sf\314=\2037
\2053 \315u\210\316 ?\206; \317` \"+\207" [c-maybe-labelp end c-commas-bound-stmts c-stmt-delim-chars-with-comma c-stmt-delim-chars c-special-brace-lists nil c-syntactic-skip-backward substring 1 t 125 123 -1 c-looking-at-special-brace-list c-crosses-statement-barrier-p] 4 (#$ . 54556)])
#@720 Return non-nil if the point is at the first token in an expression or
statement, or somewhere in the syntactic whitespace before it.
An "expression" here is a bit different from the normal language
grammar sense: It's any sequence of expression tokens except commas,
unless they are enclosed inside parentheses of some kind. Also, an
expression never continues past an enclosing parenthesis, but it might
contain parenthesis pairs of any sort except braces.
Since expressions never cross statement boundaries, this function also
recognizes statement beginnings, just like `c-at-statement-start-p'.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-at-expression-start-p #[nil "\212`\304\305\306\307 \310\"\305\304#\210o\206+ `Sf\311>\206+ \212\312u\210\313\314!)\206+ \315`\n\",\207" [c-maybe-labelp c-commas-bound-stmts end c-stmt-delim-chars-with-comma t nil c-syntactic-skip-backward substring 1 (123 125) -1 looking-at "\\s(" c-crosses-statement-barrier-p] 4 (#$ . 55394)])
#@506 Move forward past whitespace and the closest following comment, if any.
Return t if a comment was found, nil otherwise. In either case, the
point is moved past the following whitespace. Line continuations,
i.e. a backslashes followed by line breaks, are treated as whitespace.
The line breaks that end line comments are considered to be the
comment enders, so the point will be put on the beginning of the next
line if it moved past a line comment.
This function does not do any hidden buffer changes.
(defalias 'c-forward-single-comment #[nil "`\301\302!\203\f \303\225b\210\304\305!\205( m?\205( l\203' \306`\"\307\234\203' \305u\210\310)\207" [start looking-at "\\([ \n
\f ]\\|\\\\[\n
]\\)+" 0 forward-comment 1 parse-partial-sexp 7 t] 3 (#$ . 56466)])
#@267 Move forward past all following whitespace and comments.
Line continuations, i.e. a backslashes followed by line breaks, are
treated as whitespace.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-forward-comments #[nil "\300\301!\203\n m\203 \302\303!\205 \304u\210\202 \207" [forward-comment 5 looking-at "\\\\[\n
]" 2] 2 (#$ . 57235)])
(put 'c-forward-comments 'byte-optimizer 'byte-compile-inline-expand)
#@495 Move backward past whitespace and the closest preceding comment, if any.
Return t if a comment was found, nil otherwise. In either case, the
point is moved past the preceding whitespace. Line continuations,
i.e. a backslashes followed by line breaks, are treated as whitespace.
The line breaks that end line comments are considered to be the
comment enders, so the point cannot be at the end of the same line to
move over a line comment.
This function does not do any hidden buffer changes.
(defalias 'c-backward-single-comment #[nil "`\301\302x\210\303\304!\203 `Sf\305=\203 \306u\210\202 o?\205G \307\310\311#\210\312\306!\205G l\2035 \312\306!\2026 \311\205G \303\313!\203F \314u\210\302\202G \311)\207" [start " \n
\f " nil looking-at "[\n
]" 92 -1 re-search-forward "\\=\\s *[\n
]" t forward-comment "\\*/" 2] 4 (#$ . 57736)])
#@524 Move backward past all preceding whitespace and comments.
Line continuations, i.e. a backslashes followed by line breaks, are
treated as whitespace. The line breaks that end line comments are
considered to be the comment enders, so the point cannot be at the end
of the same line to move over a line comment. Unlike
c-backward-syntactic-ws, this function doesn't move back over
preprocessor directives.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-backward-comments #[nil "`o?\205f \302\303\304!\211\204: `Sf\305=\203 \304u\210\202 `Sf\306=\203: `S\206- `Sf\305=\203: \307u\210\202 )\203L \310\311!\203 \312u\210\302\202f \310\313!\205f `Sf\314=\205f `W\205f \304u\210\202 )\207" [start moved-comment nil forward-comment -1 13 10 -2 looking-at "\\*/" 2 "[\n
]" 92] 2 (#$ . 58584)])
(put 'c-backward-comments 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-debug-sws-msg '(macro . #[(&rest args) "\301\210\207" [args nil] 2]))
(defalias 'c-put-is-sws '(macro . #[(beg end) "\302\300D\301 DD\303\304\305!\205 \306BBB\207" [beg end let (put-text-property beg end 'c-is-sws t) facep c-debug-is-sws-face ((c-debug-add-face beg end 'c-debug-is-sws-face))] 5]))
(put 'c-put-is-sws 'edebug-form-spec t)
(defalias 'c-put-in-sws '(macro . #[(beg end) "\302\300D\301 DD\303\304\305!\205 \306BBB\207" [beg end let (put-text-property beg end 'c-in-sws t) facep c-debug-is-sws-face ((c-debug-add-face beg end 'c-debug-in-sws-face))] 5]))
(put 'c-put-in-sws 'edebug-form-spec t)
(defalias 'c-remove-is-sws '(macro . #[(beg end) "\302\300D\301 DD\303\304\305!\205 \306BBB\207" [beg end let (remove-text-properties beg end '(c-is-sws nil)) facep c-debug-is-sws-face ((c-debug-remove-face beg end 'c-debug-is-sws-face))] 5]))
(put 'c-remove-is-sws 'edebug-form-spec t)
(defalias 'c-remove-in-sws '(macro . #[(beg end) "\302\300D\301 DD\303\304\305!\205 \306BBB\207" [beg end let (remove-text-properties beg end '(c-in-sws nil)) facep c-debug-is-sws-face ((c-debug-remove-face beg end 'c-debug-in-sws-face))] 5]))
(put 'c-remove-in-sws 'edebug-form-spec t)
(defalias 'c-remove-is-and-in-sws '(macro . #[(beg end) "\302\300D\301 DD\303\304\305!\205 \306BBB\207" [beg end let (remove-text-properties beg end '(c-is-sws nil c-in-sws nil)) facep c-debug-is-sws-face ((c-debug-remove-face beg end 'c-debug-is-sws-face) (c-debug-remove-face beg end 'c-debug-in-sws-face))] 5]))
(put 'c-remove-is-and-in-sws 'edebug-form-spec t)
(defvar c-sws-lit-type nil)
(defvar c-sws-lit-limits nil)
(defalias 'c-enclosing-c++-attribute #[nil "\304\211\n\305=\205| `eV\205| \306`S\307\"\203 `S\202$ \310`\307\304e$S\211\205| \212b\210\n\305=\205m \311\312!\205m \212\3131G \314`\315\316#0\202I \210\304\211\205R b\210 )\205l `Sf\317=\205l `S\206d `Sf\317=\205l `)\211)\205| `V\205| B*\207" [pos-is-sws attr-end c-buffer-is-cc-mode dest nil c++-mode get-text-property c-is-sws previous-single-property-change looking-at "\\[\\[" (error) scan-lists 1 0 93] 6])
(defalias 'c-slow-enclosing-c++-attribute #[nil "\304=\205\220 \212\305 \306\3072L \nA\205K \n@\247\203D \nA@\247\203D \n@\nA@T=\203D \n@f\310=\203D \nA@f\310=\203D \311\307\nA@\"\210\nA\211\202 0\211\203\210 \3121^ \313 \314\315#0\202` \210\306\211\205i b\210 )\203\202 `Sf\316=\203\202 `S\206{ `Sf\316=\204\210 \nA\202\f \205\217 `B+\207" [c-buffer-is-cc-mode cand paren-state dest c++-mode c-parse-state nil found-cand 91 throw (error) scan-lists 1 0 93] 5])
(defalias 'c-invalidate-sws-region-before #[(beg end) "\306\211\307 \310\216\212 b\210\311 \312\f!\211 \313>\203!
\f\202W \314 \2032 \315`\316 \210`B\202W
\317=\204W \320 \211\203D \321\202W \322\323!\210\324!\203W \325\326\224\326\225B+\212b\210\320 \211 \203y :\203r @\240\202\231 \211\202\231 \322\323!\210\324!\205\231 \325 :\203\222 \326\224\240\202\231 \326\224\326\225B\211,\207" [c-sws-lit-type c-sws-lit-limits save-match-data-internal end limits lit-type nil match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] c-literal-limits c-literal-type (c c++) c-beginning-of-macro pound c-end-of-macro string c-enclosing-c++-attribute attribute skip-syntax-backward "w_" looking-at noise 1 c-noise-macro-name-re beg attr-limits] 3])
(defalias 'c-invalidate-sws-region-after-del #[(beg end _old-len) "\2051 @\303\\W\2051 \304\n\305\"\204/ \306\n\305\307A$\204/ \304\n\310\"\204/ \306\n\310\307A$\2051 A\207" [c-sws-lit-limits beg end 2 get-text-property c-in-sws next-single-property-change nil c-is-sws] 5])
(defalias 'c-invalidate-sws-region-after-ins #[(end) "\212b\210\305 \306 !\211\307>\204 \310 \203 \311`\312 \210`B\n\313>\205B \314 @\315\316 A$\314 @\317\316 A$\211 \204? \205A A*+\207" [end limits lit-type next-is next-in c-literal-limits c-literal-type (c c++) c-beginning-of-macro pound c-end-of-macro (c c++ pound) next-single-property-change c-in-sws nil c-is-sws] 7])
(defalias 'c-invalidate-sws-region-after #[(beg end old-len) "\203 @^\240\210\nA\n Z\\ Z]\241\210 \306V\205# \307 \n #\n V\205, \310\n! \212\nb\210\311\312w\210l\203A m\204A `T)\313>\203O @A \nU\203m \314 \315\"\203m eV\203m \314 S\315\"\203m S
\206r \n\f\206w \n]A\206~ \n]\n] \n\316 \n\317#,\207" [c-sws-lit-limits beg end old-len ins-end del-end 0 c-invalidate-sws-region-after-del c-invalidate-sws-region-after-ins " \f " nil (noise attribute) get-text-property c-in-sws remove-text-properties (c-is-sws nil c-in-sws nil) c-sws-lit-type] 5])
(defalias 'c-forward-sws #[nil "`\306\211\211\211\211\211\211\211\211 + , - .\307\306w\210\310/!\204C 0\203/ \3101!\204C 2\311=\203< \310\312!\204C \3103!\205_`Td^,\313.,\314\315$\211\203c \316
\314\306,$S.\202f `.\317 4\315\211 5 6\315 7\320\216
\203\363 \321`\322\"\203\363 \316`\322\306d$b\210\321`\314\"\204\240 \321`S\314\"\204\235 \323`\314\"b\210\324u\210`.\307\306w\325V\203\363 m\204\363 \321`\314\"\204\306 ``T 8 9\32698\327#\210*.T`T 8 9\33098\314\315$\210*.`\211.\211+ 8 9\33098\322\315$\210*\202u `\315`\306\211 : ; <\331 \203,`\211;\203,\212<b\210\332 )\203,\315:<b\210\333;!\210`;W\203,\306:\203n\203\204;\203\204;<V\203\204`\211<\203\204\331 \203\204`\211;\203\204<b\210\333;!\210`;W\203g\306\2041\202\204\334\335!\203xm\203n\310\336!\203\204\337u\210\202n+` U\204\220m?\202k\2120\205\270\310=!\205\270`\211\205\270\340\306x\210n\205\270o\206\270\324u\210`Sf\341=?)\203\364\306\210`Sf\341=\203\324\342y\325U\203\324\306\210\202\277`\343\n \"\211 >\344\234\203\353>\345\234\204\353\306)\342y\210m?\202k0\203 \3101!\203 \342\225b\210m?\202k2\311=\205M\310\312!\205M\212\3461$\347`\342\325#0\202&\210\306\211 ?\2052?b\210?)\205L`Sf\350=\205L`S\206D`Sf\350=\205L`)\211-\203\\-b\210m?\202k\3103!\203,\325\225b\210\306m?\203,`-\307\306w\210`Td^,\203\212
\204\233\321 \322\"\203\233\313-,\314\315$\211\203\203 T- 8 9\32698\351#\210*
\203\267. U\204\313. T 8 9\33098\314\315$\210*\315.`\211.\211+ 8 9\33098\322\315$\210*\321,S\314\"\204\375,S, 8 9\32698\327#\210*-, 8 9\33098\314\315$\210*\202u \f\211\203%\316
\314\306,$S.\202u -.\202u +`=\205^+dW\203M+\211T 8 9\32698\327#*\202^+S+ 8 9\32698\352#*-.\n\207" [safe-start macro-end macro-start simple-ws-end next-rung-is-marked rung-is-marked nil " \n
\f " looking-at c++-mode "\\[\\[" text-property-any c-is-sws t next-single-property-change buffer-modified-p #[nil "?\205 \301\302!\207" [#1=#:modified restore-buffer-modified-p nil] 2] get-text-property c-in-sws previous-single-property-change -1 0 remove-text-properties (c-in-sws nil) put-text-property c-forward-single-comment c-beginning-of-macro c-end-of-macro forward-comment 5 "\\\\[\n
]" 2 " " 92 1 parse-partial-sexp 4 7 (error) scan-lists 93 (c-is-sws nil) (c-is-sws nil c-in-sws nil) last-put-in-sws-pos rung-end-pos next-rung-pos rung-pos c-syntactic-ws-start c-opt-cpp-prefix c-noise-macro-name-re c-buffer-is-cc-mode c-doc-line-join-re #1# buffer-undo-list inhibit-read-only inhibit-modification-hooks end beg in-macro com-end com-begin c-opt-cpp-start s dest] 11])
(defalias 'c-backward-sws #[nil "`\306\211\211\211\211\307P\306 4 5 6\310\306x\210o?\205\361\212`Sf7>\2032 \311\n\312\313!\314#\206\230 8\315=\203{ `Sf\316=\203{ `S\206G `Sf\316=\203{ \212\3171\\ \320`\321\313#0\202^ \210\306\211 9\205j 9b\2109)\205q \322\323!)\203{ `\211\206\230 \321u\210\322:!\206\230 ;\205\230 \322<!\205\230 \324 \210\322=!)\205\361 \206\247 \325\225\206\247 \313\225\326\306x\210\327`6Td^\330\314$\211\203\304
\2116b\210\202\307 \fb\210\331 >\314\211 ? @\314 A\332\216
\203go\204g\333`S\334\"\203g\335`\334\306e$b\210\333`\330\"\204\375 \336`\330\306\211$b\210`6\337\306x`\326\306x^\313W\203\327`6\330\314$\211\204 \fb\210\202g\3336S\330\"\204;6S6 B C\340CB\341#\210*
6 B C\342CB\330\314$\210*
6S B C\342CB\334\314$\210*
\21164\202\326 ` Do?\205\322\306 E\343\321!\211E\204\244`Sf\344=\203\211\321u\210\202r`Sf\345=\203\244`S\206\227`Sf\344=\203\244\346u\210\202rE)\203\267\322\347!\203j\350u\210\306\202\322\322\351!\205\322`Sf\352=\205\322`DW\205\322\321u\210\202j)\210`;\203o \fU\204o\353 \203o`\306\211 F G H\fb\210\354 \210`G` V\203\321u\210`Sf\352=\203\354 \210\202\370`FI\203<\355IG\314#\203<\325\225b\210\356 \2034\354 \210`\211G\2029Fb\210\306\204\370` W\203I b\210\306\202k\fb\210\326\306x\210`Sf\352=\203[\306u\210\325y\210`\fW\203f`Hb\210\314+\202\212\326\fw\210`\2115)\fU\204\2055b\210\202 ;\203\245\212\357\360!\313W\205\232`5\322=!)\203\2455b\210\202 8\315=\203\366`Sf\316=\203\366`S\206\272`Sf\316=\203\366\212\3611\317\320`\321\313#0\202\321\210\306\211 9\205\3359b\2109)\205\353`\2115\205\353\322\323!)\203\3665b\210\202 `Sf7>\203\270\311\n\312\313!\314#\203\270`5\337\306x\210
\204/\333\fS\334\"\203/\212\326\306x\210\327`5Td^\330\314$)\203\2575T\f B C\340CB\362#\210*
\203K\f6U\204\2016Td^ J\333JS\330\"\204mJSJ B C\340CB\341#\210*\fJ B C\342CB\330\314$\210*\314)`\211\21146 B C\342CB\334\314$\210*\f\21165T B C\342CB\330\314$\210*\202\326 56`\202\326 4`=\205\360e4W\203\3324S4 B C\340CB\341#*\202\360e\325V\205\3604\211T B C\340CB\363#*-.\207" [c-doc-line-join-re attr-end doc-line-join-here cmt-skip-pos simple-ws-beg rung-is-marked nil "\\=" " \f" re-search-backward line-beginning-position 0 t c++-mode 93 (error) scan-lists -1 looking-at "\\[\\[" c-beginning-of-current-token 1 " \n
\f " text-property-any c-is-sws buffer-modified-p #[nil "?\205 \301\302!\207" [#1=#:modified restore-buffer-modified-p nil] 2] get-text-property c-in-sws previous-single-property-change next-single-property-change " \f " remove-text-properties (c-in-sws nil) put-text-property forward-comment 13 10 -2 "\\*/" 2 "[\n
]" 92 c-beginning-of-macro beginning-of-line re-search-forward c-backward-single-comment skip-syntax-backward "w_" (error) (c-is-sws nil) (c-is-sws nil c-in-sws nil) last-put-in-sws-pos next-rung-pos rung-pos c-doc-line-join-end-ch c-buffer-is-cc-mode dest c-syntactic-ws-end c-opt-cpp-prefix c-symbol-char-key c-noise-macro-name-re #1# buffer-undo-list inhibit-read-only inhibit-modification-hooks end beg start moved-comment pos pause cpp-beg c-last-c-comment-end-on-line-re rung-end-pos] 9])
(defalias 'c-partial-ws-p #[(beg end) "\212Td^e\nS]b\210\206 d\304 w\210\305f\306=\203- ` W\203- \305u\210l\204 \307u\210)`=\206\\ \nb\210 \206< d\304 w\210\305f\306=\203X ` W\203X \305u\210l\204= \307u\210)` =*\207" [end end+1 beg limit " \n
\f " nil 92 -1] 2])
(defvar c-lit-pos-cache nil)
(make-variable-buffer-local 'c-lit-pos-cache)
(defvar c-lit-pos-cache-limit 1)
(make-variable-buffer-local 'c-lit-pos-cache-limit)
(defalias 'c-cache-to-parse-ps-state #[(elt) ":\203\246 G\306Y\203\246 \307\310\211\211\211\211\307\310\211\211\3068@A@ AA@ \247\204C \311=\203I \202f \312>\203^ \311 \313=\205Y \314\202f \315\316\"\210\317 \210 \203o \nS\202p \nb\210\320 >\203\220 \310
\f\310\257 \202\243 \310
\f\257\n.
\207\320 >\203\330 :\203\267 @\202\270 b\210\307\310\211\211\211:\205\311 A@\321=\307\310\211\211:\205\325 A@\257 \207:\203\342 @\202\343 b\210:\203\362 A\203\362 \322u\210\323\324!\207" [elt type pos char-1 intermediate com-str-start 3 0 nil t (c c++) c++ 1 message "Invalid type %s in c-cache-to-parse-ps-state" ding pps-extended-state 9 -1 copy-tree (0 nil nil nil nil nil 0 nil nil nil) com-style min-depth after-quote in-comment in-string last containing depth c-emacs-features] 13])
(defalias 'c-parse-ps-state-to-cache #[(state) "\303>\203Y \304 8\203 `\304 8\305 8E\202; \306 8\203: \307 8\310=\204: `\307 8\311=\2032 \312\2023 \313\305 8E\202; `\314 8\203V \315\n:\203L \n\202N \nC\314 8C\"\202W \n)\207\304 8\203z `Sf\316=\203q `\304 8\305 8\316F\207`\304 8\305 8E\207\306 8\203\301 \307 8\310=\204\301 `Sf\317=\203\256 `\305 8Z\320V\203\256 `\307 8\311=\203\247 \312\202\250 \313\305 8\317F\207`\307 8\311=\203\273 \312\202\274 \313\305 8E\207`Sf\321>\203\317 ``SfD\207`\207" [c-emacs-features state basic pps-extended-state 3 8 4 7 syntax-table 1 c++ c 10 append 92 42 2 (47 92)] 4])
(defalias 'c-ps-state-cache-pos #[(elt) ":\204 \207@\207" [elt] 1])
(put 'c-ps-state-cache-pos 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-trim-lit-pos-cache #[nil "\205 @\211:\204 \202 @)\nV\205 A\211\204 \303\207" [c-lit-pos-cache elt c-lit-pos-cache-limit nil] 3])
(defconst c-state-nonlit-pos-interval 3000)
(defalias 'c-parse-ps-state-below #[(here) "\212\214~\210\306 \210\307\211\211\211 \211 \2034
@\211 :\204! \f\202# \f@)V\2034
@
A\211\204
\203J
@\211 :\204D \f\202F \f@)\206K eb\210
\203X \310
@!\202[ \311\312! \204\260 `\\\211X\203\260 \313`\n\307\211 %\314 8\204\207 \315>\203\245 \316 8\203\245 \nS\317u\210\316 8\203\231 \316 \233\307\240\210\314 8\203\245 \314 \233\307\240\210\320 !\211B\202` `V\203\272 `` .B\207" [c-lit-pos-cache high-elt npos state elt c c-trim-lit-pos-cache nil c-cache-to-parse-ps-state copy-tree (0 nil nil nil nil nil 0 nil nil nil nil) parse-partial-sexp 5 pps-extended-state 10 -1 c-parse-ps-state-to-cache here c-state-nonlit-pos-interval c-emacs-features c-lit-pos-cache-limit] 7])
(defvar c-semi-lit-near-cache nil)
(make-variable-buffer-local 'c-semi-lit-near-cache)
(defvar c-semi-near-cache-limit 1)
(make-variable-buffer-local 'c-semi-near-cache-limit)
(defalias 'c-semi-trim-near-cache #[nil "\211\205\" @@\nV\203 \303 @\"\211\211\202 A\211\204 \304)\207" [c-semi-lit-near-cache nc-list c-semi-near-cache-limit delq nil] 4])
(defalias 'c-semi-get-near-cache-entry #[(here) " \236\206V \306\307\306 \3102U
\203S
@@\fY\203L
@A\203A \311
@A8\203A \311
@A8W\203A \312\310
@\"\210\202L \f V\203L \f
@
A\211\204 \n0,\211
\203o
@=\204o \313
\"
B\314
!)\207" [here c-semi-lit-near-cache cand-pos-state nc-pos pos nc-list nil 0 found 8 throw delq copy-tree nc-pos-state] 5])
(defalias 'c-semi-put-near-cache-entry #[(here state) "G\304Y\203 \305\306!@\"\211\202 \nBB ]\211\207" [c-semi-lit-near-cache here state c-semi-near-cache-limit 6 delq last] 4])
(defalias 'c-semi-pp-to-literal #[(here &optional not-in-delimiter) "\212\214~\210\306 \210\307 \210\310 \311\216\312 !\211@\211 \nA \313\211 !\313\211 \" # \2033 \314ZW\203R \315 !\211 @! A\" \203L ! V\203R !\" V\204\251 \316
8\203\251 \316
8W\204\251 \317
8\203x \206q `Sf\320=\203\321
8\203\221 \322
8\204\221 \206\211 `Sf$>\203\321
8\203\251 \322
8\203\251 \206\242 `Sf\323>\203 % &'\204\311 \324\216\325&%\"\210\326 \313\211
%)\202&'@Y\203\346 %'AX\203\346 \326 \313\211
%\202&'@^&%'A]%\325&%\"\210\326 \313\211
%*\f =\204\327
\"\210\317
8\204%\321
8\203F\322
8\330=\204F\317
8\203/\331\202:\322
8\2039\332\202:\333#
#\316
8E\202~(\204|o\204|\334u\210\335)>\203_\336\337!\204|\336*!\203|\336+!\203q\333\202r\332#
#`E\202~
C.\f\207" [save-match-data-internal here pos-and-state pos near-pos s c-trim-lit-pos-cache c-semi-trim-near-cache match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] c-semi-get-near-cache-entry nil 100 c-parse-ps-state-below 8 3 92 4 7 (92 10) #[nil "\300 \207" [c-clear-string-fences] 1] c-restore-string-fences parse-partial-sexp c-semi-put-near-cache-entry syntax-table string c++ c -1 category-properties looking-at "\\s!" far-pos-and-state far-pos far-s ty c-block-comment-awkward-chars -end- -beg- c-fl-syn-tab-region not-in-delimiter c-emacs-features c-comment-start-regexp c-block-comment-start-regexp] 7])
(defvar c-full-near-cache-limit 1)
(make-variable-buffer-local 'c-full-near-cache-limit)
(defvar c-full-lit-near-cache nil)
(make-variable-buffer-local 'c-full-lit-near-cache)
(defalias 'c-full-trim-near-cache #[nil "\304\n\2053 \n@\211AA@\203 AA@W\202 @W\203, \305 \"\211\202/ \nA)\202 *\207" [c-full-lit-near-cache elt nc-list c-full-near-cache-limit nil delq] 4])
(defalias 'c-full-get-near-cache-entry #[(here) " \236\206U \306\307\306 \3102T
\203R
@\211AA@\2038 \311\fA@8V\2038 \fAA@W\2038 \312\310\f\"\210\f@W\203K \f@ V\203K \f@\f
A\211\204 \n0,\211
\203n
@=\204n \313
\"
B\314
!)\207" [here c-full-lit-near-cache cand-pos-state nc-pos elt nc-list nil 0 found 8 throw delq copy-tree nc-pos-state] 5])
(defalias 'c-full-put-near-cache-entry #[(here state end) "G\305Y\203 \306\307!@\"\211\202 \n EB\f \206 ]\211\207" [c-full-lit-near-cache here state end c-full-near-cache-limit 6 delq last] 4])
(defalias 'c-full-pp-to-literal #[(here &optional not-in-delimiter) "\212\214~\210\306 \210\307 \210\310 \311\216\312 !\211@\211 \nA@ \313 \nAA@ \313\211 ! \"\313\211 # $\313 % \203D \203D Y\203f \314 !\211!@\"!A# \203] \" V\203f \"#\313 V\203q \203\306 \315
8\203\306 \203\203 Y\204\306 \316
8\203\225 \206\216 `Sf\317=\203\316 \320
8\203\256 \321
8\204\256 \206\246 `Sf&>\203\316 \320
8\203\306 \321
8\203\306 \206\277 `Sf\322>\203\316 \323 \313\211
%\316
8\204\342 \320
8\203H\321
8\324=\204H\316
8\203\354 \325\202\367 \321
8\203\366 \326\202\367 \327$\315
8% \203\n Y\204/\323 d\313\211
\324& \316 8\204/\320 8\203,\321 8\324=\203/` \f =\204<\330
#\210
$% BE\202\226'\204\210o\204\210\331u\210\332(>\203a\333\334!\204\210\333)!\203\210\333*!\203s\327\202t\326$`%\335\336!\210
$%`BE\202\226\f =\204\224\330
\313#\210
C.\207" [save-match-data-internal here elt base near-base s c-trim-lit-pos-cache c-full-trim-near-cache match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] c-full-get-near-cache-entry nil c-parse-ps-state-below 8 3 92 4 7 (92 10) parse-partial-sexp syntax-table string c++ c c-full-put-near-cache-entry -1 category-properties looking-at "\\s!" forward-comment 1 s1 end far-base-and-state far-base far-s ty start c-block-comment-awkward-chars not-in-delimiter c-emacs-features c-comment-start-regexp c-block-comment-start-regexp] 8])
(defalias 'c-truncate-lit-pos-cache #[(pos) " ^\n ^ ^\211\207" [c-lit-pos-cache-limit pos c-semi-near-cache-limit c-full-near-cache-limit] 2])
(put 'c-truncate-lit-pos-cache 'byte-optimizer 'byte-compile-inline-expand)
(defconst c-state-cache-too-far 5000)
(defvar c-state-cache nil)
(make-variable-buffer-local 'c-state-cache)
(defvar c-state-cache-good-pos 1)
(make-variable-buffer-local 'c-state-cache-good-pos)
(defvar c-state-nonlit-pos-cache nil)
(make-variable-buffer-local 'c-state-nonlit-pos-cache)
(defvar c-state-nonlit-pos-cache-limit 1)
(make-variable-buffer-local 'c-state-nonlit-pos-cache-limit)
(defalias 'c-state-pp-to-literal #[(from to &optional not-in-delimiter) "\212\306 \307\216\310 \n\"\311\211 \312
8\204# \313
8\203N \314
8\315=\204N \312
8\203- \316\2028 \314
8\2037 \317\2028 \320\310`d\311\211
\315&\210
\f\321
8`BE\202\205 \204\203 o\204\203 \322u\210\323\324!\204\203 \323!\203\203 \323!\203r \320\202s \317`\325\326!\210
\f `BE\202\205
C.\207" [save-match-data-internal from to co-st ty s match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] parse-partial-sexp nil 3 4 7 syntax-table string c++ c 8 -1 looking-at "\\s!" forward-comment 1 not-in-delimiter c-comment-start-regexp c-block-comment-start-regexp] 7])
(defalias 'c-state-safe-place #[(here) "\214~\210\212\306\211\211\211\211\211 \n\211 \203* @\fV\203* A\211 \204 \203H @
V\203H @ A\211 \2042 @\206O e\n\f\204\302 \n\\
X\205e \n\\\211\203\272 \307\n
\"AA@\211\203\202 A
X A\203\272
b\210\310 \205\222 `
U?\205\222 `\211\203\243 \311 \210m\204\241 \306u\210`\n\203\260
X \203\272
\211\nB\202U
\203\302
B\n\fV\203\316 \n\f\n. \207" [c-state-nonlit-pos-cache macro-end macro-beg lit high-pos npos nil c-state-pp-to-literal c-beginning-of-macro c-syntactic-end-of-macro pos c c-state-nonlit-pos-cache-limit here c-state-nonlit-pos-interval] 8])
(defalias 'c-state-literal-at #[(here) "\214~\210\212\302!\303 \"AA@+\207" [here pos c-state-safe-place c-state-pp-to-literal] 3])
(defalias 'c-state-lit-beg #[(pos) "\301!@\206 \207" [pos c-state-literal-at] 2])
(put 'c-state-lit-beg 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-state-cache-lower-good-pos #[(here pos state) "\304\212 b\210\305\n8\203 \306 \304\211\n\307&` W\203 `` =\203* \202P \306 \n@T\304\n\304&\211@\n@V\203B \202P \3108\n@=\204O \202P *\207" [s pos state here nil 8 parse-partial-sexp syntax-table 6] 8])
(defvar c-state-point-min 1)
(make-variable-buffer-local 'c-state-point-min)
(defvar c-state-point-min-lit-type nil)
(make-variable-buffer-local 'c-state-point-min-lit-type)
(defvar c-state-point-min-lit-start nil)
(make-variable-buffer-local 'c-state-point-min-lit-start)
(defvar c-state-min-scan-pos 1)
(make-variable-buffer-local 'c-state-min-scan-pos)
(defalias 'c-state-get-min-scan-pos #[nil "\206 \214\212~\210 b\210\n\303=\203 \304 \210\202 \305\306!\210`\211*\207" [c-state-min-scan-pos c-state-point-min-lit-start c-state-point-min-lit-type string forward-sexp forward-comment 1] 2])
(defalias 'c-state-mark-point-min-literal #[nil "e\306\214~\210\307 !\211\2036 \212@b\210\310\n!\203 \311\202) \310 !\203( \312\202) \313)@A\211\f\202> \306\211 \211\f+\207" [lit p-min c-block-comment-start-regexp c-line-comment-starter c-state-point-min-lit-type c-state-point-min-lit-start nil c-state-literal-at looking-at c c++ string c-state-min-scan-pos] 3])
(defvar c-state-brace-pair-desert nil)
(make-variable-buffer-local 'c-state-brace-pair-desert)
(defalias 'c-state-cache-top-lparen '(macro . #[(&optional cache) "\206 \302\303\304\305 DD\306 D\305 DF)\207" [cache cash c-state-cache if consp car caar] 5]))
(defalias 'c-state-cache-top-paren '(macro . #[(&optional cache) "\206 \302\303\304\305 DD\306 D\305 DF)\207" [cache cash c-state-cache if consp car cdar] 5]))
(defalias 'c-state-cache-after-top-paren '(macro . #[(&optional cache) "\206 \302\303\304\305 DD\306 D\307\305 D\310\305 DDEF)\207" [cache cash c-state-cache if consp car cdar and 1+] 8]))
(defalias 'c-get-cache-scan-pos #[(here) "\304\211\203\" \n@:\203 \n@@\202 \n@ Y\203\" \nA\211\204 \n@\211:\203< A V\2037 @T\202R A\202R \203E T\202R \305 X\203Q \305 \202R \304*\207" [c-state-cache elt c here nil c-state-get-min-scan-pos] 3])
(defvar c-state-old-cpp-beg-marker nil)
(make-variable-buffer-local 'c-state-old-cpp-beg-marker)
(defvar c-state-old-cpp-beg nil)
(make-variable-buffer-local 'c-state-old-cpp-beg)
(defvar c-state-old-cpp-end-marker nil)
(make-variable-buffer-local 'c-state-old-cpp-end-marker)
(defvar c-state-old-cpp-end nil)
(make-variable-buffer-local 'c-state-old-cpp-end)
(defalias 'c-get-fallback-scan-pos #[(here) "\212b\210\305o\2043 \306U\2043 \307\211\310 \210*\f\203& \311\f!\203& \306\225b\210\307f\312=\203 S\202 )`)\207" [here cnt end-of-defun-function beginning-of-defun-function defun-prompt-regexp 2 0 nil beginning-of-defun looking-at 123] 2])
(defalias 'c-state-balance-parens-backwards #[(here- here+ top) "\306\211\211\211\212\214e\f}\210
\3071+ \310 \311\211#\211\205' B \202 0\202/ \210\2020 \210*\f\203] \3121X \205T \310 \313\311#\211\205T \nA\211\204@ \3060\202\\ \210\202] \210 ,\207" [lonely-rens ren+1 pa pos top here+ nil (error) scan-lists 1 (error) -1 here-] 5])
(defalias 'c-parse-state-get-strategy #[(here good-pos) "\212b\210\306 \205\n `)\211\205 \n\205 \nU?\205 \307 \203( ^\202) ! \310\211 \310\211 \206= \311 \311 W\203T \312\310\211\313\202\230 X\203u \314 \203f \f\202j \f]Z\202\230 Z\fZW\203\214 \315Z\202\230 \316\fZ\317>\203\244 \203\277 V\203\277 \320!
ZW\203\277 \321
.D\207" [here in-macro-start c-state-old-cpp-beg changed-macro-start cache-pos BOD-pos c-beginning-of-macro c-get-cache-scan-pos nil c-state-get-min-scan-pos IN-LIT 0 forward backward back-and-forward col-0-paren c-get-fallback-scan-pos BOD strategy start-point how-far good-pos c-emacs-features open-paren-in-column-0-is-defun-start c-state-cache-too-far] 4])
(defalias 'c-renarrow-state-cache #[nil "eW\203 \306 \210\307\n\307\202\236
\203 e\310 W\204 \306 \210\307 B\307 \n\211 A@:\2037 A@@\202; A@\211\n\203Q \neY\203Q A\211 \202) :\203\235 A =\204q A@:\203x A@AeV\203x \307\n\202\235 A \f \307\241\210\311 ! \f\241\210) @:\203\231 @@\202\233 @T*e\211\207" [c-state-point-min c-state-cache c-state-min-scan-pos c-state-cache-good-pos c-state-brace-pair-desert c-state-point-min-lit-start c-state-mark-point-min-literal nil c-state-get-min-scan-pos copy-sequence pa ptr cdr-ptr] 3])
(defalias 'c-append-lower-brace-pair-to-state-cache #[(from here &optional upper-lim) "\212\214\306 @:\203 @@\202 @ b\210\307 \210` \310\f\311\"\312=\203( \f\202) \306 \2045 \205U \n@=\205U @\203P @V\205U AX?\205s\205q \n@=\205q AY\205q A\n\205| \n W\205| \n \211 \203\221 \203\221 ]\202\234 \206\234 \206\234 e\313 T}\210*\3141\351 \315
\316\211#\211\205\345 \315\316\317#\211\205\345
V\204\246 W\205\345
f\320=\203\246
b\205\345 \307 \205\345 `\fW\205\345 \202\246 0\202\355 \210\202\356 \210\203
W\203 \202\242 \203RW\203R
W\203R
f\320=\203R
TB @:\2030 AB\211\202s @\247\203J @W\203J @ ABB\211\202s B\211\202s\203j
W\203jV\203j
\202ke ^B\211.\207" [new-cons c-state-cache cache-pos from macro-start-or-from bra nil c-beginning-of-macro get-text-property category c-cpp-delimiter buffer-size (error) scan-lists -1 1 123 ce upper-lim c-state-brace-pair-desert cache-lim desert-lim here] 5])
(defalias 'c-state-push-any-brace-pair #[(bra+1 macro-start-or-here) "\205/ V\204 b\210\303 \204* S\304\305\211#B\n@:\203% \nA\202& \nB\211\207\306Sd\"\207" [bra+1 macro-start-or-here c-state-cache c-beginning-of-macro scan-lists 1 c-append-lower-brace-pair-to-state-cache] 5])
(put 'c-state-push-any-brace-pair 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-append-to-state-cache #[(from here) "\212b\210\306 \210`)\212b\210\307 \203 `\202 )\310 \310\211\211\211 \212\214e}\210\3111` \312\313\314#\211\fB\312\313\211#\206N `Sf\315=\203X \f\240\210\2024 \210\203\300 V\203\300 \211\205\252 V\204\207 b\210\307 \204\245 S\312 \313\211#B@:\203\234 A\202\236 B\211\202\252 \316 Sd\"*\210SB\310\211\2020 \3171\321 \312\313\211#\2110\202\323 \210\310\2040 \211\205 V\204\357 b\210\307 \204
S\312 \313\211#B@:\203A\202B\211\202\316 Sd\"*\210\f@\211\203B
V\203&
\2025
b\210\307 \205/`\211\2065
V\203B\fA\211\202
\203P\n\203P
\n^\202U
\206U .\n\207" [here from mstart bra+1 paren+1s paren+1 beginning-of-line c-beginning-of-macro nil (error) scan-lists 1 -1 123 c-append-lower-brace-pair-to-state-cache (error) ren+1 pa+1 macro-start-or-here here-bol c-state-cache] 9])
(defalias 'c-remove-stale-state-cache #[(start-point here pps-point) "\212\214\306d}\210\212b\210\307 \205 `)\nW\205# \212\nb\210\307 \205\" `)\211\2051 \212 b\210\310 \210`) \311\211 \311\211 \311\211 \311 \203Y V\203] W\203] \202a ^\203\216 @:\203v @@\202y @Y\203\216 @\242A\211\204h \203\265 @:\203\265 @AV\203\265 @@AB\211@\312\f\203\304 =\204\304 \fT\202\305 \n\211b\210\203f@\247\204\334 A\203f`W\203f
\204\354 \313\202\371
@=\203\371
@S\314``W\203\202\311
%\211@=\203\312 `@:\2039`@A=\2039A\242A\243\211\202\314 @\247\203N@A\211\202\314 A@\247\203\312 A@AA\211\204\317 `W\203v\314`\311\211
%\203\231f\315=\203\231\242:\203\217ABB
F.\f\207" [here in-macro-start start-point start-point-actual-macro-start start-point-actual-macro-end pps-state 1 c-beginning-of-macro c-end-of-macro nil t -1 parse-partial-sexp 123 pos upper-lim scan-back-pos cons-separated pair-beg target-depth c-state-old-cpp-beg c-state-old-cpp-end c-state-cache pps-point] 7])
(defalias 'c-remove-stale-state-cache-backwards #[(here) "\306! \307\211\211\211\211\211\211\211\211\212b\210\310 \210`)\nZe] \203b @:\203E @@\202H @\211Y\203b @: A \2022 @:\203\211 @AV\203\211 @@\211 AB T\311E\202v\312!\211@\206\224 A\206\235 \212b\210\313 \203\300 \203\265 ` U\204\300 `\314 \210`\202\307 )\214 d}\210\315
#)W\203\356 \205\351 \311E\202v\214\fd}\210\3161\317\320\321#\211\205\202\373 0\202\210\202\210)\214 d}\210\3221+\317\320\211#0\202-\210\307\211)\203CT\205>\307E\202v\212\fb\210\320y\210`) \312!@\206X) Y\203k \307\211E\202v\205t\307E.
\207" [here c-state-cache-good-pos c-state-cache-too-far too-far-back here-bol here+ c-get-cache-scan-pos nil beginning-of-line t c-state-literal-at c-beginning-of-macro c-end-of-macro c-state-balance-parens-backwards (error) scan-lists -1 1 (error) here- here-lit-end here-lit-start lit good-pos dropped-cons ren pa pos cache-pos c-state-cache c-state-old-cpp-beg] 15])
(defalias 'c-state-cache-init #[nil "\306\307\306\307\306\307\306\211 \n\307 \306\211\f
\310 \207" [c-state-cache c-state-cache-good-pos c-state-nonlit-pos-cache c-state-nonlit-pos-cache-limit c-state-brace-pair-desert c-state-point-min nil 1 c-state-mark-point-min-literal c-state-point-min-lit-type c-state-point-min-lit-start c-state-min-scan-pos c-state-old-cpp-beg c-state-old-cpp-end] 2])
(defalias 'c-invalidate-state-cache-1 #[(here) " X\203 S \n^\f\n^
\n^\211)\210\n\203& \306 W\2032 \307\211 \n\307\f\202\264 \212b\210\310 \210`)\307\211
\203\200 @:\203V @A\202Y @Y\203\200 @:
@:\203r @@\202u @ A\211 \204H
\203\224 X\203\224 \311#\210 @:\203\242 @A\202\254 @\203\257 @T\206\261 \306 \n+@\205\323 @W\203\307 \307\211\207AW\205\323 \241\207" [here c-state-nonlit-pos-cache-limit pos c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit c-state-get-min-scan-pos nil beginning-of-line c-append-lower-brace-pair-to-state-cache c-state-cache-good-pos c-state-cache c-state-min-scan-pos dropped-cons too-high-pa here-bol c-state-brace-pair-desert] 5])
(defalias 'c-parse-state-1 #[nil "`\306\307!\310\211\310\211 \310\211 \310\211 \310 eU\204' \311 \210\312\"\211@A@\n\313=\203B \310
\n\314\267\202\321 \315
#\211@A@AA@AAA@\203} \204w \n\316=\203} \317\"\210\320 \"\203\231 \fZW\203\231 \321 #\202\232 \f\202\327 \322!\211@A@AA@\203\277 \317\"\210\203\313 \320\f\"\202\314 \f\202\327 \310\211. \207" [here here-bopl strategy cache-pos good-pos start-point line-beginning-position 0 nil c-renarrow-state-cache c-parse-state-get-strategy BOD #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (forward 72 back-and-forward 72 BOD 72 backward 159)) c-remove-stale-state-cache forward c-append-lower-brace-pair-to-state-cache c-append-to-state-cache c-state-cache-lower-good-pos c-remove-stale-state-cache-backwards bopl-state res cons-separated scan-backward-pos scan-forward-p c-state-point-min c-state-cache-good-pos c-state-cache c-state-cache-too-far] 5])
(defalias 'c-invalidate-state-cache #[(here) "\301\216\302\303\304\305#\210\302\306\304\305#\210\307!)\207" [here #[nil "\302\300\303#\210\302\301\303 #\207" [c-<-as-paren-syntax c->-as-paren-syntax put syntax-table] 4] put c-<-as-paren-syntax syntax-table nil c->-as-paren-syntax c-invalidate-state-cache-1] 4])
(defalias 'c-state-maybe-marker '(macro . #[(place marker) "\302\303DC\304\303\305 \306 \307BBE\310 \311BBFE\207" [place marker let -place- and or setq ((make-marker)) set-marker (-place-)] 9]))
(defalias 'c-parse-state #[nil "\306\211\212\307 \203 `\310 \211 V\204 \306\211)\311\216\312\313\314\306#\210\312\315\314\306#\210\316 ) \211\205@ \204< \317 \211\205@ \n\306\223)\211\205W
\204S \317 \211\205W
\n\306\223)*\207" [here-cpp-end here-cpp-beg -place- c-state-old-cpp-beg-marker c-state-old-cpp-beg c-state-old-cpp-end-marker nil c-beginning-of-macro c-syntactic-end-of-macro #[nil "\302\300\303#\210\302\301\303 #\207" [c-<-as-paren-syntax c->-as-paren-syntax put syntax-table] 4] put c-<-as-paren-syntax syntax-table c->-as-paren-syntax c-parse-state-1 make-marker c-state-old-cpp-end] 5])
(defvar c-debug-parse-state nil)
(byte-code "\300\301!\204 \301\302KM\210\300\207" [fboundp c-real-parse-state c-parse-state] 2)
(defvar c-parse-state-point nil)
(defvar c-parse-state-state nil)
(make-variable-buffer-local 'c-parse-state-state)
(defalias 'c-record-parse-state-state #[nil "`\302\303 \236A!\203 \303 \236A\304\211\223\210\305 \236A\304\211\223\210\306\307\310\"\211\207" [c-parse-state-point c-parse-state-state markerp c-state-old-cpp-beg nil c-state-old-cpp-end mapcar #[(arg) "J :\203 \302 !\202 \303 !\203 \304 !\202 )B\207" [arg val copy-tree markerp copy-marker] 3] (c-state-cache c-state-cache-good-pos c-state-nonlit-pos-cache c-state-nonlit-pos-cache-limit c-state-brace-pair-desert c-state-point-min c-state-point-min-lit-type c-state-point-min-lit-start c-state-min-scan-pos c-state-old-cpp-beg c-state-old-cpp-end c-parse-state-point)] 3])
(defalias 'c-replay-parse-state-state #[nil "\301\302\303\304\305\306#\307Q\"\207" [c-parse-state-state message "%s" "(setq " mapconcat #[(arg) "\301\302@A:\204 \303\202 \304\305A!\203 \301\306\307A!\"\202\" A$\207" [arg format "%s %s%s" "" "'" markerp "(copy-marker %s)" marker-position] 8] " " ")"] 7])
(defalias 'c-debug-parse-state-double-cons #[(state) "\303\211\n\203 \n@\nA :\203 \n@:\203 \304\202 *\207" [conses-not-ok state-car state nil t] 2])
(defalias 'c-debug-parse-state #[nil "`e\306 \307\307\310\307\310\307\310\307\211\310\307\211 \306 . \232\204B \311\312 \n%\210\311\313!\210\314 \210\315 !\203U \311\316 #\210\311\313!\210\314 \210\317 \210,\207" [res2 res1 min-point here c-state-old-cpp-end c-state-old-cpp-beg c-real-parse-state nil 1 message "c-parse-state inconsistency at %s: using cache: %s, from scratch: %s. POINT-MIN: %s" "Old state:" c-replay-parse-state-state c-debug-parse-state-double-cons "c-parse-state INVALIDITY at %s: %s" c-record-parse-state-state c-state-min-scan-pos c-state-point-min-lit-start c-state-point-min-lit-type c-state-point-min c-state-brace-pair-desert c-state-nonlit-pos-cache-limit c-state-nonlit-pos-cache c-state-cache-good-pos c-state-cache] 11])
(defalias 'c-toggle-parse-state-debug #[(&optional arg) "\303 \"\304 \203 \301\202 \305KM\210\306\302!\203 \307\310\311 \203$ \312\202% \313\"\207" [arg c-debug-parse-state zmacs-region-stays c-calculate-state c-parse-state c-real-parse-state boundp t message "c-debug-parse-state %sabled" "en" "dis"] 3 nil "P"])
(byte-code "\203 \301\302!\210\301\207" [c-debug-parse-state c-toggle-parse-state-debug 1] 2)
(defalias 'c-whack-state-before #[(bufpos paren-state) "\305C\211\305 \2032 @ A\n:\203 \n@\202 \n\fW\203' \305\211\202 \nC\241\210 A\202 A+\207" [newstate ptr car paren-state bufpos nil] 3])
(defalias 'c-whack-state-after #[(bufpos paren-state) "\3032E \205D @\211:\2032 \n @X\204= \n AW\203* \304\303 @AB\"\210\202= \304\303\"\210\202= \n X\204= \304\303\"\210A)\202 0\207" [paren-state car bufpos done throw] 5])
(defalias 'c-most-enclosing-brace #[(paren-state &optional bufpos) "\303 \204 \304\n\203( \n@\nA:\204 Y\203\" \303\202 \303\211\204\f )\207" [enclosingp bufpos paren-state nil 134217727] 3])
(defalias 'c-least-enclosing-brace #[(paren-state) "\303\211\n\203 \n@\nA\250\203 \202 *\207" [elem pos paren-state nil] 2])
(defalias 'c-safe-position #[(bufpos paren-state) "\205Q \303\3042P \n\205O \n@\211:\2039 AW\203& \305\304 A\"\210\202G @W\203G \305\304 @T^\"\210\202G W\203G \305\304 T^\"\210\nA\211\204 \3030)\207" [bufpos elem paren-state nil done throw] 5])
(defalias 'c-beginning-of-syntax #[nil "\306\3072H \203F @\211:\2034 \nA`X\203$ \310\307\nA\"\210\202? \n@`X\203? \310\307\n@\"\210\202? \n`X\203? \310\307\n\"\210 A\211\204\f e0\211`\311ZV\203V b\202v \306\211 \312 \210*
\203n \313
!\203n \314\225b\210` W\205v b+\207" [c-state-cache paren-state elem pos end-of-defun-function beginning-of-defun-function nil done throw 4000 beginning-of-defun looking-at 0 defun-prompt-regexp] 4])
#@454 Return non-nil if the point is on or directly after an identifier.
Keywords are recognized and not considered identifiers. If an
identifier is detected, the returned value is its starting position.
If an identifier ends at the point and another begins at it (can only
happen in Pike) then the point for the preceding one is returned.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-on-identifier #[nil "\212\306\307!\210\310!\203 \310 !\204 `\206\214 \n\311=\203E `\312\313x\210\314\313x\315W\2043 b\210\313f\316=\205A \310\f!\205A \315\225 Y\205A `)\206\214
\205\214 \317\315!\315U\205\214 \310
!\203o \203k \317\320!\315U\203o \310!\203o `\202\214 \212\205\207 \310!\205\207 \321\320!\315U\205\207 \310
!)\205\214 `)\207" [c-symbol-start c-keywords-regexp c-buffer-is-cc-mode pos c-symbol-key c-overloadable-operators-regexp skip-syntax-backward "w_" looking-at pike-mode "-!%&*+/<=>^|~[]()" nil "`" 0 96 c-backward-token-2 1 c-forward-token-2 c-opt-op-identifier-prefix] 2 (#$ . 96423)])
(defalias 'c-simple-skip-symbol-backward #[nil "\303\304!\305W\2066 \306=\2056 `\307\310x\305W\2031 \311\310x\305W\2031 \312\n!\2031 \305\225 Y\2031 \313\2025 b\210\310)\207" [c-buffer-is-cc-mode pos c-symbol-key skip-syntax-backward "w_" 0 pike-mode "-!%&*+/<=>^|~[]()" nil "`" looking-at t] 2])
(put 'c-simple-skip-symbol-backward 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-beginning-of-current-token #[(&optional back-limit) "`\304\305!\203 \306\307 \"\210\2023 \306\310 \"\311W\2033 \304\n!\203$ \311\225\206& `T\211X\205/ b)\204 `W)\207" [start back-limit c-nonsymbol-token-regexp pos looking-at "\\w\\|\\s_" skip-syntax-backward "w_" ".()" 0] 4])
(defalias 'c-end-of-token #[(&optional back-limit) "`\303\304!\305V\2046 \306\307 \"\305W\203, `W\2036 \310\n!\203& \305\225b\210\202 \311u\210\202 \310\n!\2036 \305\225b\210`V)\207" [start back-limit c-nonsymbol-token-regexp skip-syntax-forward "w_" 0 skip-syntax-backward ".()" looking-at nil] 3])
(defalias 'c-end-of-current-token #[(&optional back-limit) "`\303\304S\"\305W\203 \306\304!\210\2022 \303\307 \"\305W\2032 \310\n!\203) \305\225b\210\202, \311u\210`W\204 `V)\207" [start back-limit c-nonsymbol-token-regexp skip-syntax-backward "w_" 0 skip-syntax-forward ".()" looking-at nil] 3])
(defconst c-jump-syntax-balanced (byte-code "\301>\203 \302\207\303\207" [c-emacs-features gen-string-delim "\\w\\|\\s_\\|\\s(\\|\\s)\\|\\s\"\\|\\s|" "\\w\\|\\s_\\|\\s(\\|\\s)\\|\\s\""] 2))
(defconst c-jump-syntax-unbalanced (byte-code "\301>\203 \302\207\303\207" [c-emacs-features gen-string-delim "\\w\\|\\s_\\|\\s\"\\|\\s|" "\\w\\|\\s_\\|\\s\""] 2))
#@323 Move forward over a token.
Return t if we moved, nil otherwise (i.e. we were at EOB, or a
non-token or BALANCED is non-nil and we can't move). If we
are at syntactic whitespace, move over this in place of a token.
If BALANCED is non-nil move over any balanced parens we are at, and never move
out of an enclosing paren.
(defalias 'c-forward-over-token #[(&optional balanced) "\203 \202 \n` \3061Y `\307 \210`U\204 \310\202U m\203% \311\202U \312\f!\2035 \313`\314\"b\210\310\202U \312
!\203C \315\225b\210\310\202U \214~\210\312
!)\203Q \311\202U \311u\210\3100\202^ \210 b\210\311*\207" [balanced c-jump-syntax-balanced c-jump-syntax-unbalanced here jump-syntax c-nonsymbol-token-regexp (error) c-forward-sws t nil looking-at scan-sexps 1 0] 3 (#$ . 99163)])
#@473 Move forward over a token and any following whitespace
Return t if we moved, nil otherwise (i.e. we were at EOB, or a
non-token or BALANCED is non-nil and we can't move). If we
are at syntactic whitespace, move over this in place of a token.
If BALANCED is non-nil move over any balanced parens we are at, and never move
out of an enclosing paren.
This function differs from `c-forward-token-2' in that it will move forward
over the final token in a buffer, up to EOB.
(defalias 'c-forward-over-token-and-ws #[(&optional balanced) "\301!\302 \210\207" [balanced c-forward-over-token c-forward-sws] 2 (#$ . 99938)])
#@1292 Move forward by tokens.
A token is defined as all symbols and identifiers which aren't
syntactic whitespace (note that multicharacter tokens like "==" are
treated properly). Point is always either left at the beginning of a
token or not moved at all. COUNT specifies the number of tokens to
move; a negative COUNT moves in the opposite direction. A COUNT of 0
moves to the next token beginning only if not already at one. If
BALANCED is true, move over balanced parens, otherwise move into them.
Also, if BALANCED is true, never move out of an enclosing paren.
LIMIT sets the limit for the movement and defaults to the point limit.
The case when LIMIT is set in the middle of a token, comment or macro
is handled correctly, i.e. the point won't be left there.
Return the number of tokens left to move (positive or negative). If
BALANCED is true, a move over a balanced paren counts as one. Note
that if COUNT is 0 and no appropriate token beginning is found, 1 will
be returned. Thus, a return value of 0 guarantees that point is at
the requested position and a return value less (without signs) than
COUNT guarantees that point is at the beginning of some token.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-forward-token-2 #[(&optional count balanced limit) "\204 \305\306W\203 \307[ \n#[\207`` \306U\203! \310 \210\214\n\203* e\n}\210`\311 \210`U\2048 S\306]m\203J \306U\203D \305\fb\210\202j \306V\203c \312 !\203c m\204c `S\211\202K m\203j b\210)*\207" [count balanced limit last here 1 0 c-backward-token-2 c-end-of-current-token c-forward-sws c-forward-over-token-and-ws] 5 (#$ . 100565)])
#@63 Move backward by tokens.
See `c-forward-token-2' for details.
(defalias 'c-backward-token-2 #[(&optional count balanced limit) "\204 \306\307W\203 \310[ \n#[\207\n\204 e \203\" \202# \f` \307U\203v `\311 \210`V\203A `\nW\203v \306\202v \312!\203v \313f\314U\203t \203t \212`\315 \210\312\316!\210\307\225U\205p o\206p \317u\210`Sf\320=?)\203v \306\3211\255 \307V\205\251 \322 \210\317u\210\312!\203\227 \323`T\317\"b\210\202\232 \311 \210`\nY\205\251 `S\211\202{ 0\202\260 \210
b\210`\nW\203\272
b\210*\207" [count balanced limit c-jump-syntax-balanced c-jump-syntax-unbalanced last 1 0 c-forward-token-2 c-beginning-of-current-token looking-at nil 35 beginning-of-line "[ ]*" -1 92 (error) c-backward-sws scan-sexps jump-syntax c-syntactic-ws-start c-opt-cpp-prefix] 5 (#$ . 102281)])
#@271 Like `c-forward-token-2' but doesn't treat multicharacter operator
tokens like "==" as single tokens, i.e. all sequences of symbol
characters are jumped over character by character. This function is
for compatibility only; it's only a wrapper over `c-forward-token-2'.
(defalias 'c-forward-token-1 #[(&optional count balanced limit) "\304\305 \n #)\207" [c-nonsymbol-token-regexp count balanced limit "\\s." c-forward-token-2] 4 (#$ . 103101)])
#@273 Like `c-backward-token-2' but doesn't treat multicharacter operator
tokens like "==" as single tokens, i.e. all sequences of symbol
characters are jumped over character by character. This function is
for compatibility only; it's only a wrapper over `c-backward-token-2'.
(defalias 'c-backward-token-1 #[(&optional count balanced limit) "\304\305 \n #)\207" [c-nonsymbol-token-regexp count balanced limit "\\s." c-backward-token-2] 4 (#$ . 103555)])
#@2489 Like `re-search-forward', but only report matches that are found
in syntactically significant text. I.e. matches in comments, macros
or string literals are ignored. The start point is assumed to be
outside any comment, macro or string literal, or else the content of
that region is taken as syntactically significant text.
NOERROR, in addition to the values nil, t, and <anything else>
used in `re-search-forward' can also take the values
`before-literal' and `after-literal'. In these cases, when BOUND
is also given and is inside a literal, and a search fails, point
will be left, respectively before or after the literal. Be aware
that with `after-literal', if a string or comment is unclosed at
the end of the buffer, point may be left there, even though it is
inside a literal there.
If PAREN-LEVEL is non-nil, an additional restriction is added to
ignore matches in nested paren sexps. The search will also not go
outside the current list sexp, which has the effect that if the point
should be moved to BOUND when no match is found (i.e. NOERROR is
neither nil nor t), then it will be at the closing paren if the end of
the current list sexp is encountered first.
If NOT-INSIDE-TOKEN is non-nil, matches in the middle of tokens are
ignored. Things like multicharacter operators and special symbols
(e.g. "`()" in Pike) are handled but currently not floating point
constants.
If LOOKBEHIND-SUBMATCH is non-nil, it's taken as a number of a
subexpression in REGEXP. The end of that submatch is used as the
position to check for syntactic significance. If LOOKBEHIND-SUBMATCH
isn't used or if that subexpression didn't match then the start
position of the whole match is used instead. The "look behind"
subexpression is never tested before the starting position, so it
might be a good idea to include \=\= as a match alternative in it.
Optimization note: Matches might be missed if the "look behind"
subexpression can match the end of nonwhite syntactic whitespace,
i.e. the end of comments or cpp directives. This since the function
skips over such things before resuming the search. It's on the other
hand not safe to assume that the "look behind" subexpression never
matches syntactic whitespace.
Bug: Unbalanced parens inside cpp directives are currently not handled
correctly (i.e. they don't get ignored as they should) when
PAREN-LEVEL is set.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-syntactic-re-search-forward #[(regexp &optional bound noerror paren-level not-inside-token lookbehind-submatch) "\204 d \203\f \306`\307\211\211`\307\211e\307 & ' ( ) *\3101`(\311+,#\204] (*=\203Y \203Y ,\312>\204Y \313*\306#\211'@\306=\203Y `S\307\202\313&\314\224 \307'%'`&-\205\200 \203} '@\314Y\205\200 -\225\211\203\222 \313&
\307'%\202\230 &'\f\315\234\203\247 \311\316,#\202\353\f\317\234\203\266 \320\321,#\202\353\f\322\234\204\360
\206\301 `Sf\323=\203\360 \324
S\325\"\204\360
f\326>\203\360
f\323U\203\347 \311\316,#\202\353\320\321,#\202\353 \2038\f@\211)\314U\2048)\314V\203#-\203&b\210\202\356\313&\314\307'%'`\211&\202\353,\203/`S\307\202\327\330+C\"\202\353\f\331\234\211)\203\211-\204L)\250\204S&b\210\202\356\332\333)\"\334 . /\320/,#\203|\313&`\307\211'%'`&'\331\234\202\200\307\211.\204].*\202\353\212\335 0\336\216\337*!+\203\263\340 \210`X\204\356,\203\252\307\202\327\330+C\"\202\3531\203\350
W\204\326
\212
b\210\335 0\341\216\342 !\210*`\211)W\203\350-\203\341&b\202\353 ^b\202\353\334\307\205(`U\203' `U\203\n,?\205\327\330+C\"\202\307u\210\334\205\202' 0\202' 2*b\210\3272@2A\")\210\n\2035\314\225b\210\314\225\202\212,\334=\203C*b\210\202\211,\343>\204Pb\210\202\211\313&\307\211'%\211'\331\234\204h'\317\234\203\206,\344=\203x'\345\234b\210\202\211\313d\307\211'\325&\210\202\211b\210\307. \207" [bound paren-level found last-token-end-pos check-state check-pos -1 nil (error) re-search-forward (nil t) parse-partial-sexp 0 7 "[\n
]" 4 search-forward "*/" 5 47 get-text-property syntax-table (47 42) signal search-failed 3 make-string 1 t match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] c-beginning-of-macro c-end-of-macro #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] c-end-of-current-token (before-literal after-literal) before-literal 8 state-pos state search-pos tmp start regexp noerror lookbehind-submatch continue ender save-match-data-internal not-inside-token err] 10 (#$ . 104014)])
#@766 Like `skip-chars-backward' but only look at syntactically relevant chars,
i.e. don't stop at positions inside syntactic whitespace or string
literals. Preprocessor directives are also ignored, with the exception
of the one that the point starts within, if any. If LIMIT is given,
it's assumed to be at a syntactically relevant position.
If PAREN-LEVEL is non-nil, the function won't stop in nested paren
sexps, and the search will also not go outside the current paren sexp.
However, if LIMIT or the buffer limit is reached inside a nested paren
then the point will be left at the limit.
Non-nil is returned if the point moved, nil otherwise.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-syntactic-skip-backward #[(skip-chars &optional limit paren-level) "`\212b\210\306 !\210`)\307` \310\311
\" \203! \312 \210``\307
x\313W\203b \314 \211\203< b\210\202W \212\306 !\205M `\nW\205M `\211)\203b b\203b \203' \312 \210\202' `W*\203\351 `\307\211 \205\345 \212\315\f\316#`@\313U)?\205\345 @\313W\203\335 \212\315\f\307\211%\211@\313W)\203\335 \3171\321 \320\316@[#b\210` \203\314 \fY\203\314 b\210\307\202\315 \3210\202\345 \210 \206\327 eb\210\307\202\345 \322\234Tb\210\307+\204 `\312 \210`V\204 `U-?\207" [start limit start-macro-beg lit-beg paren-level-pos skip-chars c-beginning-of-macro nil string-match "^\\^[^ \n
]+$" c-backward-sws 0 c-literal-start parse-partial-sexp -1 (error) scan-lists t 1 opt-ws macro-start pos pps-end-pos state-2 paren-level] 7 (#$ . 108690)])
#@480 Return the type of literal point is in, if any.
The return value is `c' if in a C-style comment, `c++' if in a C++
style comment, `string' if in a string literal, `pound' if DETECT-CPP
is non-nil and in a preprocessor line, or nil if somewhere else.
Optional LIM is used as the backward limit of the search. If omitted,
or nil, `c-beginning-of-defun' is used.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-in-literal #[(&optional _lim detect-cpp) "\214~\210\302`!\211A@\206 \205 \212\303 )\205 \304*\207" [lit detect-cpp c-semi-pp-to-literal c-beginning-of-macro pound] 3 (#$ . 110321)])
#@770 Return a cons of the beginning and end positions of the comment or
string surrounding point (including both delimiters), or nil if point
isn't in one. If LIM is non-nil, it's used as the "safe" position
to start parsing from. If NEAR is non-nil, then the limits of any
literal next to point is returned. "Next to" means there's only
spaces and tabs between point and the literal. The search for such a
literal is done first in forward direction. If NOT-IN-DELIMITER is
non-nil, the case when point is inside a starting delimiter won't be
recognized. This only has effect for comments which have starting
delimiters with more than one character.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-literal-limits #[(&optional lim near not-in-delimiter) "\212` \2034 \306 `\"\307\n8\204! \310\n8\2050 \311\n8\312=?\2050 \313\n8\306`d\314\211\n\312&\210`B)\202P \315 \"\211 AA@\211 \203N
A\204N
@dB\202O
*\211 \206\356 \205\356 b\210\316\314w\210\317 !\203\205 `\3201y \321`\322\"b\210`0\202} \210\202\200 \206\201 dB\202\356 \317 !\203\225 `\323 \210`B\202\356 \316\314x\210`\314 ! \"\212\324#!\325W)\203\300 \3261\271 \321`\327\"b\210`0\202\273 \210\314!\202\343 \3301\314 \331u\210\3320\202\320 \210\202\343 \203\343 \317\333!\203\343 \"b\210\334 \210`!!\205\355 !\"B*+\207" [pos lim s not-in-delimiter pp-to-lit limits parse-partial-sexp 3 4 7 syntax-table 8 nil c-full-pp-to-literal " " looking-at (error) scan-sexps 1 c-forward-single-comment skip-syntax-backward 0 (error) -1 (error) -2 t "\\*/" c-backward-single-comment lit-limits near c-string-limit-regexp c-comment-start-regexp beg end c-string-syntax] 9 (#$ . 111007)])
#@215 Return the start of the string or comment surrounding point, or nil if
point isn't in one. SAFE-POS, if non-nil, is a position before point which is
a known "safe position", i.e. outside of any string or comment.
(defalias 'c-literal-start #[(&optional safe-pos) "\203# \302`\"\303 8\204 \304 8\205! \305 8\306=?\205! \307 8)\207\310`!AA@\207" [safe-pos s parse-partial-sexp 3 4 7 syntax-table 8 c-semi-pp-to-literal] 3 (#$ . 112750)])
(defalias 'c-literal-limits-fast 'c-literal-limits)
#@488 If the argument is a cons of two buffer positions (such as returned by
`c-literal-limits'), and that range contains a C++ style line comment,
then an extended range is returned that contains all adjacent line
comments (i.e. all comments that starts in the same column with no
empty lines or non-whitespace characters between them). Otherwise the
argument is returned.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-collect-line-comments #[(range) "\212\3061g :\203b @b\210\307 !\203b i`\310\311!A \312 \203? ` Y\203? \307 !\203?
iU\203? `\310\311!\202 \nb\210\313\314w\210\307 !\203[
iU\203[ \315y\311U`\204B \f\n,B\202c 0\202i \210)\207" [range c-line-comment-starter end bopl beg col (error) looking-at line-beginning-position 0 c-backward-single-comment " " nil 1] 4 (#$ . 113250)])
#@417 Convenience function that given the result of `c-literal-limits',
returns nil or the type of literal that the range surrounds, one
of the symbols `c', `c++' or `string'. It's much faster than using
`c-in-literal' and is intended to be used when you need both the
type of a literal and its limits.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-literal-type #[(range) ":\203- \212@b\210\302 !\203 \303\202+ \302\304!\204& \302\305!\203* \302\306!\203* \307\202+ \310)\207\207" [range c-string-limit-regexp looking-at string "//" "\\s<" "#" c++ c] 2 (#$ . 114143)])
(defalias 'c-determine-limit-get-base #[(start try-size) "b\210\305 \210`\211 Ze]\306\n!\211AA@\206 \n\211 eY\203% \f\2021 \307\n\310\211 @\311&\210`+\207" [start try-size pos s cand c-backward-sws c-semi-pp-to-literal parse-partial-sexp nil syntax-table] 8])
(put 'c-determine-limit-get-base 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-determine-limit #[(how-far-back &optional start try-size) "\212\206 ` \206 \306\n_ \211b\210\307 \210`\211 Ze]\310 !\211 AA@\206- \211 eY\2038
\202D \311 \312\211\f@\313&\210`-\211 \311 \211\" \312\211 \312 \314 b\210\315 !\210`\211W\203\305 \311 \312\211\f\313&\316\f8\203\201 \317\f8\313=\203\207 \320\f8\203\215 \321\f8\202\216 ` Z\211\314V\203\241 BB\316\f8\203\257 \317\f8\313=\203\265 \320\f8\203\277 \311`\312\211\f\313&`\211\202d \nW\203\347 \203\347 @AA\\\211\202\307 \204eV\203\376 \322\n\306 _#\2029e\2029\nY\203@\nZ\\\2029e=\203 e\2029 ZV\203.@\2029\322\nZ\306 _#.\n\207" [start try-size how-far-back pos s cand 2 c-backward-sws c-semi-pp-to-literal parse-partial-sexp nil syntax-table 0 forward-comment 4 7 3 8 c-determine-limit base stack elt size count] 8])
(defalias 'c-determine-+ve-limit #[(how-far &optional start-pos) "\212\206 ` \305``\"\211 b\210m\204H \306V\203H \305\f\211 \\d^\307\211\n\310&\311 `\fZ\312#`\313\n8\203 \305\fd\307\211\n\310&`\202 `,\207" [start-pos how-far s count pos parse-partial-sexp 0 nil syntax-table - 1 8] 8])
(defvar c-find-decl-syntactic-pos nil)
(make-variable-buffer-local 'c-find-decl-syntactic-pos)
(defvar c-find-decl-match-pos nil)
(make-variable-buffer-local 'c-find-decl-match-pos)
(defalias 'c-invalidate-find-decl-cache #[(change-min-pos) "\205
W\205
\302\211\207" [c-find-decl-syntactic-pos change-min-pos nil] 2])
(put 'c-invalidate-find-decl-cache 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-debug-put-decl-spot-faces '(macro . #[(match-pos decl-pos) "\302\303!\205 \304\300D\301 DD\305BB\207" [match-pos decl-pos facep c-debug-decl-spot-face c-save-buffer-state ((c-debug-add-face (max match-pos (point-min)) decl-pos 'c-debug-decl-sws-face) (c-debug-add-face decl-pos (min (1+ decl-pos) (point-max)) 'c-debug-decl-spot-face))] 4]))
(defalias 'c-debug-remove-decl-spot-faces '(macro . #[(beg end) "\302\303!\205 \304\305\306 \307BBB\306 \310BBBF\207" [beg end facep c-debug-decl-spot-face c-save-buffer-state nil c-debug-remove-face ('c-debug-decl-spot-face) ('c-debug-decl-sws-face)] 7]))
(defconst c-bs-interval 5000)
(defvar c-bs-cache nil)
(make-variable-buffer-local 'c-bs-cache)
(defvar c-bs-cache-limit 1)
(make-variable-buffer-local 'c-bs-cache-limit)
(defvar c-bs-prev-pos most-positive-fixnum)
(make-variable-buffer-local 'c-bs-prev-pos)
(defvar c-bs-prev-stack nil)
(make-variable-buffer-local 'c-bs-prev-stack)
(defalias 'c-init-bs-cache #[nil "\305\306\n\305\211\207" [c-bs-cache c-bs-cache-limit most-positive-fixnum c-bs-prev-pos c-bs-prev-stack nil 1] 2])
(defalias 'c-truncate-bs-cache #[(pos &rest _ignore) " ^\211\207" [c-bs-cache-limit pos] 2])
(defalias 'c-update-brace-stack #[(stack from to) "\306\211\307A@ \212 \203 X\203 b\210\202/ \203+ b\210\306\202/ b\210`W\203Z\310\n@\311X\203C \202E \312#\203Z` V\203Z`\313\307!\211 \314 \")
\315\232\203\223 \316u\210\317\320!\306u\210\203\223 \n\203\215 \n@\311X\203\204 \307\202\207 \n@T\nAB\202\217 \307C\202/
\321\232\203\317 \316u\210\317\322!\306u\210\203\317 \n\203\271 \n@\307V\203\271 \n@S\nAB\202\313 \nA\203\312 \n@\307=\203\312 \nA\202\313 \n\202/
\323\232\203\316u\210\317\320!\306u\210\203\316u\210\324\211 ! \"\325\306!*\203\375 `V\203/ `\202/ \306u\210\202/
\326\232\203 \n\203 \n@\311=\203 \316\nAB\202/
\327\232\203)\n@\316=\204/
\330\235\203E\n\203/ \nA\203/ \n@\311X\203/ \nA\202/ \f\331 #\211 $#N*\203/ \311\nB\202/ \332 \210` \n.BB\207" [stack bound-<> s prev-match-pos kwd-sym match nil 1 c-syntactic-re-search-forward 0 after-literal match-string-no-properties intern-soft "{" -1 looking-at "\\s(" "}" "\\s)" "<" t c-forward-<>-arglist ":" "," (";" "," ")") c-flat-decl-block-kwds c-beginning-of-current-token to from c-brace-stack-thing-key c-brace-stack-no-semi-key keyword c-keywords-obarray c-restricted-<>-arglists c-parse-and-markup-<>-arglists lang-constant keyword-sym] 6])
(defalias 'c-brace-stack-at #[(here) "\212\214~\210 \nX\306\211\211\211\211 \n \211 \f\203. \f@@\nV\203. \fA\211\f\204 \f\f\203M \f@@
V\203M \f@\fA\211\f\2046 \f\203Y \f@@\206Z e\f\203f \f@\202l e\306\307CBB\n \204\244 \nA
\\\211
X\203\244 \310
\f#\211\n@\nA \fd=\204\236 \nB\f\211\202x
\nV\203\254
\203\311
X\203\311 \n@V\203\311 \202\322 \n@\nA
\nV\203\334
\310
#\211\n@\nA\211. \207" [c-bs-cache c-bs-prev-pos c-bs-cache-limit high-elt npos pos nil 1 c-update-brace-stack stack elt can-use-prev c here c-bs-interval c-bs-prev-stack] 8])
(defalias 'c-bs-at-toplevel-p #[(here) "\302!\211?\206 A@\303X)\207" [here stack c-brace-stack-at 1] 3])
(defalias 'c-find-decl-prefix-search '(macro . #[nil "\300\207" [(progn (unless cfd-prop-match (save-excursion (while (progn (goto-char (c-next-single-property-change (point) 'c-type nil cfd-limit)) (and (< (point) cfd-limit) (not (eq (c-get-char-property (1- (point)) 'c-type) 'c-decl-end))))) (setq cfd-prop-match (point)))) (unless cfd-re-match (if (> cfd-re-match-end (point)) (goto-char cfd-re-match-end)) (while (progn (setq cfd-re-match-end (re-search-forward c-decl-prefix-or-start-re cfd-limit 'move)) (cond ((null cfd-re-match-end) (setq cfd-re-match cfd-limit) nil) ((c-got-face-at (if (setq cfd-re-match (or (match-end 1) (and c-dposr-cpp-macro-depth (match-end (1+ c-dposr-cpp-macro-depth))))) (progn (goto-char cfd-re-match) (1- cfd-re-match)) (goto-char (match-beginning 0)) (point)) c-literal-faces) (while (progn (unless (and (or (match-end 1) (and c-dposr-cpp-macro-depth (match-end (1+ c-dposr-cpp-macro-depth)))) (c-got-face-at (1- (point)) c-literal-faces) (not (c-got-face-at (point) c-literal-faces))) (goto-char (c-next-single-property-change (point) 'face nil cfd-limit))) (and (< (point) cfd-limit) (c-got-face-at (point) c-literal-faces)))) t) ((and c-opt-identifier-concat-key (match-string 1) (save-excursion (goto-char (match-beginning 1)) (save-match-data (looking-at c-opt-identifier-concat-key)))) t) ((and (match-string 1) (string= (match-string 1) ":") (save-excursion (or (/= (c-backward-token-2 2) 0) (not (looking-at c-decl-start-colon-kwd-re))))) t) (t nil)))) (unless cfd-re-match (c-backward-syntactic-ws) (setq cfd-re-match (point)))) (if (< cfd-re-match cfd-prop-match) (setq cfd-match-pos cfd-re-match cfd-re-match nil) (setq cfd-match-pos cfd-prop-match cfd-prop-match nil)) (setq cfd-top-level (c-bs-at-toplevel-p cfd-match-pos)) (goto-char cfd-match-pos) (when (< cfd-match-pos cfd-limit) (while (progn (c-forward-comments) (cond ((looking-at c-noise-macro-name-re) (c-forward-noise-clause-not-macro-decl nil)) ((looking-at c-noise-macro-with-parens-name-re) (c-forward-noise-clause-not-macro-decl t)) ((and (< (point) cfd-limit) (looking-at c-doc-line-join-re)) (goto-char (match-end 0)))))) (setq cfd-continue-pos (if cfd-prop-match (min cfd-prop-match (point)) (point)))))] 1]))
(defalias 'c-find-decl-spots #[(cfd-limit cfd-decl-re cfd-face-checklist cfd-fun) "`d\306e?\205\n \306\307\211\310`! 3 4 5 6 7 8\306\211\211\211 9 : ; <`= > ?\311?\312\"\211 @:\203\\ @\203W @@>>\204W @A\211@\204E @\202a @>>+\203/o\204\255 `S= > ?\311?\312\"\211 @:\203\231 @\203\224 @@>>\204\224 @A\211@\204\202 @\202\236 @>>+\203\255 \313`\312\306e$b\210\202e \314A!\204\301 \315 \211 B\203\300 Bb\210)`\211<\203/ \2128b\210\316y\210`)X\203/\2128b\210\317`\312\306 $b\210` W\203\"`= > ?\311?\312\"\211 @:\203@\203@@>>\204@A\211@\204@\202 @>>+\204\334 ` U)\203/<\202\370\212\316y\307U\205In\205I` Y\205I\320u\210`Sf\321=)\203W8S\322;\202\370\323 \203_\322;8 CD\205tCDW\205t\306\211D)\210`\211:D=\204\216\214D\206\207ed}\210\324 \210)`D=\203\244E\203\244E3:\202\370:Do\203\263\307\2116\202\274\320u\210\325 \210` W\203\3544\204\341\212\317`\326\306 $b\210` W\203\335\311`S\326\"\327=\203\305`4)6\204r5`V\203\3615b\210\330F \331#\2115\204 6\202g\316\225\206G\205GT\225\2116\203!6b\2106S\202&\307\224b\210`= > ?\311?\312\"\211 @:\203T@\203O@@>>\204O@A\211@\204=@\202Y@>>+\203(\316\225\204nG\203\337GT\225\203\337`S= > ?\311?\312\"\211 @:\203\236@\203\231@@>>\204\231@A\211@\204\207@\202\243@>>+\203\337`= > ?\311?\312\"\211 @:\203\326@\203\321@@>>\204\321@A\211@\204\277@\202\333@>>+\203\347\317`\312\306 $b\210` W\203\361`= > ?\311?\312\"\211 @:\203 @\203@@>>\204@A\211@\204@\202!@>>+\204]\202\361H\203F\332\316!\203F\212\316\224b\210\333 I\334\216\314H!+\204\361\332\316!\203g\332\316!\335\230\203g\212\336\337!\307U?\206c\314J!?)\204\3616\204r\324 \210`664W\203\20463\3066\202\21343\3064\3103!3b\2103 W\203\354\340\341!\203\245m\203\233\314\342!\203\261\337u\210\202\233\314K!\203\276\343\306!\202\333\314L!\203\313\343\322!\202\333` W\203\336\314M!\203\336\307\225b\204\2334\203\3524`^\202\353`38W\205\3663E
\203
8W\203 ;\203\261<\2068b\210` No?\205|\306 O\340\320!\211O\204N`Sf\344=\2033\320u\210\202 `Sf\345=\203N`S\206A`Sf\344=\203N\346u\210\202 O)\203a\314\347!\203\337u\210\306\202|\314\350!\205|`Sf\321=\205|`NW\205|\320u\210\202)\210o\204\205\320u\210\325 \210\351 \203\377\212\336\337!\307U\205\243\212\352 \210\314P!)\205\243`)\2119\203\3779b\210\202\377<\203\373\204\301<b\210\202\3368b\210\313`\326\306<$b\210`<V\203\336\311`\326\"\327=\203\305`<U\203\377\314Q!\204\377\353 \210` V\203\377 b\210\202\3778b\210`6\2036
W\203\30664\203 4
W\203 \3064:\203G3\203t3:W\203t:b\210\354 \210
\203t
`W\203t`\202t4\204i\212\317`\326\306 $b\210` W\203e\311`S\326\"\327=\203M`4)6\204\3725`V\203y5b\210\330F \331#\2115\204\213 6\202\357\316\225\206\231G\205\231GT\225\2116\203\2516b\2106S\202\256\307\224b\210`= > ?\311?\312\"\211 @:\203\334@\203\327@@>>\204\327@A\211@\204\305@\202\341@>>+\203\260\316\225\204\366G\203gGT\225\203g`S= > ?\311?\312\"\211 @:\203&@\203!@@>>\204!@A\211@\204@\202+@>>+\203g`= > ?\311?\312\"\211 @:\203^@\203Y@@>>\204Y@A\211@\204G@\202c@>>+\203o\317`\312\306 $b\210` W\203y`= > ?\311?\312\"\211 @:\203\244@\203\237@@>>\204\237@A\211@\204\215@\202\251@>>+\204\345\202yH\203\316\332\316!\203\316\212\316\224b\210\333 I\355\216\314H!+\204y\332\316!\203\357\332\316!\335\230\203\357\212\336\337!\307U?\206\353\314J!?)\204y6\204\372\324 \210`664W\203\f63\3066\20243\3064\3103!3b\2103 W\203t\340\341!\203-m\203#\314\342!\2039\337u\210\202#\314K!\203F\343\306!\202c\314L!\203S\343\322!\202c` W\203f\314M!\203f\307\225b\204#4\203r4`^\202s`,3 W\203&\n3\206\202`Sf\356=\203\222\3113S\357\"\203\360
\fU\204\360
\fV\203\243\354 \210`` Y\204\355\314R!\203\355S\203&\n`S > ?\311?\312\"\211 @:\203\344@\203\337@@>>\204\337@A\211@\204\315@\202\351@>>+\204&\n
b\210` W\203&\n4\204\212\317`\326\306 $b\210` W\203\311`S\326\"\327=\203\374`4)6\204\251 5`V\203(5b\210\330F \331#\2115\204: 6\202\236 \316\225\206HG\205HGT\225\2116\203X6b\2106S\202]\307\224b\210`= > ?\311?\312\"\211 @:\203\213@\203\206@@>>\204\206@A\211@\204t@\202\220@>>+\203_ \316\225\204\245G\203 GT\225\203 `S= > ?\311?\312\"\211 @:\203\325@\203\320@@>>\204\320@A\211@\204\276@\202\332@>>+\203 `= > ?\311?\312\"\211 @:\203
@\203 @@>>\204 @A\211@\204\366@\202 @>>+\203 \317`\312\306 $b\210` W\203(`= > ?\311?\312\"\211 @:\203S @\203N @@>>\204N @A\211@\204< @\202X @>>+\204\224\202(H\203} \332\316!\203} \212\316\224b\210\333 I\360\216\314H!+\204(\332\316!\203\236 \332\316!\335\230\203\236 \212\336\337!\307U?\206\232 \314J!?)\204(6\204\251 \324 \210`664W\203\273 63\3066\202\302 43\3064\3103!3b\2103 W\203u\340\341!\203\334 m\203\322 \314\342!\203\350 \337u\210\202\322 \314K!\203\365 \343\306!\202\n\314L!\203\n\343\322!\202\n` W\203\n\314M!\203\n\307\225b\204\322 4\203!\n4`^\202\"\n`\202u` W\205\322\f`8Y\203\222\n3 V\203W\n\2123b\210\212\323 \205I\n`3W)\203T\n\361 \210`\202U\n\307) \307U\204o\n `V\203j\ne }\210\202o\n\307\202\222\n \307V\203w\n\306T3 \307U?\n#\203\207\n\3064 \307U\204\222\ne7}\210
b\210
U\203\242\n \2113\202w4\204\304\n\212\317`\326\306 $b\210` W\203\300\n\311`S\326\"\327=\203\250\n`4)6\204U\f5`V\203\324\n5b\210\330F \331#\2115\204\346\n 6\202J\f\316\225\206\364\nG\205\364\nGT\225\2116\203 6b\2106S\202 \307\224b\210`= > ?\311?\312\"\211 @:\2037 @\2032 @@>>\2042 @A\211@\204 @\202< @>>+\203 \f\316\225\204Q G\203\302 GT\225\203\302 `S= > ?\311?\312\"\211 @:\203\201 @\203| @@>>\204| @A\211@\204j @\202\206 @>>+\203\302 `= > ?\311?\312\"\211 @:\203\271 @\203\264 @@>>\204\264 @A\211@\204\242 @\202\276 @>>+\203\312 \317`\312\306 $b\210` W\203\324\n`= > ?\311?\312\"\211 @:\203\377 @\203\372 @@>>\204\372 @A\211@\204\350 @\202\f@>>+\204@ \202\324\nH\203)\f\332\316!\203)\f\212\316\224b\210\333 I\362\216\314H!+\204\324\n\332\316!\203J\f\332\316!\335\230\203J\f\212\336\337!\307U?\206F\f\314J!?)\204\324\n6\204U\f\324 \210`664W\203g\f63\3066\202n\f43\3064\3103!3b\2103 W\203u\340\341!\203\210\fm\203~\f\314\342!\203\224\f\337u\210\202~\f\314K!\203\241\f\343\306!\202\276\f\314L!\203\256\f\343\322!\202\276\f` W\203\301\f\314M!\203\301\f\307\225b\204~\f4\203\315\f4`^\202\316\f`\202u.\n\207" [c-type-decl-end-used cfd-limit cfd-top-level cfd-macro-end cfd-token-pos cfd-continue-pos nil 0 c-bs-at-toplevel-p get-text-property face previous-single-property-change looking-at c-literal-start 1 next-single-property-change -1 92 t c-beginning-of-macro c-backward-sws c-beginning-of-current-token c-type c-decl-end re-search-forward move match-string match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] ":" c-backward-token-2 2 forward-comment 5 "\\\\[\n
]" c-forward-noise-clause-not-macro-decl 13 10 -2 "\\*/" "[\n
]" c-on-identifier beginning-of-line c-forward-single-comment c-forward-sws #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] 60 syntax-table #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] c-end-of-macro #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] cfd-match-pos cfd-prop-match cfd-re-match-end cfd-re-match cfd-buffer-end cfd-start-pos hash-define-pos syntactic-pos start-in-macro start-in-literal c-literal-faces faces pos pos-faces c-literal-start-regexp lit-start change-min-pos c-find-decl-syntactic-pos c-find-decl-match-pos c-decl-prefix-or-start-re c-dposr-cpp-macro-depth c-opt-identifier-concat-key save-match-data-internal c-decl-start-colon-kwd-re c-noise-macro-name-re c-noise-macro-with-parens-name-re c-doc-line-join-re start moved-comment c-opt-cpp-macro-define-id c-doc-bright-comment-start-re cfd-decl-re cfd-face-checklist cfd-fun] 12])
(defvar c-found-types nil)
(make-variable-buffer-local 'c-found-types)
(defalias 'c-clear-found-types #[nil "\301\302\303\304\305$\211\207" [c-found-types make-hash-table :test equal :weakness nil] 5])
(put 'c-clear-found-types 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-add-type #[(from to) "\305 \n#\306 \f\"?\205 \307\310 \311\312#\f\"\210\313 \314\f#)\207" [from to c-recognize-<>-arglists type c-found-types c-syntactic-content gethash remhash substring 0 -1 puthash t] 5])
(defalias 'c-unfind-type #[(name) "\302 \"\207" [name c-found-types remhash] 3])
(defalias 'c-check-type #[(from to) "\304\305 \n# \"\207" [from to c-recognize-<>-arglists c-found-types gethash c-syntactic-content] 5])
(put 'c-check-type 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-list-found-types #[nil "\302\303\304 \"\210\305\306\")\207" [type-list c-found-types nil maphash #[(type _) " B\211\207" [type type-list] 2] sort string-lessp] 3])
(defalias 'c-trim-found-types #[(beg end _old-len) " V\203B \212dW\203$ b\210\303 \203$ b\210\304 \203$ \305\306`\"!\210 eV\203A b\210\304 \203A b\210\303 \203A \305\306` \"!\210)\n\205h \307 \"\203\\ U\206h \310\311\312\n8\"\206h \n@\313=\205h \305\nA@!\207" [end beg c-maybe-stale-found-type c-beginning-of-current-token c-end-of-current-token c-unfind-type buffer-substring-no-properties c-partial-ws-p string-match "^[ \n
\f ]*$" 5 c-decl-id-start] 4])
(defalias 'c-clear-<-pair-props #[(&optional pos) "\212\203 b\210\202
`\306`\307\" \232\205Z \307 p\310\216\311\f!\210\3121. \313`\314\315#0\2020 \210\316\211 \203:
b\210
\210,\306`S\307\"\232\203Q `S\317\211T\320#\210)\317\211T\321#))\207" [pos c-<-as-paren-syntax #1=#:buffer #2=#:table c-no-parens-syntax-table dest get-text-property syntax-table #[nil "rq\210\302 !)\207" [#1# #2# set-syntax-table] 2] set-syntax-table (error) scan-lists 1 0 nil remove-text-properties (category . #3=(nil)) (category . #3#) c->-as-paren-syntax] 5])
(defalias 'c-clear->-pair-props #[(&optional pos) "\212\203 b\210\202
`\306`\307\" \232\205V \307 p\310\216\311\f!\210\3121. \313`\314\315#0\2020 \210\316\211 \2038
b\210,\306`\307\"\232\203M `\317\211T\320#\210)\317\211T\321#))\207" [pos c->-as-paren-syntax #1=#:buffer #2=#:table c-no-parens-syntax-table dest get-text-property syntax-table #[nil "rq\210\302 !)\207" [#1# #2# set-syntax-table] 2] set-syntax-table (error) scan-lists -1 1 nil remove-text-properties (category . #3=(nil)) (category . #3#) c-<-as-paren-syntax] 5])
(defalias 'c-clear-<>-pair-props #[(&optional pos) "\301f\302=\203 \303!\207\301f\304=\203 \305!\207\306\307!\210\310 \207" [pos nil 60 c-clear-<-pair-props 62 c-clear->-pair-props message "c-clear-<>-pair-props called from wrong position" ding] 2])
(defalias 'c-clear-<-pair-props-if-match-after #[(lim &optional pos) "\212\203 b\210\202
`\306`\307\" \232\205c \307 p\310\216\311\f!\210\3121. \313`\314\315#0\2020 \210\316\211 \203:
b\210
\210,`Y\203b \306`S\307\"\232\203b `S\317\211T\320#\210)\317\211T\321#\210)\322)\207" [pos c-<-as-paren-syntax #1=#:buffer #2=#:table c-no-parens-syntax-table dest get-text-property syntax-table #[nil "rq\210\302 !)\207" [#1# #2# set-syntax-table] 2] set-syntax-table (error) scan-lists 1 0 nil remove-text-properties (category . #3=(nil)) (category . #3#) t lim c->-as-paren-syntax] 5])
(defalias 'c-clear->-pair-props-if-match-before #[(lim &optional pos) "\212\203 b\210\202
`\306`\307\" \232\205_ \307 p\310\216\311\f!\210\3121. \313`\314\315#0\2020 \210\316\211 \2038
b\210,`X\203^ \306`\307\"\232\203^ `\317\211T\320#\210)\317\211T\321#\210)\322)\207" [pos c->-as-paren-syntax #1=#:buffer #2=#:table c-no-parens-syntax-table dest get-text-property syntax-table #[nil "rq\210\302 !)\207" [#1# #2# set-syntax-table] 2] set-syntax-table (error) scan-lists -1 1 nil remove-text-properties (category . #3=(nil)) (category . #3#) t lim c-<-as-paren-syntax] 5])
(defalias 'c-before-change-check-<>-operators #[(beg end) " V\204' \n\306V\205 b\205\307`\nZe]x\210`Sf\310=\205\311 !\205 b\210\312\313`\314Ze]\315#\204E b\210\316\317`\314\\d^\315#\205\212\320 \315\211 #\315 $\321\216 b\210\322 %b\210\323 &\324\211 ' (\324\211 ) *%\206s b\210\325\326!)\327\330)\"\210`Sf\310=\203\234 \331 \210\324f\310=\203z \332 !\210`'\202z \333 \210&\203\252 &A\202\253 b\210\334\326!*\335\336*\300#\203\332 `Sf\337=\203\332 \340 \210`Sf\337=\203\262 \341`S\"\210`(\202\262 \342 \210'\203\356 '+W\203\356 '+(\205 (,V\205 (\211,.\f\207" [end beg c-<-pseudo-digraph-cont-len c-<-pseudo-digraph-cont-regexp #1=#:modified buffer-undo-list 0 "^<" 60 looking-at search-backward "<" 1024 t search-forward ">" buffer-modified-p #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-literal-start c-literal-limits nil c-determine-limit 512 c-syntactic-skip-backward "^;{}<" c-backward-token-2 c-clear-<-pair-props-if-match-after c-forward-sws c-determine-+ve-limit c-syntactic-re-search-forward "[;{}>]" 62 c-end-of-current-token c-clear->-pair-props-if-match-before c-backward-sws inhibit-read-only inhibit-modification-hooks beg-lit-start end-lit-limits new-beg new-end beg-limit end-limit c-new-BEG c-new-END] 5])
(defalias 'c-after-change-check-<>-operators #[(beg end) "\212b\210\303\304!\204 \305\306x\307W\203@ b\210\310 \210`W\203@ \303 !\203@ \307\225\211W\203@ \311w\210`W\203@ \312 \210\306u\210\202- \nW\205\205 \nb\210\303\304!\204W \305\306x\307W\205\205 \nb\210\310 \210`\nW\205\205 \303 !\205\205 \n\307\225\211W\205\205 \311\nw\210`\nW\205\205 \312 \210\306u\210\202r )\207" [beg c-<>-multichar-token-regexp end looking-at "[<>]" "<>" nil 0 c-beginning-of-current-token "^<>" c-clear-<>-pair-props] 3])
(defalias 'c-restore-<>-properties #[(_beg _end _old-len) "\306 \307\211\307\310\216\307 \311\211 b\210\312 \211\203# Ab\210`W\205h \313\314\315#\205h \316u\210\212\317 \210\320!?\205T \321 \210`Sf\322>\205T \323`\324\"\325=?)\326\311!\204# \327 \204# b\210\202# .\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks c-parse-and-markup-<>-arglists c-restricted-<>-arglists buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil c-literal-limits c-syntactic-re-search-forward "<" bound -1 c-backward-token-2 looking-at c-backward-sws (40 44) get-text-property c-type c-decl-arg-start c-forward-<>-arglist c-forward-over-token-and-ws lit-limits c-new-BEG c-new-END c-opt-<>-sexp-key] 5])
(defvar c-old-beg-rs nil)
(defvar c-old-end-rs nil)
(defvar c-raw-string-end-delim-disrupted nil)
(defalias 'c-raw-string-pos #[nil "\306`!\307\211\211\211\211 \212
A@\204( \307f\310=\204{ \311\312`\313Ze]\314#\202x
A@\315=\203\276 \316
8b\203\276 \307f\310=\204v \307f\317=\203\276 ` `\320Ze]b\210\321 T\322#\203a ` W\204O ` T=\205r \323\224\205r \323\224Sb)\203\276 o?\203\276 \212\307f\324=\203\211 \307u\210\202\221 `Sf\324=\205\225 \325 !)\203\276 `\323\225\326\323! Tb\210\327 \330\"\204\276 \331\332\312Q\307\314#\203\276 \333\224`S)\f\205\342 ` X\203\315 \334\202\334 \n\203\333 `\nV\203\333 \335\202\334 \307\f \n \257.\207" [id close-quote-pos close-paren-pos open-paren-pos open-quote-pos state c-semi-pp-to-literal nil 34 search-backward "\"" 17 t string 2 40 18 search-forward-regexp limit 1 82 looking-at match-string-no-properties get-text-property syntax-table search-forward ")" 0 open-delim close-delim here c-c++-raw-string-opener-re c-c++-raw-string-opener-1-re] 6])
(defalias 'c-raw-string-in-end-delim #[(beg end) "\212\302Ze]b\210\303\304 \302\\d^\305#\203 `X\204 `X\206$ \306\224 Y?\205- \306\224\307\225B)\207" [beg end 17 search-forward-regexp ")\\([^ ()\\\n
]\\{0,16\\}\\)\"" t 0 1] 4])
(defalias 'c-depropertize-raw-string #[(id open-quote open-paren bound) "\306\307\"\310\311 \307\312\313%\211\203(
\f^\"\f^\"#\f^\211#)\210\n\204R\314\315$\316Q\310\317#\205\327\311\320\224T\320\225S\307\321\313%\211\203]
\f^\"\f^\"#\f^\211#)\210\320\224 %T%W\205\213 \306T\307\"\203v T\206\213 \322T\307\310%$\211\205\213 %W\205\213 \211 &\203\362 &\320\224 ' ()('\310 '\211 ('W\203\271 \306(\307\"\203\271 (\202\317 \322(\307\310'$\211'W\203\315 \f\202\317 *+^)\323('\324#\210*&
\f^\"\f^\"#\f^\211#)\210\306\320\225S\307\"\205N\212\320\225Sb\210\3251\326`\327\"b0\202\210\202&\203&`S )\f^)\323\f\211T\330#\210)\320\225S )\f^)\323\f\211T\331#\210)\320\225S
\f^\"\f^\"#\f^\211#**\202\327\n\332\232\203]+\203c\n\333\232\203\232 )\f^)\323\f\211T\334#\210)
\f^\"\f^\"#\f^\211#)\210 )\f^)\323\f\211T\335#)\202\327 )\f^)\323\f\211T\336#\210)
\f^\"\f^\"#\f^\211#)\210 )\f^)\323\f\211T\337#\210)\340T+\307\341$*\207" [open-paren first open-paren-prop open-quote pos c-lit-pos-cache-limit get-text-property syntax-table nil c-clear-char-property-with-value-on-char-function (1) 34 search-forward ")" "\"" t 0 (1) next-single-property-change remove-text-properties (syntax-table nil) (error) scan-sexps 1 (syntax-table . #1=(nil)) (syntax-table . #1#) (15) (1) (syntax-table . #1#) (syntax-table . #1#) (syntax-table . #1#) (syntax-table . #1#) c-clear-char-property-with-value-function (15) c-semi-near-cache-limit c-full-near-cache-limit id closing-paren first-st -to- -from- c-syntax-table-hwm most-positive-fixnum bound] 7])
(defalias 'c-depropertize-raw-strings-in-region #[(start finish) "b\210` W\205d \305\306\n\307 \310\260 \311#\205d \212\312\224b\210\313 )\204 \314\224\2036 \315\316\314!\317\224T\314\225\320$\210\202 \321\224b\210\322 \210` \321\225b\210`\fW\203` \323 \f\311#\203` \315\316\324!\312\224T\324\225\f$\210\202C )\202 \207" [start finish c-anchored-cpp-prefix c-c++-raw-string-opener-re eom re-search-forward "\\(" "\\)\\|\\(" "\\)" t 0 c-in-literal 4 c-depropertize-raw-string match-string-no-properties 3 nil 2 c-end-of-macro c-syntactic-re-search-forward 1] 6])
(defalias 'c-before-change-check-raw-strings #[(beg end) "b\210\306\307 \310 \311\211 \311 \312\216\313\" \306\211 b\210\314 b\210\314 \204; ?\206X\203 \203 \3158\203W @\3158X\203 A@SAT\311\316\"\210^ ]\211 \202X\203\300 W\203\300 b\203\300 `Sf\317=\203\300 \320 \203\300 `\321 \210` \316 \"\210 ^ ]\211 *\202XAA\232\203\327 @\204\327 @?\206X\203\fA@=\203\355 W\204\f@\322=\203K\203\f@\322=\203\fAA\232\204K\323\2068 \206 A@S \203. T\202/d)\316\"\210^ ]\211 \202X@\322=\205X\232.\207" [end c-raw-string-end-delim-disrupted c-old-END-literality #1=#:modified buffer-undo-list inhibit-read-only nil c-in-literal buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-raw-string-in-end-delim c-raw-string-pos 3 c-depropertize-raw-strings-in-region 92 c-beginning-of-macro c-end-of-macro open-delim 4 inhibit-modification-hooks beg term-del Rquote close-quote c-old-beg-rs c-old-end-rs c-new-BEG c-new-END eom bom close] 4])
(defalias 'c-propertize-raw-string-id #[(start end) "\212b\210\306 w\205: ` W\205: ` \n^\307\n\211T\310\311$\210)`
\f^ \f^ \f\f^\211\f)\210\312u\210\202 )\207" [start end -pos- c-syntax-table-hwm pos c-lit-pos-cache-limit "^\"" put-text-property syntax-table (1) nil c-semi-near-cache-limit c-full-near-cache-limit] 5])
(defalias 'c-propertize-raw-string-opener #[(id open-quote open-paren bound) "\306T \"\210\307\310\n\311Q \312#\203i \313\224\313\225 \306\313\224T\313\225S\"\210 b\210\314\315
\"\210`
W\203c ` ^ \316\211T\317\320$\210)` ^ ^ ^\211 )\210\321u\210\202# \fb\210*\312\207 ^ \316\211T\317\322$\210) ^ ^ ^\211 )\210 ^ \316\211T\317\323$\210) \203G b\210\214 Td}\210\324\325 T\312#)\203D\326\224\203\374 \326\224 ^ \316\211T\317\327$\210)\326\224 ^ ^ ^\211 )\210\202D\330\224 ^ \316\211T\317\331$\210)\330\224T ^ \316\211T\317\332$\210)\330\224T ^ ^ ^\211 )\210 b\210\321\207" [open-quote open-paren id bound after-quote end-string c-propertize-raw-string-id search-forward ")" "\"" t 0 skip-syntax-forward "^\"" put-text-property syntax-table (1) nil (1) (15) re-search-backward "\\(\\(\\`[^\\]?\\|[^\\][^\\]\\)\\(\\\\\\(.\\|\n\\)\\)*\\(\\\\.\\)\\|\\(\\`\\|[^\\]\\|\\(\\`[^\\]?\\|[^\\][^\\]\\)\\(\\\\\\(.\\|\n\\)\\)+\\)\\([^\\]\\)\\)\\(\\\\\n\\)*\\=" 10 (15) 5 (1) (15) -pos- c-syntax-table-hwm pos c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit] 5])
(defalias 'c-after-change-unmark-raw-strings #[(beg end _old-len) "\306 \307\211\307\310\216\311\211 \311\211 5 6\311 78b\210\212m\204: \311\210\212`b\210\312\313\311x\314\"\315U)\204: \311y\210\202 \311\210`)9\204\331 \316:
\307#\203\331 \3178!\2115A@\320=\203\331 \321\2168b\210\3225@8\250\203u \3225@8c\210\202\227 \3225@8\307=\203\227 \323c\2108 ;<;^<\324;\211T\325\326$\210)8 =>=^>?=^?@=^\211@)\210\212\314\224b\210\327 AB\330A8\203\315 \330A8T\202\316
]B*\331`
T\"\210)C\332Ze]b\210\316:B\333#\211\203\365 \315\225CX\204\341 \f\203\315\2248X\203D\315\224^D\331DB\"\210E\203\261E@\334=\203\261\335EA@\325\"\336\232\203\261EA@Sb\210\337:!\204\261`T =<=^<\340=\211T\341#\210)`T =>=^>?=^?@=^\211@)\210`\211 F\342 W\203\210\335F\325\"\343\232\204\210\344F\325\311\342 $\211F\202jF\342 W\205\231Fb\210\316\345!\210`)\203\261`S =<=^<\340=\211T\346#\210)G\204\303E\203RE@\334=\203REA@b\210\337H!\203R\347\314!6\350\3516\352Q\311\307#\203RdBEA@B I J<JI\311 = I\211 JIW\203\335J\325\"\203J\202'\344J\325\311I$\211=IW\203%=\202'K+^<\340JI\353#\210*EA@ =>=^>?=^?@=^\211@)\2109\320=\2031C\332Ze]b\210\316\3548\355\\\307#\211\203v\315\225CW\204a\f\2031\315\2248X\2031\347\314!6\315\224b\210\356\3576\360Q\311\307#\211\203\254\317`!\2115\203\254\3225@8\361>\204\213\f\2031`D^DdB`B I\211 JI I J<JI\311 = I\211 JIW\203\350\335J\325\"\203\350J\202 \344J\325\311I$\211=IW\203\376=\202 K+^<\340JI\362#\210*\340JI\363#\210*` =>=^>?=^?@=^\211@)\210C8W\205RCb\210`7\316L8\307#\205R\364 \210\3317`\".\n\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks found eoll buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil logand "\\\\" 1 0 search-forward-regexp c-semi-pp-to-literal string #[nil "b\210\301\302!\207" [end delete-char 1] 2] 3 34 put-text-property syntax-table (15) c-raw-string-pos 4 c-depropertize-raw-strings-in-region 18 bound open-delim get-text-property (1) looking-at remove-text-properties (syntax-table . #2=(nil)) line-end-position (15) next-single-property-change "\\(\n\\|.\\)" (syntax-table . #2#) match-string-no-properties search-forward ")" "\"" (syntax-table . #3=(nil)) ")\\([^ ()\\\n
]\\{0,16\\}\\)\"" 17 search-backward "R\"" "(" (t 34) (syntax-table . #3#) (c-fl-syn-tab nil) c-end-of-macro state id found-beg end c-old-END-literality c-c++-raw-string-opener-re -pos- c-syntax-table-hwm pos c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit end-bs c-new-END beg c-new-BEG c-old-beg-rs place c-raw-string-end-delim-disrupted c-c++-raw-string-opener-1-re -to- -from- most-positive-fixnum c-anchored-cpp-prefix] 7])
(defalias 'c-maybe-re-mark-raw-string #[nil "`\306\211\211\211\211 `S\206 `Sf\307=\205B \310\311!\205B \212\312 \211\205+ \313 \210`)\314\315\316!`S\316\225 $\204A \206? db\210\317.\207" [found Rquote id macro-end in-macro here nil 82 looking-at "\\([^ ()\\\n
]\\{0,16\\}\\)(" c-beginning-of-macro c-end-of-macro c-propertize-raw-string-opener match-string-no-properties 1 t] 7])
(defvar c-promote-possible-types nil)
(defvar c-parse-and-markup-<>-arglists nil)
(defvar c-restricted-<>-arglists nil)
(defvar c-record-type-identifiers nil)
(defvar c-record-ref-identifiers nil)
(defvar c-last-identifier-range nil)
(defalias 'c-record-type-id '(macro . #[(range) "\242\301=\203 \302\303\301\304BBE\207\305\300DC\306BB\207" [range cons setq c-record-type-identifiers (c-record-type-identifiers) let ((if range (setq c-record-type-identifiers (cons range c-record-type-identifiers))))] 5]))
(defalias 'c-record-ref-id '(macro . #[(range) "\242\301=\203 \302\303\301\304BBE\207\305\300DC\306BB\207" [range cons setq c-record-ref-identifiers (c-record-ref-identifiers) let ((if range (setq c-record-ref-identifiers (cons range c-record-ref-identifiers))))] 5]))
(defvar c-record-found-types nil)
(defalias 'c-forward-keyword-prefixed-id '(macro . #[(type) "\301\302\303\304\305\306\307\300=\203 \310\202 \311E\312BBD\313\314\313\315\300=\203% \316\202& \317E\320BBB\257\207" [type let (res) (setq c-last-identifier-range nil) while if setq res (c-forward-type) (c-forward-name) (nil (cond ((looking-at c-keywords-regexp) (c-forward-keyword-clause 1)) ((and c-opt-cpp-prefix (looking-at c-noise-macro-with-parens-name-re)) (c-forward-noise-clause)))) when (memq res '(t known found prefix maybe)) c-record-type-identifiers (c-record-type-id c-last-identifier-range) (c-record-ref-id c-last-identifier-range) (t)] 10]))
(defalias 'c-forward-id-comma-list '(macro . #[(type update-safe-pos) "\302\303\304\205 \305\306BB\304\307\310\311 DFED\207" [update-safe-pos type while and progn (setq safe-pos (point)) ((eq (char-after) 44)) (forward-char) (c-forward-syntactic-ws) c-forward-keyword-prefixed-id] 8]))
(defalias 'c-forward-noise-clause #[nil "\301 \210\302f\303=\203) \3041 \305`\306\307#0\202 \210\302\211\205\" b\210)\203) \310 \210\311\207" [dest c-forward-token-2 nil 40 (error) scan-lists 1 0 c-forward-sws t] 5])
(defalias 'c-forward-noise-clause-not-macro-decl #[(maybe-parens) "\303 \210\203F `\304\305!\203 m\203 \306\307!\203 \310u\210\202 \311f\312=\203B \31313 \314`\315\316#0\2025 \210\311\211\205> \nb\210\n)\204E b\210)\317\207" [maybe-parens here dest c-end-of-token forward-comment 5 looking-at "\\\\[\n
]" 2 nil 40 (error) scan-lists 1 0 t] 5])
(defalias 'c-forward-keyword-clause #[(match) "\306!\307 \n\")\310\211\311\310 (\211 )\2055\225b\210\312 \210`()\313 *\211 +*N*\203\336 \310\211 ,-\314 \211,\204] \315.!\203L \316\317!\202Z /\203] \3150!\203] \320 \2047 ,\321>\205z 1\203y -\211 2\203x 21B1)\311)\203\336 `(\310f\322=\203\251\310u\210\312 \210\310\211 ,-\314 \211,\204\272 \315.!\203\251 \316\317!\202\267 /\203\272 \3150!\203\272 \320 \204\224 ,\321>\205\327 1\203\326 -\211 2\203\325 21B1)\311)\204~ \202\251)\323 *\211 +*N*\203\232\310\211 ,-\324 \211,\204\315.!\203\316\317!\202/\203\3150!\203\320 \204\363 ,\321>\20561\2035-\211 2\203423B3)\311)\203\232`(\310f\322=\203\251\310u\210\312 \210\310\211 ,-\324 \211,\204v\315.!\203e\316\317!\202s/\203v\3150!\203v\320 \204P,\321>\205\2231\203\222-\211 2\203\22123B3)\311)\204:\202\251)\325 *\211 +*N*\203\310f\326=\203\310u\210\3271\300\330`\317\211#0\202\302\210\310\211\203\251
\206\314`Sf\331=\203\2511\203)\332 *\211 +*N*\203\3334
\311#\203\334\224b\210\314 \204\347\3155!\210\334\225b\210\202\347
b\210\312 \210`(\202\251)\335 *\211 +*N*\203A\310f\336=\203A\337)\340 *\211 +*N*!\203A\312 \210`(\202\251)\341 *\211 +*N*\203t\3154!\204t\3421f\343`\317\"b\210\3110\202h\210\310\203t\312 \210`(\202\251)\344 *\211 +*N*\203\2516\203\232\3156!\203\251\212\334\225b\210\345 )\204\2516\203\243\334\225b\210\312 \210`()\346 *\211 +*N*\2030\310f\347=\203r\310u\210\312 \210\310\211 ,-\314 \211,\204\361\315.!\203\340\316\317!\202\356/\203\361\3150!\203\361\320 \204\313,\321>\2051\203
-\211 2\203\f21B1)\311)\2030`(\310f\322=\2030\310u\210\312 \210\310\211 ,-\314 \211,\204N\315.!\203=\316\317!\202K/\203N\3150!\203N\320 \204(,\321>\205k1\203j-\211 2\203i21B1)\311)\204\20201\2030(b\210\3157!\2030\334\225b\210\312 \210\310\211 ,-\314 \211,\204\265\315.!\203\244\316\317!\202\262/\203\265\3150!\203\265\320 \204\217,\321>\205\3221\203\321-\211 2\203\32021B1)\311)\2030\310f\322=\2030\310u\210\312 \210\310\211 ,-\314 \211,\204\315.!\203\376\316\317!\202\f/\203\3150!\203\320 \204\351,\321>\205,1\203+-\211 2\203*21B1)\311)\204\326(b\210\311-\207" [match keyword c-keywords-obarray c-restricted-<>-arglists c-parse-and-markup-<>-arglists pos match-string intern-soft nil t c-forward-sws c-type-list-kwds c-forward-type looking-at c-forward-keyword-clause 1 c-forward-noise-clause (t known found prefix maybe) 44 c-ref-list-kwds c-forward-name c-paren-any-kwds 40 (error) scan-lists 41 c-paren-type-kwds c-syntactic-re-search-forward 0 c-<>-sexp-kwds 60 c-forward-<>-arglist c-<>-type-kwds c-nonsymbol-sexp-kwds (error) scan-sexps c-protection-kwds c-end-of-current-token c-colon-type-list-kwds 58 safe-pos kwd-sym lang-constant keyword-sym res c-last-identifier-range c-keywords-regexp c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-record-type-identifiers range c-record-ref-identifiers c-symbol-start c-symbol-key c-post-protection-token c-colon-type-list-re] 6])
(defalias 'c-forward-<>-arglist #[(all-types) "`\306! \205 \307 \3102 \311
!\2110\203& \n:\203\" \n \244\307\202, \fb\210\312+\207" [c-found-types c-record-type-identifiers c-record-found-types old-found-types start all-types copy-hash-table t angle-bracket-arglist-escape c-forward-<>-arglist-recur nil] 3])
(defalias 'c-forward-<>-arglist-recur #[(all-types) "`\306\211\306
\204I \307`\310\"\203I \306u\210\3111% \312`\313\211#0\202' \210\306\211 2\2052 2b\210\314)\203B `Sf\315=\203B \314\202\213\fb\210\306\202\213\306u\210\3163!\203Z \3164!\203\202\317 \2105\203g 6\204r 7\3208\321Q\232\204\315 \317 \210\306f\322=\203\202 \306u\210\202\260 \3169!\203\260 \316:!\204\260 6\203\232 5\204\241 ;\323=\203\255 \314\211 <\324 \210*\202\260 \325 \210\317 \210\3167!\203\315 \313\225b\210\317 \210\314\211 <\324 \210*\317 \210`\326=\306\314\211$\203\202`Sf\315=\2038\212\327 \210\316>!)\203\364 \330\225b\210\202Z
\2033 \203 @S\331 ?\211 @\332@\211T\333?$+\210 A\211\204\374 \f @\332@\211T\334\335$\210)`S @\332@\211T\334\336$\210)\314\202\202`Sf\337=\203)`\306\211\211\211 A B C D\3163!\203c\3164!\204c\330\225b\210\202%\340u\210\212\341 \210`C\342\343!\330W\204\246;\344=\203\246`\345\306x\330W\203\240\346\306x\330W\203\240\316E!\203\240\330\225\nY\203\240\314\202\244\nb\210\306)\210\316F!\211A\204\270\316:!?\205\274`\211D)\203\345\314\211 <\347A\205\341\350\313! G\351GH\")\352 I\211 JIN*!*BB\204\355\nb\210B\203%B5\203%A\204%K\203\317 \210\316K!\203DCBLBL\202%DCB5B5,\202Z `Sf\353=\203W\3541>\312`\313\211#0\202@\210\306\211 2\205K2b\210\314)\203W`Sf\355=\204Z M\204{`Sf\356=\203k\306f\356=\203s`Sf\357=\203{` B\211\202\360\361\306\"\204Z \205\213\206\213\314-\207" [c-record-found-types arg-start-pos pos res start c-parse-and-markup-<>-arglists nil get-text-property syntax-table (error) scan-lists 1 t 62 looking-at c-forward-sws "\\(" "\\)" 63 java-mode c-forward-type c-forward-over-token-and-ws c-syntactic-re-search-forward c-backward-token-2 0 c-<>-arg-sep put-text-property c-type category c-<-as-paren-syntax c->-as-paren-syntax 60 -1 c-backward-sws skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" c-forward-<>-arglist-recur match-string intern-soft c-<>-type-kwds 40 (error) 41 38 44 throw angle-bracket-arglist-escape dest c-<-op-cont-regexp c-<-pseudo-digraph-cont-regexp c-record-type-identifiers all-types c-inside-<>-type-key regexp-unmatchable c-identifier-start c-keywords-regexp c-buffer-is-cc-mode c-promote-possible-types c-<>-notable-chars-re c-multichar->-op-not->>->>>-regexp value -pos- keyword-match subres id-end id-start c-symbol-key c-opt-<>-sexp-key keyword c-keywords-obarray lang-constant keyword-sym c-opt-identifier-concat-key c-record-ref-identifiers c-restricted-<>-arglists] 6])
(defalias 'c-backward-<>-arglist #[(all-types &optional limit) "`\306u\210 \204> \307`\310\"\203> \3111 \312`\306\313#0\202 \210\314\211\205( \nb\210\315)\2037 \314f\316=\2037 \315\202\220 b\210\314\202\220 \317\320 \315#\210`Sf\316=\204R b\210\202\214 `\321 \210`V\204> \306u\210` \322
!\203\207 `U\203s \fb\210\314\202\210 `V\203\200 b\210\314\202\210 \fb\210\315\202\210 \315)\204> `U?)\207" [start c-parse-and-markup-<>-arglists dest limit beg-pos all-types -1 get-text-property syntax-table (error) scan-lists 1 nil t 60 c-syntactic-skip-backward "^<;{}" c-beginning-of-current-token c-forward-<>-arglist] 5])
(defalias 'c-forward-name #[nil "``\306\211\211\211 \307$!\203\344\310\225\211b\210\311\312!\310W\204R %\313=\203R ` \314\306x\310W\203L \315\306x\310W\203L \307&!\203L \310\225
Y\203L \316\202P
b\210\306)\210`\307'!\2039%\317=\203\344\307\320!\203\344\321\224\203\214 \212\322 \210\3231} \324u\210\3160\202\202 \210\306\202\210 \205\210 \307\325!)\202\215 \316\203\344 b\210\326 \210 \206\233 `Sf\327=\203\263 \330 \211 (\203\257 `()\202\344\307)!\203 \307*!\203\322 \212\331 \310=\205\316 \306f\332=?)\203 \333 \203\344`\334\307\335!\203\350 \310\225b\210\202 \307)!\203\344\330 \203\344\307\325!\203\344\310\225b\210\326 \210\306f\336=\203\344\306u\210\326 \210`\307+!\203\333 \337\225b\210\202 \307,!\203\344`\310\225B-\310\225b\210\326 \210`\334\202\344\n\203H\n U\204H\n B- b\210\326 \210`\316\211\203\344
b\210.\204c/\203\344.\203y\307.!\203y\310\225b\210\326 \210\202\f /\203\344\306f\340=\203\344\306 -\341\306!)\203\344\326 \210\306f\332=\204\242\306-\342\f
T\"\210`.\203\312\307.!\203\3120\203\301\n\203\301\n B1B1\321u\210\326 \210\202\f 0\203\342\n\203\342\306f\332=\204\342\n B0B0\343
b\210 .\207" [c-promote-possible-types id-end id-start res start pos nil looking-at 0 skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" t c++-mode "\\(operator\\|\\(template\\)\\)\\([^[:alnum:]_$]\\|$\\)" 2 c-backward-sws (error) -2 "::" c-forward-sws 101 c-forward-name c-forward-token-2 40 c-forward-type operator "[*&]" 42 1 60 c-forward-<>-arglist c-add-type template c-identifier-key c-buffer-is-cc-mode c-symbol-key c-keywords-regexp subres c-identifier-start c-ambiguous-overloadable-or-identifier-prefix-re c-opt-type-modifier-key c-overloadable-operators-regexp c-last-identifier-range c-opt-identifier-concat-key c-recognize-<>-arglists c-record-type-identifiers c-record-ref-identifiers] 7])
(defalias 'c-forward-type #[(&optional brace-block-too) "\203 \306\307!\203 \310\311!\210\312 \210`\313\211\211\211\211\211 ) *+\2039 \306+!\2039 \314\225b\210\312 \210\315\202& \306,!\203v \314\225b\210\312 \210\313f\316=\205d \3171[ \320`\314\"b0\202` \210\313\202d \205d \321\211\203o \312 \210\202\236*b\210\202\236\306-!\203!\314\225b\210\312 \210\306.!\203\221 \322\314!\202\257 \306/!\203\241 \314\225b\210\312 \202\257 0\203\262 \3061!\203\262 \323 \204\204 `)\324 \211??\f\311=\203\342 \325)`\"\2102\203\342 3\203\342 3\211 4\203\341 42B2)5\203
\326>\203\313f\327=\203\212\3301\n\320`\314\"b\210\312 \210`\211)0\202\f\210\313)\203)b\210\311
\204\236*b\210\202\236\313)\3066!\203;\212`\324 \211\203:`3)\3067!\203H\311\211\202^\331 8\332\216\3339!\210\306:!*\203-\334\211\203-\n\203\203\212\335 ;\336\216\314\225b\210\312 \210`\211)+\nY\204\203\313\211\203-\314\2252\203\240<\204\226
\311=\203\240\314\224\314\225B2B2=\203\n\335 ;\337\216\306=!*\203\n\313 >\322\314!\210`>\306=!\203\3412\203\332\3067!\203\332\314\224\314\225B2B2\322\314!\210\202\272\3067!\203 2\203\367\314\224\314\225B2B2\322\314!\210\311\202>b\210\315)\202\236\335 ;\340\216\322\314!*\204\236)\203#)b\210\202\236\314\225b\210\312 \210\202\236\f\203\236\f\341\267\202\230\nb\210
\204C<\203i\325 \n\"\2102\203` \203` \211 4\203_42B2)
\204\236\342\202\236\343 !\203s\342\202t\344\202\236\nb\210\312 \210\313f\316=\203\223\343 !\203\217\342\202\224\344\202\224\311\202\236*b\210\313
\203\243?\203\272\306?!\203\272\314\225b\210\312 \210\311\202\247@\203\320\306@!\203\320\314\225b\210\312 \210\202\277\306A!\203\343\314\225b\210\312 \210\311\202\320B\203\216`)
\345>\206\363< <2\205\375<? C\313 D\306B!\203\211\314\225b\210\312 \210\346 \211D\203\211
\311=\204sD\311=\203M\f\347=\2040\325 \n\"\2102\203H \203H \211 4\203G42B2)\311\202s
\334=\204sD\334=\203_\334\202s
\342=\204sD\342=\203q\342\202s\344
\311=\203\215C:\203\215C2\2442\202\215)b\210+C\203\243
\350>\203\243 \203\243 CBC
.\207" [c-recognize-<>-arglists id-range id-end id-start name-res res looking-at "<" c-forward-<>-arglist t c-forward-sws nil 1 prefix 40 (error) scan-sexps decltype c-forward-keyword-clause c-forward-noise-clause c-forward-name c-add-type (t nil) 123 (error) syntax-table #[nil "\301!\207" [c-with-syntax-table-orig-table set-syntax-table] 2] set-syntax-table known match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 567 template 632)) found c-check-qualified-type maybe (t known) c-forward-type template (known found) pos start c-opt-type-modifier-prefix-key c-typeof-key c-type-prefix-key c-decl-hangon-key c-pack-key c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-record-type-identifiers c-last-identifier-range range brace-block-too c-identifier-start c-primitive-type-key c-with-syntax-table-orig-table c-identifier-syntax-table c-known-type-key save-match-data-internal c-promote-possible-types c-opt-type-component-key safe-pos c-opt-type-modifier-key c-opt-type-suffix-key c-type-decl-suffix-ws-ids-key c-opt-type-concat-key c-record-found-types subres] 8])
(defalias 'c-forward-annotation #[nil "`\304\305!\203D \304 !\204D \306u\210\304\n!\203D \307\225b\210\310 \210\304\311!\203@ \31211 \313`\314\307#0\2023 \210\306\211\205< b\210 )\202A \315\206H b\210\306)\207" [pos c-keywords-regexp c-symbol-key dest looking-at "@" nil 0 c-forward-sws "(" (error) scan-lists 1 t] 5])
(defalias 'c-pull-open-brace '(macro . #[(ps) "\301\302\303\304DD\305\306DEE\307\304D\305\306DEEE\207" [ps progn while consp car setq cdr prog1] 8]))
(defalias 'c-forward-over-compound-identifier #[nil "\305 \205I \306\211\307\211`\310 \210\n\311 `\"P\312 \210\f\203@ \313\f!\203@ `\310 \210`\312 \210\305 \203@ \311 \"P\211\204
\306\232?\205H ,\207" [end start consolidated-:: consolidated c-opt-identifier-concat-key c-on-identifier "" nil c-forward-over-token buffer-substring-no-properties c-forward-sws looking-at] 4])
(defalias 'c-back-over-compound-identifier #[nil "\305\306 \205\225 \307\310!\311W\204> \312=\203> `\313\305x\311W\2038 \314\305x\311W\2038 \315 !\2038 \311\225\nY\2038 \316\202< \nb\210\305)\210`\317 \210\320 \210\f\203\221 \315\f!\203\221 \317 \210\307\310!\311W\204\214 \312=\203\221 `\313\305x\311W\203\204 \314\305x\311W\203\204 \315 !\203\204 \311\225\nY\203\204 \316\202\210 \nb\210\305)\203\221 `\202> b\210\316)\207" [end c-buffer-is-cc-mode pos c-symbol-key c-opt-identifier-concat-key nil c-on-identifier skip-syntax-backward "w_" 0 pike-mode "-!%&*+/<=>^|~[]()" "`" looking-at t c-backward-sws c-backward-token-2] 2])
(defalias 'c-check-qualified-type #[(from) "\212b\210\304 \211\2055 \n\203- G\305V\203- \306 \"\204- \307\n \"\203- \310 \305\225\"\202 \306 \"\2055 *\207" [from compound c-opt-identifier-concat-key c-found-types c-forward-over-compound-identifier 0 gethash string-match substring] 4])
(defalias 'c-back-over-member-initializer-braces #[nil "`\303\3042\216 \3051 \306`\307\310#0\202 \210\303\211\205 \nb\210\n)\204) \311\304\303\"\210\312 \210\313 \2046 \311\304\303\"\210\312 \210`Sf\314=\203\210 \307u\210\312 \210`Sf\315>\204T \311\304\303\"\210\3161a \306`\307\310#0\202c \210\303\211\205l \nb\210\n)\204u \311\304\303\"\210\312 \210\313 \204\202 \311\304\303\"\210\312 \210\2029 `Sf\317=0\211\204\226 b\210*\207" [res here dest nil done (error) scan-lists -1 0 throw c-backward-sws c-back-over-compound-identifier 44 (41 125) (error) 58] 5])
(defalias 'c-back-over-list-of-member-inits '(macro . #[nil "\300\207" [(while (eq (char-before) 44) (backward-char) (c-backward-syntactic-ws) (when (not (memq (char-before) '(41 125))) (throw 'level nil)) (when (not (c-go-list-backward)) (throw 'done nil)) (c-backward-syntactic-ws) (while (eq (char-before) 62) (when (not (c-backward-<>-arglist nil)) (throw 'done nil)) (c-backward-syntactic-ws)) (when (not (c-back-over-compound-identifier)) (throw 'level nil)) (c-backward-syntactic-ws))] 1]))
(defalias 'c-back-over-member-initializers #[(&optional limit) "\214`\306 \307\211\211\211 \203 `}\210\3102\261\3112\335 \312 \210`Sf\313>\203R \31418 \315`\316\317#0\202: \210\307\211 \205F b\210 )\204O \320\310\307\"\210\312 \210\321 \203Z \312 \210`Sf\322=\203\305 \316u\210\312 \210`Sf\323>\204u \320\311\307\"\210\3241\202 \315`\316\317#0\202\204 \210\307\211 \205\220 b\210 )\204\231 \320\310\307\"\210\312 \210`Sf\325=\203\265 \326\307!\204\257 \320\310\307\"\210\312 \210\202\234 \321 \204\277 \320\311\307\"\210\312 \210\202Z `Sf\327=\205\334 \212\330 \210\331 !)?\205\334 \332 0\211\203\351 \333 \211\204\253\f@:\203\366 \fA\211\202\352 \f@\fA\211\203\253 \203\f Y\203\253\3112\246 b\210\312 \210\321 \204 \320\311\307\"\210\312 \210`Sf\322=\203\216\316u\210\312 \210`Sf\323>\204>\320\311\307\"\210\3341K\315`\316\317#0\202M\210\307\211 \205Y b\210 )\204b\320\310\307\"\210\312 \210`Sf\325=\203~\326\307!\204x\320\310\307\"\210\312 \210\202e\321 \204\210\320\311\307\"\210\312 \210\202#`Sf\327=\205\245\212\330 \210\331 !)?\205\245\332 0\211\202\337 \205\260\n0\211\204\271
b\210.\207" [res at-top-level level-plausible pos paren-state here c-parse-state nil done level c-backward-sws (41 125) (error) scan-lists -1 0 throw c-back-over-compound-identifier 44 (41 125) (error) 62 c-backward-<>-arglist 58 c-backward-token-2 looking-at c-just-after-func-arglist-p c-at-toplevel-p (error) limit dest c-:$-multichar-token-regexp] 7])
#@216 From the beginning of a struct/union, etc. move forward to
after the brace block which defines it, leaving point at the
start of the next token and returning point. On failure leave
point unchanged and return nil.
(defalias 'c-forward-class-decl #[nil "`\303 !\203E \304 \305=\203E \306 \203E \304 \305=\203E \307f\310=\203E \3111/ \312`\313\305#0\2021 \210\307\211\205: \nb\210\n)\203E \314 \210`\202I b\210\307)\207" [here c-class-key dest looking-at c-forward-token-2 0 c-on-identifier nil 123 (error) scan-lists 1 c-forward-sws] 5 (#$ . 164818)])
(defalias 'c-forward-declarator #[(&optional limit accept-anon) "`\306\211\211\211\211 #\204 d#`#W\203\361\306 $\307\310%!\203- \311\312!\202\203 &\203> \310'!\203> \313 \202\203 \310(!\203\206 )\314=\203b \315\224\203b `\316 \210\310\317!\204b \320$\202\206 \310*!\203k \320\306f\321=\203{ T\306u\210\202 \312\225b\210\322 \210\320\204 $\204\215 `$\204\227 \316 \203\242 \212\323 \210`\211)\202\263 +\203\257 \306\211\320\202\263 `
U?)\203\361 \307U\204\320 \3241\313 \325`\312 #b0\202\315 \210\306\203\361`#X\203\361\310%!\203\344 \311\312!\202\362 &\203\365 \310'!\203\365 \313 \204\327 `#X\203\361\306 ,`#W\203\326`#W\203\246\326\327#\320\211$\211,\203\246`Sf\330=\203\246\310-!\2030\307\225b\210\202)\331>\203\212\3321E\325`\333\312#0\202G\210\306\211 .\205R.b\210\320)\205\242\306f\321=\205\242\323 \210\334\335!\307W\204\236)\336=\205\242` /\337\306x\307W\203\225\340\306x\307W\203\225\3100!\203\225\307\225/Y\203\225\320\202\232/b\210\306)\205\242\3101!)\203,\203\326`Sf\341=\203\326\3421\300\325`\312\211#0\202\302\210\306\211 .\205\315.b\210\320)\203\326\320\202\377 ,\203\336\333u\210`#X)\203\361\f \n\312\224\257\202\365
b\210\306.\207" [decorated paren-depth brackets-after-id id-end id-start here nil 0 looking-at c-forward-keyword-clause 1 c-forward-noise-clause c++-mode 3 c-forward-name "\\(::\\)" t 40 c-forward-sws c-backward-sws (error) scan-lists c-syntactic-re-search-forward "[;:,]\\|\\s)\\|\\(=\\|\\s(\\)" 58 (c++-mode java-mode) (error) -1 skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" 91 (error) limit got-identifier c-decl-hangon-key c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-type-decl-prefix-key c-buffer-is-cc-mode c-type-decl-operator-prefix-key accept-anon found c-:-op-cont-regexp dest pos c-symbol-key c-paren-stmt-key] 7])
#@1389 Assuming point is at the start of a comma separated list of declarators,
apply CDD-FUNCTION to each declarator (when CDD-LIST is non-nil) or just the
first declarator (when CDD-LIST is nil). When CDD-FUNCTION is nil, no
function is applied.
CDD-FUNCTION is supplied with 6 arguments:
0. The start position of the declarator's identifier;
1. The end position of this identifier;
[Note: if there is no identifier, as in int (*);, both of these are nil.]
2. The position of the next token after the declarator (CLARIFY!!!).
3. CDD-NOT-TOP;
4. Non-nil if the identifier is of a function.
5. When there is an initialization following the declarator (such as "=
...." or "( ....".), the character which introduces this initialization,
otherwise nil.
Additionally, if CDD-COMMA-PROP is non-nil, mark the separating commas with
this value of the c-type property, when CDD-LIST is non-nil.
Stop at or before CDD-LIMIT (which may NOT be nil).
If CDD-NOT-TOP is non-nil, we are not at the top-level ("top-level" includes
being directly inside a class or namespace, etc.).
Return non-nil if we've reached the token after the last declarator (often a
semicolon, or a comma when CDD-LIST is nil); otherwise (when we hit CDD-LIMIT,
or fail otherwise) return nil, leaving point at the beginning of the putative
declarator that could not be processed.
This function might do hidden buffer changes.
(defalias 'c-do-declarators #[(cdd-limit cdd-list cdd-not-top cdd-comma-prop cdd-function) "`\306\211\211\211\211\211\211\211\211\211 % & ' ( ) \204\307*!\211%\203`(%@'%A@&\306f\310=\205\276 +\311=\203b ,\203b %AAAA@\204b \212\306u\210\312 \210\313\314!)\205\276 %AA@?\205\276 +\311=?\206\276 \212\306\211u\210\312 \210\3152\275 \306f\316=\203\214 \317\315\320\"\210\321 \211\204\233 \317\315\306\"\210\202\246 \f\322=\204\246 \317\315\320\"\210\307\306\320\"\210\306f\323=\203\273 \306u\210\312 \210\202\200 \3200*%AAA@\205\312 \306f
\203\214*\203\332 e*}\210\3241\347 \325`\326\327#0\202\351 \210\306)\211 -\205\366 -b\210-)\203 \214e*\206d}\210\312 \210)\202\273\320\202\273 \203\255 \330=\203W\331\326\306*#\327U\203W\306f\332=\203W\214*\2037e*}\210\3331D\325`\326\327#0\202F\210\306)\211 -\205S-b\210-)\204\230 \332=\203\230.\203\230\212\214*\203ne*}\210\3341{\325`\326\327#0\202}\210\306)\211 -\205\212-b\210-*\211\203\230\335 \204\230b\210\336\337*\340\320$\203\250\341u\210\202\273\320\202\273\214e*\206\265d}\210\312 \210)/\203\317/'&(,
&\2100\203 `*W\203 \313\342!\203 1\203\364` 2\3432\211T\3441$\210)\306u\210\214e*\206\377d}\210\312 \210)`)\202 \320\211\203 `)V\203 \320\202!)b\210\306. \207" [cdd-after-block cdd-exhausted c-last-identifier-range cdd-got-init cdd-got-type cdd-got-func nil c-forward-declarator 40 c++-mode c-forward-sws looking-at "[*&]" is-function 41 throw t c-forward-type maybe 44 (error) scan-lists 1 0 61 c-forward-token-2 123 (error) (error) c-looking-at-statement-block c-syntactic-re-search-forward "[;,{]" move -1 "," put-text-property c-type cdd-decl-res cdd-id-end cdd-id-start cdd-next-pos cdd-pos cdd-limit c-buffer-is-cc-mode cdd-not-top dest c-recognize-bare-brace-inits cdd-function cdd-list cdd-comma-prop -pos-] 12 (#$ . 167256)])
(defalias 'c-fdoc-shift-type-backward '(macro . #[(&optional short) "\301?\205 \302\303\304\305?\205 \306\257\207" [short progn (setq identifier-type at-type identifier-start type-start got-parens nil got-identifier t got-suffix t got-suffix-after-parens id-start paren-depth 0) (if (setq at-type (if (eq backup-at-type 'prefix) t backup-at-type)) (setq type-start backup-type-start id-start backup-id-start) (setq type-start start-pos id-start start-pos)) (or at-type-decl (setq at-type-decl backup-at-type-decl)) (or maybe-typeless (setq maybe-typeless backup-maybe-typeless)) (setq start id-start)] 6]))
(defalias 'c-forward-decl-or-cast-1 #[(preceding-token-end context last-cast-end) "`\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211 \306 @ A B C D E F G H I J K L M N O P Q\212Rb\210o\206V ` S\307 \210\310`S\"T\235)@)\311 \203d \312 \210\202Y ` U\306\211 V W\306\211 X Y\313Z!\203\200 \314\211\204\224 \313[!\204\224 \\\315=\203\277 \313\316!\203\277 \317 ]\320\216\313^!\203\244 \314I*\321\322! _\323_`\")V\212\324\322!\210`W)\202\335 a\203\335 \313b!\203\335 `Y\325 \203\332 \313b!\204\316 `W\326\314!\211X\203E\\\327=\203
G\330 _\323_`\")=\203
\313\331!\203
\314A\306XUb\210P\203(\332DP\333=\203(\212Ob\210\314 c\326 \210*PMOLNKXPUO`N\306\211FEV\204OY\203\336V\334 d\211 edN*\204cY\203yP\203oWN\202sWQWb\202\350\306MWQX\203\255V\335 d\211 edN*\203\227\314FV\336 d\211 edN*\205\350\314\211E\202\350V\335 d\211 edN*\203\277\314JV\336 d\211 edN*\203\321\314H\314DVGWb\202\350X\205\350X\314=?-\204d P\337\267\202 \313f!\203 \324\322!\202a\203\313b!\203\325 \204\363`N\202\n\314P\202\nP\204)QN\202\nP\340=\203\n\\\327=\203\n\212\306\211\211 g h iNb\210\341 \210`h\342\343!\344W\204\211\\\345=\203 ` j\346\306x\344W\203\200\347\306x\344W\203\200\313k!\203\200\344\225jY\203\200\314\202\205jb\210\306)\203 \310`h\"i\350\306x\344W\203 `g\342\343!\344W\204\331\\\345=\203 ` j\346\306x\344W\203\320\347\306x\344W\203\320\313k!\203\320\344\225jY\203\320\314\202\325jb\210\306)\203 `OY\203 \310`g\"i\232\203 hb\203 \312 \210\306f\351=\203 Ob\210\306\211PMON,`\344\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211 l m n o p q r s t u v w x y j z UNb\210{\203c|}\232\203c\306f\351=\203\314zTz\306u\210`l\202\314\313|!\203\314\\\327=\203\216\352\224\203\216`j\353 \211w\203\314jm\313\354!\203\314\306w\306f\351=\203\243zTz\306u\210`l\202\306t\204\256z\344Ut\314y\317 ]\355\216\313~!*\203\302\314s\322\225b\210\312 \210\202cz\344Vxw\2049\313!\203\365`\211j\203\365\353 \211w\203\365j\211m\2049\313\356!\203\314\211v\2049H\2039P\340=\204+P\333=\2039O\203+\357\310O\212Ob\210\360 \210`)\"!\210\306POmON\314wa\203J\313b!\203J\325 \202\341\313\200!\203\352\\\361=\203\222y\204\222\201\362=\204h
\203\222\306f\363=\203\222l\203\222P\364>\204\352w\203\352\212lb\210\312 \210\306\326 \365>*\203\352\306f\363=\203\253z\344V\203\352zSz\306u\210\202\344\317 ]\366\216\313\367!*\203\313\3701\307\371`\322\"b\210\3140\202\320\210\202\352\322\225b\210\314\203\352r\204\343z\344U\203\343\344\224r\314\211u\202\341z\344V\203\352t\204\352P\314=\204\352M\204?H\204?E\204?{\203\352\201\372>\203\352\212lb\210\312 \210\326 \206;\\\361=\205;\201\362=\2047
\205;\306f\363=)\203\352z ;`j\3732\210;\344V\203\206\3741_\375j\322\211#0\202a\210\306\211j\203tj\206m`Sf\363=\204y\376\373\306\"\210jb\210;S\211;\202L\3140)\203\352PpOo\306x\314\211wuNr\344zM\377=\203\257\314\202\261M\211P\203\302LOKN\202\312QOQNJ\204\323FJH\204\334EHNU\314\203\352\312 \210\2029w\204cA\203\373\313\202!\204H\204E\203cy\204cP\203cPpOo\306x\314\211wuNr\344zM\377=\2032\314\2024M\211P\203ELOKN\202MQOQNJ\204VFJH\204_EHNUA\203\313\203!\203\212\344\225b\210\312 \210`O\326 P)\313\204!\203\220\322\225b\210\312 \210\202\201D 2\376 z\344V\203\201\234 1\256\375`\322z#b0\202\260\210\306\204D\332=\203PpOo\306x\314\211wuNr\344zM\377=\203\335\314\202\337M\211P\203\360LOKN\202\370QOQNJ\204FJH\204\nEHNU\376\201D D\201\235 >\"\210\313\201\201\236 =\203*\201\237 \202<\201\201\240 >\2049\201\241 \202<\201\242 !qw\203P\204NH\203_y\204_x\204_\376\201D \314\"\210x\203\223 s\203sr\204\223 q\203\223 M\204\261H\204\261E\204\261D\314=\204\261\212mb\210\326 \201\243 >?\205\255Nb\210\201\244 O\211b\210\326 \210\341 \210`{!)\203\223 PpOo\306x\314\211wuNr\344zM\377=\203\324\314\202\326M\211P\203\347LOKN\202\357QOQNJ\204\370FJH\204EHNU\202\223 M\203t`UU\203X\306f\201\245 =\203N\\\315=\204ND\314=\2035\376\201D \314\"\210\202X\205\203XD\332=\203X\314C\376\201D \314\"\210\202X\314C\376\201D \314\"\210u\203\311y\204\311x\204\311\314C\376\201D \314\"\210\202\311P\314=\203\202\376\201D \314\"\210`UU\203\311q\203\301\201\201\246 \267\202\263\206\204\241\207\203\267P\201\247 >\202\264P\201\250 >\202\264\306\203\301\376\201D \314\"\210\202\311\376\201D D\"\210x\203Z y\204Z \201\201\251 >\203Z P\314=\204Z M\204 H\204 E\204 {\203Z u\203 \313\210!\204Z PpOo\306x\314\211wuNr\344zM\377=\203& \314\202( M\211P\2039 LOKN\202A QOQNJ\204J FJH\204S EHNU\202\223 y\203p x\204i u\203p \376\201D \314\"\210P\203\223 y\204\223 x\204\223 r\203\223 rf\351=\203\223 \376\201D \306\"\210\201\204\267 \\\327=\203\267 D\332=\203\267 l\203\267 lSb\210\376\201D \314\"\210D\203\303 \376\201D \314\"\210w\203_\n\313\211!\203_\n\201\362=\204\346
\204\346 \201\306=\203_\n\322\224\203_\nx\203S\ny\204S\nu\204S\nP\314=\204S\nPpOo\306x\314\211wuNr\344zM\377=\203 \n\314\202!\nM\211P\2032\nLOKN\202:\nQOQNJ\204C\nFJH\204L\nEHNU\202X\nr\203_\n\376\201D \314\"\210y\204i\nx\204y\nP\201\252 >\203y\n\376\201D \314\"\210P\201\253 >\203\211\n\376\201D \314\"\210\\\327=\203\364\np\203\364\np\201\254 >\204\355\nof\201\255 =\203\364\n\212oTb\210\312 \210\201\256 \212\201\257 \216\201\260 \213!\210\313\214!+\204\355\n\212oTb\210`\326 \210` \215 \216\201\261 \201\262 \216\215\217#\220\"+\203\364\n\376\201D \314\"\210w\203\256 t\203, P\203, q\204 \313\201\263 !\203, \201\201\264 >\203, u\203# @\203, \314\376\201D \314\"\210r\2049 \313\201\263 !\203R P\333=\203R \201\201\265 =\204R \314\376\201D \314\"\210\221\203\345 t\203\345 P\203\345 u\203k @\203\345 \212mb\210n\206{ `Sf\201\266 >)\212Ob\210\326 \205\223 \341 \210l\206\223 \306f\201\267 >) \222\211 \223?\222?=\204\252 \314\376\201D \314\"\210*\202\345 q\203\345 \201\201\270 >\204\345 y\203\306 v\203\336 \201\201\271 =\203\345 \207\204\345 x\204\336 u\203\345 \376\201D \314\"\210\201\201\271 =\206\375 \\\361=\205\375 \201\362=\206\375
0D.\212\224\205\247\fReV\205\247\fR\206\f`Sf\224>\205\247\f\312 \210\313\201\272 !\205\247\f\306\211 ju\210\312 \210`B\313\225!\205n\f\344\225j\201\273 \224\204a\f\322\224\203Y\fD\204a\fP\201\274 >\202^\f\313\226!?\205n\f\313\227!?\206n\f\344\225jX)\205\247\fReV\205\247\fRSb\210`\230=\206\247\f\341 \210\342\343!\344W\203\227\f\313\231!\202\247\f`Sf\201\275 >?\205\247\f\201\276 ?)\203\320\f\203\306\fP\203\306\fP\314=\204\306\f\314 cOb\210\326 \210)Bb\210\201\277 \202x
D\203s
C\203
M\377=\203\345\f\314\202\347\fM\211P\203\370\fLOKN\202
QOQNJ\204
FJH\204
EH\201\201\271 =\203=
\313\201\300 !\203=
`\201\301 \232\211 j \233\201\302 \233\211T\201\303 \232$+\210\203R
P\203R
\314 c\212Ob\210\326 \210*NJ\204^
I\205c
JIB\nO\201\362=\206n
\257\202x
\f \306.\207" [c-record-type-identifiers c-record-ref-identifiers maybe-expression save-rec-ref-ids save-rec-type-ids make-top nil c-backward-token-2 buffer-substring-no-properties c-forward-annotation c-forward-sws looking-at t java-mode "@[A-Za-z0-9]+" match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] match-string 1 intern-soft c-forward-keyword-clause c-forward-noise-clause c-forward-type c++-mode "auto" "[=(]" ids found c-decl-hangon-kwds c-typedef-decl-kwds c-typeless-decl-kwds #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 499 prefix 535)) maybe c-backward-sws skip-syntax-backward "w_" 0 pike-mode "-!%&*+/<=>^|~[]()" "`" ":~ \n
\f" 40 3 c-forward-name "\\(::\\)" #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] "[0-9]" c-unfind-type c-end-of-token c-mode top 41 (nil maybe) (nil maybe) #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] "\\s(" (error) scan-sexps (nil top) pd (error) scan-lists throw prefix at-decl-start new-style-auto cast-end backup-if-not-cast at-decl-or-cast backup-maybe-typeless backup-at-type-decl prev-kwd-sym maybe-typeless at-typedef at-type-decl backup-id-start backup-type-start backup-at-type id-start type-start at-type start-pos preceding-token-end tok-end c-pre-start-tokens start kwd-sym kwd-clause-end found-type noise-start c-make-top-level-key c-prefix-spec-kwds-re c-buffer-is-cc-mode save-match-data-internal c-typedef-key keyword c-keywords-obarray c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-promote-possible-types lang-constant keyword-sym c-decl-hangon-key end-1 end-2 name pos c-symbol-key after-paren-pos name-start c-parse-and-markup-<>-arglists identifier-start identifier-type at-decl-end got-suffix-after-parens got-function-name-prefix got-prefix-before-parens got-suffix got-number got-identifier got-parens got-prefix paren-depth c-recognize-typeless-decls c-type-decl-prefix-key regexp-unmatchable c-type-decl-operator-prefix-key c-identifier-start c-type-decl-suffix-key context c-auto-ops-re c-haskell-op-re c-type-decl-suffix-ws-ids-key c-has-bitfields c-recognize-knr-p c-recognize-paren-inits c-after-suffixed-type-maybe-decl-key c-after-suffixed-type-decl-key c-with-syntax-table-orig-table c-identifier-syntax-table c-known-type-key to from c-recognize-<>-arglists c-found-types c-asymmetry-fontification-flag space-after-type space-before-id c-cast-parens c-primary-expr-regexp c-keywords-regexp c-nonsymbol-token-regexp last-cast-end c-simple-stmt-key value -pos- (error) (t ids) <> "[,>]" (nil top) "[,)]" "[,;]" (nil maybe) c-directly-in-class-called-p 58 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (decl 2199 <> 2218)) (known found) (known found) (nil top) (t known) (t known) (found known) 126 syntax-table #[nil "\301!\207" [c-with-syntax-table-orig-table set-syntax-table] 2] set-syntax-table gethash c-syntactic-content "=[^=]" (nil top) arglist (32 9) (32 9) (nil top) decl "\\s)" 2 (t known found) (41 93) c-on-identifier cast "," c-decl-arg-start put-text-property c-type] 23])
(defalias 'c-forward-label #[(&optional assume-markup preceding-token-end limit) "`\306\211\211\211\211 \307/!\203c \310\225 01\203& \310\2240B2B20b\210\311\3123\313\211\306\310&\203Y \314\224\203Y \314\224b\210`S\315 4\211 5 6\3166\211T\3174$+\210\313\202^ 0b\210\313)\202\2437\203\233 \3077!\203\233 \310\225b\2101\203\201 \310\224`B2B2`S\315 4\211 5 6\3166\211T\3174$+\210\313\202\2438\203\240\306f\320=\204\2409\203\263 9eX\202\307 \212\321 \210`9o\206\306 :\205\306 : )\204y;\203\3229S\317\"\315=\204y\2129Sb\210\323 \210\307<!\206\356 \307=!)\204y9\206\370 `Sf\324=\203\240\325 \202v\2129Sb\210\323 \210\307<!\206\307=!)\204y9\206\"`Sf\324=\203.\325 \202v9\2064`Sf\320=\203\240\214\2129Sb\210\212\326 \205I`)\211\203S\nd}\210\327\330\306\313#\210`\306 1 >?\205h\307?!?\205u\331 \210\332\306>
#,\203\240@\333=\203\250\334\335\306\313#\203\250\336u\210\214e3\206\223d}\210\331 \210)\307\337!\203\250\306u\210\313\211\202!
b\210\311\3403\313\211$\203\240\336u\210`@\333=\205\307\341\342
`{\"\214e3\206\320d}\210\331 \210)\307\337!\203\372\306u\210\343
\f\"\211\344\230\204\360\345\230\203\364\346\202\365\347\211\202! \203\240\334\3503\313#\203\240\214e3\206d}\210\331 \210)\307\337!\203\240\306u\210\351\211\203\240\214
`}\210\3522\233
b\210\307A!\203A
b\210\306\353\352\306\"\210\3541S\355`\310\"b\210\331 \210\3130\202W\210\202^\203^m\20301\203\203
b\210\307/!\204\203\311B\306\313#\203\203\356\224\356\225B2B2\202mdS\315 4\211 5 6\3166\211T\3174$+\210db0\210)\202\243
b\210 .\207" [kwd label-type macro-start qt-symbol-idx label-end start nil looking-at 1 c-syntactic-re-search-forward "[;{=,@]\\|\\(\\=\\|[^:]\\):\\([^:]\\|\\'\\)" t 2 c-decl-end put-text-property c-type 58 c-backward-sws get-text-property c-beginning-of-current-token 41 c-after-conditional c-beginning-of-macro c-syntactic-skip-backward "^-]:?;}=*/%&|,<>!@+" c-forward-sws c-forward-label c++-mode search-forward-regexp "\\=p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\>[^_]" -1 ":\\([^:]\\|\\'\\)" "[ \n[:?;{=*/%&|,<>!@+-]" string-match "\\(p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|more\\)\\>" buffer-substring-no-properties "signals" "Q_SIGNALS" qt-1kwd-colon goto-target "\\=\\(slots\\|Q_SLOTS\\)\\>" qt-2kwds-colon check-label throw (error) scan-sexps 0 c-label-kwds-regexp kwd-end c-record-type-identifiers c-record-ref-identifiers limit value pos -pos- c-opt-extra-label-key c-recognize-colon-labels preceding-token-end c-at-vsemi-p-fn assume-markup c-label-prefix-re c-block-stmt-1-key pte c-opt-cpp-prefix c-buffer-is-cc-mode c-nonlabel-token-key c-symbol-key] 8])
(defalias 'c-forward-objc-directive #[nil "`\306\307\306\211 \310\311!\203 \312\225b\210\202\214 \310\313!\203\271 \314\225b\210`\315\306w\210\306f\316=\2038 \306u\210l\204# \317u\210\320 \203\271 \3212\211 \310\322!\203r \306f\306u\210\323 \210\320 \204Z \324\321\306\"\210 \325=\203r \306f\326=\204l \324\321\306\"\210\306u\210\323 \210\306f\327=\203\207 \307\211\306 \330\307!+\202\210 \3070\203\271 \214 \206\222 ed}\210\331 \210)\332\f`S\333#\210`S\333 \211 !\334!\211T\335 $+\210\307\202\300 \332\f`\333#\210\306-\207" [c-recognize-<>-arglists lim c-promote-possible-types start-char start c-restricted-<>-arglists nil t looking-at "\\(\\(?:@\\(?:end\\|p\\(?:r\\(?:ivate\\|otected\\)\\|ublic\\)\\)\\)\\)\\([^[:alnum:]_$@]\\|$\\)" 1 "\\(\\(?:@\\(?:i\\(?:mplementation\\|nterface\\)\\|protocol\\)\\)\\)\\([^[:alnum:]_$@]\\|$\\)" 0 " \n
\f " 92 -1 c-forward-type break "[:(]" c-forward-sws throw 40 41 60 c-forward-<>-arglist c-backward-sws c-clear-c-type-property c-decl-end put-text-property c-type c-parse-and-markup-<>-arglists value pos -pos-] 6])
(defalias 'c-beginning-of-inheritance-list #[(&optional lim) "\302\303\304#\210\305 !\204 \305\306!\205 \302\307\304#\303U\205 \202 \207" [lim c-symbol-start c-backward-token-2 0 t looking-at "[<,]\\|::" 1] 4])
(defalias 'c-in-method-def-p #[nil "\212\301 \210\205 \302!\205 `)\207" [c-opt-method-key beginning-of-line looking-at] 2])
(defalias 'c-in-gcc-asm-p #[nil "\205 \212\301 \210\302\303!\210\304e\305\306#\210\307!)\207" [c-opt-asm-stmt-key beginning-of-line backward-up-list 1 c-beginning-of-statement-1 nil t looking-at] 4])
#@879 Return a determination as to whether point is "at the top level".
Informally, "at the top level" is anywhere where you can write
a function.
More precisely, being at the top-level means that point is either
outside any enclosing block (such as a function definition), or
directly inside a class, namespace or other block that contains
another declaration level.
If point is not at the top-level (e.g. it is inside a method
definition), then nil is returned. Otherwise, if point is at a
top-level not enclosed within a class definition, t is returned.
Otherwise, a 2-vector is returned where the zeroth element is the
buffer position of the start of the class declaration, and the first
element is the buffer position of the enclosing class's opening
brace.
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info.
(defalias 'c-at-toplevel-p #[nil "\301 \302!?\206
\303!)\207" [paren-state c-parse-state c-most-enclosing-brace c-search-uplist-for-classkey] 2 (#$ . 185880)])
(defalias 'c-just-after-func-arglist-p #[(&optional lim) "`\306\307\n\306\211\211\310%\311=\205\213 \312=\205 \313 ?\205\213 \314\f!\205* \212\214~\210\315\n!*?\205\213 \316\212\317 \210`)\320\306#\242\211\205\213 \247\205\213 W\205\213 ` V\204V \314\321!?\205\213 \212b\210\306f\322=\203j \323`\324\"b\210\202y
\203y \314
!\203y \325\326\310\"\210` W\205\212 \327\330 \310\211$\205\212 `S)*\207" [id-start beg lim c-buffer-is-cc-mode c-cpp-expr-functions-key c-opt-op-identifier-prefix nil c-beginning-of-statement-1 t same objc-mode c-forward-objc-directive looking-at c-beginning-of-macro c-forward-decl-or-cast-1 c-backward-sws top "[=,]" 40 scan-sexps 1 c-forward-token-2 2 c-syntactic-re-search-forward "("] 6])
(defalias 'c-in-knr-argdecl #[(&optional lim) "\212\214\212\306 \205 `)\212\205 \307 \205 `)\n\206 e\206\" e]\310\211 ` %\311 &\310\211 ' (\310\211 ) *\310\211 + ,\310 - \206I d}\210\3122\360&\313V\205\357&S&\314\315!\210`Sf\316=\203l `\202~ `Sf\317=\203y \310\202~ \320\312\310\"\210
\203\310
b\210\3211\222 \322`\323\313#0\202\224 \210\310\211 .\205\240 .b\210.)\204\251 \320\312\310\"\210`\211\203\302
b\210\324 \210\310f\325>\204\302\fb\210\326 \210\327 `=\204\374 \310f\316=\203\302\3301\335 \322`\323\331#0\202\337 \210\310\211 .\205\352 .b\210\332)\203\302\326 \313=\203\302\327 `=\203\302\fb\210\333 \203\302\327 \211(\203\302\3342B\310u\210\335 \210\336(`\"'B'\324 \210\310f\337=\203=\333 \210\327 \211(\204\320\334\310\"\210\202\310f\316=0\203\302\310u\210
)\324 \210\340)\310\211#\211*:\204k)b\210\324 \210\310f\341=-\202\257\310f\342=\203\257`T\211)\203\257*@b\203\257\343 \211+\203\257\336+@+A@\"'\235\211-\203\257)b\210`%W\324 \210\203\257\310-\202N-\203\302\320\312
b\210\324 \210`\"\210\202O \fb\210\202O \3441\325\322`\323\313#0\202\327\210\310\211 .\205\343.b\210.)\204O \320\312\310\"\210\202O 0.\207" [macro-start macro-end lim low-lim before-lparen after-rparen c-beginning-of-macro c-end-of-macro nil 20 knr 0 c-syntactic-skip-backward "^)]}=" 41 93 throw (error) scan-lists -1 c-forward-sws (59 123 61) c-backward-token-2 c-on-identifier (error) 1 t c-forward-over-token-and-ws id-list c-end-of-current-token buffer-substring-no-properties 44 c-forward-decl-or-cast-1 123 59 c-forward-declarator (error) here pp-count-out ids id-start after-prec-token decl-or-cast decl-res c-last-identifier-range identifier-ok dest] 5])
(defalias 'c-skip-conditional #[nil "\300`\301\302!\203\f \303\202 \301\304!\203 \305\202 \306\"b\207" [scan-sexps looking-at "\\<else\\([ \n]\\|\\\\\n\\)+if\\>\\([^_]\\|$\\)" 3 "\\<\\(do\\|else\\|try\\|finally\\)\\>\\([^_]\\|$\\)" 1 2] 4])
(defalias 'c-after-conditional #[(&optional lim) "\212\305\306\307#\310U\205W \311 !\203 \305\306\307#\310U\202 \307\205W \311\n!\204V \312f\313=\205W \305\306\307#\310U\205W \311 !\203F \305\306\307#\310U\202G \307\205W \311 !\204V \311\f!\205W `)\207" [lim c-block-stmt-hangon-key c-block-stmt-1-key c-block-stmt-2-key c-block-stmt-1-2-key c-backward-token-2 1 t 0 looking-at nil 40] 4])
(defalias 'c-after-special-operator-id #[(&optional lim) "\212\205* \303\304\305 #\306U\205* \307!\205* \n\203) \303\304\305 #\306U\205* \307\n!\205* `)\207" [c-overloadable-operators-regexp lim c-opt-op-identifier-prefix c-backward-token-2 1 nil 0 looking-at] 4])
(defalias 'c-backward-to-block-anchor #[(&optional lim) "`\212\302 \210`)U?\205 \303!\211\205 b)\207" [lim start back-to-indentation c-after-conditional] 3])
(put 'c-backward-to-block-anchor 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-backward-to-decl-anchor #[(&optional lim) "`\212\301 \210`)U?\205 \302!\207" [lim back-to-indentation c-beginning-of-statement-1] 2])
(put 'c-backward-to-decl-anchor 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-search-decl-header-end #[nil "` \303=\203j \304\305\306\307\310\211%\205 \311!\204e \212\3121( \313`\314\"b\210\3100\202- \210\306\2023 \2053 \315\n!)\204e `Sf\316=\205 \3171W \3201P \321`\322\211#0\202R \210\306b0\202[ \210\202^ \204e db\210\306\202 `\202 \304\323\306\307\310\211%\205 \311!\205 `\202j )\207" [base c-buffer-is-cc-mode c-opt-op-identifier-prefix c++-mode c-syntactic-re-search-forward "[;{<=]" nil move t c-end-of-current-token (error) scan-sexps -1 looking-at 60 (error) (error) scan-lists 1 "[;{=]"] 6])
(defalias 'c-beginning-of-decl-1 #[(&optional lim) "\3062?``\307\n\310\311#`\310 \203 \312 !\204d `U\204d \214\n\206* ed}\210\313 \210)`Sf\314>\204d \203D \204d \212\315u\210\312\316!)\204d \307\n\310\311#\211\317=\204d
`\f\202
b\210*!\203\267 `\310 \" #\310f\320=\204} b\210\321\n!\211\"\203\262 \"W\203\262 \"b\210\307\n\310\311#\317=\204\262 \322\306#f\320=\203\251 \323\202\252 \324\"B\"\210\202\266 #b\210* \323=\203:\212\325\326\311\211\211%\203\356 `Sf\327=\203\356 $\203\356 %\203\356 \212\330 \210\312$!\210\330 \210\312%!)\204\276 `Sf\327=\2050\325\331\311\211$\2050`Sf\320=\2050\3321!\3331\334`\335\211#0\202\210\310b\210\3110\202&\210\310\2020\2050\325\336\311\211$?)\203:\324\310B\202= \310B+0\207" [start last-stmt-start lim move tentative-move beg return c-beginning-of-statement-1 nil t looking-at c-backward-sws (59 125 58 nil) -1 "\\s(" macro 123 c-in-knr-argdecl throw previous same c-syntactic-re-search-forward "[;={]" 61 c-backward-token-2 "[;{]" (error) (error) scan-lists 1 ";" c-opt-method-key c-at-vsemi-p-fn c-recognize-knr-p knr-argdecl-start fallback-pos c-overloadable-operators-regexp c-opt-op-identifier-prefix] 6])
(defalias 'c-end-of-decl-1 #[nil "`\3042\240 \305 \210 \203\" `Sf\306=\203\" \307!\203\" \310\311\312\313\314$\210`Sf\315=\203\210 \3161B \3171; \320`\321\211#0\202= \210\312b0\202J \210db\210\322\304\312\"\210\n\203\203 \212`b\210\310\323\n\324Q \314\211\211%\205 \321\224\205 `Sf\325=?\205 \310\326 \314\211\211%\205 `Sf\315=*\204\210 \322\304\314\"\210`Sf\306=\203\225 \322\304\314\"\210\310\327\312\313\314$\204\210 \3120)\207" [start c-recognize-knr-p c-opt-block-decls-with-vars-key lim return c-search-decl-header-end 59 c-in-knr-argdecl c-syntactic-re-search-forward "{" nil move t 123 (error) (error) scan-lists 1 throw "[;=([{]\\|\\(" "\\)" 95 "[;=([{]" ";"] 6])
(defalias 'c-looking-at-decl-block #[(_containing-sexp goto-start &optional limit) "`\306\211\307 \f\310#\210
\2031 `Sf\311=\2031 \310 $\312\306\f\"\2030 \307 \f\310#\210`Sf\311=\204 )%\203\302 `Sf\313=\203\302 ` &\3141N \315`\316\317#0\202P \210\306\211 '\205\\ 'b\210')\203\271 \320 \210\321\322!\317W\204\241 (\323=\203\271 ` )\324\306x\317W\203\230 \325\306x\317W\203\230 \326*!\203\230 \317\225)Y\203\230 \310\202\235 )b\210\306)\203\271 \326+!\204\257 \326,!\203\271 \307 \f\310#\210\310\202\276 &b\210\306)\2041 -\203\327 \327.\n\310\211$\205\316\317\224\211b\210\327/\n\310\211\211%\203)\317\224\211b\21001\232\204\330 2\331\216\212\3260!\205 \332\333\310\"\317U\205 \3263!+?\205\316\333\224\204`\334 \203`\326.!\206%\3264!?\202](\323=\205\316\nb\210\332 \317U\205\316\3265!\205\316\335\333! 6\33667\")\337 8\211 98N*\205\316`\310\205\316-\203\312b\210` W\203\304\326*!\203\254\317\225\335\317! 6\33667\") : ;:\203\241:\340 8\211 98N*\204\241\341\317!\204\250;b\210\342 \210*\202h\327. \343\310$\203\277\317\224\211b\210\202h \202hb\210\202\315 b\210 +\207" [first-specifier-pos kwd-start open-brace c-block-prefix-charset limit c-recognize-<>-arglists nil c-syntactic-skip-backward t 62 c-backward-<>-arglist 41 (error) scan-lists -1 0 c-backward-sws skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" looking-at c-syntactic-re-search-forward match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] c-backward-token-2 1 c-forward-type match-string intern-soft c-modifier-kwds c-protection-kwds c-forward-keyword-clause c-forward-sws move c-parse-and-markup-<>-arglists c-opt-cpp-prefix after-paren dest c-buffer-is-cc-mode pos c-symbol-key c-paren-nontype-key c-noise-macro-with-parens-name-re goto-start c-symbol-start c-decl-block-key c-after-brace-list-key regexp-unmatchable save-match-data-internal c-brace-list-key c-type-decl-prefix-key c-specifier-key keyword c-keywords-obarray lang-constant keyword-sym kwd-sym end] 7])
(defalias 'c-directly-in-class-called-p #[(name) "\304 \211@:\203 A\211\202 @A\211f\305=\205J b\210\212\306@:\203/ A\211\202# @A\307\"\205I \310\n!\205I \311\225b\210\312 \210\310 !)*\207" [paren-state brace-pos c-class-key name c-parse-state 123 c-looking-at-decl-block nil looking-at 1 c-forward-sws] 4])
(defalias 'c-search-uplist-for-classkey #[(paren-state) "\302!\211\205% \212 b\210\303f\304=\205$ \305\306 \"\303\"\205$ \307 \210\310` \"))\207" [paren-state open-paren-pos c-most-enclosing-brace nil 123 c-looking-at-decl-block c-safe-position back-to-indentation vector] 5])
(defalias 'c-most-enclosing-decl-block #[(paren-state) "@:\203
A\211\202 @A@:\203 A\211\202 @A \203N \212 b\210\303\n\304\")\204N \n@:\203E A\211\2029 @A\202& *\207" [paren-state open-brace next-open-brace c-looking-at-decl-block nil] 4])
(defalias 'c-cheap-inside-bracelist-p #[(paren-state) "\302\212 @:\203 A\211\202 @ A\211\203) b\210\303 \210\304 \210\305\306!\203 *\207" [b-pos paren-state nil c-backward-sws c-backward-token-2 looking-at "="] 3])
(defalias 'c-backward-typed-enum-colon #[nil "`\305\212\306\307 \310\"\203y \311\312!\203/ \3131 \314`\315\316#0\202\" \210\305\211\205+ \nb\210\317)\203y \311\320!\204 \306\305f\321\"\203k \212\322 \210\323 \206L \307 \210\311 !)\203k `\305u\210\324 \210\325 \203f \324 \210` =\204y \305\202y \306\305f\326\"\204 \311\f!\204 )\205\202 b\210\317*\207" [colon-pos here dest c-brace-list-key c-symbol-key nil eql c-backward-token-2 0 looking-at "\\s)" (error) scan-lists -1 1 t "::" 58 c-backward-sws c-on-identifier c-forward-sws c-forward-type 40] 5])
(defalias 'c-backward-over-enum-header #[nil "`\306\n\203 \307 \210\310 \311=\203\245 \312\313!\2034 \3141% \315`\316\317#0\202' \210\306\211\2050 b\210\320)\203\245 \312\f!\203I \321 \203I \204I \320\211\202\242 \203` \322\306f\323\"\204[ \312
!\203` \306\202 \312!\204 \312!\204\245 \306f\324=\203\217 \310 \311=\203\245 \312!\204 \203\245 \312!\202\242 \203\241 \306f\325=\203\241 \312\326!\204 \306\204 \312!\206\260 b\210\306*\207" [before-identifier here c-recognize-post-brace-list-type-p dest c-symbol-key c-postfix-decl-spec-key nil c-backward-typed-enum-colon c-backward-token-2 0 looking-at "\\s)" (error) scan-lists -1 1 t c-on-identifier eql 44 40 60 "\\s(" c-after-brace-list-key c-brace-list-key c-decl-hangon-key c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-recognize-<>-arglists] 5])
(defalias 'c-looking-at-or-maybe-in-bracelist #[(&optional containing-sexp lim) "\212`\306=\205 \307\310\211\211\211\211\211\211\211 5 6 7 8 9 : ;\311\312\313<#5\314=\2035\315=\203@ \310f\316=\203z \214<\203K <d}\210\3171X \320`\321\312#0\202Z \210\310)\211 =\205f =b\210\313)\203z \310f\322=\203z \3239\303\211\202\260 \324>!\203\210 \310\2119\202\260 \324?!\204\263 \324@!\203\243 \324A!\204\243 `\211\202\260 \310f\322=\203\257 \313\202\310\203\2125\315=\203\302 \310f\316=\203\371 \214<\203\315 <d}\210\3251\332 \320`\321\312#0\202\334 \210\310)\211 =\205\350 =b\210\313)\205\n\310f\322=\205\n\303\211\202\n\324>!\206\n\324?!\206\n`\310)\203\3239B\203R\310f\326=\203R9\307=\203R\311\312\313<#\315U\2043\310\202L\324B!\203A\313\2118\202L\324\327!\203K\307\202L\310\2119\202 `9\204]\310\202\353\f\203\204\fb\203\204\330 \2115\203\2045b\203\204\331<!@\332=\203\204`\310B\202\353\f\203\231\333 \210`Sf\322=\203\231\f\303B\202\353\n\203\263\212\311\312\313<#\315U\205\253\334 )\203\263\310\202\353
b\2109\307=\203\314\310f\335=\203\312\3109\202x:\203\334\324:!\203\334\3109\202xC\203\356\324?!\203\356\3139\202x\310f\336=\203x\337\2119\337=\203x\311\312\313<#\315U\203xD\203\324D!\203\310\202r\306=\2039\310f\340=\2045\310f\326=\2039`Sf\340=\2039\310\202r\324\341!\203C\337\202r\314=\203q\212`\342\310x\210` E F`Sf\343=\205i\344EF\"?\205i\345 ?+\203q\310\202r\313\2119\202\3719\307=\203\266\310f\316=\204\232\212\333 \210`Sf)\346=\203\232\310\2119\202\270\311\312\313<#\315U\204\266\212C\205\272\311\312\310<#\315=\205\272\310f\322=)\203\305\313\2119\202\270\310\2119\202\2709\203\341\347G!\210` \206\3358B\202\353\f\203\227\212\310f\335=\203\361\350\313!\210`7\324H!\2036\350 \210\310f\343=\2036\351`\352\"\2036\214\f\203e\f}\210\3531\"\320`\312\315#0\202$\210\310)\211 =\2032=b\210=\210)\354 \210\324I!\203M\212\312\225b\210\354 \210`\f)=?\205\207\355\212\333 \210`)\310\211#\2115:\205\2075@\f=\206\2075@\fV\203r\310\202\207\3562\207\2125@b\210\357d\313\310\211\360%\210)\3100)\203\2277 \206\2238B\202\353\310f\335=\204\253\212\333 \210`Sf)\346=\203\257\310\202\353`\2116\203\352\361 \203\352`;=\203\352\362 \210` J;b\210\310u\210\363\364J\313\211$\205\336`Sf\335=?\205\3466\310B)\202\353\313.\f\207" [c-buffer-is-cc-mode c-decl-block-key parens-before-brace in-paren after-type-id-pos pos pike-mode dontknow nil c-backward-token-2 1 t c++-mode 0 44 (error) scan-lists -1 40 c++-noassign looking-at (error) 91 "\\sw\\|\\s_\\|[.[]" c-back-over-member-initializers c-beginning-of-decl-1 same c-backward-sws c-looking-at-c++-lambda-capture-list 59 61 maybe 96 "\\s." "^<>" 60 c-crosses-statement-barrier-p c-in-literal 125 c-beginning-of-statement-1 c-forward-over-token-and-ws get-text-property syntax-table (error) c-forward-sws c-forward-decl-or-cast-1 find-decl c-do-declarators #[(id-start id-end tok not-top func init) " V\203 \302\303\304\"\207 =\205 \302\303\305\"\207" [id-start after-type-id-pos throw find-decl nil t] 3] c-forward-to-cpp-define-body c-end-of-macro c-syntactic-re-search-forward "[;,]" res macro-start bufpos inexpr-brace-list braceassignp class-key start lim dest c-pre-id-bracelist-key c-return-key c-symbol-start c-keywords-regexp c-opt-inexpr-brace-list-key c-has-compound-literals c-opt-op-identifier-prefix pos< here containing-sexp c-opt-<>-sexp-key c-class-key macro-end] 12])
(defalias 'c-inside-bracelist-p #[(containing-sexp paren-state accept-in-paren) "\212b\210\305 \205\n `)\206w \212\306\307\n\306=\203c \203c \2034 @:\203. A\211\202\" @ Ab\210\310 \211\"\203D \307\211\202 \307f\311=\204Q \307\211\202 \312 \211\"\211\306=\203 \307\202 \n:\205v \f\204t \nA\313=?\205v \n@+\207" [containing-sexp next-containing bufpos paren-state accept-in-paren c-backward-over-enum-header t nil c-looking-at-inexpr-block 123 c-looking-at-or-maybe-in-bracelist in-paren] 4])
(defalias 'c-looking-at-special-brace-list #[(&optional _lim) "\205\277 \3051\275 \212`\306\211\211 \307 \210\306f\310=\203+ \311u\210\307 \210`\306f\236\202E \306f\236\211\203E `\312 \210\313u\210\306f\310=\205D `\f\205\272 \205\272 \3141e \fb\210\315`\311\"b\210``Sf\316U0\202i \210\202\266 \203\266 \3171\226 b\210\320\321!\203\203 \315`\311\"b\210\322\202\222 \nb\210\313u\210\312 \210`Sf AU0\202\230 \210\306\203\266 `Sfz\316U\203\256 \307 \210`\nSU\205\272 \f\nB B\202\272 \fC B-0\207\210\306\207" [c-special-brace-lists type end inner-beg beg (error) nil c-forward-sws 40 1 c-backward-sws -1 (error) scan-sexps 41 (error) looking-at "\\s(" t] 4])
(defalias 'c-looking-at-bos #[(&optional _lim) "\300 \207" [c-at-statement-start-p] 1])
(make-obsolete 'c-looking-at-bos 'c-at-statement-start-p "22.1")
(defalias 'c-looking-at-statement-block #[nil "`\3041 \305`\306\307#0\202 \210\310\211\205 b\210 )\203i `\311u\210\312\313\314#\210`Sf\315=\2035 \314\202e `Sf\316=\203A \310\202e \317 \210`\nS=\206e \320 \n\314#\206e \320\321\n\314\211$\203d \311u\210\322 \202e \310)\202\237 \310u\210\320\323\310\314\211$\203} `Sf\315=\202\237 \317 \210m\206\237 \320 \310\314\211$\206\237 \320\321\310\314\211$\203\236 \311u\210\322 \202\237 \310b\210)\207" [here dest there c-keywords-regexp (error) scan-lists 1 0 nil -1 c-syntactic-skip-backward "^;," t 59 44 c-forward-sws c-syntactic-re-search-forward "{" c-looking-at-statement-block "[;,]"] 6])
(defalias 'c-looking-at-inexpr-block #[(lim containing-sexp &optional check-at-end) "\212\306\307\310\211\211\206 \206 e\310f\311=\205 ` 0 1 23\312=\203T \212\313\314 \315#\210`Sf\316=\203C \317 \203C \3204!\203) \3204!\205K `)\211\203T \fb\2102\306=\203\346\321 \210` V\203\346o\204\346\322u\210\320\323!\203\346\3241\201 \310u\210\325`\322\"b0\202\203 \210\310\203\346\3205!\203t\326\327! 6\33067\") 8\n\2038\331 9\211 :9N*\203
\332=?\205p\320;!\203` <\317\327\310 #\307U\203\327 \310fz\333=\203\327 `<\202\277 <b\210\334 )\203\212=\205\376 3\335=\205\376 \nb\210\336\327\315\"\307U\205\376 \310f\337=)\205p\340`B\202p8\341 9\211 :9N*\203#\310\3071\3100\306\202p8\342 9\211 :9N*\203=
?\205p\343`B\202p8\344 9\211 :9N*\203\\
\203V
\337=\205p\345`B\202p8\346 9\211 :9N*\203o\310\202p\306)\202\340\320\347!\203\337
\203\306
\332=\203\234\310f\332=\203\234`Tf\332=\204\2341T1\306\202\340
\337=\203\302\310f\332=\203\302`Tf\332=\204\3021\307=\203\302\3271`0\306\202\340\310\202\340\320\350!\204\333\310f\211\332=\203\333\3271`0\306\202\340\306\2112\202V 2\306=\203\3203\312=\2031\n\20311\327=\2031\2120b\210` \206\neX\206&\317\327\310 #\210\351 \205 \320>!?\205&\320?!?)\2031\3450B\202\322@\205\322\n\205\322\205\322f\337=\205\322b\210\212\214 \206Oed}\210\321 \210)`Sf\316=\203\237\352`S\353\"\203\237\214 \203o d}\210\3541|\355`\322\307#0\202~\210\310)\211 A\205\213Ab\210A)\203\237\214 \206\225ed}\210\321 \210)\202V` \206\245eV\205\253\351 )\206\306B\203\271\356 \206\306C\205\306\212\nb\210\357 )??\205\322\343`B\202\3222.\207" [containing-sexp lim block-follows closest-lim haskell-op-pos passed-paren maybe 0 nil 123 c++-mode c-syntactic-skip-backward "^;=}>" t 62 c-backward-token-2 looking-at c-backward-sws -1 "[]).]\\|\\w\\|\\s_" (error) scan-sexps match-string 1 intern-soft c-inexpr-class-kwds 91 119 c-at-statement-start-p pike-mode c-forward-token-2 40 inexpr-class c-paren-any-kwds c-inexpr-block-kwds inexpr-statement c-lambda-kwds inlambda c-block-stmt-kwds "\\s(" "\\[\\[" c-on-identifier get-text-property syntax-table (error) scan-lists c-looking-at-special-brace-list c-looking-at-statement-block bracket-pos passed-bracket-pairs res c-buffer-is-cc-mode c-haskell-op-re c-keywords-regexp keyword c-keywords-obarray kw-sym lang-constant keyword-sym c-class-key prev check-at-end c-symbol-chars c-opt-op-identifier-prefix c-recognize-paren-inexpr-blocks dest c-special-brace-lists c-has-compound-literals] 9])
(defalias 'c-looking-at-inexpr-block-backward #[(paren-state) "\212`\242\304\n:\2059 \nAb\210\214e \206 d}\210\305 \210)` U\2059 \n@b\210A\211\2032 \242\306\307 \" \",\207" [paren-state containing-sexp elem here nil c-forward-sws c-looking-at-inexpr-block c-safe-position] 4])
(defalias 'c-looking-at-c++-lambda-capture-list #[nil "\301f\302=\205, `Sf\302=?\205, `Tf\302=?\205, \212\303\304!\304=\206% \305!)\205, \306 ?\207" [c-pre-lambda-tokens-re nil 91 c-backward-token-2 1 looking-at c-in-literal] 2])
(defalias 'c-at-macro-vsemi-p #[(&optional pos) "\212\214~\210\203 b\210\202 ` \205\321 \306\307x\310=\205\321 \306\307w\205\321 \311\312!\203P \310\225b\203P \311\n!\203@ \313\314!\203P \306\307w\202M \311 !\203L \307\210\202P \307\204\" l\205\321 b\205\321 \315 \210`=\205\321 `Sf\316=\203\211 \3171w \320`\321\310#0\202y \210\307\211 \205\202 \fb\210\f)\205\321 \315 \210\322\323!\310W\204\303
\324=\205\321 `\325\307x\310W\203\273 \326\307x\310W\203\273 \311!\203\273 \310\225Y\203\273 \327\202\277 b\210\307)\205\321 \311 !\205\321 b\205\321 \330 ?*\207" [pos c-macro-with-semi-re c-block-comment-start-regexp c-line-comment-start-regexp dest c-buffer-is-cc-mode " " nil 0 looking-at "\\(\\\\[\n
][ ]*\\)*" forward-comment 1 c-backward-sws 41 (error) scan-lists -1 skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" t c-in-literal c-symbol-key] 5])
(defalias 'c-macro-vsemi-status-unknown-p #[nil "\300\207" [t] 1])
(defvar c-auto-newline-analysis nil)
(defalias 'c-brace-anchor-point #[(bracepos) "\212\212b\210\303 \210`)b\210` V\203 \304\n!\204 \305 \210\202 ` V\203* `\202+ *\207" [bracepos boi c-other-decl-block-key back-to-indentation looking-at c-backward-token-2] 2])
(defalias 'c-add-syntax #[(symbol &rest args) " B\nB\211\207" [symbol args c-syntactic-context] 2])
(put 'c-add-syntax 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-append-syntax #[(symbol &rest args) " \nBC\244\211\207" [c-syntactic-context symbol args] 3])
(put 'c-append-syntax 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-add-stmt-syntax #[(syntax-symbol syntax-extra-args stop-at-boi-only containing-sexp paren-state &optional fixed-anchor) "`\212\306 \210`)U\203 \307\310` $\207\n\212\306 \210`)\212\306 \210`)\311 1\307\310\3122\"\2051 ` $\210\3132\375 `
U\203I \204I \3143!\205\374 ` 44
U\204e \315 \203e `4\212\306 \210`)\202L 4b\210)`
\3165! 6 7 8\212\306 \210`)6\317=`8U\203\221 \320\313\321\"\210\202\370 6\322=\203\261 `7Y\203\261 \314\323!\203\261 \2128b\210\314\324!)\204\370 9\204\321 87U\204\321 6\325>\203\321 8b\210\320\313\311\"\210\202\370 9\204\340 6\326>\203\340 \32196\322=\203\370 \327\311C :\211 ;:B\nB\211*\210+\2028 0\203\3745\203\374<\2035\fV\203\3745b\210=\2035\330 \211 >\2034>@@`W\2034>@@\2115b\210)\3315?\"?\332?!5\212\306 \210`)`\311f\311 6 @ A@\333=\203\317A
U\204\267B\203\244\2145\206ned}\210\334 \210)\314\335!\203\200\336 \204\244\212ATb\210\337 \210\311f)\340=\203\244\341\311 :\211 ;:B\nB\211*\210\202\267\342\311AD :\211 ;:B\nB\211*\210
5\203\3035T\202\304e]b\210\3436\311\202\343\3165!\2116\317=6\343=\203\322A`U\204\322\311\211 C D\212Ab\210\344\3455?\"5\"\211D)\203#D@\346=\203\347\202\350\311C :\211 ;:B\nB\211*\210\202\316\314E!\203P\351\352\353!2\"A\212Ab\210\306 \210`)`]C :\211 ;:B\nB\211*\210\202\316\354A?\311#\203\215\212Ab\210\355 )\203y\347\311C :\211 ;:B\nB\211*\210\202\316\356\311C :\211 ;:B\nB\211*\210\202\316\212Ab\210\3575\211\"\211C:\205\243CA\360=)\203\275\356C@C :\211 ;:B\nB\211*\210\202\316\347\311C :\211 ;:B\nB\211*\210*\202\343\350\311C :\211 ;:B\nB\211*\210A
U\203\361Ab\210\202\370\212\306 \210`)+\2024 \n\311 F\211 G1=?\205AG@A\211F\2038F@\204/FGA\204'<\204+`\202-<\240\210FA\211F\204GA\211G\202.\207" [syntax-symbol syntax-extra-args c-syntactic-context on-label anchor-boi boi back-to-indentation apply c-add-syntax nil rassq back-up-block looking-at c-backward-single-comment c-beginning-of-statement-1 label throw t up "else\\>[^_]" "if\\>[^_]" (up previous) (up previous beginning) substatement c-looking-at-special-brace-list c-whack-state-after c-most-enclosing-brace 40 c-backward-sws "\\>" c-on-identifier c-forward-sws 123 inexpr-statement arglist-cont-nonempty same c-looking-at-inexpr-block c-safe-position inlambda defun-block-intro statement-block-intro assoc match-string 1 c-inside-bracelist-p c-looking-at-statement-block brace-list-intro c-looking-at-or-maybe-in-bracelist in-paren syntax-last c-other-decl-block-key-in-symbols-alist c-comment-start-regexp savepos containing-sexp step-type old-boi old-pos stop-at-boi-only args symbol fixed-anchor c-special-brace-lists special-list paren-state paren-char paren-pos c-recognize-paren-inexpr-blocks bspec inexpr c-other-decl-block-key q p] 7])
(defalias 'c-add-class-syntax #[(symbol containing-decl-open containing-decl-start containing-decl-kwd _paren-state) "b\210 \306=\203$ `\212\307 \210`)U\203$ C\211\nB B\211*\210\207\fb\210\307 \210 `C\211\nB B\211*\210
\310 \211 \f N*\203a \f\212\fb\210\307 \210`)U\204a \311\312\211\nB B\211*\210`\207" [containing-decl-open symbol args c-syntactic-context containing-decl-start containing-decl-kwd inclass back-to-indentation c-inexpr-class-kwds inexpr-class nil lang-constant keyword-sym] 3])
(defalias 'c-guess-continued-construct #[(indent-point char-after-ip beg-of-same-or-containing-stmt containing-sexp paren-state) "\306\211\nb\210\307\306w\210 \203 \310 \206 \f\311=\211\203\301 \212\306f\311=\205/ \312
\313\"\205/ `\211-)\203I \314-C .\211 /.B0B\2110*\202 :\204Y \315`
1B\306#\203q \316
!\210\3172\203g \320\202h \321\306\211
1%\202 \322 \204\236 \316
\306\211\313$\323=\203\236 \212\306 3\324\212\325 \210`)\306\211#*\203\236 \317\326\306\313
1%\202 \nb\210\327 \210\3304!\203\266 \317\321\306\313
1%\202 \317\331\306\211
1%\202 \330\332!\203\363 \212-b\210\333\332\n\334\313\211%\205\357 \335\212\336 \210`)C .\211 /.B0B\2110*\210\313)\206 \212\337 \210\306f)\311=\203,\322 \204,\316
\306\211\313$\323=\203,\212\306 3\324\212\325 \210`)\306\211#*\203,\317\340\306\313
1%\202 5\341=\203q`\211\203q\316 \203q\342 \203O`W\203O\337 \210\202>`Yb\210\203q\316
!\210\343`C .\211 /.B0B\2110*\202 5\344=\203\377\212\nb\210\3451\211\346`\347\350#0\202\213\210\306\211\205\264f\351=\205\264\206\234`Sf\351U?\205\264Tb\210\3306!?\206\264\3307!)\203\377b\210\316
\313\"\210\212\214
\206\307ed}\210\325 \210)`Sf)\351=\203\346b\210\352\353
\313#\210\337 \210\202\351\336 \210\354`D .\211 /.B0B\2110*\202 \316
!\210\317\321\306\211
1%*\207" [placeholder special-brace-list indent-point c-special-brace-lists char-after-ip containing-sexp nil " " c-looking-at-special-brace-list 123 c-looking-at-decl-block t class-open c-inside-bracelist-p c-beginning-of-statement-1 c-add-stmt-syntax brace-list-open statement-cont c-at-statement-start-p same c-forward-decl-or-cast-1 c-backward-sws defun-open backward-sexp looking-at substatement-open "\\(<<\\|>>\\)\\([^=]\\|$\\)" c-syntactic-re-search-forward move stream-op back-to-indentation c-forward-sws func-decl-cont java-mode c-forward-annotation annotation-var-cont c++-mode (error) scan-lists -1 1 60 c-syntactic-skip-backward "^,;" template-args-cont beg-of-same-or-containing-stmt args symbol c-syntactic-context paren-state c-auto-newline-analysis c-recognize-typeless-decls c-return-key c-buffer-is-cc-mode c-<-op-cont-regexp c-<-pseudo-digraph-cont-regexp] 7])
#@51 Return the syntactic context of the current line.
(defalias 'c-guess-basic-syntax #[nil "\212\306 \210\307 \310\211\310\311\216` \312\211 @\312\211 A B\312\211 C D\312\211 E F\312\211 G H\312\211 I J\312\211 K L\312\211 M N\312\211 O P\312\211 Q R\312 S\313 T\314T! U\312 VW W\315T!\211R\203\247 Rb\210\312f\316=\203\247 \317\315TR\"\310\"\211G\203\247 RO`P\312RGb\210\320X!\205\245 \321\322! J\323JY\")QT\203\377 T@RTATR:\203\367 \212RAb\210Z\324=\203\324 \325 \203\324 \326\327\312\310#\210`ST\203\351 T@RTAT\202\363 RTBT\312R)\202RTS\202eSR\203Rf\330=\203\310W\fb\210\214S\206 ed}\210\331 \210)`B`SfA\fb\210\332\312w\210\312fC\333S!\211@\334=\203Z\334\335\336!C [\211 \\[BFB\211F*\210\202\303 @\337>\203\203\340S!\211G\203\203@GC [\211 \\[BFB\211F*\210\202\303 \212\341 \205\215`\211D)\203\356D\212\342 \210`)U\204\356\343I]\203\323\212Db\210\344 \203\313\212\fb\210\342 \210`) ^`^VE\345I`^U)\202\317\310E\312)\203\356IDC [\211 \\[BFB\211F*\210\312D\202\303 \320\346!\203\347R!\210\350\351\312\310RT%\210\202\303 \320\352!\203+\212\347R!\353=`G)\203+Gb\210\350\354\312\310RT%\210\202\303 \212Z\355\267\202?\320\356!\202@\320\357!\202@\312\205\247\3601U\331 \210\361`\362\"b\210\3100\202Z\210\312\202\247\205\247\312f\316=\205\247\3631v\331 \210\361`\362\"b\210\3100\202{\210\312\202\247\205\247\312f\330=\203\231\3641\224\361`\362\"b\210\3100\202\232\210\312\202\247\310\205\247\320\365!\205\247`\211G)\203\274Gb\210\350\366\312\310RT%\210\202\303 \212_\205_A\367=?\205_`\205\324`B!?\205_C\370>?\205_A\371=\203\356\372U!\205_``G\347S!\211H\373=\204\362H\374=\203\fGb\210\202>`GH\375=\203>\320_!\204>\312 a\347S!\211a\373=\204 a\376=\2039`G\202=Gb\210)GV\205_\320b!\203[\377\322\312\"\336U\205_\312f\330=\202_\320_!)\203\302H\376=\203\261Gb\210C\316=\203\204\350\201\214 \312\211RT%\210\202\303 \212\fb\210\342 \210\201\215 )\203\242\350\201\216 \312\211RT%\210\202\303 \350\201\217 \312\211RT%\210\202\303 \201\220 \fCGST%\210\202\303 \212\320c!\205dZ\201\221 =\206dR\205dRb\205d\312f\316=\205d\331 \210`Sf\201\222 =\205d\201\223 1\201\224 `\362\336#0\202\210\312\211 d\205db\210d)\205d\331 \210\201\225 \201\226 !\336W\204`Z\201\227 =\205d` e\201\230 \312x\336W\203W\201\231 \312x\336W\203W\320f!\203W\336\225eY\203W\310\202\\eb\210\312)\205d\320b!)\203\301R\203\251Rb\210\315UR\"\211S S`\212\342 \210`)U?\205\230\201\232 S!\211 g\205\227gb))\210\350\201\233 \312\310ST%\210\202\303 \201\233 eC [\211 \\[BFB\211F*\210\202\303 \212\342 \210\320h!?\205\331\320c!?\205\331\201\215 )\203\203O\203\201\234 \201\235 OPQT%G\201\236 GC [ \\F\\[BC\244\211F*\210\202\303 R\203kRb\210\315UR\"S\212\347S!\376=\2037\320\201\237 !\2037\201\233 \2028\373I)S S`\212\342 \210`)U?\205[\201\232 S!\211 g\205Zgb))\210\350I\312\310ST%\210\202\303 \201\236 eC [\211 \\[BFB\211F*\210\202\303 \201\240 \201\241 RT\"R\310#\211G\203\364G@\201\242 \236\211I\203\255IAI\202\277C\316=\203\272\201\243 \202\275\201\244 IGAb\210\342 \210\350I\312\310\315U`\"T%\210`GA=\204\303 G@\312 [\211 \\[BFB\211F*\210\202\303 O\204\376R\204Hi\203\n\201\245 \206C\316=\211L\203\315\212\312 jC\316=\205S\317R\310\"\211j\205S`Gjb\210\320f!\205S\321\336!\211J J\323JY\")\201\246 k\211 lkN**\203\200Gb\210\350J\201\247 \230\203k\201\250 \202u\201\251 J\201\252 P!\312\310RT%\210\202\303 \212\fb\210\332\312w\210\312f\316=\205\233\317R\310\"\205\233`\211G)\203\270\201\253 GC [\211 \\[BFB\211F*\210\202\303 \212\fb\210\332\312w\210\201\254 \203\323\212\342 \210`)\211G\202\373\201\255 RS\"\211G:\205\373GA\205\353\201\256 I\212G@b\210\342 \210`)\211G)\203Hm\204/I\201\256 =\203/\347S!\210\201\256 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 \201\257 GC [\211 \\[BFB\211F*\210\202\303 O\203\205Q\201\246 k\211 lkN*\204\205\201\243 \312 [\211 \\[BFB\211F*\210\201\234 \201\235 OPQT%\210\202\303 \212\201\260 S!\210\320n!\203\234\201\261 \322!\202\254o\203\257\320p!\203\257\201\262 \204\215\201\263 \212\342 \210`)C [\211 \\[BFB\211F*\210)\202\303 \212Z\324=\205\343\201\264 \211G\205\343`\211M)\2037\212\331 \210`)MTU\203Gb\210\201\265 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 MTb\210\201\266 \210\201\267 `C [\211 \\[BFB\211F*\210\202\303 \212\201\270 S\201\271 \201\272 !]!\211G\205P`\211M)\203\346Mf\201\273 =\203Gb\210\201\265 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 q\203\304\201\274 S!\203\304\347S!\210\201\275 \212\342 \210`)C [\211 \\[BFB\211F*\210O\203\303 \201\234 \201\235 OPQT%\210\202\303 \347S!\210\201\276 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 Z\324=\203 C\201\277 =\203\375\332\312w\210\312u\210\320r!\204\313 A\201\273 =\2048 \212C\201\273 =\2054 \201\300 1% \322u\210\3100\202* \210\312\2024 \2054 \312f\201\273 =?)\203a \212\347S!\210\320s!\203Y \322\225b\210\201\266 \210\201\301 \312!\210\201\266 \210\320t!)\204\313 Z\201\302 =\203\322\n\212\347S!\210`)\312\211 u v w\212u\204\271 \320r!\203\223 v`BK\310u\202\263 \201\303 1\244 \361`\362\"b\210\3100\202\246 \210\312\203\260 `wX\203\263 \310u\310v\202{ )K+\203\322\n\201\304 KA`\"\204\322\nC\201\273 =\203\366 \347S!\210\201\305 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 A\201\273 =\2036\n\347S!\210\201\305 \212\342 \210`)C [\211 \\[BFB\211F*\210O\203\303 \201\234 \201\235 OPQT%\210\202\303 K\203\263\nKAK@ v\211 xb\210\320\201\306 !\203r\n\201\276 \347S!\210\212\342 \210`)C [\211 \\[BFB\211F*\210\202\257\nv\203\220\n\201\307 xC [\211 \\[BFB\211F*\210\202\257\n\201\305 KAb\210\347S!\210`C [\211 \\[BFB\211F*\210*\202\303 \201\310 S!\210\201\307 `C [\211 \\[BFB\211F*\210\202\303 Z\201\311 =\203 `G\350\347 \375=\203\363\n`GU\204\363\n\201\256 \202\366\n\201\312 \312\211RT%\210\202\303 \212y\203l \326\201\313 S\310#\210`SV\203u z\203/ \201\314 S!\211G\203/ Gb\210\202 `Sf\201\315 =\203I \201\316 \312S\"\204 \362u\210\202 `Sf\201\317 =\203u \362u\210\212\201\301 \312!)\203 \312u\210\202u \202 \202u \326\201\320 S\310#\210`G`Sf\201\321 >)\203W
\212G\206\212 `Sf\201\322 =\205\330 Gb\205\330 \201\323 \322\312S#\336=\205\330 `GS=\205\330 \347S!\375=\205\330 \320{!\205\330 ` |\377\322\312\211#\336=\205\327 \201\324 \205\327 |\211G))\203\365 \201\325 GC [\211 \\[BFB\211F*\210\202\303 Z\324=\203{\f\212\214\fb\210\201\326 1\f\201\224 `\362\322#0\202\f\210\312\211G\205!\fGf\201\317 =*\203{\fGb\210\347S\310\"\210\212\214S\2067\fed}\210\331 \210)`Sf)\201\317 =\203^\fGb\210\326\201\327 S\310#\210\201\266 \210\202a\f\342 \210\201\330 `GD [\211 \\[BFB\211F*\210\202\303 Z\324=\203
\212\347S!\210`G\320\201\331 !\203\231\f\377\322\312\f#\210\320t!\205\340\f\377\201\332 \312\f#\336U\205\340\f\312f\201\317 =\203\277\f\377\322\310\f#\336U\202\300\f\310\205\340\f`\fW\203\332\f\320}!\203\332\f\377\322\312\f#\336U\204\303\f\312f\201\273 =)\203
Gb\210\201\307 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 `\211G\203,
\201\260 R!@\375=\203,
\212\331 \210`Sf)\371=\203,
`GW\204
\350`G=\203:
\201\333 \202L
A\201\277 =\203I
\201\256 \202L
\201\325 \312\211RT%\210\202\303 C\371=\203\243
Q\201\246 k\211 lkN*\203\243
Pb\210\350\201\334 Q!\201\247 \230\203\207
\201\335 \202\225
\201\251 \201\334 Q!\201\336 P!\312\310\315T`\"T%\210\202\303 R\203\312
C\371=\203\312
OR=\203\312
\201\234 \201\337 OPQT%\210\202\303 q\203R\204A\371=\204\212\201\260 S!A\211G\205\363
_\205\362
\320_!?)\203G\fW\203Gb\210\201\340 `C [\211 \\[BFB\211F*\210\202\303 ~\203Q\320~!\203Q\347\312\310\"\210`\fU\2034eb\210\201\341 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 \214S\206Xed}\210\331 \210)`Sf\371=\203\340\212` gU\203\206U@:\203\206U@A`=\203\206U@@b\210\201\260 R!\210`Gg`U?\205\240\201\342 \210`\fY*\203\340\212U\205\256U@:?\206\311Gb\210\201\343 \201\344 \f\310#\205\311`SU@@=)\203\340Gb\210\350\201\256 \312\211RT%\210\202\303 D\203\354\fDV\204\212`GA\201\345 >\206m`\203`B!\206mA\201\273 =\203-\347S!\373=\203-\214S\206 ed}\210\331 \210)`\211G\206mZ\201\346 =\205m\201\347 2m\347S!\210`G\201\350 \203k`\fW\203k\201\266 \210`\fY\203e\201\351 \201\347 \310\"\210`G\202D\3120)\203Gb\210\201\312 \335 C [\211 \\[BFB\211F*\210O\203\351Q\201\246 k\211 lkN*\203\331\201\352 O!b\210\350\201\334 Q!\201\247 \230\203\275\201\353 \202\313\201\251 \201\354 \201\334 Q!P!\312\310\315T`\"T%\210\202\351\201\234 \201\235 OPQT%\210]\203\303 D\203\303 D\212\fb\210\342 \210`)U\204\303 \345\312 [\211 \\[BFB\211F*\210\312D\202\303 ~\203P\212\347S!\210\306 \210\320~!\2053`\211G)\203P\201\355 GC [\211 \\[BFB\211F*\210\202\303 y\203\224`Sf\201\317 =\203\224z\203m\201\314 S!\204\224\347\201\241 `T\"!\210\201\330 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 D\203\255\347R!\210\350\201\333 \312\310RT%\210\202\303 Z\201\302 =\203\371`\211G\203\371\347 \203\371\201\356 \203\321\201\266 \210\202\302`GYGb\210\203\371\201\357 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 \347\201\241 `T\"!\210Z\201\346 =\203+`G\201\350 \203'`\fW\203'\201\266 \210`G\202Gb\210\201\256 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 i\203Z\212Rb\210\201\245 )\204\370Rf\316=\204\370C\201\360 >\203\270Rb\210\212\342 \210`)G\201\361 1\210\201\362 \322!\210\3100\202\214\210\202\240\203\240`GY\203\240\312u\210\332\312w\210\202\244Gb\210\350\201\363 RC\310\315T`\"T%\210\202\303 C\316=\203FRf\330=\203\341\212\205\335\347S\310\312\310$\375=\205\335\320!)\203F\201\364 `T\312#\211G\203\370\201\365 \211I\202\201\366 I\201\240 \201\241 RT\"R\"\243\211G\203FGb\210\342 \210\350I@\312\310\315T`\"T%\210`GU\204\303 IA\312 [\211 \\[BFB\211F*\210\202\303 A\201\367 >\203\234Rb\210\212\342 \210`)G\201\370 1l\201\362 \322!\210\3100\202p\210\202\204\203\204`GY\203\204\312u\210\332\312w\210\202\210Gb\210\350\201\371 RC\310\315T`\"T%\210\202\303 Rb\210\201\372 1\261\361`\362\"b\210\3100\202\265\210\202 \203 \320\201\373 !\203 RTb\210\214e\f\206\314d}\210\201\266 \210)A\367=\203\363\201\333 `C [\211 \\[BFB\211F*\210\202\303 \201\325 `C [\211 \\[BFB\211F*\210\202\303 ~\203iRf\201\374 =\203iRSb\210\214\212\312\211 \200 \201\201\375 \210*\202\203=\320\202!\203=\336\225b\210`)\206Ced}\210\331 \210)\320f!\204i\201\376 RC [\211 \\[BFB\211F*\204\303 RTb\210\212\201\266 \210`)\335\201\332 !W\203\314Rb\210\212\342 \210`)G\201\377 1\234\201\362 \322!\210\3100\202\240\210\202\264\203\264`GY\203\264\312u\210\332\312w\210\202\270Gb\210\350\201 RC\310\315U`\"T%\210\202\303 \214e\f\206\323d}\210\201\266 \210)\201\212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 Z\324=\203\217\212\fb\210\332\312w\210\320r!)\203\217\fb\210\332\312w\210C\201\273 =\203J\214S\206&ed}\210\331 \210)\201\305 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 A\201\273 =\203p\201\305 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 \201\310 S!\210\201\307 `C [\211 \\[BFB\211F*\210\202\303 Z\201\311 =\2048i\203\252\212Rb\210\201\245 )\206\263\201\364 RT\310#\211L\2038L:\203K\212Rb\210\312f)\330=\203KCLA@=\203KL@@b\210\332\312x\210n\203\374\201\201\325 \201 \211G\"\203\374GF\202\303 \347\201\241 RST\"!\210\377\336!\210\320n!\203\201\261 \322!\202+o\203.\320p!\203.\201\262 \204\f\201\257 \212\342 \210`)C [\211 \\[BFB\211F*\210\202\303 L:\203\215L@@b\210\212\fb\210\342 \210\312f\201\222 =\203q`TL@A=\206\211\312fLAA=\205\211\377 \336U\205\211`TL@A=)\202\277C\371=\203\2011\264\2011\253\201\224 `\362\322#0\202\255\210\312b\210\3100\202\270\210\202\203`RU\203`\212\342 \210`)=\203\345\201`C [\211 \\[BFB\211F*\210\202\303 \212\201\264 \205\356`)\206\367\315U`\"S\347S\312\211\310$\210\350\201\312\310ST%\210\202\303 \fb\210\347R\312\211\310$\210`\fU\204}\212\342 \210`)RV\2038\212\342 \210`)b\210\202}L:\203ML@@b\210\377\322\312\f#\210\202QRb\210\312u\210\f\206Yd \203\201\203w\210\312f\201=\203|`\203W\203|\312u\210l\204[\362u\210)`\fU\203\344L:\203\222L@@b\210\202\226Rb\210`\212\342 \210`)=\203\271\201 `C [\211 \\[BFB\211F*\210\202\303 \212\201\264 \205\302`)\206\313\315U`\"S\347S\312\211\310$\210\350\201 \312\310ST%\210\202\303 C\316=\204i\203'\212\fb\210\214e\201\n \206\376d}\210\201\266 \210)\201\245 `!)\203'\201 `C [\211 \\[BFB\211F*\210\202\303 \350\201\f\312\310RT`&\210\202\303 A\201
>\204\205`\203N`B!\204\205A\371=\203\\\372U!\203\205`\212\347R!\210`\211G)V\203\205GRU\204\205\201\220 \fCGRT%\210\202\303 C\371=\203\216\315T!SRb\210\201\232 \203\316S S`\212\342 \210`)U?\205\275\201\232 S!\211 g\205\274gb))\210\350\201\312\310ST%\210\202\303 \201\240 \201\241 RT\"\312\"\211G\203PG@\201=\203\361\201\202\364\201IRb\210\342 \210R`U\203I`C [\211 \\[BFB\211F*\210\202\303 GAb\210\342 \210\350I\312\310\315T`\"T%\210`GAU\204\303 G@\312 [\211 \\[BFB\211F*\210\202\303 \212S\205jSb\210\317\315TS\"\312\"\205j`\211G)\203\304S S`\212\342 \210`)U?\205\202\347S!)\210\342 \210\212Gb\210\320\204!)\203\254\201`C [\211 \\[BFB\211F*\210\202\303 \201`C [\211 \\[BFB\211F*\210\202\303 \212\201 ?\205\360\347S\312\211\310$\375=\205\360`\211G\205\360\312 \205\201\212\331 \210`)\312\211#))\203\342 \210`RU\204Gb\210\350\201\312\310ST%\210\202\303 S\203c`\211G\212\342 \210`)U\204-\347S!\373=\204Gb\210\320c!\203P\201`C [\211 \\[BFB\211F*\210\202\303 Rb\210\350\201\312\310ST%\210\202\303 Rb\210S S`\212\342 \210`)U?\205{\347S!)\210\350\201\312\211\315T!T%\210\202\303 y\203\373\214R\203\236Rd}\210\2011\257\201\224 \f\362\322#0\202\261\210\312)\211N\203\373Nf\201\317 =\203\373\212Nb\210\342 \210`)GRb\210`GY\203\343\312u\210\332\312w\210\202\347Gb\210\350\201\330 NC\310\315U`\"T%\210\202\303 \fb\210` \206\347R! \207`\206U\203H\206\207H\312\202(\207H`\212\342 \210`)U?*\204\376H\375=\203H`\fU\204H\350\201\325 \312\211RT%\210\202\303 H\373=\203`\320c!\204`\347R!\211H\202JH\373=\203\203\350C\316=\203u\201\202x\201\312\310RT%\210\202\303 H\373=\203\224\347R!\211H\202\205H\374=\203\305\350\201\333 \312\310RT%\210C\316=\203\303 \201\312 [\211 \\[BFB\211F*\210\202\303 Rb\210\315TR\"S\201\232 \203$S S`\212\342 \210`)U?\205\370\201\232 S!\211 g\205\367gb))\210\350\201\312\310ST%\210C\316=\203\303 \201\312 [\211 \\[BFB\211F*\210\202\303 \201\240 \201\241 RT\"\312\"\211G\203\275G@\201=\203G\201\202J\201I\342 \210R`U\203mI`C [\211 \\[BFB\211F*\210\202\237GAb\210\342 \210\350I\312\310\315U`\"T%\210`GAU\204\237G@\312 [\211 \\[BFB\211F*\210C\316=\203\303 \201\312 [\211 \\[BFB\211F*\210\202\303 \212\315T!\211G?\206\334Gb\210\312f\316=\205\334\317\315T`\"\312\")\203 S S`\212\342 \210`)U?\205\364\347S!)\210\342 \210\201`C [\211 \\[BFB\211F*\210\202\303 \212\201 ?\205= \347S\312\211\310$\375=\205= `\211G\205= \312 \205\201\212\331 \210`)\312\211#))\203^ \342 \210`RU\204O Gb\210\350\201\312\310ST%\210\202\303 `\211G\212\342 \210`)U\204u \347S!\373=\204^ Gb\210\320c!\203\230 \201`C [\211 \\[BFB\211F*\210\202\250 Rb\210\350\201\312\310ST%\210C\316=\203\303 \201\312 [\211 \\[BFB\211F*\210\fb\210\332\312w\210\320\210!\203\364 \377\336\312\201\n #\336U\204\364 \201\312 [ \\F\\[BC\244\211F*\210\211\203 \320\211!\203 \201\312 [ \\F\\[BC\244\211F*\210F\211 \212\203\\ \212@\211 \213A:\2030 \213A\242\2023 \213A)\250\203S \212@\211 \213A:\203J \213A\242\202M \213A)V\202\\ \212A\211\212\204 )D\203\233 D\212\342 \210`)=\203\233 Z\201\227 =\203\202 DTf\201 =\204\233 \201 \312 [ \\F\\[BC\244\211F*\210\202+ ]\203+ D\203+ E\203\360 VDW\204\326 \201\371 F\236\204+ \201F\236\204+ \201 F\236\204+ \201\363 F\236\204+ \312F\343DC [\211 \\[BFB\211F*\210\202+ DV=\203+ \345F\236\204+ \212Db\210\344 ?\206 `\212\fb\210\342 \210`)X)\203+ \345\312 [\211 \\[BFB\211F*\210F. \207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks indent-point case-fold-search beginning-of-line buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil c-parse-state copy-tree c-most-enclosing-brace 123 c-looking-at-decl-block looking-at match-string 1 intern-soft c++-mode c-back-over-member-initializer-braces c-syntactic-skip-backward "^}" 40 c-backward-sws " " c-in-literal string line-beginning-position 0 (c c++) c-literal-start c-beginning-of-macro back-to-indentation cpp-macro-cont c-forward-to-cpp-define-body cpp-define-intro "else\\>[^_]" c-beginning-of-statement-1 c-add-stmt-syntax else-clause "while\\>[^_]" beginning do-while-closure #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (c++-mode 563 java-mode 569)) "catch\\>[^_]" "\\(catch\\|finally\\)\\>[^_]" (error) scan-sexps -1 (error) (error) "\\(try\\|catch\\)\\>[^_]" catch-clause 59 (41 93 44) 125 c-looking-at-inexpr-block-backward label previous same up c-forward-token-2 literal char-before-ip before-ws-ip char-after-ip macro-start in-macro-expr c-syntactic-context placeholder 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 state-cache syntactic-relpos c-commas-bound-stmts c-keywords-regexp c-keywords-obarray c-buffer-is-cc-mode args symbol c-syntactic-indentation-in-macros indent-boi c-opt-block-stmt-key c-at-vsemi-p-fn step c-block-stmt-2-key c-label-kwds-regexp dest pos c-symbol-key start c-syntactic-ws-start c-special-brace-lists tmp lang-constant keyword-sym c-auto-newline-analysis c-specifier-key c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-recognize-knr-p c-opt-postfix-decl-spec-key c-opt-<>-sexp-key c-class-key done cont fence where c-recognize-<>-arglists c-overloadable-operators-regexp c-equals-type-clause-key preserve-point c-class-id-suffix-ws-ids-key c-opt-method-key c-opt-inexpr-brace-list-key end-of-defun-function beginning-of-defun-function defun-prompt-regexp limit c-other-decl-block-key c-recognize-typeless-decls prev-point last-step-type c-comment-start-regexp c-opt-friend-key p langelem substatement-open c-forward-label substatement-label substatement c-guess-continued-construct idl-mode 41 (error) scan-lists skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" c-after-conditional case-label c-add-class-syntax inclass access-label "switch\\>[^_]" c-looking-at-inexpr-block c-safe-position ((inexpr-class . class-open) (inexpr-statement . block-open)) inline-open lambda-intro-cont c-looking-at-special-brace-list c-other-block-decl-kwds "extern" extern-lang-open intern "-open" class-open c-backward-over-enum-header c-looking-at-or-maybe-in-bracelist topmost-intro-cont brace-list-open c-beginning-of-decl-1 c-forward-keyword-clause c-forward-noise-clause defun-open c-back-over-member-initializers member-init-intro c-forward-sws member-init-cont c-just-after-func-arglist-p c-determine-limit 500 58 c-in-knr-argdecl knr-argdecl-intro func-decl-cont 44 (error) c-forward-<>-arglist java-mode (error) c-crosses-statement-barrier-p inher-intro "throws\\>[^_]" inher-cont c-beginning-of-inheritance-list awk-mode topmost-intro "^;,=<>" c-after-special-operator-id 62 c-backward-<>-arglist 60 "^;,=" (44 61 60) 61 c-backward-token-2 c-on-identifier statement-cont (error) "^,;" template-args-cont "static\\>[^_]" 2 statement symbol-name extern-lang-close "-close" class-close knr-argdecl objc-method-intro c-end-of-decl-1 c-syntactic-re-search-forward "{" (59 123 125 nil) objc-mode not-in-directive c-forward-objc-directive throw c-brace-anchor-point inextern-lang "in" objc-method-args-cont c-forward-annotation annotation-top-cont (41 93) (error) backward-up-list arglist-close c-inside-bracelist-p (brace-list-open . inexpr-class) (block-open . inexpr-statement) (40 91) (error) arglist-intro (error) "\\<for\\>[^_]" 91 beginning-of-defun objc-method-call-cont (error) arglist-cont-nonempty arglist-cont assoc c-guess-basic-syntax (error) (error) brace-list-close " \n
\f " 92 brace-list-intro line-end-position brace-entry-open brace-list-entry (59 58) block-close inlambda inline-close defun-close c-at-statement-start-p c-forward-decl-or-cast-1 (error) statement-case-open statement-case-intro block-open statement-block-intro defun-block-intro comment-intro friend 34 cpp-macro] 8 (#$ . 213401)])
(defalias 'c-evaluate-offset #[(offset langelem symbol) "\247\203 \202\277\306!\203 \202\277\204 \307\202\277\310\267\202D \202\277 [\202\277\311 _\202\277\311 [_\202\277 \311\245\202\277 [\311\245\202\277\312!\203j \313\n\211@)\n\211A:\203_ \nA\242\202a \nA)B!\n #\202\277<\203\245@\314=\203\203 \315\316 #\210\317 \210\307\202\277@\320>\203 \307\211@ A\211\203\313@\n #\211\203\374 \204\257
\202\374
\250\203\327 \306 !\203\315 \315\321@
\f&\210\317 \210\202\374 \f
\" \202\374 \250\203\357 \315\322@
\f&\210\317 \210\202\374 \323\f \324H
\324H\"! A\211\204\231 +\202\277@\325=\203{\307\211 A\211\203u\313@\n #\211\203n \2042
\202n
\250\203T\306 !\203K\323 \324H
\\! \202n
\\ \202n\306 !\203k\315\326@
%\210\317 \210\202n
A\211\204 *\202\277\307 @\327=\203\210A \204\237\203\237\313@\n # A\202\210 )\202\2779\203\265\330!\203\265J\202\277\315\331 #\210\317 \210\307\211 \203\342 \250\204\342\306 !\203\347 G\332Y\203\347 \324H\250\203\347 \202\363\315\333 $\210\317 \210\307)\207" [offset c-basic-offset langelem symbol method val vectorp nil #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (+ 33 - 37 ++ 42 -- 48 * 55 / 61)) 2 functionp c-evaluate-offset quote message "The offset %S for %s was mistakenly quoted" ding (min max) "Error evaluating offset %S for %s: Cannot combine absolute offset %S with relative %S in `%s' method" "Error evaluating offset %S for %s: Cannot combine relative offset %S with absolute %S in `%s' method" vector 0 add "Error evaluating offset %S for %s: Cannot combine absolute offsets %S and %S in `add' method" first boundp "Unknown offset format %S for %s" 1 "Error evaluating offset %S for %s: Got invalid value %S" res] 8])
(defalias 'c-calc-offset #[(langelem) "\211@)\211\n\236\211\243 \203 \306\f #\202(
\203& \307\310 \"\210\311 \210\312\313\f!\2043 \f\247\2037 \f\202B \f9\203A \fJ\206B \312+\207" [langelem symbol c-offsets-alist match offset c-strict-syntax-p c-evaluate-offset message "No offset found for syntactic symbol %s" ding 0 vectorp] 5])
(defalias 'c-get-offset #[(langelem) "\211A:\203 A\242\202 A)\203. \301\211@)\211A:\203( A\242\202* A)D!\207\301!\207" [langelem c-calc-offset] 4])
(defalias 'c-get-syntactic-indentation #[(langelems) "\306\307\n\203@ \n@\310 ! \311\f!\203 \f\306\234e\2029 \f\\\2049 \n@\211 A:\2035
A\242\2027
A)\nA*\202 \203O \212b\210i)\\\202P *\207" [anchor indent langelems c-syntactic-element res langelem 0 nil c-calc-offset vectorp] 3])
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\303#\210\300\306\302\303#\210\300\307\302\303#\210\300\310\302\311#\210\300\312\302\303#\210\300\313\302\303#\210\300\314\302\303#\210\300\315\302\303#\210\300\316\302\317#\210\320\321!\207" [put c-bos-pop-state edebug-form-spec t c-bos-save-error-info c-state-cache-top-lparen c-state-cache-top-paren c-state-cache-after-top-paren c-state-maybe-marker (form symbolp) c-record-type-id c-record-ref-id c-forward-keyword-prefixed-id c-forward-id-comma-list c-pull-open-brace (symbolp) provide cc-engine] 4)
Zerion Mini Shell 1.0