;ELC ;;; Compiled ;;; in Emacs version 30.2 ;;; with all optimizations. #@13 (fn INIT) (byte-code "\300\301!\210\300\302!\207" [require cc-defs cc-vars] 2) (defalias 'c-declare-lang-variables '(macro . #[0 "\301\302\303A\"B\207" [c-lang-variable-inits progn mapcan #[257 "\211\300\234\203\301@\302\300\234F\202\301@\303BB\304\305@DDD\207" [2 defvar nil (nil) make-variable-buffer-local quote] 6 (#$ . 83)]] 4])) (defvar c-no-parens-syntax-table nil)#@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'. (make-variable-buffer-local 'c-no-parens-syntax-table) (defvar c-identifier-syntax-modifications nil (#$ . 473))#@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. (make-variable-buffer-local 'c-identifier-syntax-modifications) (defvar c-identifier-syntax-table nil (#$ . 942))#@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). (make-variable-buffer-local 'c-identifier-syntax-table) (defvar c-get-state-before-change-functions nil (#$ . 1242))#@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 . (make-variable-buffer-local 'c-get-state-before-change-functions) (defvar c-before-font-lock-functions nil (#$ . 2083))#@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). (make-variable-buffer-local 'c-before-font-lock-functions) (defvar c-before-context-fontification-functions nil (#$ . 3004))#@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. (make-variable-buffer-local 'c-before-context-fontification-functions) (defvar c-at-vsemi-p-fn nil (#$ . 3607))#@419 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. (make-variable-buffer-local 'c-at-vsemi-p-fn) (defvar c-vsemi-status-unknown-p-fn nil (#$ . 3988))#@49 Whether the language has bitfield declarations. (make-variable-buffer-local 'c-vsemi-status-unknown-p-fn) (defvar c-has-bitfields nil (#$ . 4510))#@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'. (make-variable-buffer-local 'c-has-bitfields) (defvar c-single-quotes-quote-strings nil (#$ . 4663)) (make-variable-buffer-local 'c-single-quotes-quote-strings) (defvar c-string-delims nil) (make-variable-buffer-local 'c-string-delims) (defvar c-ml-string-non-punc-skip-chars nil)#@362 If non-nil, a regexp that matches a multi-line string opener. It may also match context. Such an opener must be at least 2 characters long, and must contain a " character. (match-string 1) matches the actual delimiter and (match-string 2) matches the actual ". If a delimiter contains several "s, it is recommended to configure the first of them as "the" ". (make-variable-buffer-local 'c-ml-string-non-punc-skip-chars) (defvar c-ml-string-opener-re nil (#$ . 5415))#@63 If non-nil, the maximum length of a multi-line string opener. (make-variable-buffer-local 'c-ml-string-opener-re) (defvar c-ml-string-max-opener-len nil (#$ . 5890))#@440 If non-nil, a regexp that matches any multi-line string closer. It may also match context. A search for this regexp starting at the end of the corresponding opener must find the first closer as the first match. Such a closer must include a " character. (match-string 1) matches the actual delimiter and (match-string 2) matches the actual ". If a delimiter contains several "s, it is recommended to regard the last of them as "the" ". (make-variable-buffer-local 'c-ml-string-max-opener-len) (defvar c-ml-string-any-closer-re nil (#$ . 6062))#@256 If non-nil, the maximum length of a multi-line string closer. This must include the length of any "context trailer" following the actual closer and any "context leader" preceding it. This variable is ignored when `c-ml-string-back-closer-re' is non-nil. (make-variable-buffer-local 'c-ml-string-any-closer-re) (defvar c-ml-string-max-closer-len nil (#$ . 6615))#@240 If non-nil, the maximum length of a ml string closer without its leader. By "leader" is meant the context bytes preceding the actual multi-line string closer, that part of `c-ml-string-any-closer-re''s match preceding (match-beginning 1). (make-variable-buffer-local 'c-ml-string-max-closer-len) (defvar c-ml-string-max-closer-len-no-leader nil (#$ . 6984))#@915 A regexp to move back out of a putative ml closer point is in. This variable need only be non-nil for languages with multi-line string closers that can contain an indefinite length "leader" preceding the actual closer. It was designed for formats where an unbounded number of \s or "s might precede the closer proper, for example in Pike Mode or csharp-mode. If point is in a putative multi-line string closer, a backward regexp search with `c-ml-string-back-closer-re' will leave point in a "safe place", from where a forward regexp search with `c-ml-string-any-closer-re' can test whether the original position was inside an actual closer. When non-nil, this variable should end in "\\\==". Note that such a backward search will match a minimal string, so a "context character" is probably needed at the start of the regexp. The value for csharp-mode would be something like "\$?:\\`\\|[^\"]\$\"*\\\==". (make-variable-buffer-local 'c-ml-string-max-closer-len-no-leader) (defvar c-ml-string-back-closer-re nil (#$ . 7348))#@459 If non-nil, a function which creates a closer regexp matching an opener. Such a function is given one argument, a multi-line opener (a string), and returns a regexp which will match the corresponding closer. When this regexp matches, (match-string 1) should be the actual closing delimiter, and (match-string 2) the "active" " it contains. A forward regexp search for this regexp starting at the end of the opener must find the closer as its first match. (make-variable-buffer-local 'c-ml-string-back-closer-re) (defvar c-make-ml-string-closer-re-function nil (#$ . 8387))#@540 If non-nil, a function which creates an opener regexp matching a closer. Such a function is given one argument, a multi-line closer (a string), and returns a regexp which will match the corresponding opener. When this regexp matches, (match-string 1) should be the actual opening delimiter, and (match-string 2) the "active" " it contains. A backward regexp search for this regexp starting at the start of the closer might not find the opener as its first match, should there be copies of the opener contained in the multi-line string. (make-variable-buffer-local 'c-make-ml-string-closer-re-function) (defvar c-make-ml-string-opener-re-function nil (#$ . 8969)) (make-variable-buffer-local 'c-make-ml-string-opener-re-function) (defvar c-ml-string-cpp-or-opener-re nil) (make-variable-buffer-local 'c-ml-string-cpp-or-opener-re) (defvar c-cpp-or-ml-match-offset nil)#@61 Whether the language has numbers quoted like 4'294'967'295. (make-variable-buffer-local 'c-cpp-or-ml-match-offset) (defvar c-has-quoted-numbers nil (#$ . 9845))#@76 Whether literal initializers {...} are used other than in initializations. (make-variable-buffer-local 'c-has-quoted-numbers) (defvar c-has-compound-literals nil (#$ . 10011))#@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. (make-variable-buffer-local 'c-has-compound-literals) (defvar c-modified-constant nil (#$ . 10193))#@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. (make-variable-buffer-local 'c-modified-constant) (defvar c-symbol-start nil (#$ . 10520))#@103 Set of characters that can be part of a symbol. This is of the form that fits inside [ ] in a regexp. (make-variable-buffer-local 'c-symbol-start) (defvar c-symbol-chars nil (#$ . 10780))#@66 Regexp matching a sequence of at least one identifier character. (make-variable-buffer-local 'c-symbol-chars) (defvar c-symbol-char-key nil (#$ . 10973))#@129 Regexp matching identifiers and keywords (with submatch 0). Assumed to match if `c-symbol-start' matches on the same position. (make-variable-buffer-local 'c-symbol-char-key) (defvar c-symbol-key nil (#$ . 11133))#@97 This is the set of chars that can't be part of a symbol, i.e. the negation of `c-symbol-chars'. (make-variable-buffer-local 'c-symbol-key) (defvar c-nonsymbol-chars nil (#$ . 11353))#@179 Regexp that matches any character that can't be part of a symbol. It's usually appended to other regexps to avoid matching a prefix. It's assumed to not contain any submatchers. (make-variable-buffer-local 'c-nonsymbol-chars) (defvar c-nonsymbol-key nil (#$ . 11542)) (make-variable-buffer-local 'c-nonsymbol-key) (defvar c-opt-identifier-concat-key nil) (make-variable-buffer-local 'c-opt-identifier-concat-key) (defvar c-opt-identifier-prefix-key nil)#@145 Regexp that matches the start of an (optionally qualified) identifier. It should also match all keywords. It's unspecified how far it matches. (make-variable-buffer-local 'c-opt-identifier-prefix-key) (defvar c-identifier-start nil (#$ . 12002))#@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" in C++. (make-variable-buffer-local 'c-identifier-start) (defvar c-identifier-key nil (#$ . 12255))#@98 This regexp matches (a component of) a module name. Currently (2022-09) just C++ Mode uses this. (make-variable-buffer-local 'c-identifier-key) (defvar c-module-name-re nil (#$ . 12683))#@571 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. Note that from CC Mode 5.36, this character use is obsolete, having been superseded by the "multi-line string" mechanism. If both mechanisms are set for a language, the newer one prevails over the old `c-multiline-string-start-char'. See the variables in the page containing `c-ml-string-opener-re' in cc-langs.el for further directions. (make-variable-buffer-local 'c-module-name-re) (defvar c-multiline-string-start-char nil (#$ . 12876))#@333 Set if the language resolves escaped newlines first. This makes a difference in a string like "...\\ ". When this variable is nil, the first backslash escapes the second, leaving an unterminated string. When it's non-nil, the string is continued onto the next line, and the first backslash escapes whatever begins that next line. (make-variable-buffer-local 'c-multiline-string-start-char) (defvar c-escaped-newline-takes-precedence nil (#$ . 13555)) (make-variable-buffer-local 'c-escaped-newline-takes-precedence) (defvar c-string-innards-re-alist nil)#@69 The symbol which starts preprocessor constructs when in the margin. (make-variable-buffer-local 'c-string-innards-re-alist) (defvar c-opt-cpp-symbol nil (#$ . 14117))#@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. (make-variable-buffer-local 'c-opt-cpp-symbol) (defvar c-opt-cpp-prefix nil (#$ . 14290))#@113 Regexp matching the prefix of a cpp directive anchored to BOL, in the languages that have a macro preprocessor. (make-variable-buffer-local 'c-opt-cpp-prefix) (defvar c-anchored-cpp-prefix nil (#$ . 14573))#@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. (make-variable-buffer-local 'c-anchored-cpp-prefix) (defvar c-opt-cpp-start nil (#$ . 14786)) (make-variable-buffer-local 'c-opt-cpp-start) (defvar c-cpp-include-key nil)#@117 Cpp directive (without the prefix) that is followed by a macro definition, or nil if the language doesn't have any. (make-variable-buffer-local 'c-cpp-include-key) (defvar c-opt-cpp-macro-define nil (#$ . 15139)) (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)#@125 Regexp which matches the start of a CPP directive which contains an expression, or nil if there aren't any in the language. (make-variable-buffer-local 'c-opt-cpp-macro-define-id) (defvar c-cpp-expr-intro-re nil (#$ . 15551)) (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)#@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. (make-variable-buffer-local 'c-overloadable-operators-regexp) (defvar c-opt-op-identifier-prefix nil (#$ . 16129)) (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-negation-op-re nil) (make-variable-buffer-local 'c-negation-op-re) (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)#@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. (make-variable-buffer-local 'c-<-op-cont-regexp) (defvar c-<-pseudo-digraph-cont-regexp nil (#$ . 17457))#@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. (make-variable-buffer-local 'c-<-pseudo-digraph-cont-regexp) (defvar c-<-pseudo-digraph-cont-len nil (#$ . 17752)) (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)#@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). (make-variable-buffer-local 'c-haskell-op-re) (defvar c-pre-start-tokens nil (#$ . 19231)) (make-variable-buffer-local 'c-pre-start-tokens) (defvar c-pre-lambda-tokens-re nil)#@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. (make-variable-buffer-local 'c-pre-lambda-tokens-re) (defvar c-line-comment-starter nil (#$ . 19581))#@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. (make-variable-buffer-local 'c-line-comment-starter) (defvar c-block-comment-starter nil (#$ . 20024))#@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. (make-variable-buffer-local 'c-block-comment-starter) (defvar c-block-comment-ender nil (#$ . 20511)) (make-variable-buffer-local 'c-block-comment-ender) (defvar c-block-comment-ender-regexp nil)#@146 List of characters which, inside a block comment, could be the first character of a double character construct. This doesn't include backslash. (make-variable-buffer-local 'c-block-comment-ender-regexp) (defvar c-block-comment-awkward-chars nil (#$ . 20920)) (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)#@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. (make-variable-buffer-local 'c-line-comment-start-regexp) (defvar c-last-c-comment-end-on-line-re nil (#$ . 21477)) (make-variable-buffer-local 'c-last-c-comment-end-on-line-re) (defvar c-literal-start-regexp nil)#@54 Regexp to match the start of documentation comments. (make-variable-buffer-local 'c-literal-start-regexp) (defvar c-doc-comment-start-regexp nil (#$ . 21888))#@58 Non-nil when the default comment style is block comment. (make-variable-buffer-local 'c-doc-comment-start-regexp) (defvar c-block-comment-is-default nil (#$ . 22052)) (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)#@40 Regexp to append to `paragraph-start'. (make-variable-buffer-local 'c-syntactic-eol) (defvar c-paragraph-start nil (#$ . 22476))#@43 Regexp to append to `paragraph-separate'. (make-variable-buffer-local 'c-paragraph-start) (defvar c-paragraph-separate nil (#$ . 22610)) (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-self-contained-typename-key nil) (make-variable-buffer-local 'c-self-contained-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)#@101 Set to t when we recognize a colon and then a type after an enum, e.g., enum foo : int { A, B, C }; (make-variable-buffer-local 'c-after-brace-list-key) (defvar c-recognize-post-brace-list-type-p nil (#$ . 24044)) (make-variable-buffer-local 'c-recognize-post-brace-list-type-p) (defvar c-other-decl-block-key nil)#@104 Alist associating keywords in c-other-decl-block-decl-kwds with their matching "in" syntactic symbols. (make-variable-buffer-local 'c-other-decl-block-key) (defvar c-other-decl-block-key-in-symbols-alist nil (#$ . 24365)) (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-using-key nil) (make-variable-buffer-local 'c-using-key) (defvar c-no-type-key nil) (make-variable-buffer-local 'c-no-type-key) (defvar c-equals-type-clause-key nil) (make-variable-buffer-local 'c-equals-type-clause-key) (defvar c-equals-nontype-decl-key nil) (make-variable-buffer-local 'c-equals-nontype-decl-key) (defvar c-fun-name-substitute-key nil) (make-variable-buffer-local 'c-fun-name-substitute-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)#@122 The token which (may) follow a protection keyword, e.g. the ":" in C++ Mode's "public:". nil if there is no such token. (make-variable-buffer-local 'c-protection-key) (defvar c-post-protection-token nil (#$ . 25743)) (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)#@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. (make-variable-buffer-local 'c-make-top-level-key) (defvar c-colon-type-list-re nil (#$ . 26253))#@202 Regexp matching buffer content that may come between a keyword in `c-colon-type-list-kwds' and a putative colon, or nil if there are no such keywords. Exception: it does not match any C++ attributes. (make-variable-buffer-local 'c-colon-type-list-re) (defvar c-sub-colon-type-list-re nil (#$ . 26606)) (make-variable-buffer-local 'c-sub-colon-type-list-re) (defvar c-paren-nontype-key nil) (make-variable-buffer-local 'c-paren-nontype-key) (defvar c-pre-concept-<>-key nil) (make-variable-buffer-local 'c-pre-concept-<>-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-generic-key nil) (make-variable-buffer-local 'c-generic-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-paren-clause-key nil) (make-variable-buffer-local 'c-paren-clause-key) (defvar c-block-stmt-with-key nil) (make-variable-buffer-local 'c-block-stmt-with-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-module-key nil) (make-variable-buffer-local 'c-module-key) (defvar c-constant-key nil) (make-variable-buffer-local 'c-constant-key) (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)#@64 List of keywords which may need to cause electric indentation. (make-variable-buffer-local 'c-opt-bitfield-key) (defvar c-std-abbrev-keywords nil (#$ . 28900)) (make-variable-buffer-local 'c-std-abbrev-keywords) (defvar c-keywords-regexp nil) (make-variable-buffer-local 'c-keywords-regexp) (defvar c-stmt-block-only-keywords-regexp nil) (make-variable-buffer-local 'c-stmt-block-only-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) (defvar c-per-++---match nil) (make-variable-buffer-local 'c-per-++---match) (defvar c-per-&*+--match nil) (make-variable-buffer-local 'c-per-&*+--match) (defvar c-per-\(-match nil)#@136 Regexp matching a keyword that is followed by a colon, where the whole construct can precede a declaration. E.g. "public:" in C++. (make-variable-buffer-local 'c-per-\(-match) (defvar c-decl-start-colon-kwd-re nil (#$ . 29753)) (make-variable-buffer-local 'c-decl-start-colon-kwd-re) (defvar c-decl-prefix-re nil)#@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. (make-variable-buffer-local 'c-decl-prefix-re) (defvar c-decl-start-re nil (#$ . 30077)) (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)#@144 Regexp matching keywords which might, but needn't, declare variables with no explicit type given, or nil in languages without such specifiers. (make-variable-buffer-local 'c-block-prefix-charset) (defvar c-maybe-typeless-specifier-re nil (#$ . 30786)) (make-variable-buffer-local 'c-maybe-typeless-specifier-re) (defvar c-type-decl-prefix-key nil)#@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'). (make-variable-buffer-local 'c-type-decl-prefix-key) (defvar c-type-decl-operator-prefix-key nil (#$ . 31140)) (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)#@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. (make-variable-buffer-local 'c-opt-type-concat-key) (defvar c-opt-type-suffix-key nil (#$ . 31966)) (make-variable-buffer-local 'c-opt-type-suffix-key) (defvar c-known-type-key nil)#@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. (make-variable-buffer-local 'c-known-type-key) (defvar c-special-brace-lists nil (#$ . 32522))#@58 Non-nil means K&R style argument declarations are valid. (make-variable-buffer-local 'c-special-brace-lists) (defvar c-recognize-knr-p nil (#$ . 32763)) (make-variable-buffer-local 'c-recognize-knr-p) (defvar c-pre-id-bracelist-key nil)#@77 A regexp matching tokens which, preceding a brace, make it a non-bracelist. (make-variable-buffer-local 'c-pre-id-bracelist-key) (defvar c-pre-brace-non-bracelist-key nil (#$ . 33005))#@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. (make-variable-buffer-local 'c-pre-brace-non-bracelist-key) (defvar c-recognize-typeless-decls nil (#$ . 33196))#@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. (make-variable-buffer-local 'c-recognize-typeless-decls) (defvar c-recognize-<>-arglists nil (#$ . 33646))#@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. (make-variable-buffer-local 'c-recognize-<>-arglists) (defvar c-<>-notable-chars-re nil (#$ . 34118)) (make-variable-buffer-local 'c-<>-notable-chars-re) (defvar c-enum-clause-introduction-re nil)#@64 Non-nil means that an enum structure can contain declarations. (make-variable-buffer-local 'c-enum-clause-introduction-re) (defvar c-enums-contain-decls nil (#$ . 34870))#@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; (make-variable-buffer-local 'c-enums-contain-decls) (defvar c-recognize-paren-inits nil (#$ . 35047))#@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}; (make-variable-buffer-local 'c-recognize-paren-inits) (defvar c-recognize-bare-brace-inits nil (#$ . 35298))#@125 Non-nil to recognize gcc style in-expression blocks, i.e. compound statements surrounded by parentheses inside expressions. (make-variable-buffer-local 'c-recognize-bare-brace-inits) (defvar c-recognize-paren-inexpr-blocks nil (#$ . 35570)) (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)#@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'. (make-variable-buffer-local 'c-opt-postfix-decl-spec-key) (defvar c-recognize-colon-labels nil (#$ . 36116))#@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. (make-variable-buffer-local 'c-recognize-colon-labels) (defvar c-label-prefix-re nil (#$ . 36441))#@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. (make-variable-buffer-local 'c-label-prefix-re) (defvar c-nonlabel-token-key nil (#$ . 36688))#@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. (make-variable-buffer-local 'c-nonlabel-token-key) (defvar c-nonlabel-nonparen-token-key nil (#$ . 37048))#@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. (make-variable-buffer-local 'c-nonlabel-nonparen-token-key) (defvar c-nonlabel-token-2-key nil (#$ . 37462))#@213 Optional regexp matching labels. Normally, labels are detected according to `c-nonlabel-token-key' and `c-decl-prefix-re'. This regexp can be used if there are additional labels that aren't recognized that way. (make-variable-buffer-local 'c-nonlabel-token-2-key) (defvar c-opt-extra-label-key nil (#$ . 37776)) (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)#@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. (make-variable-buffer-local 'c-type-decl-end-used) (defvar c-maybe-decl-faces nil (#$ . 38335)) (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)#@22 (fn ARG PREVSTATE) (make-variable-buffer-local 'c-auto-newline) (defalias 'c-calculate-state #[514 "\203\300!\211\262\301U\203?\207\301V\207" [prefix-numeric-value 0] 4 (#$ . 38904)]) (defvar c-macro-start 'unknown) (defalias 'c-query-and-set-macro-start #[0 "9\203\212\304 \305\211\305\306\307\"\216\310 \205`-\262\211\207\207" [c-macro-start buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] c-beginning-of-macro] 5]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-query-and-set-macro-start speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-query-macro-start #[0 "9\203\212\304 \305\211\305\306\307\"\216\310 \205`-\207\207" [c-macro-start buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] c-beginning-of-macro] 5]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-query-macro-start speed -1 put byte-optimizer byte-compile-inline-expand] 5) (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)#@16 (fn BEG END) (make-variable-buffer-local 'c-macro-cache-no-comment) (defalias 'c-invalidate-macro-cache #[514 "?\206?@X\203\304\211\304\211\211\207A\203.AW\203.\304\241\210\304\211\211\207 \205? W\205?\304\211\211\207" [c-macro-cache c-macro-cache-start-pos c-macro-cache-syntactic c-macro-cache-no-comment nil] 5 (#$ . 40398)]) (defalias 'c-macro-is-genuine-p #[0 "`\301 \210`e=\203$`\302U\204$\214~\210\301 \210\303!\205 \302\224=)\202%\304b\210\207" [c-anchored-cpp-prefix beginning-of-line 1 looking-at t] 3])#@306 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. (fn &optional LIM) (defalias 'c-beginning-of-macro #[256 "`\306 \205\314 @\203A` @Y\203A A\203` AX\204%`\nX\203A @\206,eW?\205\314\2066e @]b\210\n]\307\207\310\211\310\211\214\203Rd}\210\311 \210\203_Y\203\235\312 \313\314\"\216`SSf\315=\203u\316y\210\202f \203\233\317 \307#\203\233\320\225b\210\321 \203\224\311 \210`\211\262\202\230b\210\310\204f)\210\322 \210`X\203\307\312 \313\323\"\216\324!)\262\203\307\325 \203\307`C\310\307\202\313b\210\310)\207" [c-opt-cpp-prefix c-macro-cache c-macro-cache-start-pos c-macro-cache-syntactic c-macro-cache-no-comment c-last-c-comment-end-on-line-re line-end-position t nil beginning-of-line match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] 92 -1 re-search-forward 1 c-backward-single-comment back-to-indentation #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] looking-at c-macro-is-genuine-p c-opt-cpp-start] 9 (#$ . 40954)])#@564 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. (fn &optional LIM) (defalias 'c-end-of-macro #[256 "\214\211\203 e}\210A\203\"`AX\203\"`@Y\203\"Ab\202\230@\2034` X\2034`@Y\204<\304\211\304\211\305 \306\307\"\216`\304\210`Sf\310=\203Ym\204Y\304u\210\202D\311`\"\3128\205x\3138?\205x\311`d\304\211\314&\210`\211\262\262\204D@\205\225`@V\205\225?\205\225`\241\210\304\211)\266\202)\207" [c-macro-cache c-macro-cache-start-pos c-macro-cache-syntactic c-macro-cache-no-comment nil match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] 92 parse-partial-sexp 4 7 syntax-table] 12 (#$ . 42196)]) (defalias 'c-syntactic-end-of-macro #[0 "`\301 \210`\302\203b\210\202A\303\"\262\3048\204*\3058\203?\3068\307=\204?V\203?\3108S\262\303\"\262\202``\207" [c-macro-cache-syntactic c-end-of-macro nil parse-partial-sexp 3 4 7 syntax-table 8] 6]) (defalias 'c-no-comment-end-of-macro #[0 "`\301 \210`\302\203b\210\202F\303\"\262\3048\2031V\2031\3058T\262\303\"\262\202\3068\203D\3078\310=\204D\3058b\210``\207" [c-macro-cache-no-comment c-end-of-macro nil parse-partial-sexp 3 8 4 7 syntax-table] 6]) (defalias 'c-forward-over-cpp-define-id #[0 "\205 \301!\205 \302\225b\207" [c-opt-cpp-macro-define-id looking-at 0] 2]) (defalias 'c-forward-to-cpp-define-body #[0 "\205\301!\205\302\225\303 U?\205\302\225b\207" [c-opt-cpp-macro-define-start looking-at 0 line-end-position] 2])#@18 (fn ELT DLIST) (defalias 'c-delq-from-dotted-list #[514 "\211\300:\203*@=\203!\211\203\211A\241\210\202#A\262\202#\210\211A\262\202\207" [nil] 6 (#$ . 44184)])#@28 (fn FROM TO PAREN-LEVEL) (defalias 'c-syntactic-content #[771 "\212\214}\210b\210\301C\211\301\211\302\303#\203\243\304\224\211\262b\210\305 \210`U\203-\301u\210\202\203A\212\306\307#@\307U\262`)\262V\203s`W\203s\310\311!\203s\212Sb\210\310\311!)\203s\312\"\313D\241\210AA\262\202\200\312\"C\241\210A\262\211\203\235\306\314#@\314U\203\235\312`S`\"C\241\210A\262`\262\202\312\"C\241\210\315\316A\"*\207" [c-syntactic-ws-start nil re-search-forward t 0 c-forward-sws parse-partial-sexp 1 looking-at "\\w\\|\\s_" buffer-substring-no-properties " " -1 apply concat] 11 (#$ . 44368)])#@18 (fn SHIFT-AMT) (defalias 'c-shift-line-indentation #[257 "d`Z\304C\305U\204h9\203/\212\306 \307\211\307\310\311\"\216\312 \205'`-\262\211\2020\203M\313\314!\203M\212\315\304x\210n)\203M\316c\210\317u\210\211\307\240\210\310\320\"\216\321 \322 \212\323 \210`)|\210\324 \210\211\\j)\266`\212\323 \210`)W\203}\211\242\204}\323 \202\211dZ`V\205\211dZb)\207" [c-macro-start buffer-undo-list inhibit-read-only inhibit-modification-hooks nil 0 buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] c-beginning-of-macro looking-at "[ ]*\\\\$" " " 120 -1 #[0 "\300\242\205\301\302!\207" [V0 delete-char 1] 2] current-indentation line-beginning-position back-to-indentation beginning-of-line] 8 (#$ . 45015)])#@16 (fn KEYWORD) (defalias 'c-keyword-sym #[257 "\301\"\207" [c-keywords-obarray intern-soft] 4 (#$ . 45818)])#@34 (fn KEYWORD-SYM LANG-CONSTANT) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-keyword-sym speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-keyword-member #[514 "N\207" [] 4 (#$ . 45934)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-keyword-member speed -1 put byte-optimizer byte-compile-inline-expand] 5) (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)#@24 (fn &optional QUIET) (make-variable-buffer-local 'c-parsing-error) (defalias 'c-echo-parsing-error #[256 "\203 \203\211\204\302\303 \"\210\304 \210 \207" [c-report-syntactic-errors c-parsing-error message "%s" ding] 4 (#$ . 46687)]) (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))#@18 (fn POS VALUE) (defalias 'c-put-c-type-property #[514 "\300\211T\301$\207" [put-text-property c-type] 7 (#$ . 47139)])#@22 (fn FROM TO VALUE) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-put-c-type-property speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-clear-c-type-property #[771 "\212b\210\300`\301\"=\203`\302\211T\303#\266\304`\301\305$b\210`W\205'\202)\207" [get-text-property c-type remove-text-properties (c-type nil) next-single-property-change nil] 8 (#$ . 47267)])#@21 (fn BEG END FACE) (defalias 'c-debug-add-face #[771 "\303 \304\211\304\305\306\"\216\307\"\310\203;\210\211@A\262\311\312\"=\203\313!^\262\314!]\262\315!\210\202\316\317\"\312#,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] overlays-in nil overlay-get face overlay-start overlay-end delete-overlay overlay-put make-overlay] 11 (#$ . 47686)]) (defalias 'c-debug-remove-face #[771 "\303 \304\211\304\305\306\"\216\307\"\310\203?@\262A\262\311\312\"=\203\313!^\262\211\314!]\262\315!\210\202W\203Q\316\317\n\"\312#\210\211V\205b\316\317\"\312#,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] overlays-in nil overlay-get face overlay-start overlay-end delete-overlay overlay-put make-overlay] 13 (#$ . 47686)]) (defalias 'c-looking-at-c++-attribute '(macro . #[0 "\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 . #[0 "\300\207" [(setq stack (cons (cons state saved-pos) stack))] 1]))#@29 (fn &optional DO-IF-DONE) (defalias 'c-bos-pop-state '(macro . #[256 "\300\301\302\303BBBB\207" [if (setq state (car (car stack)) saved-pos (cdr (car stack)) stack (cdr stack)) t ((setq pre-stmt-found t) (throw 'loop nil))] 6 (#$ . 49128)])) (put 'c-bos-pop-state 'edebug-form-spec t) (defalias 'c-bos-pop-state-and-retry '(macro . #[0 "\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 . #[0 "\300\207" [(setq saved-pos (vector pos tok ptok pptok))] 1])) (defalias 'c-bos-restore-pos '(macro . #[0 "\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]))#@20 (fn MISSING GOT) (defalias 'c-bos-save-error-info '(macro . #[514 "\300\301\302\303FE\207" [setq saved-pos vector pos] 8 (#$ . 49945)])) (put 'c-bos-save-error-info 'edebug-form-spec t) (defalias 'c-bos-report-error '(macro . #[0 "\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]))#@2579 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. (fn &optional LIM IGNORE-LABELS NOERROR COMMA-DELIM HIT-LIM) (defalias 'c-beginning-of-statement-1 #[1280 "\306`\306\203\307\202\f\310\206\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211 \206&\n\311\306\211\211\214\203@e]\202Ae\262~\210\212\312 \203U`U\204U`\262)`\262`\206`eV\203r\214\206ked}\210\313 )\210 \203{ \204\203\314\306x\315U\203V`Sf>\203\330\316u\210`\262`\206\231eV\203\253\214\206\244ed}\210\313 )\210`Sf>\204\316`Sf\317>\204\316`Sfz\320=\204\316 \203\330 \203\330\321\262\262\202\254b\210\322\323!\203\346\262\3242\220\212\205\325\306x\210`Sf\326=\205`S\262\327 \210`SSf\330=?\205\322@!\205\325\306w\210`=)\203gb\210\331 \203R`\2060dW\203B\214e\206\204%`=\203B\203B \204% \203K !\203KBB\262\364\262\202KBB\262\352\365#\262\360\262\203W\306\262\306\262\306\342=\203k`Y\203R\321\262\202R`\206reV\203\204\214\206}ed}\210\313 )\210`\306?\205\223`Sf\366=\262\3671\244\370`\316\"b\210\3330\202\246\210\306\204\261\333\262\335\324\306\"\210\212\322C!\205\364`\"\206\300eV\203\322\214!\206\313ed}\210\313 )\210\3711\341\370`\316\"b\210\3330\202\346\210\306\202\364\205\364\322D!\205\364`\211\262)\203\374b\210\2047\312 \2037\212`\"\206eV\203 \214!\206ed}\210\313 )\210`)\262\212\372 \210\373`\")\204D`\211\262\202:\322\374!\203D`\"Y\204\210\204aE\203a\322E!\203a\212\372 \210\373`\")\2027\306f\375=\203\f\211\204\f\376\"\306\333#\204\f\212\377\340\333\306#\210\322\201W!)\204\fF\203\273\212\377\340\333\306#\210\322G!\203\245\322H!\204\245\377\340\333\306#\210\322F!?\205\267\206\267\306f\366=?)\203\f\212\201X1\315\201Y`\340\315#0\202\317\210\306\211\205\327\211b\210\211\262\205\374\332 \210\322I!?\206\374\315\225\315\224Z\322J!\205\372\315\225\315\224ZV\262)\203\f\212\370`\340\"b\210`)\2027\322\201Z!\2033\212\201[1&\201Y\316\211#0\202(\210\306Tb\210\373`\")\2027\373`\"\262\203P\262\262\262\342\262\f\335\324\333\"\210\266`W\203^\335\324\306\"\210K\203|\201\\ \211\262\203|\262\333\262\333\262\335\324\306\"\210L\203\347\247\203\272 \204\272\212\206\222b\210\322H!)\204\272\322H!\204\272\201]`\"\204\272\206\262\262\n`\262\202\347\n\203\347\204\347\322M!\203\341\322N!\204\341\201]`\"\204\341`\262\f\202\347\306\262\n\306\262\333=\204\200\247\203l\206\371\262\322O!\204E\212\201^1\370`\316\"b\210\3330\202\210\306\202 \205 \322P!)\204EQ\201_=\203J\306f\320=\203J\212\377\346!\315U\205A\322R!)\204J\306\202l\203_ \204g\206Z\262\202g\206e\262\333\306\262 \f\204\200\322S!\203\200\206~\262 \306\262 \210\211\262`\262\211\2620\204\346\203\260\203\255W\204\255Y\203\260\306\262\203\363\201`!\203\347G\355=\203\347\204\347\344\345\340\234 \346\234\347e\212\f\315\234b\210\327 \210`)\"T$A@A\262A\262\202\260\311=\203B\201a>\204B\322T!\203f\320=\203\211\202 \322U!\203\202 \211\211\262\203BV\2035\262\202BU\203B\201b\262\204\254\333=\203\254\351=\204\254\203\254\204\254\f\203\207\fX\204\207 \203| W\203| \202~b\210\322V!\203\254W\203\226\262\202\254\201c\262 \203\254 W\203\254 \262b\210\203\331\351=\204\331\322R!\203\331W\203\316\262\311=\203\331\201c\262`V\203 `\206\347eV\203\371\214\206\362ed}\210\313 )\210 \203 `!\204 \201d\306x\315U\204 `\262\202\331b,\210\207" [c-commas-bound-stmts c-opt-block-stmt-key regexp-unmatchable c-maybe-labelp case-fold-search c-at-vsemi-p-fn 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 test eq purecopy t data (else 408 else-boundary 486 while 586 while-boundary 644 catch 751 catch-boundary 829)) boundary else-boundary format-message "No matching `%s' found for `%s' on line %d" 2 count-lines #s(hash-table test eq purecopy t data (if 493 boundary 524)) beginning vector while-boundary #s(hash-table test eq purecopy t data (do 651 boundary 682)) 3 catch-boundary #s(hash-table test eq purecopy t data (try 836 catch 867 boundary 874)) catch #s(hash-table test eq purecopy t data (boundary 947 else 997 while 1021 catch 1077 finally 1077)) if else while try 44 (error) scan-sexps (error) c-end-of-macro c-crosses-statement-barrier-p "\\\\$" 123 c-looking-at-inexpr-block c-backward-token-2 c-opt-cpp-start c-parsing-error c-vsemi-status-unknown-p-fn c-block-stmt-hangon-key c-block-stmt-2-key c-opt-cpp-prefix c-opt-block-decls-with-vars-key c-symbol-start c-keywords-regexp c-non-after-{}-ops-re 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 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 "-.+!*&~@`#"] 39 (#$ . 50406)])#@216 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. (fn FROM TO) (defalias 'c-punctuation-in #[514 "\212b\210`w\210`\206dW\203 \214e\206d}\210\301 )\210`V\203+\210`\202\210`W\2053`)\207" [c-symbol-chars c-forward-sws] 5 (#$ . 59916)])#@790 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. (fn FROM TO) (defalias 'c-crosses-statement-barrier-p #[514 "\203 \202 \n\203\202\f\306\211\211\211\214~\210\212\3072\264b\210\310\311!^w\210`W\203~n\203l\212\312!\211\262\203Db\210`\310\313!V\203W\214\310\313!d}\210\314 )\210`\262 \205` )\203l\315\307\"\210\202\"`\206sdW\203\205\214e\206d}\210\316 )\210`Y\203\224\315\307\306\"\210\202\"\317!\211\262\203\245Ab\210\202\"\306f\320=\203\373\321=\205\351\322\323!\205\351\212\3241\307\325`\326\313#0\202\311\210\306\211\205\321\211b\210\211\262\205\350`Sf\327=\205\350`SSf\327=\205\350`)\211\262\203\365\211b\210\202\"\306u\210\202\"\306f\330=\203 \306u\210\306f\330=\203`W\203\306u\210\202\"`S \202\"\306f\331=\203=\306 \2033!\2025\"\313\332O\262\202\"#\203o\322#!\203o\212\333\306x\210n\205]o\206]`SSf\334=?)\203g\335 \210\202\"#\306w\210\202\"\306f>\203\"\315\307`\"\210\202\"`\206\205eV\203\227\214\206\220ed}\210\314 )\210n\203\242o\204\242\336u\210`W\205\263 \205\263 \205\263`0*\207" [c-commas-bound-stmts c-stmt-boundary-skip-chars-with-comma c-stmt-boundary-skip-chars c-stmt-boundary-skip-list-with-comma c-stmt-boundary-skip-list c-at-vsemi-p-fn 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 -2 " " 92 c-end-of-macro -1 c-buffer-is-cc-mode c-maybe-labelp c-stmt-delim-chars-with-comma c-stmt-delim-chars c-opt-cpp-symbol] 12 (#$ . 60323)])#@407 Return non-nil if 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 #[0 "\212`\305\306 \203 \n\202\307\305O\305\310#\210o\206:`Sf\311=\206:`Sf\312=\2036\f\2052\313u\210\314 ?\206:\315`\"*\207" [c-maybe-labelp c-commas-bound-stmts c-stmt-delim-chars-with-comma c-stmt-delim-chars c-special-brace-lists nil c-syntactic-skip-backward 1 t 125 123 -1 c-looking-at-special-brace-list c-crosses-statement-barrier-p] 5 (#$ . 62640)])#@716 Return non-nil if 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 #[0 "\212`\303\304\305\n\306\304O\304\303#\210o\206*`Sf\307>\206*\212\310u\210\311\312!)\206*\313`\"+\207" [c-maybe-labelp c-commas-bound-stmts c-stmt-delim-chars-with-comma t nil c-syntactic-skip-backward 1 (123 125) -1 looking-at "\\s(" c-crosses-statement-barrier-p] 5 (#$ . 63455)])#@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. (make-obsolete 'c-at-expression-start-p nil "CC mode 5.35") (defalias 'c-forward-single-comment #[0 "`\300\301!\203\302\225b\210\303\304!\205'm?\205'l\203&\305`\"\306\234\203&\304u\210\307\207" [looking-at "\$[ \n \f]\\|\\\\[\n ]\$+" 0 forward-comment 1 parse-partial-sexp 7 t] 4 (#$ . 64504)])#@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 #[0 "\300\301!\203\nm\203\302\303!\205\304u\210\202\207" [forward-comment 5 looking-at "\\\\[\n ]" 2] 2 (#$ . 65321)])#@134 Call (forward-comment -1), taking care of escaped newlines. Return the result of `forward-comment' if it gets called, nil otherwise. (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-forward-comments speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-forward-comment-minus-1 '(macro . #[0 "\300\207" [(if (not comment-end-can-be-escaped) (forward-comment -1) (let ((dist (skip-syntax-backward " >"))) (when (and (< dist 0) (progn (skip-syntax-forward " " (- (point) dist 1)) (eq (char-after) 10))) (forward-char))) (cond ((and (eq (char-before) 10) (eq (char-before (1- (point))) 92)) (backward-char) nil) (t (forward-comment -1))))] 1 (#$ . 65749)]))#@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 #[0 "`\301\302x\210\303\304!\203`Sf\305=\203\306u\210\202o?\205\271\307\310\311#\210\204.\312\306!\202b\313\314!\211\315W\203I\316\317`ZS\"\210\302f\320=\203I\302u\210\210`Sf\320=\203_`SSf\305=\203_\306u\302\207\312\306!\205\271l\203\252\204s\312\306!\202\253\313\314!\211\315W\203\216\316\317`ZS\"\210\302f\320=\203\216\302u\210\210`Sf\320=\203\244`SSf\305=\203\244\306u\302\207\312\306!\202\253\311\205\271\303\321!\203\270\322u\302\207\311\207" [comment-end-can-be-escaped " \n \f" nil looking-at "[\n ]" 92 -1 re-search-forward "\\=\\s *[\n ]" t forward-comment skip-syntax-backward " >" 0 skip-syntax-forward " " 10 "\\*/" 2] 7 (#$ . 66446)])#@526 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 #[0 "`o?\205\232\301\204\302\303!\202H\304\305!\211\306W\203,\307\310`ZS\"\210\301f\311=\203,\301u\210\210`Sf\311=\203E`SSf\312=\203E\303u\210\301\202H\302\303!\211\262\204s`Sf\313=\203\\\303u\210\202`Sf\311=\203s`SSf\313=\203s\314u\210\202\203\200\315\316!\203\317u\301\207\315\320!\205\232`Sf\312=\205\232`W\205\232\303u\210\202\207" [comment-end-can-be-escaped nil forward-comment -1 skip-syntax-backward " >" 0 skip-syntax-forward " " 10 92 13 -2 looking-at "\\*/" 2 "[\n ]"] 8 (#$ . 67662)])#@19 (fn &rest ARGS) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-backward-comments speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-debug-sws-msg '(macro . #[128 "\300\207" [nil] 2 (#$ . 68749)])) (defalias 'c-put-is-sws '(macro . #[514 "\300\301D\302DD\303\304\305!\205\306BBB\207" [let beg end (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))] 7 (#$ . 40398)])) (put 'c-put-is-sws 'edebug-form-spec t) (defalias 'c-put-in-sws '(macro . #[514 "\300\301D\302DD\303\304\305!\205\306BBB\207" [let beg end (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))] 7 (#$ . 40398)])) (put 'c-put-in-sws 'edebug-form-spec t) (defalias 'c-remove-is-sws '(macro . #[514 "\300\301D\302DD\303\304\305!\205\306BBB\207" [let beg end (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))] 7 (#$ . 40398)])) (put 'c-remove-is-sws 'edebug-form-spec t) (defalias 'c-remove-in-sws '(macro . #[514 "\300\301D\302DD\303\304\305!\205\306BBB\207" [let beg end (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))] 7 (#$ . 40398)])) (put 'c-remove-in-sws 'edebug-form-spec t) (defalias 'c-remove-is-and-in-sws '(macro . #[514 "\300\301D\302DD\303\304\305!\205\306BBB\207" [let beg end (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))] 7 (#$ . 40398)])) (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 #[0 "\301=\205\217\212`\302Ze]\303\304x\210`Sf\305=\203.`SSf\305=\204.`V\203.\306u\210\202 `Sf\305=\205\214`SSf\305=\205\214\307u\266`\214`\302\\d^\211\203Re}\210\3101a\311`\312\313#0\262\202d\266\303)\211\205m\211b\210\211\262\205\214`Sf\314=\205\214`SSf\314=\205\214\315 ?\205\214\211`B)\266\202\207" [c-buffer-is-cc-mode c++-mode 200 nil "^[;{}" 91 -1 -2 (error) scan-lists 1 0 93 c-literal-limits] 7]) (defalias 'c-invalidate-sws-region-before #[514 "\303\211\304 \305\306\"\216\212b\210\307 \310!\211\311>\203#\211\266\202^\312 \2036\313`\314 \210`B\266\202^\211\315=\204\\\316 \211\203J\317\266\202^\320\321!\210\322\n!\203\\\323\324\224\324\225B\266)\212b\210\316 \211\203 :\203w @\240\262\202\242\211\211\262\202\242\320\321!\210\322\n!\205\240\323 :\203\231 \324\224\240\262\202\242\324\224\324\225B\211\262*\207" [c-sws-lit-type c-sws-lit-limits c-noise-macro-name-re nil match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 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] 8 (#$ . 40398)])#@24 (fn BEG END OLD-LEN) (defalias 'c-invalidate-sws-region-after-del #[771 "\2051@\301\\W\2051\302\303\"\204/\304\303\305A$\204/\302\306\"\204/\304\306\305A$\2051A\207" [c-sws-lit-limits 2 get-text-property c-in-sws next-single-property-change nil c-is-sws] 8 (#$ . 71822)])#@12 (fn END) (defalias 'c-invalidate-sws-region-after-ins #[257 "\212\211b\210\300 \301!\211\302>\204\303 \203\210\304`\305 \210`B\262\211\306>\205A\307@\310\311A$\307@\312\311A$\204=\211\205?A\266\202)\207" [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] 9 (#$ . 72117)]) (defalias 'c-invalidate-sws-region-after #[771 "\203@^\240\210AZ\\Z]\241\210\211\302V\205$\303#V\205-\304!\212b\210\305\306w\210l\203Am\204A`T\262) \307>\203P@\262A\262U\203o\310\311\"\203oeV\203o\310S\311\"\203oS\262\312\206u\206zA\206\201$\262\313\314#\207" [c-sws-lit-limits c-sws-lit-type 0 c-invalidate-sws-region-after-del c-invalidate-sws-region-after-ins " \f" nil (noise attribute) get-text-property c-in-sws max remove-text-properties (c-is-sws nil c-in-sws nil)] 10 (#$ . 71822)]) (defalias 'c-forward-sws #[0 "`\306\211\211\211\211\211\211\211\211`\306\307\306w\262\211\310V\203\"b\210\311\312\\\"\262\266\313!\204F \2034\313\n!\204F\314=\203@\313\315!\204F\313\f!\205O`Td^\262\316\n \317\320$\211\262\203h\321\317\306$S\262\n\202k`\262\n\322 \320\211/\3200\323\324\"\216\203\377\325`\326\"\203\377\321`\326\306d$b\210\325`\317\"\204\246\325`S\317\"\204\243\327`\317\"b\210\330u\210`\262`\306\307\306w\262\211\310V\203\301b\210\311\312\\\"\262\262\310V\203\377m\204\377\325`\317\"\204\335``T\331\332#\266\nT`T\333\317\320$\266\n`\262\f\211\262\n\333\326\320$\266\202z`\262\320\262`\306\211\334 \203,`\262\212b\210\335 )\203,\210\320b\210\336!\210`W\203,\306\262\211\203f\203|\203|V\203|`\262\334 \203a`\211\262\203ab\210\336!\210`W\203]\306\262\2040\266\202~\337\340!\203pm\203f\313\341!\203|\342u\210\202f\266`U\204\211m?\202k\212 \205\303\3131!\205\303`\262`\306\343\306x\262\211\310W\203\260b\210\344\312\\\"\262\266n\205\303o\206\303\330u\210`Sf\345=?)\203\376\306\210`Sf\345=\203\337\346y\310U\203\337\306\210\202\312`\262\347\"\211\350\234\203\365\211\351\234\204\365\306\262\210\346y\210m?\202k \203\313\n!\203\346\225b\210m?\202k\314=\205M\313\315!\205M\212\3521+\353`\346\310#0\202-\210\306\211\2055\211b\210\211\262\205L`Sf\354=\205L`SSf\354=\205L`)\211\262\203\\ b\210m?\202k\313\f!\203%\310\225b\210\306\262m?\203%`\262\n`\306\307\306w\262\211\310V\203\211b\210\311\312\\\"\262\266`Td^\262 \203\241\204\263\325\326\"\203\263\316\n\n\317\320$\211\262\203 \203 T\331\f\355#\266\203\311\nU\204\327T\333\f\317\320$\266\320\262\n`\262\f\211\262\n\333\326\320$\266\325 S\317\"\204\375S\331\332#\266\333\n\n\317\320$\210\202z\211\262\203\321\317\306\f$S\262\202z \262\202z`=\205LdW\203AT\331 \332#\262\202LS\331\n\356#\262,\262\207" [c-syntactic-ws-start c-opt-cpp-prefix c-noise-macro-name-re c-buffer-is-cc-mode c-doc-line-join-re buffer-undo-list nil " \n \f" 0 skip-syntax-forward " >" looking-at c++-mode "\\[\\[" text-property-any c-is-sws t next-single-property-change buffer-modified-p make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] get-text-property c-in-sws previous-single-property-change -1 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 " " skip-syntax-backward 92 1 parse-partial-sexp 4 7 (error) scan-lists 93 (c-is-sws nil) (c-is-sws nil c-in-sws nil) inhibit-read-only inhibit-modification-hooks c-opt-cpp-start] 19]) (defalias 'c-backward-sws #[0 "`\306\211\211\211\211\307P\306`\306\310\306x\262\211\311W\203\"b\210\312\313\\\"\262\266o?\205r\212`Sf >\203<\314\315\311!\316#\206\230\n\317=\203~`Sf\320=\203~`SSf\320=\203~\212\3211a\322`\323\311#0\202c\210\306\211\205k\211b\210\211\262\205s\324\325!)\203~`\211\262\206\230\323u\210\324!\206\230\f\205\230\324 !\205\230\326 \210\3248!)\205r\211\206\247\327\225\206\247\311\225\262`\306\330\306x\262\211\311W\203\301b\210\312\313\\\"\262\266\331` Td^\332\316$\211\262\203\334\211\262 b\210\202\337b\210\333 \316\2119:\316;\334\335\"\216\203\234o\204\234\336`S\337\"\203\234\340`\337\306e$b\210\336`\332\"\204\341`\332\306\211$b\210`\262 `\306\342\306x\262\211\311W\2031b\210\312\313\\\"\262\262`\262`\306\330\306x\262\211\311W\203Nb\210\312\313\\\"\262\262^\311W\203c\331`\n\332\316$\211\262\204ib\210\202\234\336 S\332\"\204}S\343\344#\266\345\n\332\316$\210S\345\337\316$\266\262 \262\202\357`o?\205:\306<\204\256\346\323!\202\345\312\313!\211\311W\203\311\347\350`ZS\"\210\306f\351=\203\311\306u\210\210`Sf\351=\203\342`SSf\352=\203\342\323u\210\306\202\345\346\323!\211\262\204`Sf\353=\203\371\323u\210\202\243`Sf\351=\203`SSf\353=\203\354u\210\202\243\203 \324\355!\203\235\356u\266\202<\324\357!\205:`Sf\352=\205:`W\205:\323u\210\202\235\266`\262\f\203\351U\204\351\360 \203\351`\306\211b\210\361 \210`\262`V\203s\323u\210`Sf\352=\203s\361 \210\202[\210`=\203\235\362=\316#\203\235\327\225b\210\363 \203\226\361 \210`\211\262\202\232\211b\210\306\204[`W\203\254b\266\202Bb\210`\306\330\306x\262\211\311W\203\310b\210\312\313\\\"\262\266`Sf\352=\203\325\306u\210\327y\210`W\203\342`\262b\266\202\214\212`\306\330w\262\211\311V\203b\210\347\313\\\"\262\266`)\211\262 U\204b\210\202\214\f\2035\212\312\364!\311W\205*`\262\3248!)\2035b\210\202\214\n\317=\203z`Sf\320=\203z`SSf\320=\203z\212\3651Z\322`\323\311#0\202\\\210\306\211\205d\211b\210\211\262\205o`\262\324\325!)\203zb\210\202\214`Sf >\203B\314\315\311!\316#\203B`\262`\306\342\306x\262\211\311W\203\247b\210\312\313\\\"\262\266\204\336\336S\337\"\203\336\212`\306\330\306x\262\211\311W\203\316b\210\312\313\\\"\262\266\331` Td^\332\316$)\2038T\343\366#\266\203\364 U\204Td^\336S\332\"\204\n\211S\343\344#\266\345\332\316$\210\316\262\210`\262\211\262\345\337\316$\266\211\262\nT\345\332\316$\266\202\357\262 `\262\202\357`=\205oeW\203^S\343 \344#\262\202oe\327V\205oT\343\367#\262,\262\207" [c-doc-line-join-re c-doc-line-join-end-ch c-buffer-is-cc-mode c-syntactic-ws-end c-opt-cpp-prefix c-symbol-char-key nil "\\=" " \f" 0 skip-syntax-backward " >" re-search-backward line-beginning-position 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 make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 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 skip-syntax-forward " " 10 92 13 -2 "\\*/" 2 "[\n ]" c-beginning-of-macro beginning-of-line re-search-forward c-backward-single-comment "w_" (error) (c-is-sws nil) (c-is-sws nil c-in-sws nil) c-noise-macro-name-re buffer-undo-list inhibit-read-only inhibit-modification-hooks comment-end-can-be-escaped c-last-c-comment-end-on-line-re] 19]) (defalias 'c-partial-ws-p #[514 "\212\211Td^eS]b\210\206d\300w\210\301f\302=\203+`W\203+\301u\210l\204\303u\210\210`=\206Yb\210\211\206:d\300w\210\301f\302=\203U`W\203U\301u\210l\204:\303u\210\210`=)\207" [" \n \f" nil 92 -1] 6 (#$ . 40398)]) (defvar c-lit-pos-cache nil) (make-variable-buffer-local 'c-lit-pos-cache) (defvar c-lit-pos-cache-limit 1)#@12 (fn ELT) (make-variable-buffer-local 'c-lit-pos-cache-limit) (defalias 'c-cache-to-parse-ps-state #[257 "\211:\203\204\211G\301Y\203\204\302\211\211\211\3018@A@AA@\262\211\247\204+\211\303=\2031\211\262\202O\211\304>\203F\303\262\211\305=\205A\306\262\202O\307\310 \"\210\311 \210\203XS\202Yb\210\312>\203s\313\302\211 \302\313\302\211\257\207\313\302\211 \302\313\302\257\n\207\312>\203\267\211:\203\224\211@\202\225\211b\210\313\302\211\211\211:\205\246A@\314=\313\302\211\211\n:\205\264\nA@\257\207\211:\203\301\211@\202\302\211b\210\211:\203\321\211A\203\321\315u\210\316\317!\207" [c-emacs-features 3 nil t (c c++) c++ 1 message "Invalid type %s in c-cache-to-parse-ps-state" ding pps-extended-state 0 9 -1 copy-tree (0 nil nil nil nil nil 0 nil nil nil)] 19 (#$ . 79814)])#@14 (fn STATE) (defalias 'c-parse-ps-state-to-cache #[257 "\301>\203T\3028\203`\3028\3038E\202;\3048\203:\3058\306=\204:`\3058\307=\2032\310\2023\311\3038E\202;`\3128\203S\313:\203K\202MC\3128C\"\207\207\3028\203u`Sf\314=\203l`\3028\3038\314F\207`\3028\3038E\207\3048\203\274\3058\306=\204\274`Sf\315=\203\251`\3038Z\316V\203\251`\3058\307=\203\242\310\202\243\311\3038\315F\207`\3058\307=\203\266\310\202\267\311\3038E\207`Sf\317>\203\312``SfD\207`\207" [c-emacs-features pps-extended-state 3 8 4 7 syntax-table 1 c++ c 10 append 92 42 2 (47 92)] 6 (#$ . 80656)]) (defalias 'c-ps-state-cache-pos #[257 "\211:\204\207@\207" [] 2 (#$ . 79814)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-ps-state-cache-pos speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-trim-lit-pos-cache #[0 "\205@\211:\203\f@ V\205A\211\204\302\207" [c-lit-pos-cache c-lit-pos-cache-limit nil] 3]) (defconst c-state-nonlit-pos-interval 3000)#@13 (fn HERE) (defalias 'c-parse-ps-state-below #[257 "\212\214~\210\304 \210\305\211\211\211\203(@\211:\203@V\203(\210@A\262\202\f\2037@\211:\2034@\2068eb\210\203E\306@!\202H\307\310!\262\211\204\241` \\\211\262X\203\241\311`\305\211%\262\3128\204v\313\n>\203\225\3148\203\225S\262\315u\210\3148\203\211\314\233\305\240\210\3128\203\225\312\233\305\240\210\316!\262B\202N`V\203\251``*B\207" [c-lit-pos-cache c-state-nonlit-pos-interval c-emacs-features c-lit-pos-cache-limit 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] 12 (#$ . 81681)]) (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 #[0 "\211\205\211@@ V\203\302@\"\211\262\202A\202\207" [c-semi-lit-near-cache c-semi-near-cache-limit delq] 5]) (defalias 'c-semi-get-near-cache-entry #[257 "\211\236\206T\301\302\301\3032R\203P@@\262Y\203I@A\203>\304@A8\203>\304@A8W\203>\305\303@\"\210\202IV\203I\266\211@A\262\202\2110\266\204\211\203h\211@=\204h\306\"\211B\307!\207" [c-semi-lit-near-cache nil 0 found 8 throw delq copy-tree] 8 (#$ . 81681)])#@19 (fn HERE STATE) (defalias 'c-semi-put-near-cache-entry #[514 "G\302Y\203\303\304!@\"\211\202BB ]\211\207" [c-semi-lit-near-cache c-semi-near-cache-limit 6 delq last] 6 (#$ . 83083)])#@40 (fn HERE &optional NOT-IN-DELIMITER) (defalias 'c-semi-pp-to-literal #[513 "\212\214~\210\304 \210\305 \210\306 \307\310\"\216\311!\211@\211A\312\211\211\211\203,\313ZW\203L\314!\262@\262A\262\203FV\203L\262\262\nV\204\251\3158\203\251\n\3158W\204\251\3168\203w\n\206p`Sf\317=\203\265\3208\203\220\3218\204\220\n\206\211`Sf>\203\265\3208\203\251\3218\203\251\n\206\242`Sf\322>\203\265\323\f\312\211 %\262=\204\303\324\"\210\3168\204\327\3208\203\371\3218\325=\204\371\3168\203\342\210\326\202\357\3218\203\355\210\327\202\357\210\330\3158E\202- \204+o\204+\331u\210\332 >\203\333\334!\204+\333\n!\203+\333!\203\"\210\330\202$\210\327`E\202-C+\207" [c-block-comment-awkward-chars c-emacs-features c-comment-start-regexp c-block-comment-start-regexp c-trim-lit-pos-cache c-semi-trim-near-cache match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] c-semi-get-near-cache-entry nil 100 c-parse-ps-state-below 8 3 92 4 7 (92 10) parse-partial-sexp c-semi-put-near-cache-entry syntax-table string c++ c -1 category-properties looking-at "\\s!"] 17 (#$ . 83287)]) (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 #[0 "\211\205.\211@\211AA@\203 AA@W\202 @W\203)\302\"\211\266\202\202\210A\202\207" [c-full-lit-near-cache c-full-near-cache-limit delq] 6]) (defalias 'c-full-get-near-cache-entry #[257 "\211\236\206S\301\302\301\3032Q\203O@\262AA@\2035\304A@8V\2035AA@W\2035\305\303\"\210@W\203H@V\203H\266\211@A\262\202\2110\266\204\211\203g\211@=\204g\306\"\211B\307!\207" [c-full-lit-near-cache nil 0 found 8 throw delq copy-tree] 8 (#$ . 81681)])#@23 (fn HERE STATE END) (defalias 'c-full-put-near-cache-entry #[771 "G\302Y\203\303\304!@\"\211\202EB \206 ]\211\207" [c-full-lit-near-cache c-full-near-cache-limit 6 delq last] 7 (#$ . 85173)]) (defalias 'c-full-pp-to-literal #[513 "\212\214~\210\304 \210\305 \210\306 \307\310\"\216\311!\211@\211A@\312AA@\312\211\211\211\211 \2035\2035 Y\203X\313!\262@\262A\262 \203O\nV\203X\262\n\262\312\262 \nV\203d\203w\3148\203w\203\206 Y\203\206\315\n\312\211\f%\262\202\357\3168\203\232 \206\223`Sf\317=\204\320\3208\203\265\3218\204\265 \206\256`Sf>\204\320\3208\203\357\3218\203\357 \206\311`Sf\322>\203\357 \nY\203\345\315\n\312\211\f%\202\355\315\314 8\"\262\3168\204\3208\203s\3218\323=\204s\3168\203\324\202\3218\203\325\202\326\262\3148\262\2030Y\204W\315d\312\211\f\323&\262\3168\204W\3208\203T\3218\323=\203W`\262=\204h\327 #\210BE\202\302\f\204\257o\204\257\330u\210\331 >\203\213\332\333!\204\257\332\n!\203\257\332!\203\235\266\326\202\240\266\325`\334\335!\210`BE\202\302=\204\277\327 \312#\210C+\207" [c-block-comment-awkward-chars c-emacs-features c-comment-start-regexp c-block-comment-start-regexp c-trim-lit-pos-cache c-full-trim-near-cache match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] c-full-get-near-cache-entry nil c-parse-ps-state-below 8 parse-partial-sexp 3 92 4 7 (92 10) syntax-table string c++ c c-full-put-near-cache-entry -1 category-properties looking-at "\\s!" forward-comment 1] 21 (#$ . 83287)])#@12 (fn POS) (defalias 'c-truncate-lit-pos-cache #[257 "^ ^\n^\211\207" [c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit] 3 (#$ . 86821)])#@263 Truncate CC Mode's literal cache. This function should be added to the `before-change-functions' hook by major modes that use CC Mode's filling functionality without initializing CC Mode. Currently (2020-06) these are `js-mode' and `mhtml-mode'. (fn BEG END) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-truncate-lit-pos-cache speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-foreign-truncate-lit-pos-cache #[514 "^ ^\n^\211\207" [c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit] 5 (#$ . 86993)])#@239 Initialize CC Mode's literal cache. This function should be called from the mode functions of major modes which use CC Mode's filling functionality without initializing CC Mode. Currently (2020-06) these are `js-mode' and `mhtml-mode'. (defalias 'c-foreign-init-lit-pos-cache #[0 "\303^ ^\n^\211\207" [c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit 1] 3 (#$ . 87575)]) (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)#@43 (fn FROM TO &optional NOT-IN-DELIMITER) (make-variable-buffer-local 'c-state-nonlit-pos-cache-limit) (defalias 'c-state-pp-to-literal #[770 "\212\302 \303\304\"\216\305\"\306\211\3078\204\"\3108\203O\3118\312=\204O\3078\203,\313\2027\3118\2036\314\2027\315\262\305`d\306\211\312&\210\3168`BE\202\205\204\203o\204\203\317u\210\320\321!\204\203\320!\203\203\320 !\203r\266\315\202u\266\314`\322\323!\210`BE\202\205C*\207" [c-comment-start-regexp c-block-comment-start-regexp match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] parse-partial-sexp nil 3 4 7 syntax-table string c++ c 8 -1 looking-at "\\s!" forward-comment 1] 14 (#$ . 88312)]) (defalias 'c-state-safe-place #[257 "\214~\210\212\303\211\211\211\211\211\203 @ V\203 A\262\202\203>@V\203>@\262A\262\202#@\206Ee\262\204\272\n\\X\205W\n\\\211\262\203\262\304\"AA@\262\203xAXA\262\203\262b\210\305 \205\210`U?\205\210`\262\203\232\306 \210m\204\230\303u\210\210`\203\250\211X\262\203\262\262B\202K\203\272B V\203\302*\207" [c-state-nonlit-pos-cache c-state-nonlit-pos-cache-limit c-state-nonlit-pos-interval nil c-state-pp-to-literal c-beginning-of-macro c-syntactic-end-of-macro] 11 (#$ . 81681)]) (defalias 'c-state-literal-at #[257 "\214~\210\212\300!\301\"\262AA@*\207" [c-state-safe-place c-state-pp-to-literal] 5 (#$ . 81681)]) (defalias 'c-state-lit-beg #[257 "\300!@\206\211\207" [c-state-literal-at] 3 (#$ . 86821)])#@23 (fn HERE POS STATE) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-state-lit-beg speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-state-cache-lower-good-pos #[771 "\300\212b\210\3018\203#\302\300\211\303&\262`W\203#`\262\211\262`=\203/\3018\202W\302@T\300\300&\262\211@@V\203I\202W\3048@=\204V\202W)\207" [nil 8 parse-partial-sexp syntax-table 6] 11 (#$ . 89856)]) (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 #[0 "\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 #[0 "e\305\214~\210\306!\262\211\2034\212\211@b\210\307!\203\310\202(\307 !\203'\311\202(\312)\211@\211A\211\202;\305\211\211)\207" [c-block-comment-start-regexp c-line-comment-starter c-state-point-min-lit-type c-state-point-min-lit-start c-state-min-scan-pos nil c-state-literal-at looking-at c c++ string] 5]) (defvar c-state-brace-pair-desert nil)#@24 (fn &optional CACHE) (make-variable-buffer-local 'c-state-brace-pair-desert) (defalias 'c-state-cache-top-lparen '(macro . #[256 "\211\206\300\301\302\303DD\304D\303DF\207" [c-state-cache if consp car caar] 7 (#$ . 91314)])) (put 'c-state-cache-top-lparen 'edebug-form-spec t) (defalias 'c-state-cache-top-paren '(macro . #[256 "\211\206\300\301\302\303DD\304D\303DF\207" [c-state-cache if consp car cdar] 7 (#$ . 91314)])) (put 'c-state-cache-top-paren 'edebug-form-spec t) (defalias 'c-state-cache-after-top-paren '(macro . #[256 "\211\206\300\301\302\303DD\304D\305\303D\306\303DDEF\207" [c-state-cache if consp car cdar and 1+] 10 (#$ . 91314)])) (put 'c-state-cache-after-top-paren 'edebug-form-spec t) (defalias 'c-get-cache-scan-pos #[257 "\301\203 @:\203@@\202@Y\203 A\262\202\210\211@\211:\2035\211AV\2033\211@T\207A\207\211\203;T\207\302 X\203E\302 \207\301\207" [c-state-cache nil c-state-get-min-scan-pos] 5 (#$ . 81681)]) (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 #[257 "\212\214\211\304_V\203\211\304_Z}\210\211b\210\305o\204U\211\306U\204U\307\211\310 *\210o\204J\203J\311\312P!\203J\306\225\206>`Sf\313=\203 \306\225Sb\210\307f\313=\203S\202\210o?\205\\`*\207" [c-state-cache-too-far end-of-defun-function beginning-of-defun-function defun-prompt-regexp 10 2 0 nil beginning-of-defun looking-at "\\s(" 123] 5 (#$ . 81681)])#@24 (fn HERE- HERE+ TOP) (defalias 'c-state-balance-parens-backwards #[771 "\300\211\211\211\212\214e}\210\262\3011(\302\303\211#\211\262\205'B\262\262\2020*\210\262\211\203N\3041M\211\205L\302\305\303#\211\262\205L\262A\20260\210\207" [nil (error) scan-lists 1 (error) -1] 11 (#$ . 93074)])#@22 (fn HERE GOOD-POS) (defalias 'c-parse-state-get-strategy #[514 "\212b\210\304 \205\n`)\211\205\205\211U?\205\211\305\203&^\202'!\306\211\211\211\2063\307 \262\307 W\203K\310\262\306\262\306\262\210\311\202\214 X\203e\312\262]\262Z\262\202\214 Z ZW\203\200\313\262 Z\262\202\214\314\262\262Z\262\315 >\203\226\n\203\265\211V\203\265\316 !\262\203\265ZW\203\265\317\262\262D\207" [c-state-old-cpp-beg c-emacs-features open-paren-in-column-0-is-defun-start c-state-cache-too-far 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] 12 (#$ . 93396)]) (defalias 'c-renarrow-state-cache #[0 "eW\203\306 \210\307\n\307\202\216 \203e\310 W\204 \306 \210\307 B\307A@:\2032A@@\2025A@\211\262\203H\211eY\203HA\262\202$:\203\214A =\204dA@:\203mA@AeV\203m\307\n\266\202\216A\307\241\210\311 !\241\266 @:\203\210 @@\202\212 @T\266e\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] 5])#@38 (fn FROM HERE &optional UPPER-LIM) (defalias 'c-append-lower-brace-pair-to-state-cache #[770 "\212\214\302@:\203@@\202@b\210\303 \210`\211=\2045\211W\2035\211b\210\304 \210`Y\2035\2026\211\302\204?\262 \205\\ @=\205\\ @\203W @V\205\\ AX?\205b \205u @=\205u AY\205u A\205\201 W\205\201\203\217\211\203\217]\202\230\206\230\211\206\230e\305 T}\266\3061\337\307\310\211#\211\262\205\336\307\310\311#\211\262\205\336V\204\242\211W\205\336f\312=\203\242b\210\303 \205\336`W\205\336\202\2420\210\211\203\360\211W\203\360\211\262\202\236\211\203>\211W\203>W\203>f\312=\203>TB\262@:\203AB\211\202b@\247\2036\211@W\2036@ABB\211\202bB\211\202b\211\203SW\203S\211V\203S\202Te ^b\210\303 \210`B\211*\207" [c-state-cache c-state-brace-pair-desert nil c-beginning-of-macro c-end-of-macro buffer-size (error) scan-lists -1 1 123] 12 (#$ . 94665)])#@34 (fn BRA+1 MACRO-START-OR-HERE) (defalias 'c-state-push-any-brace-pair #[514 "\205/V\204b\210\301 \204*S\302\303\211#B@:\203%A\202&B\211\207\304Sd\"\207" [c-state-cache c-beginning-of-macro scan-lists 1 c-append-lower-brace-pair-to-state-cache] 7 (#$ . 95630)])#@18 (fn FROM HERE) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-state-push-any-brace-pair speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-append-to-state-cache #[514 "\212\211b\210\301 \210`)\212b\210\302 \203`\202)\303\303\211\211\211\212\214e }\210\3041S\305\306\307#\262B\262\305\306\211#\262\206B`Sf\310=\203L\262\240\210\202)\210\203\247V\203\247\205\224V\204sb\210\302 \204\217S\305\306\211#B@:\203\206A\202\207B\211\266\202\226\311Sd\"\266SB\262\303\262\303\262\202%\3121\267\305\306\211#\211\2620\202\271\210\303\204%\205\362V\204\321b\210\302 \204\355S\305\306\211#B@:\203\344A\202\345B\211\266\202\364\311Sd\"\266@\211\262\203$V\203\202b\210\302 \205`\262\211\206V\203$A\262\202\364\2032\211\2032^\2028\2068 *\207" [c-state-cache beginning-of-line c-beginning-of-macro nil (error) scan-lists 1 -1 123 c-append-lower-brace-pair-to-state-cache (error)] 17 (#$ . 95915)])#@35 (fn START-POINT HERE PPS-POINT) (defalias 'c-remove-stale-state-cache #[771 "\212\214\303d}\210\212b\210\304 \205`)W\205\"\212b\210\304 \205!`)\211\205/\212\211b\210\305 \210`)\306\211\211\211\211\211\211\203HV\203M W\203M\202Q^\262\n\203v\n@:\203c\n@@\202e\n@Y\203v\n@\242\262\nA\211\204W\n\203\226\n@:\203\226\n@AV\203\226\n@@\nAB\211@\262\307\262\203\251\n=\204\251T\202\253\f\262b\210\n\203>\n@\247\204\277\nA\203>`\fW\203>\204\320\210\310\202\334@=\203\334\210@S\311`` W\203\352\f\202\354 \306%\262@=\203\260`\262\n@:\203`\n@A=\203\nA\242\262\nA\243\211\202\261\n@\247\203*\n@\262\nA\211\202\261\nA@\247\203\260\nA@\262\nAA\211\204\264`W\203P\311`\f\306\211%\262\203kf\312=\203k\n\242:\203d\nAB\nB* F\207" [c-state-old-cpp-beg c-state-old-cpp-end c-state-cache 1 c-beginning-of-macro c-end-of-macro nil t -1 parse-partial-sexp 123] 20 (#$ . 96964)]) (defalias 'c-remove-stale-state-cache-backwards #[257 "\304!\305\211\211\211\211\211\211\211\211\212b\210\306 \210`)\f Ze]\n\203G\n@:\203-\n@@\202/\n@\211\262\fY\203G\n@:\262 \nA\n\262\f\202\n@:\203i\n@AV\203i\n@@\262\f\nABT\f\307E\207\310!\262@\206w \262A\206\201 \262\212b\210\311 \203\242\203\226`U\204\242`\262\312 \210`\262\202\250\262\262)\214\fd}\210\313#)\262\fW\203\314 \205\311\f\307E\207\214d}\210\262\f\3141\354\315\f\316\317#\211\262\f\205\353\n\262\f\202\3300)\210\214\211d}\210\3201\315\f\316\211#0\202\210\305)\211\262\203 T \205\f\305E\207\212b\210\316y\210`)\310!@\206(\211\262\262\fY\203:\f\305\211E\207 \205C\305E\207" [c-state-cache-good-pos c-state-cache-too-far c-state-cache c-state-old-cpp-beg 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)] 18 (#$ . 81681)]) (defalias 'c-state-cache-init #[0 "\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 #[257 "\211X\203 \211S\211 ^\n^^\210\f\203\"\211\306 W\203,\307\211\307\202X\211\fW\203X\310!\211@A@AA@\203H\311\"\210\211\203T\312\"\202U\266\f@\205w\211\f@W\203k\307\211\f\207\211\fAW\205w\f\241\207" [c-state-nonlit-pos-cache-limit c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit c-state-cache-good-pos c-state-cache c-state-get-min-scan-pos nil c-remove-stale-state-cache-backwards c-append-lower-brace-pair-to-state-cache c-append-to-state-cache c-state-min-scan-pos c-state-brace-pair-desert] 9 (#$ . 81681)]) (defalias 'c-parse-state-1 #[0 "`\304\305!\306\211\211\211\211\211\211\211\211eU\204\307 \210\310 \"\262@\262 A@\262\311=\2031\306\312\267\202\310\313\f\f#\262@\262A@\262AA@\262AAA@\262\203m\204g\314=\203m\315\f\"\210\316\f\"\262\203\216ZW\203\216\317#\202\220\266\202\316\320!\262@\262\266A@AA@\203\263\315\f\"\210\211\203\300\316\f\"\202\302\266\202\316\306\211\266\n\207" [c-state-point-min c-state-cache-good-pos c-state-cache c-state-cache-too-far line-beginning-position 0 nil c-renarrow-state-cache c-parse-state-get-strategy BOD #s(hash-table test eq purecopy t data (forward 56 back-and-forward 56 BOD 56 backward 150)) 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] 16]) (defalias 'c-invalidate-state-cache #[257 "\300\216\301\302\303\304#\210\301\305\303\304#\210\306!)\207" [#[0 "\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] 5 (#$ . 81681)])#@21 (fn PLACE MARKER) (defalias 'c-state-maybe-marker '(macro . #[514 "\300\301DC\302\301\303\304\305BBE\306\307BBFE\207" [let -place- and or setq ((make-marker)) set-marker (-place-)] 11 (#$ . 101178)])) (put 'c-state-maybe-marker 'edebug-form-spec '(form symbolp)) (defalias 'c-parse-state #[0 "\304\211\212\305 \203`\262\306 \211\262V\204\266\304\211)\307\216\310\311\312\304#\210\310\313\312\304#\210\314 )\205:\2046\315 \304\223\205J\n\204F\315 \n\304\223\207" [c-state-old-cpp-beg-marker c-state-old-cpp-beg c-state-old-cpp-end-marker c-state-old-cpp-end nil c-beginning-of-macro c-syntactic-end-of-macro #[0 "\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] 6]) (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)#@12 (fn ARG) (make-variable-buffer-local 'c-parse-state-state) (defalias 'c-record-parse-state-state #[0 "`\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 #[257 "\211J:\203\300!\202\301!\203\302!\202B\207" [copy-tree markerp copy-marker] 5 (#$ . 102211)] (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 #[0 "\301\302\303\304\305\306#\307Q\"\207" [c-parse-state-state message "%s" "(setq " mapconcat #[257 "\300\301@A:\204\302\202\303\304A!\203!\300\305\306A!\"\202#A$\207" [format "%s %s%s" "" "'" markerp "(copy-marker %s)" marker-position] 9 (#$ . 102211)] " " ")"] 7]) (defalias 'c-debug-parse-state-double-cons #[257 "\300\211\203@\262A\262:\203@:\203\210\301\202\207" [nil t] 4 (#$ . 80656)]) (defalias 'c-debug-parse-state #[0 "`e\306 \307\211\310\307\310\307\310\307\211\310\307\211\306 .\262\232\204<\311\312%\210\311\313!\210\314 \210\315!\203O\311\316#\210\311\313!\210\314 \210\317 \210\207" [c-state-old-cpp-end c-state-old-cpp-beg c-state-min-scan-pos c-state-point-min-lit-start c-state-point-min-lit-type c-state-point-min 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-brace-pair-desert c-state-nonlit-pos-cache-limit c-state-nonlit-pos-cache c-state-cache-good-pos c-state-cache] 15])#@22 (fn &optional ARG) (defalias 'c-toggle-parse-state-debug #[256 "\302\"\303\203\300\202\304KM\210\305\301!\203\306\307\310\203$\311\202%\312\"\207" [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"] 4 (#$ . 104127) "P"])#@27 (fn BUFPOS PAREN-STATE) (byte-code "\203\301\302!\210\301\207" [c-debug-parse-state c-toggle-parse-state-debug 1] 2) (defalias 'c-whack-state-before #[514 "\300C\211\300\2031\210@A\262\211:\203\211@\202\211W\203%\300\262\202C\241\210A\262\202A\207" [nil] 7 (#$ . 104467)]) (defalias 'c-whack-state-after #[514 "\3002D\211\205C\211@\211:\2033@X\204>AW\203*\301\300@AB\"\266\202?\301\300\"\266\202?X\204>\301\300\"\210\210A\2020\207" [done throw] 7 (#$ . 104467)])#@37 (fn PAREN-STATE &optional BUFPOS) (defalias 'c-most-enclosing-brace #[513 "\300\204\301\262\203)\210@A\262\211:\204\211Y\203#\210\300\202\300\262\202\207" [nil 134217727] 5 (#$ . 104983)])#@20 (fn PAREN-STATE) (defalias 'c-least-enclosing-brace #[257 "\300\211\203\210@A\262\211\250\203\211\262\202\207" [nil] 4 (#$ . 105197)]) (defalias 'c-safe-position #[514 "\205P\300\3012N\205M\210\211@\211:\2038\211AW\203%\302\301A\"\210\202F\211@W\203F\302\301@T^\"\210\202F\211W\203F\302\301T^\"\210A\262\202 0\262\207" [nil done throw] 7 (#$ . 104467)]) (defalias 'c-beginning-of-syntax #[0 "\304\3052F\203D\210\211@\211:\2032\211A`X\203\"\306\305A\"\210\202=\211@`X\203=\306\305@\"\210\202=\211`X\203=\306\305\"\210A\262\202e0\211`\307ZV\203Q\211b\207\304\211\310 *\210o\204{\203{\311\312P!\203{\313\225\206o`Sf\314=\203Q\313\225Sb\210`W\205\203\211b\207" [c-state-cache end-of-defun-function beginning-of-defun-function defun-prompt-regexp nil done throw 4000 beginning-of-defun looking-at "\\s(" 0 123] 6])#@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 #[0 "\212\306\307!\210\310!\203\310 !\204`\206\214\n\311=\203E`\312\313x\210\314\313x\315W\2042\211b\210\313f\316=\205@\310!\205@\315\225Y\205@`\262\206\214\f\205\214\317\315\313\320\321!#\315U\205\214\310\f!\203q \203m\317\322!\315U\203q\310 !\203q`\202\214\212 \205\207\310 !\205\207\323\322!\315U\205\207\310\f!)\205\214`)\207" [c-symbol-start c-keywords-regexp c-buffer-is-cc-mode c-symbol-key c-overloadable-operators-regexp c-opt-op-identifier-prefix skip-syntax-backward "w_" looking-at pike-mode "-!%&*+/<=>^|~[]()" nil "`" 0 96 c-backward-token-2 c-determine-limit 500 1 c-forward-token-2] 5 (#$ . 106079)]) (defalias 'c-simple-skip-symbol-backward #[0 "\302\303!\304W\2063\305=\2053`\306\307x\304W\203.\310\307x\304W\203.\311 !\203.\304\225Y\203.\312\207\211b\266\307\207" [c-buffer-is-cc-mode c-symbol-key skip-syntax-backward "w_" 0 pike-mode "-!%&*+/<=>^|~[]()" nil "`" looking-at t] 4])#@29 (fn &optional BACK-LIMIT) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-simple-skip-symbol-backward speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-beginning-of-current-token #[256 "`\301\302!\203\303\304\"\210\2022\303\305\"\306W\2032\301!\203#\306\225\206%`T\211X\205-\211b\262\204`W\207" [c-nonsymbol-token-regexp looking-at "\\w\\|\\s_" skip-syntax-backward "w_" ".()" 0] 5 (#$ . 107500)]) (defalias 'c-end-of-token #[256 "`\301\302!\303V\2045\304\305\"\303W\203+`W\2035\306!\203%\303\225b\210\202\307u\210\202\306!\2035\303\225b\210`V\207" [c-nonsymbol-token-regexp skip-syntax-forward "w_" 0 skip-syntax-backward ".()" looking-at nil] 5 (#$ . 107500)]) (defalias 'c-end-of-current-token #[256 "`\301\302S\"\303W\203\304\302!\210\2021\301\305\"\303W\2031\306!\203(\303\225b\210\202+\307u\210`W\204`V\207" [c-nonsymbol-token-regexp skip-syntax-backward "w_" 0 skip-syntax-forward ".()" looking-at nil] 5 (#$ . 107500)]) (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))#@401 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. LIMIT is the limit to where we might move to. (fn &optional BALANCED LIMIT) (defalias 'c-forward-over-token #[512 "\203\202 `\206d\3031r``\206dW\203+\214e\206%d}\210\304 )\210`U\2044\305\202pm\203<\306\202p\307!\203N\211\310`\311\"^b\210\305\202p\307\n!\203^\312\225^b\210\305\202p\214~\210\307\n!)\203l\306\202p\306u\210\3050\207\210b\306\207" [c-jump-syntax-balanced c-jump-syntax-unbalanced c-nonsymbol-token-regexp (error) c-forward-sws t nil looking-at scan-sexps 1 0] 10 (#$ . 108878)])#@499 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. (fn &optional BALANCED) (defalias 'c-forward-over-token-and-ws #[256 "\300!\301 \210\207" [c-forward-over-token c-forward-sws] 3 (#$ . 109730)])#@1329 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. (fn &optional COUNT BALANCED LIMIT) (defalias 'c-forward-token-2 #[768 "\204\300\262\301W\203\302[#[\207``\301U\203 \303 \210\214\203)e}\210`\304 \210`U\2048S\301]\262m\203K\301U\203E\300\262b\210\202k\301V\203d\305!\203dm\204d\210`S\262\202Km\203k\211b\210)\207" [1 0 c-backward-token-2 c-end-of-current-token c-forward-sws c-forward-over-token-and-ws] 7 (#$ . 110357)])#@100 Move backward by tokens. See `c-forward-token-2' for details. (fn &optional COUNT BALANCED LIMIT) (defalias 'c-backward-token-2 #[768 "\204\304\262\305W\203\306[#[\207\211\204\210e\203#\202$ `\305U\203t`\307 \210`V\203@`W\203t\304\262\202t\310\n!\203t\311f\312U\203q\203q\212`\313 \210\310\314!\210\305\225U\205mo\206m\315u\210`Sf\316=?)\203t\304\262\3171\277\305V\205\272`\206\204eV\203\225\214\206\216ed}\210\320 )\210\315u\210\310!\203\250\321`T\315\"b\210\202\253\307 \210`Y\205\272\210`S\262\202x0\210\202\303\210\211b\210`W\203\314\211b\210\207" [c-jump-syntax-balanced c-jump-syntax-unbalanced c-syntactic-ws-start c-opt-cpp-prefix 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] 8 (#$ . 112061)])#@308 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'. (fn &optional COUNT BALANCED LIMIT) (defalias 'c-forward-token-1 #[768 "\301\302#)\207" [c-nonsymbol-token-regexp "\\s." c-forward-token-2] 7 (#$ . 112912)])#@310 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'. (fn &optional COUNT BALANCED LIMIT) (defalias 'c-backward-token-1 #[768 "\301\302#)\207" [c-nonsymbol-token-regexp "\\s." c-backward-token-2] 7 (#$ . 113351)])#@2575 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 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. (fn REGEXP &optional BOUND NOERROR PAREN-LEVEL NOT-INSIDE-TOKEN LOOKBEHIND-SUBMATCH) (defalias 'c-syntactic-re-search-forward #[1537 "\204d\262\203\300\262`\301\211\211`\301\211e\301\3021`\262\303#\204U =\203Q\203Q\f\304>\204Q\305 \300#\262@\300=\203Q`S\262\301\202\305\306\224\301\n%\262`\262 \205x\203u@\306Y\205x \225\211\262\203\214\305\301\n%\262\202\222\262\262\307\234\203\242\303\310#\202\353\311\234\203\262\312\313#\202\353\314\234\204\356\206\275`Sf\315=\203\356\316S\317\"\204\356f\320>\203\356f\315U\203\344\303\310#\202\353\312\313#\202\353\2037@\211\262 \306U\2047\306V\203! \203b\210\202\356\305\306\301\n%\262`\211\262\202\353\f\203.`S\262\301\202\321\322C\"\202\353\323\234\211\262 \203\202 \204K\250\204Qb\210\202\356\324\325 \"\326\312#\203v\305`\301\211\f%\262`\262\323\234\202z\301\211\262\204W\262\202\353\212\327 \330\331\"\216\332\n!*\262\203\260\333 \210`X\204\356\f\203\247\301\202\321\322C\"\202\353\n\203\350W\204\326\212b\210\327 \330\334\"\216\335!)\266`)\211\262W\203\350 \203\340b\202\353^b\202\353\210\326\301\205`U\203`U\203\f?\205\321\322C\"\202\301u\210\326\205\2020\210\202& b\210\321@A\"\266\211\2031\306\225b\210\306\225\207\f\326=\203?b\210\202\206\f\336>\204M b\210\202\206\305\301\211\n%\262\323\234\204d\311\234\203\202\f\337=\203s\340\234b\210\202\206\305d\301\211\n\317&\210\202\206 b\210\301\207" [-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 make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] c-beginning-of-macro c-end-of-macro #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] c-end-of-current-token (before-literal after-literal) before-literal 8] 23 (#$ . 113795)])#@817 Like `skip-chars-backward' but only look at syntactically relevant chars. This means 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. (fn SKIP-CHARS &optional LIMIT PAREN-LEVEL) (defalias 'c-syntactic-skip-backward #[769 "`\212\211b\210\300!\210`)\301`\302\303\"\211\203G``\206eV\2030\214\206)ed}\210\304 )\210\203<`V\203C`\262\210\202G\211b\266`\301 x\305W\203\256\306 \211\262\203ab\210\202}\212\300 !\205t`W\205t`\211\262)\203\256\211b\203\256\203I``\n\206\211eV\203\233\214 \206\224ed}\210\304 )\210 \203\252`\nX\203\252\211b\210\210\202I`W\266\202\2030`\301\211\205+\212\307\310#\266\202`@\305U)?\205+@\305W\203$\212\307\301\211%\262@\305W)\203$\3111\312\310@[#b\210`\262 \203 Y\203 b\210\301\202\3130\266\203\202-\210 \206eb\266\2020\314\234Tb\210\301\266\203\204``\2068eV\203J\214\206Ced}\210\304 )\210`V\204`U?\207" [c-beginning-of-macro nil string-match "^\\^[^ \n ]+$" c-backward-sws 0 c-literal-start parse-partial-sexp -1 (error) scan-lists t 1] 17 (#$ . 118306)])#@511 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. (fn &optional LIM DETECT-CPP) (defalias 'c-in-literal #[512 "\214~\210\300`!\211A@\206\205\212\301 )\205\302)\207" [c-semi-pp-to-literal c-beginning-of-macro pound] 4 (#$ . 120031)])#@812 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. (fn &optional LIM NEAR NOT-IN-DELIMITER) (defalias 'c-literal-limits #[768 "\212`\2034\303`\"\3048\204\3058\205/\3068\307=?\205/\3108\303`d\311\211\307&\210`B\262\202P\312\"\211AA@\211\203N\211A\204N\211@dB\266\202\202P\266\201\211\206\341\205\341b\210\313\311w\210\314!\203\201`\3151u\316`\317\"b\210`0\202y\210\202|\206}dB\202\341\314 !\203\220`\320 \210`B\202\341\313\311x\210`\311\212\321\n!\322W)\203\267\3231\261\316`\324\"b\210`0\262\202\330\266\311\202\330\3251\303\326u\210\3270\202\307\210\202\330\203\330\314\330!\203\330b\210\331 \266`\211\205\337\211B\266\202)\207" [c-string-limit-regexp c-comment-start-regexp c-string-syntax 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] 13 (#$ . 120707)])#@240 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. (fn &optional SAFE-POS) (defalias 'c-literal-start #[256 "\211\203!\300`\"\3018\204\3028\205 \3038\304=?\205 \3058\207\306`!AA@\207" [parse-partial-sexp 3 4 7 syntax-table 8 c-semi-pp-to-literal] 4 (#$ . 122400)])#@500 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. (fn RANGE) (defalias 'c-literal-limits-fast 'c-literal-limits) (defalias 'c-collect-line-comments #[257 "\212\3011g\211:\203b\211@b\210\302!\203bi`\303\304!A\305 \203=`Y\203=\302!\203=iU\203=`\262\303\304!\262\202\211b\210\306\307w\210\302!\203ZiU\203Z\310y\304U`\262\204@B\266\204\202c\2110\202i\210\211)\207" [c-line-comment-starter (error) looking-at line-beginning-position 0 c-backward-single-comment " " nil 1] 7 (#$ . 122845)])#@429 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. (fn RANGE) (defalias 'c-literal-type #[257 "\211:\203-\212\211@b\210\301!\203\302\202+\301\303!\204&\301\304!\203*\301\305!\203*\306\202+\307)\207\207" [c-string-limit-regexp looking-at string "//" "\\s<" "#" c++ c] 3 (#$ . 123801)])#@23 (fn HERE ORG-START) (defalias 'c-determine-limit-no-macro #[514 "b\210\300 \205 `\211\203b\210\300 \205`=\204\207\207" [c-beginning-of-macro] 5 (#$ . 124466)])#@23 (fn START TRY-SIZE) (defalias 'c-determine-limit-get-base #[514 "b\210Ze]\300!\211AA@\206\211eY\203\207\301\302\211@\303&`\207" [c-semi-pp-to-literal parse-partial-sexp nil syntax-table] 13 (#$ . 124644)])#@56 (fn HOW-FAR-BACK &optional START TRY-SIZE ORG-START) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-determine-limit-get-base speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-determine-limit #[1025 "\212\206`\206\211\206\300_b\210Ze]\301!\211AA@\206'\211eY\2032\266\204\202A\302\303\211@\304&\266`\211\302\211\"\303\211\211\305b\210\306!\210`\262\nW\203\277\302\303\211 \304&\262\3078\203y\3108\304=\203\3118\203\205\3128\202\206`Z\262\305V\203\230BB\262\3078\203\246\3108\304=\203\254\3118\203\271\302`\303\211 \304&\262`\262\202V\211W\203\333\203\333@\262A\262\211A\\\262\202\277\204\nV\203\353\202ReV\203ZeV\203\313\n\300_\f$\202R\202R\211Y\203%\314@Z\\\n\"\202Re=\2030e\202R\n ZV\203D\314@\n\"\202R\313Z\n\300_\f$)\207" [2 c-semi-pp-to-literal parse-partial-sexp nil syntax-table 0 forward-comment 4 7 3 8 c-determine-limit c-determine-limit-no-macro] 21 (#$ . 124872)])#@36 (fn HOW-FAR &optional START-POS) (defalias 'c-determine-+ve-limit #[513 "\212\211\206`\300``\"b\210m\204I\301V\203I\300\211\\d^\302\211\303&\262`ZZS\262`\262\3048\203\300d\302\211\303&\262`\262\202`)\207" [parse-partial-sexp 0 nil syntax-table 8] 12 (#$ . 125940)]) (defvar c-find-decl-syntactic-pos nil) (make-variable-buffer-local 'c-find-decl-syntactic-pos) (defvar c-find-decl-match-pos nil)#@23 (fn CHANGE-MIN-POS) (make-variable-buffer-local 'c-find-decl-match-pos) (defalias 'c-invalidate-find-decl-cache #[257 "\205 \211W\205 \301\211\207" [c-find-decl-syntactic-pos nil] 3 (#$ . 126369)])#@27 (fn MATCH-POS DECL-POS) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-invalidate-find-decl-cache speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-debug-put-decl-spot-faces '(macro . #[514 "\300\301!\205\302\303D\304DD\305BB\207" [facep c-debug-decl-spot-face c-save-buffer-state match-pos decl-pos ((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))] 6 (#$ . 126579)])) (put 'c-debug-put-decl-spot-faces 'edebug-form-spec t) (defalias 'c-debug-remove-decl-spot-faces '(macro . #[514 "\300\301!\205\302\303\304\305BBB\304\306BBBF\207" [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)] 9 (#$ . 40398)])) (put 'c-debug-remove-decl-spot-faces 'edebug-form-spec t) (defconst c-bs-interval 2000) (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 #[0 "\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])#@25 (fn POS &rest IGNORE) (defalias 'c-truncate-bs-cache #[385 "^\211\207" [c-bs-cache-limit] 4 (#$ . 127974)])#@22 (fn STACK FROM TO) (defalias 'c-update-brace-stack #[771 "\305\211\306A@\212\211\203X\203b\210\202)\211\203%\211b\266\305\202)b\210`W\203Q\307@\310X\203<\202= \311#\203Q`V\203Q`\262\312\306!\262\313\n\"\262\262\314\232\203\214\315u\210\316\317!\305u\210\203\214\203\205@\310X\203|\306\202@TAB\202\207\306C\262\202)\320\232\203\311\315u\210\316\321!\305u\210\203\311\203\262@\306V\203\262@SAB\202\304A\203\303@\306=\203\303A\202\304\262\202)\322\232\203\373\315u\210\316\317!\305u\210\203\373\315u\210\323\305\324\305!*\203\365`V\203)\210`\202)\305u\210\202)\325\232\203\203@\310=\203\315AB\262\202)\326\232\203\"@\315=\204)\327\235\203?\203)A\203)@\310X\203)A\262\202)\330N\266\202\203)\310B\262\202)\306V\203Z\331 \210`)BB\207" [c-brace-stack-thing-key c-brace-stack-no-semi-key c-keywords-obarray c-restricted-<>-arglists c-parse-and-markup-<>-arglists 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] 12 (#$ . 128092)]) (defalias 'c-brace-stack-at #[257 "\212\214~\210\306 \nX\306\211\211\211\211\203'@@\nV\203'A\262\202\203D@@ V\203D\210@A\262\202*\203P@@\206Qe\262\203^@\202be\306\307E\262\211\204\227A\262\f\\\211\262 X\203\227\310#\262@\262A\262d=\204\221B\262\202l\nV\203\237\203\272 X\203\272 @V\203\272 \262 \262\202\302@\262A\262\nV\203\314\310#\262@A\211+\207" [c-bs-cache c-bs-prev-pos c-bs-cache-limit c-record-type-identifiers c-bs-interval c-bs-prev-stack nil 1 c-update-brace-stack] 13 (#$ . 81681)]) (defalias 'c-bs-at-toplevel-p #[257 "\300!\211?\206 \211A@\301X\207" [c-brace-stack-at 1] 4 (#$ . 81681)]) (defalias 'c-find-decl-prefix-search '(macro . #[0 "\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 (let ((cfd-cbsw-lim (max (- (point) 1000) (point-min)))) (c-backward-syntactic-ws cfd-cbsw-lim) (setq cfd-re-match (if (or (bobp) (> (point) cfd-cbsw-lim)) (point) (point-min)))))) (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]))#@57 (fn CFD-LIMIT CFD-DECL-RE CFD-FACE-CHECKLIST CFD-FUN) (defalias 'c-find-decl-spots #[1028 "`d\306e?\205\306\307\211\310`!\306\211\211\211` \311\312\"\211:\2036\211\2031\211@>\2041A\202\"\266\202\202;\211>\266\203\203\346o\204u`S \311\312\"\211:\203b\211\203]\211@>\204]A\202N\266\202\202g\211>\266\203\203u\313`\312\306e$b\210\202>\314\n!\204\205\315 \211\203\204\211b\210\210`\211\262\203\346\212b\210\316y\210`)X\203\346\212 b\210\317`\312\306$b\210`W\203\330` \311\312\"\211:\203\320\211\203\313\211@>\204\313A\202\274\266\202\202\325\211>\266\203\204\241`U)\203\346\262\202\275\212\316y\307U\205n\205`Y\205\320u\210`Sf\321=)\203 S\262\322\262\202\275\323 \203\322\262 \205'\211W\205'\306\211\266`\262=\204U`\2068e`\324Z]e]V\203U\214\206He`\324Z]e]d}\210\325 )\210`=\203h\f\203h\f\262 \262\202\275\212\323 )\203z \262 \262\202\275o\203\207\307\211\262 \202\221\320u\210\326 \210`W\203\262 \204\270\212\317`\327\306$b\210`W\203\264\311`S\327\"\330=\203\232`)\262\n\2044\n`V\203\310\nb\210\331 \332#\262\n\204\334\262\f\202\316\225\206\352:\205\352:T\225\211\262 \203\372b\210S\202\377\307\224b\210` \311\312\"\211:\203\211\203\211@>\204A\202 \266\202\202\"\211>\266\203\203\277\316\225\2046:\203\205:T\225\203\205`S \311\312\"\211:\203V\211\203Q\211@>\204QA\202B\266\202\202[\211>\266\203\203\205` \311\312\"\211:\203}\211\203x\211@>\204xA\202i\266\202\202\202\211>\266\203\203\216\317`\312\306$b\210`W\203\310` \311\312\"\211:\203\264\211\203\257\211@>\204\257A\202\240\266\202\202\271\211>\266\203\204%\202\310;\203\340\333\316!\203\340\212\316\224b\210\334 \335\336\"\216\314;!*\262\204\310\333\316!\203\333\316!\337\230\203\212\340\341!\307U?\206\375\314!\203\217\346\322!\202\240`W\203\243\314?!\203\243\307\225b\204_ \203\257 `^\202\260`\262W\205\274\203W\203\203\250\206\324 b\210`o?\205t\306@\204\350\343\320!\202\347\350!\211\307W\203\351\352`ZS\"\210\306f\353=\203\306u\210\210`Sf\353=\203`SSf\321=\203\320u\210\306\202\343\320!\211\262\204J`Sf\354=\2033\320u\210\202\335`Sf\353=\203J`SSf\354=\203J\355u\210\202\335\203Z\314\356!\203\327\341u\266\202v\314\357!\205t`Sf\321=\205t`W\205t\320u\210\202\327\266o\204}\320u\210\326 \210\360 \203\364\212\340\341!\307U\205\233\212\361 \210\314A!)\205\233`)\211\262\203\364\211b\210\202\364\203\360\204\266b\210\202\322 b\210\313`\327\306$b\210`V\203\322\311`\327\"\330=\203\272`U\203\364\314B!\204\364\362 \210`V\203\364b\210\202\364 b\210`\262\203W\203\306\262\f \203 W\203\306\262\n\203W\203uW\203ub\210`\2061dW\203C\214e\206=d}\210\363 )\210\203R`W\203R`\262\266\202w \204{\212\317`\327\306$b\210`W\203w\311`S\327\"\330=\203]`)\262\n\204\367\n`V\203\213\nb\210\331 \332#\262\n\204\237\262\f\202\304\316\225\206\255:\205\255:T\225\211\262 \203\275b\210S\202\302\307\224b\210` \311\312\"\211:\203\340\211\203\333\211@>\204\333A\202\314\266\202\202\345\211>\266\203\203\202\316\225\204\371:\203H:T\225\203H`S \311\312\"\211:\203\211\203\211@>\204A\202\266\202\202\211>\266\203\203H` \311\312\"\211:\203@\211\203;\211@>\204;A\202,\266\202\202E\211>\266\203\203Q\317`\312\306$b\210`W\203\213` \311\312\"\211:\203w\211\203r\211@>\204rA\202c\266\202\202|\211>\266\203\204\350\202\213;\203\243\333\316!\203\243\212\316\224b\210\334 \335\364\"\216\314;!*\262\204\213\333\316!\203\304\333\316!\337\230\203\304\212\340\341!\307U?\206\300\314!\203R\346\322!\202c`W\203f\314?!\203f\307\225b\204\" \203r `^\202s`\262\266W\203\n\206\203`Sf\365=\203\222\311S\366\"\203\370U\204\370V\203\272`\206\245dW\203\267\214e\206\261d}\210\363 )\210`\262`Y\204\365\314 !\203\365\203\n`\f\311\312\"\211:\203\355\211\203\350\211@>\204\350A\202\331\266\202\202\362\211>\266\203\204\nb\210`W\203\n\204\"\212\317`\327\306$b\210`W\203\311`S\327\"\330=\203`)\262\204\236 `V\2032b\210\331 \332#\262\204F \262\202k \316\225\206T:\205T:T\225\211\262 \203db\210S\202i\307\224b\210` \311\312\"\211:\203\207\211\203\202\211@>\204\202A\202s\266\202\202\214\211>\266\203\203) \316\225\204\240:\203\357:T\225\203\357`S \311\312\"\211:\203\300\211\203\273\211@>\204\273A\202\254\266\202\202\305\211>\266\203\203\357` \311\312\"\211:\203\347\211\203\342\211@>\204\342A\202\323\266\202\202\354\211>\266\203\203\370\317`\312\306$b\210`W\2032` \311\312\"\211:\203 \211\203 \211@>\204 A\202\n \266\202\202# \211>\266\203\204\217\2022;\203J \333\316!\203J \212\316\224b\210\334 \335\367\"\216\314;!*\262\2042\333\316!\203k \333\316!\337\230\203k \212\340\341!\307U?\206g \314!\203\365 \346\322!\202\n`W\203 \n\314?!\203 \n\307\225b\204\305 \203\n`^\202\n`\262\202w`W\205\257\f`\nY\203\204\nV\203I\n\212b\210\212\323 \205:\n`W)\203E\n\370 \210`\202F\n\307)\262\307U\204b\n`V\203\\\ne}\210\202b\n\307\262\202\204\n\307V\203j\n\210\306\n\307U?#\203y\n\306\262\307U\204\204\ne }\210b\210U\203\225\n \262\202w\204\270\n\212\317`\327\306$b\210`W\203\264\n\311`S\327\"\330=\203\232\n`)\262\2044\f`V\203\310\nb\210\331 \332#\262\204\334\n \262\202\f\316\225\206\352\n:\205\352\n:T\225\211\262 \203\372\nb\210S\202\377\n\307\224b\210` \311\312\"\211:\203\211\203\211@>\204A\202 \266\202\202\"\211>\266\203\203\277\316\225\2046:\203\205:T\225\203\205`S \311\312\"\211:\203V\211\203Q\211@>\204QA\202B\266\202\202[\211>\266\203\203\205` \311\312\"\211:\203}\211\203x\211@>\204xA\202i\266\202\202\202\211>\266\203\203\216\317`\312\306$b\210`W\203\310\n` \311\312\"\211:\203\264\211\203\257\211@>\204\257A\202\240\266\202\202\271\211>\266\203\204%\202\310\n;\203\340\333\316!\203\340\212\316\224b\210\334 \335\371\"\216\314;!*\262\204\310\n\333\316!\203\f\333\316!\337\230\203\f\212\340\341!\307U?\206\375\314!\203\213\f\346\322!\202\234\f`W\203\237\f\314?!\203\237\f\307\225b\204[\f\203\251\f`^\202\252\f`\262\202w\207" [c-type-decl-end-used c-literal-faces c-literal-start-regexp c-find-decl-syntactic-pos c-find-decl-match-pos c-decl-prefix-or-start-re 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 10000 c-backward-sws c-beginning-of-current-token c-type c-decl-end re-search-forward move match-string match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] ":" c-backward-token-2 2 1000 forward-comment 5 "\\\\[\n ]" c-forward-noise-clause-not-macro-decl skip-syntax-backward " >" skip-syntax-forward " " 10 13 -2 "\\*/" "[\n ]" c-on-identifier beginning-of-line c-forward-single-comment c-forward-sws #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] 60 syntax-table #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] c-end-of-macro #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] c-dposr-cpp-macro-depth c-opt-identifier-concat-key c-decl-start-colon-kwd-re c-noise-macro-name-re c-noise-macro-with-parens-name-re c-doc-line-join-re comment-end-can-be-escaped c-opt-cpp-macro-define-id c-doc-bright-comment-start-re] 25 (#$ . 132378)]) (defvar c-found-types nil) (make-variable-buffer-local 'c-found-types) (defvar c-record-found-types nil) (defalias 'c-clear-found-types #[0 "\301\302\303\304\305$\211\207" [c-found-types make-hash-table :test equal :weakness nil] 5])#@16 (fn FROM TO) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-clear-found-types speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-add-type-1 #[514 "\304#\305 \"?\205,\306\307 #\210\n?\205,\310\"\311=\205,\311\225G=\205,\312!\207" [c-recognize-<>-arglists c-found-types c-record-found-types c-symbol-key c-syntactic-content gethash puthash t string-match 0 c-fontify-new-found-type] 7 (#$ . 141298)]) (defalias 'c-add-type #[514 "\203 \203 X\203\211Y\203\303\211\207\304\"\207" [c-new-id-start c-new-id-end c-new-id-is-type t c-add-type-1] 5 (#$ . 141298)])#@13 (fn NAME) (defalias 'c-unfind-type #[257 "\301\"\207" [c-found-types remhash] 4 (#$ . 141930)]) (defalias 'c-check-type #[514 "\302\303# \"\207" [c-recognize-<>-arglists c-found-types gethash c-syntactic-content] 7 (#$ . 141298)])#@15 (fn TYPE _) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-check-type speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-list-found-types #[0 "\301C\302\303\304\"\"\210\305\242\306\"\207" [c-found-types nil maphash make-closure #[514 "\300\300\242B\240\207" [V0] 5 (#$ . 142173)] sort string-lessp] 5]) (defalias 'c-trim-found-types #[771 "V\203B\212dW\203$b\210\301 \203$b\210\302 \203$\303\304`\"!\210eV\203Ab\210\302 \203Ab\210\301 \203A\303\304`\"!\210)\205h\305\"\203\\U\206h\306\307\3108\"\206h@\311=\205h\303A@!\207" [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] 7 (#$ . 71822)])#@22 (fn &optional POS) (defalias 'c-clear-<-pair-props #[256 "\212\211\203\211b\210\202 \210`\306`\307\"\232\205v\307 p\310\311#\216\312 !\210\31310\314`\315\316#0\2022\210\317\211\2039\211b\210)\266\306`S\307\"\n\232\203_`S\320\211T\321#\266`S^\f^ ^\210\320\211T\322#\210\211^\f^ ^\211\262)\207" [c-<-as-paren-syntax c-no-parens-syntax-table c->-as-paren-syntax c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit get-text-property syntax-table make-closure #[0 "r\300q\210\302\301!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table (error) scan-lists 1 0 nil remove-text-properties (category . #1=(nil)) (category . #1#)] 7 (#$ . 142983)]) (defalias 'c-clear->-pair-props #[256 "\212\211\203\211b\210\202 \210`\306`\307\"\232\205s\307 p\310\311#\216\312 !\210\31310\314`\315\316#0\2022\210\317\211\2039\211b\210)\266\306`\307\"\n\232\203\\`\320\211T\321#\266`^\f^ ^\210\320\211T\322#\210\211^\f^ ^\211\262)\207" [c->-as-paren-syntax c-no-parens-syntax-table c-<-as-paren-syntax c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit get-text-property syntax-table make-closure #[0 "r\300q\210\302\301!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table (error) scan-lists -1 1 nil remove-text-properties (category . #1=(nil)) (category . #1#)] 7 (#$ . 142983)]) (defalias 'c-clear-<>-pair-props #[256 "\300f\301=\203\302!\207\300f\303=\203\304!\207\305\306!\210\307 \207" [nil 60 c-clear-<-pair-props 62 c-clear->-pair-props message "c-clear-<>-pair-props called from wrong position" ding] 3 (#$ . 142983)])#@26 (fn LIM &optional POS) (defalias 'c-clear-<-pair-props-if-match-after #[513 "\212\211\203\211b\210\202 \210`\306`\307\"\232\205l\307 p\310\311#\216\312 !\210\31310\314`\315\316#0\2022\210\317\211\2039\211b\210)\266`Y\205l\306`S\307\"\n\232\205l`S\320\211T\321#\266\320\211T\322#\210\211^\f^ ^\210`)\207" [c-<-as-paren-syntax c-no-parens-syntax-table c->-as-paren-syntax c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit get-text-property syntax-table make-closure #[0 "r\300q\210\302\301!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table (error) scan-lists 1 0 nil remove-text-properties (category . #1=(nil)) (category . #1#)] 8 (#$ . 144596)]) (defalias 'c-clear->-pair-props-if-match-before #[513 "\212\211\203\211b\210\202 \210`\306`\307\"\232\205j\307 p\310\311#\216\312 !\210\31310\314`\315\316#0\2022\210\317\211\2039\211b\210)\266`X\205j\306`\307\"\n\232\205j`\320\211T\321#\266`^\f^ ^\210\320\211T\322#\210`)\207" [c->-as-paren-syntax c-no-parens-syntax-table c-<-as-paren-syntax c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit get-text-property syntax-table make-closure #[0 "r\300q\210\302\301!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table (error) scan-lists -1 1 nil remove-text-properties (category . #1=(nil)) (category . #1#)] 8 (#$ . 144596)])#@23 (fn PT-S PT-SEARCH) (defalias 'c-end-of-literal #[514 "AA@\205\224A@AA@\303\212\304\267\202\220\2039\305!\2039 \306\307!!\262GSZe]b\210\310\303\311#\210\202\220b\210\310\312\303\311#\210\202\220\206J`Sf\313=\203\204f\314=\203\204S\n^\315\211T\316\317$\266\320d\303\211 @\316&\210S\n^\321\211T\322#\266\202\220\320d\303\211 @\316&\210`)\266\203\207" [c-ml-string-opener-re c-make-ml-string-closer-re-function c-syntax-table-hwm nil #s(hash-table test eq purecopy t data (string 22 c 69 c++ 69)) c-ml-string-opener-at-or-around-point match-string 1 re-search-forward stay "\$?:\\\\\\(?:.\\|\n\$\\|[^\"\n\\]\\)*[\"\n]" 92 10 put-text-property syntax-table (1) parse-partial-sexp remove-text-properties (syntax-table nil)] 12 (#$ . 145961)])#@34 (fn BEG END &optional OLD-LEN) (defalias 'c-unmark-<>-around-region #[770 "\211\204\nV\205\271\206`Sf\306>\203S\202f\307>\203(T\202)\310!\211AA@\310!\211AA@\311\"\311\"\312\211\211=\203o=\203o?\205\206 \206be]\206he]B\262\202\210\206v \206~e]\206\204e]B\262\211\205\267\313 \314\211\314\315\316\"\216\312C\312\211C\315\317 &\216\203\357b\210\fA@\320=\203F=\204F\321\312w\210\312f\322=\203F\321\312x\323U\204F\211\314\240\210\324 S\325\"\203S^\326\211T\327#\266S^\330\211T\325\331$\210\326\211T\332#\210\326\211T\333#\266\202FS^\330\211T\325\331$\210\326\211T\334#\210\326\211T\335#\266S^\326\211T\336#\266b\210\206Pd\324`\325\"`Y\203`\266\312\202\206\211\203l\312u\210\266\201\202\206\337`\325\312$\211\205\204\211W\205\204\211Tb\210\324\325\"\266\203\211\262\203\241\324`S\340\"\204J`SB\242B\240\210\202J^\330\325\341$\210V\203\357\203\357\206\302`Sf\322=\203\357\324S\325\"\342\232\203\357S\343B\242B\240\210S^\330\211T\325\344$\266b\210\345 \312\211\211\206\376b\210\346\347!\262Ab\210\350\351\"\210`Sf\352=\2035\353 \210\312f\352=\203\n\354 @!\211\262\203/\211\262\n`\262\202\n@b\210\355\347!\262\356\357\360#\203\231`Sf\361=\203\231`Sf\361=\203?\362\f!\203k\312f\361=\204k\323\225b\210\202?\363 A`S\"\211\262\203\207\n\203\204\211W\203\207\211\262 \203\223`\nV\203?`\262\n\202?-\266\203\250 W\203\250\205\2674V\205\267\2114\266\213\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-syntax-table-hwm c->-op-cont-regexp c-new-BEG (47 42) (47 42) c-semi-pp-to-literal c-end-of-literal nil buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] #[0 "\304\203`\307\306\305W\203\310\306\311\"\203\210\306\202(\312\306\311\307\305$\211\262\305W\204(\210\211\305W\203:^\313\305\314#\210\210\301\242\211\203_\211@\211A\203Z\211@^\315\211T\311A$\266\210A\202=\210\300\242\205\312\310\303S\311\"\203\233\303S^\313\211T\316#\266\302S^\315\211T\311\317$\210\313\211T\320#\210\313\211T\321#\207\303S^\315\211T\311\317$\210\313\211T\322#\210\313\211T\323#\266\302S^\313\211T\324#\262\207" [V0 V1 V2 V3 V4 V5 V6 nil get-text-property syntax-table next-single-property-change remove-text-properties (syntax-table nil) put-text-property (syntax-table . #1=(nil)) #2=(15) (c-is-sws . #1#) (c-in-sws . #1#) (c-is-sws . #1#) (c-in-sws . #1#) (syntax-table . #1#) most-positive-fixnum c-syntax-table-hwm] 8] string "\\\\" 10 0 get-text-property syntax-table remove-text-properties (syntax-table . #1#) put-text-property #2# (c-is-sws . #1#) (c-in-sws . #1#) (c-is-sws . #1#) (c-in-sws . #1#) (syntax-table . #1#) next-single-property-change category (1) (15) (15) (1) c-literal-start c-determine-limit 5000 c-syntactic-skip-backward "^;{}<" 60 c-backward-token-2 c-clear-<-pair-props-if-match-after c-determine-+ve-limit c-syntactic-re-search-forward "[;{}>]" end 62 looking-at c-clear->-pair-props-if-match-before c-new-END] 28 (#$ . 146747)]) (defalias 'c-before-change-check-<>-operators #[514 "\211V\205Bb\210`Sf\211\302>\205@\303`S\304\"\205@b\210\305\306=\203(\202) !\205@\211\306=\204;\307f\310=?\205@\311S\"\262\207" [c-<-op-cont-regexp c->-op-cont-regexp (60 62) get-text-property syntax-table looking-at 60 nil 62 c-unmark-<>-around-region] 6 (#$ . 40398)]) (defalias 'c-after-change-check-<>-operators #[514 "\212b\210\301\302!\204\303\304x\305W\203Ab\210\306 \210`W\203A\301!\203A\305\225\211\262W\203A\307w\210`W\203A\310 \210\304u\210\202.W\205\207\211b\210\301\302!\204X\303\304x\305W\205\207\211b\210\306 \210`W\205\207\301!\205\207\211\305\225\211\262W\205\207\307w\210`W\205\207\310 \210\304u\210\202t)\207" [c-<>-multichar-token-regexp looking-at "[<>]" "<>" nil 0 c-beginning-of-current-token "^<>" c-clear-<>-pair-props] 5 (#$ . 40398)]) (defalias 'c-<>-get-restricted #[0 "\212\301 \210\302!?\205\303 \210`Sf\304>\205\305`\306\"\307=?)\207" [c-opt-<>-sexp-key c-backward-token-2 looking-at c-backward-sws (40 44) get-text-property c-type c-decl-arg-start] 3]) (defalias 'c-restore-<>-properties #[771 "\306 \307\211\307\310\311\"\216\307\312\fb\210\313 \211\262\203\211Ab\210` W\205_\314\315 \316#\205_`Sf\317=\203N\320u\210\321 \322\312!\204J\323 \204J b\210)\202\212\324\312\211\321#\203[\f`^)\202-\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-parse-and-markup-<>-arglists c-new-BEG c-new-END buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] nil c-literal-limits c-syntactic-re-search-forward "[<>]" bound 60 -1 c-<>-get-restricted c-forward-<>-arglist c-forward-over-token-and-ws c-backward-<>-arglist c-restricted-<>-arglists] 10 (#$ . 71822)])#@206 Return `c-ml-string-any-closer-re'. This is a suitable language specific value of `c-make-ml-string-closer-re-function' for most languages with multi-line strings (but not C++, for example). (fn OPENER) (defalias 'c-ml-string-make-closer-re #[257 "\207" [c-ml-string-any-closer-re] 2 (#$ . 151758)])#@202 Return `c-ml-string-opener-re'. This is a suitable language specific value of `c-make-ml-string-opener-re-function' for most languages with multi-line strings (but not C++, for example). (fn CLOSER) (defalias 'c-ml-string-make-opener-re #[257 "\207" [c-ml-string-opener-re] 2 (#$ . 152067)])#@78 Construct a regexp for a C++ raw string closer matching OPENER. (fn OPENER) (defalias 'c-c++-make-ml-string-closer-re #[257 "\300\301\302\303O!\304Q\207" ["\$)" regexp-quote 2 -1 "\\(\"\$\\)"] 6 (#$ . 152367)])#@78 Construct a regexp for a C++ raw string opener matching CLOSER. (fn CLOSER) (defalias 'c-c++-make-ml-string-opener-re #[257 "\300\301\302\303O!\304Q\207" ["\$R\\(\"\$" regexp-quote 1 -1 "(\\)"] 6 (#$ . 152587)]) (defvar c-old-beg-ml nil) (defvar c-old-1-beg-ml nil) (defvar c-old-end-ml nil) (defvar c-beg-pos nil) (defvar c-end-pos nil) (defvar c-ml-string-end-delim-disrupted nil)#@22 (fn STRING-DELIMS) (defalias 'c-depropertize-ml-string-delims #[257 "\305@A@@@\305W\203\306\307\"\203\210\2021\310\307\305$\211\262W\203.\266\201\2021\266\211W\205B ^\311\312#\210\211\266\202\211\262\203X\211\n^^\f^\210A\205\266AA@A@\305W\203v\306\307\"\203v\210\202\215\310\307\305$\211\262W\203\212\266\201\202\215\266\211W\205\236 ^\311\313#\210\211\266\202\211\262\205\266\211\n^^\f^\211\262\207" [most-positive-fixnum c-syntax-table-hwm c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit nil get-text-property syntax-table next-single-property-change remove-text-properties (syntax-table . #1=(nil)) (syntax-table . #1#)] 10 (#$ . 152979)])#@19 (fn OPEN-DELIM) (defalias 'c-get-ml-closer #[257 "\212\211A@b\210\301`S\302\"\303\232?\205)\304\305@A@\"!\306\307#\205)\310\224\310\225\311\224BB)\207" [c-make-ml-string-closer-re-function get-text-property syntax-table (15) re-search-forward buffer-substring-no-properties nil t 1 2] 6 (#$ . 153720)]) (defalias 'c-ml-string-opener-around-point #[0 "`\302SZe]b\210\303 S\\d^\304#\211\262\203!\305\225X\204\n\211\2054\305\224W\2054\305\224\305\225\306\224BBb\210\207" [c-ml-string-max-opener-len c-ml-string-opener-re nil search-forward-regexp bound 1 2] 6])#@31 (fn &optional START FINISH) (defalias 'c-ml-string-opener-intersects-region #[512 "`\302\204 `\262\204`\262SZe]b\210\303 S\\d^\304#\211\262\203/\305\225X\204\211\205B\305\224W\205B\305\224\305\225\306\224BBb\210\207" [c-ml-string-max-opener-len c-ml-string-opener-re nil search-forward-regexp bound 1 2] 8 (#$ . 154303)])#@27 (fn &optional POSITION) (defalias 'c-ml-string-opener-at-or-around-point #[256 "`\302\204 `\262SZe]b\210\303 \\d^\304#\211\262\203'\305\225W\204\211\205:\305\224X\205:\305\224\305\225\306\224BBb\210\207" [c-ml-string-max-opener-len c-ml-string-opener-re nil search-forward-regexp bound 1 2] 7 (#$ . 154652)])#@22 (fn OPENING-POINT) (defalias 'c-ml-string-back-to-neutral #[257 "\212\211b\210\302!\210\303\225) \204,\212\304 \210o\204&`SSf\305=\203&\306u\210\202`)]b\207\307 \310\311!]\312#\207" [c-ml-string-opener-re c-ml-string-back-closer-re looking-at 1 beginning-of-line 92 -1 re-search-backward line-end-position 0 bound] 7 (#$ . 154984)])#@27 (fn BEG END OPEN-DELIM) (defalias 'c-ml-string-in-end-delim #[771 "\212b\210\211\203A@X\203\211A@b\210\202\303@!\210\304\203=\305 !\203=\306 \307=\203=\310 \211\262\203=\311\225b\204n\304\312 \n\\d^\313#\203b\212\314\225b\210\306 \203X\313\202^\310 \266\202\313\304)\204>\211\205i`X\262\204=\315!\266\310 ?\206\221m\204\203`X\206\221\311\224V\206\221\316\224b\210\317 ??\205\232\314\224\314\225B)\207" [c-ml-string-back-closer-re c-ml-string-any-closer-re c-ml-string-max-closer-len-no-leader c-ml-string-back-to-neutral nil looking-at c-in-literal string match-data 0 search-forward-regexp t 1 set-match-data 2 c-literal-start] 9 (#$ . 155332)]) (defalias 'c-ml-string-delims-around-point #[0 "`\306`!\307\211\211\211\211A@\204`SZe]b\210\307\262\310 S\\\311#\203{\312\224W\203{\212\312\224b\210\313 \206D\314 \205D\315 \210`W)\204u\312\224\211\262\203{`X\203{\316 \317\320\"\216\310\n\321\312!! \311#)\262\203{`X\203{\307\262\202\204\222A@\322=\203\277\3238b\210\324 \203\277\312\224\312\225\323\224BB\262A@b\210\310\n\321\312!!\307\311#\205\266\312\224\312\225\323\224BBB\262b\210\207A@\204L\204\325\fSZe]b\210\202\337b\210\325\307\311#\210\310 S\\\311#\203L\312\225Y\203L\323\225X\203L\312\224\312\225\323\224BB\262@b\210\306`!\211\262\203LA@\322=\203L\3238b\210\326 \211\262\203L\211A@b\210\312\224\312\225\323\224BB\262\310\n\321\312!!\307\311#\203Lb\210B\207b\307\207" [c-ml-string-max-opener-len c-ml-string-opener-re c-make-ml-string-closer-re-function c-ml-string-back-closer-re c-ml-string-max-closer-len c-ml-string-any-closer-re c-semi-pp-to-literal nil re-search-forward t 1 c-in-literal c-beginning-of-macro c-end-of-macro match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] match-string-no-properties string 2 c-ml-string-opener-at-or-around-point re-search-backward c-ml-string-opener-around-point c-ml-string-max-closer-len-no-leader] 13])#@25 (fn ML-STRING-DELIMS) (defalias 'c-position-wrt-ml-delims #[257 "\211\204\300\207`@A@W\203\301\207\211A\203`A@X\203 \302\207`AA@=\203+\303\207\304\207" [nil open-delim string after-close close-delim] 3 (#$ . 157339)]) (defalias 'c-before-change-check-ml-strings #[514 "\211b\210\306\307 b\210\310 \311\n!\n\206o?\205!Sb\210\310 \211b\210\211=\204E\n\203I\211\n@@Y\203I\nA\203E\211\nAA@W\203I\n\202K\310 \311 !\312 \313\211\313\314\315\"\216\316\n@#\306\211\204s?\206V\203\247\203\247\nA\203\211@\nA@X\203\247\266\n@@A\313\317\"\210^]\211\202V \203\335W\203\335b\210`Sf\320=\203\335\321 \203\335`\322 \210`\317\"\210^]\211\266\202\202V\n \232\203\360\323=\203\360\323=\206V\n\203,\n@@=\203W\204,\324=\203 \203,\324=\203,\n \232\203,\324=\205V\324=\205V\n \232\205V \2061\nAA@ \2069\n@@\262\211\206Bd\266\202\317\"\210^]\211,\207" [c-ml-string-end-delim-disrupted c-old-END-literality c-old-beg-ml c-beg-pos c-old-1-beg-ml c-old-end-ml nil c-in-literal c-ml-string-delims-around-point c-position-wrt-ml-delims buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] c-ml-string-in-end-delim c-depropertize-ml-strings-in-region 92 c-beginning-of-macro c-end-of-macro string open-delim c-end-pos buffer-undo-list inhibit-read-only inhibit-modification-hooks c-new-BEG c-new-END] 12 (#$ . 40398)]) (defalias 'c-after-change-unmark-ml-strings #[771 "\306 \307\211\307\310\311\"\216\312\211\211\211b\210\212m\204G\312\210\212`b\210\2034\312f\313>\2034`Sf\314=\202=\315\316\312x\317\"\320U?)\203G\312y\210\202\312\210`)\262\f\204\353\321 \307#\203\353\322!\262A@\323=\203\353\310\324\"\216b\210\325@8\250\203\203\325@8c\210\202\257\325@8\307=\203\257\326c\210:^:\327\211T\330\331$\210\332\211T\333#\210\332\211T\334#\210;^;<^<=^=\210\212\317\225Tb\210>\335?\336\317!!\312\307#\203\337\317\225S\202\340]>)\337`T\")\210b\210=\203\340!\262\202\341\"\262\211\203\217\211@X\203\217\322@!\211\262\203\217A@\204\217@@^@\211A@b\210\335?\342@A@\"!\312\307#\203H>\317\225]>@b\210\343\344\326!P>\206Wdw\210`W\203p\345`\330\"\346\232\204p\312u\210\202W`W\205{\321\347!\210`\266\202\203\210\350`S!\210\202L\337@>\"\210A\204\240B\203\250C\351=\203\250B@@b\202W\203\222B\204\222D\203\222\212Sb\210\352D@@!\210\335?\342D@@D@A@\"!\312\353#\210`V)\203\222D@@b\210@`^@`;^;<^<=^\211=\262\203\222\354 !\203\222\317\225b\210\335?\336\317!!\312\307#\203\222\345\355\224\356\"\203+\350\355\224!\210d\211>B\2066D@@\312W\203J\345\330\"\203J\210\202b\357\330\312$\211\262W\203^\266\201\202b\266E\211W\203t:^:\332\360#\210\266B\206}D@@;^;<^<=^=\210B\203aC\323=\203a=\203ab\210\352B@@!\210FA\203\307FAA@ZG\\d^\202\310dFA\203\331FAA@Z\202\332d\335?\342B@@B@A@\"!\353#\203_\317\225W\203_\211>]\211>B@@\312W\203\345\330\"\203\210\202+\357\330\312$\211\262W\203'\266\201\202+\266E\211W\203=:^:\332\361#\210\266B@@@^@B@@;^;<^<=^=\210\266W\203\214\f\323=\203\214B\203\214b\210\352B@@!\210\321H\212b\210\312\210`)GS\\\307#\211\262\203\247\317\225W\203\247\317\225b\210\202\203\214\320\224X\203\214I\362\317!!\363\312\307#\211\262\203\326\322`!\211\262\203\326\325@8\364>\204\271\210\203\214`@^@d>`>J\203@K\203@KW\203@\211JV\203@\211W\203?\312W\203\345\356\"\203\210\211\202+\357\356\312$\211\262W\204+\210E\211\262\203?\211W\203?\365!\210T\202\210\312W\203S\345\330\"\203S\210\202d\357\330\312$\211\262W\204d\210E\211W\203v:^:\332\366#\210\266`;^;<^<=^=\210\212b\210\367 \210`)b\210`\212b\210\312\210`)W\205\331\335L\212b\210\312\210`)\370#\205\331\317\225X\203\230\317\224Y\203\230\317\224b\210\371 \210\337\317\224`\"\210\202\230,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-escaped-newline-takes-precedence c-old-END-literality c-ml-string-opener-re buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] nil (10 13) 92 logand "\\\\" 1 0 search-forward-regexp c-semi-pp-to-literal string #[0 "\300b\210\304\305!\210\300 ^\n^^\211\207" [V0 c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit delete-char 1] 3] 3 34 put-text-property syntax-table (15) remove-text-properties (c-is-sws . #1=(nil)) (c-in-sws . #1#) re-search-forward match-string-no-properties c-depropertize-ml-strings-in-region c-ml-string-opener-at-or-around-point c-ml-string-opener-intersects-region buffer-substring-no-properties "^" char-to-string get-text-property (15) "\$\n\\|.\$" c-remove-string-fences open-delim c-ml-string-back-to-neutral bound looking-at 2 c-fl-syn-tab next-single-property-change (syntax-table . #2=(nil)) (syntax-table . #2#) match-string re-search-backward (t 34) c-clear-syn-tab (syntax-table . #2#) beginning-of-line boundt c-end-of-macro c-syntax-table-hwm c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit c-new-END c-make-ml-string-closer-re-function c-new-BEG c-ml-string-end-delim-disrupted c-old-beg-ml c-beg-pos c-old-1-beg-ml most-positive-fixnum c-old-end-ml c-ml-string-max-closer-len-no-leader c-ml-string-any-closer-re c-make-ml-string-opener-re-function c-min-syn-tab-mkr c-max-syn-tab-mkr c-anchored-cpp-prefix] 19 (#$ . 71822)]) (defalias 'c-maybe-re-mark-ml-string #[0 "\300\211\211\301`S!\211\262\2058\212@b\210\302 )?\2058\212\303 \262\205&\304 \210`)\262\305\"\2047\211\2065db\210\306\207" [nil c-ml-string-opener-at-or-around-point c-in-literal c-beginning-of-macro c-end-of-macro c-propertize-ml-string-opener t] 6])#@14 (fn DELIM) (defalias 'c-propertize-ml-string-id #[257 "\212\211@b\210A@w\210`A@W\205=`AA=\2047` ^\305\211T\306\307$\266`\n^^\f^\210\310u\210\202)\207" [c-ml-string-non-punc-skip-chars c-syntax-table-hwm c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit put-text-property syntax-table (1) nil] 7 (#$ . 163280)])#@20 (fn DELIM BOUND) (defalias 'c-propertize-ml-string-opener #[514 "\306!\210A@b\210\307\310@A@\"!\311#\203_\312\224\312\225\313\224BB\306!\210A@b\210\314 @\"\210`@W\203Y`\n^\315\211T\316\317$\266`^\f^ ^\210\320u\210\202*\211A@b\311\207AA\n^\315\211T\316\321$\266A@S\n^\315\211T\316\322$\210\323\211T\324#\210\323\211T\325#\266AAS^\f^ ^\210\211\203+\211b\210\214A@d}\210\326\327A@\311#)\203(\330\224\203\354\330\224\n^\315\211T\316\322$\210\323\211T\331#\210\323\211T\332#\266\330\224^\f^ ^\210\202(\333\224\n^\315\211T\316\334$\266\333\224T\n^\315\211T\316\322$\210\323\211T\335#\210\323\211T\336#\266\333\224^\f^ ^\210\211b\210\320\207" [c-make-ml-string-closer-re-function c-ml-string-non-punc-skip-chars c-syntax-table-hwm c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit c-propertize-ml-string-id re-search-forward buffer-substring-no-properties t 1 2 skip-syntax-forward put-text-property syntax-table (1) nil (1) (15) remove-text-properties (c-is-sws . #1=(nil)) (c-in-sws . #1#) re-search-backward "\$\\(\\`[^\\]?\\|[^\\][^\\]\$\$\\\\\\(.\\|\n\$\\)*\$\\\\.\$\\|\$\\`\\|[^\\]\\|\\(\\`[^\\]?\\|[^\\][^\\]\$\$\\\\\\(.\\|\n\$\\)+\\)\$[^\\]\$\\)\$\\\\\n\$*\\=" 10 (c-is-sws . #1#) (c-in-sws . #1#) 5 (1) (c-is-sws . #1#) (c-in-sws . #1#)] 10 (#$ . 163637)]) (defvar c-neutralize-pos nil) (defvar c-neutralized-prop nil)#@28 (fn STRING-DELIMS BOUND) (defalias 'c-depropertize-ml-string #[514 "A\203H\306AAA\307\"\310\232\203HAAAb\210\3111$\312`\313\"b0\202(\210\202H\203H`S^\314\211T\315#\266`S ^\n^^\210\316!\210A\203XAA@\202Y\211\317\211\203\263@A@\317W\203u\306\307\"\203u\210\202\214\320\307\317$\211\262W\203\211\266\201\202\214\266\f\211W\205\235^\314\321#\210\211\262\211\262\203\263 ^\n^^\210\322 \206\273@@\206\300d\"\262\3238?\2063 \204\365\3248\306 \307\" ^\325\211T\307\326$\266 ^\n^^\211\207\3238 f=\2053\203 ^\325\211T\307$\266\202\" ^\314\211T\327#\266 ^\n^^\210\317\211\207" [c-syntax-table-hwm c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit most-positive-fixnum c-neutralize-pos get-text-property syntax-table (15) (error) scan-sexps 1 remove-text-properties (syntax-table . #1=(nil)) c-depropertize-ml-string-delims nil next-single-property-change (syntax-table nil) parse-partial-sexp 3 8 put-text-property (1) (syntax-table . #1#) c-neutralized-prop] 12 (#$ . 165079)])#@21 (fn START FINISH) (defalias 'c-depropertize-ml-strings-in-region #[514 "\306b\210`W\203\225\307 \310#\203\225\nT\224\203O\nT\224\nT\225\n\311\\\224BB\312\307\313\nT!!\f\\d^\310#\205G\314\225X\205G\314\224\314\225\311\224BBB\306\"\266\202\311\224b\210\315 \210`\311\225b\210`W\203\221\316 \310#\203\221\212\314\224\314\225\311\224BB\312\307\313\314!!\310#\205\210\314\224\314\225\311\224BBB\")\266\202[\210\202\205\327\203\262^\317\211T\320$\266\202\301^\321\211T\322#\266^^^\211\262\207" [c-neutralize-pos c-ml-string-cpp-or-opener-re c-cpp-or-ml-match-offset c-make-ml-string-closer-re-function c-ml-string-max-closer-len-no-leader c-ml-string-opener-re nil re-search-forward t 2 c-depropertize-ml-string match-string-no-properties 1 c-end-of-macro c-syntactic-re-search-forward put-text-property syntax-table remove-text-properties (syntax-table nil) c-neutralized-prop c-syntax-table-hwm c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit] 10 (#$ . 166188)])#@34 (fn BEG END &optional OLD_LEN) (defalias 'c-before-after-change-check-c++-modules #[770 "\306 \307\211\307\310\311\"\216\312\211\211b\210\313 \211\262\203\211b\210`Y\203N\314\312\307\"\262`\262\315>\203N\316!\203N\f`^\317\320`\321\\d^\307#\203N `]\203YW\205\215b\210\313 ?\205\215\314\312\307\"\262`\262\322>\205\215\316!\205\215\f`^\317\320`\321\\d^\307#\205\215 `]\211,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-module-key c-new-BEG c-new-END buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 2] nil c-literal-start c-beginning-of-statement-1 (same previous) looking-at c-syntactic-re-search-forward ";" 500 (same previous)] 12 (#$ . 167246)]) (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)#@14 (fn RANGE) (defalias 'c-record-type-id '(macro . #[257 "\211\242\300=\203\301\302\300\303BBE\207\304\305DC\306BB\207" [cons setq c-record-type-identifiers (c-record-type-identifiers) let range ((if range (setq c-record-type-identifiers (cons range c-record-type-identifiers))))] 6 (#$ . 168264)])) (put 'c-record-type-id 'edebug-form-spec t) (defalias 'c-record-ref-id '(macro . #[257 "\211\242\300=\203\301\302\300\303BBE\207\304\305DC\306BB\207" [cons setq c-record-ref-identifiers (c-record-ref-identifiers) let range ((if range (setq c-record-ref-identifiers (cons range c-record-ref-identifiers))))] 6 (#$ . 168264)]))#@35 (fn TYPE &optional STOP-AT-END) (put 'c-record-ref-id 'edebug-form-spec t) (defalias 'c-forward-keyword-prefixed-id '(macro . #[513 "\300\301\302\303\304\305\306\307=\203\310\311 E\202\312DE\313BBD\314\315\314\316 \307=\203.\317\202/\320E\314\321\322\n?\205:\323F\324BBBB\257\207" [let (res pos) (setq c-last-identifier-range nil) while if setq res type c-forward-type nil c-forward-name ((progn (setq pos (point)) nil) (and (cond ((looking-at c-keywords-regexp) (c-forward-keyword-clause 1 t)) ((and c-opt-cpp-prefix (looking-at c-noise-macro-with-parens-name-re)) (c-forward-noise-clause t))) (progn (setq pos (point)) (c-forward-syntactic-ws) t))) 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) pos (goto-char pos) (c-forward-syntactic-ws) (t)] 13 (#$ . 168903)]))#@51 (fn TYPE UPDATE-SAFE-POS &optional STOP-AT-END) (put 'c-forward-keyword-prefixed-id 'edebug-form-spec t) (defalias 'c-forward-id-comma-list '(macro . #[770 "\300\301\302\303\304\205\305\306BB\304\307\310\311\312\f\313BB\257ED\314?\205#\315\257\207" [let ((pos (point))) while and progn (setq safe-pos (point)) ((setq pos (point)) (c-forward-syntactic-ws) (eq (char-after) 44)) (forward-char) (setq pos (point)) (c-forward-syntactic-ws) c-forward-keyword-prefixed-id (t) (goto-char pos) (c-forward-syntactic-ws)] 15 (#$ . 169803)]))#@30 (fn &optional STOP-AT-END) (put 'c-forward-id-comma-list 'edebug-form-spec t) (defalias 'c-forward-noise-clause #[256 "\300\301 \204 db\210\210`\302 \210\300f\303=\2033\3041\"\305`\306\307#0\202$\210\300\211\205,\211b\210\211\262\2033\210`\211b\210\204=\302 \210\310\207" [nil c-forward-over-token c-forward-sws 40 (error) scan-lists 1 0 t] 6 (#$ . 170351)])#@21 (fn MAYBE-PARENS) (defalias 'c-forward-noise-clause-not-macro-decl #[257 "\300 \210\211\203E`\301\302!\203m\203\303\304!\203\305u\210\202\306f\307=\203A\31012\311`\312\313#0\2024\210\306\211\205<\211b\210\211\262\204D\211b\210\210\314\207" [c-end-of-token forward-comment 5 looking-at "\\\\[\n ]" 2 nil 40 (error) scan-lists 1 0 t] 6 (#$ . 170726)]) (defalias 'c-forward-over-colon-type-list #[0 "`\302\303\302\304#\203_\302f\305=\204_ \306=\203_ \306=\205S\307\310!\205S\212\31111\312`\313\314#0\2023\210\302\211\205;\211b\210\211\262\205R`Sf\315=\205R`SSf\315=\205R`)\211\262\203_\211b\210\202\302f\305=\203j\302u\304\207b\302\207" [c-sub-colon-type-list-re c-buffer-is-cc-mode nil re-search-forward t 58 c++-mode looking-at "\\[\\[" (error) scan-lists 1 0 93] 7])#@36 (fn MATCH &optional STOP-AT-END) (defalias 'c-forward-keyword-clause #[513 "\306!\307\"\262\310\211\311\310\205\311\225b\210`\262\312 \210\313N\266\202\203\310\211\211\314\310\311\"\211\262\203:\210`\202`\315\f!\203G\316\317\311\"\202U \203`\315)!\203`\320\311!\203`\210`\312 \210\202+\321>\205*\203w\211\203v\211*B*\210\211\203~\211b\210\311\266\202\203`\262\312 \210``\262\210`\312 \210\310f\322=\203\377\310u\266`\312 \210\310\211\211\314\310\311\"\211\262\203\265\210`\202\333\315\f!\203\302\316\317\311\"\202\320 \203\333\315)!\203\333\320\311!\203\333\210`\312 \210\202\246\321>\205\372*\203\362\211\203\361\211*B*\210\211\203\371\211b\210\311\266\202\204\213\211b\266\202\337\323N\266\202\203\355\310\211\211\324\311!\211\262\203\"\210`\202H\315\f!\203/\316\317\311\"\202= \203H\315)!\203H\320\311!\203H\210`\312 \210\202\321>\205g*\203_\211\203^\211+B+\210\211\203f\211b\210\311\266\202\203\355`\262\312 \210``\262\210`\312 \210\310f\322=\203\346\310u\266`\312 \210\310\211\211\324\311!\211\262\203\234\210`\202\302\315\f!\203\251\316\317\311\"\202\267 \203\302\315)!\203\302\320\311!\203\302\210`\312 \210\202\216\321>\205\341*\203\331\211\203\330\211+B+\210\211\203\340\211b\210\311\266\202\204s\211b\266\202\337\325N\266\202\203[\310f\326=\203[\310u\210\3271\330`\317\211#0\202\210\310\211\262\203U\211\206`Sf\331=\203U*\203O\332N\266\202\203O\333,\311#\203O\334\224b\210\314 \2041\315-!\210\334\225b\210\2021\211b\210`\262\312 \210\202\337\335N\266\202\203\201\310f\336=\203\201\337\340N\266\202!\203\201`\262\312 \210\202\337\341N\266\202\203\257\315,!\204\257\3421\241\343`\317\"b\210\3110\202\243\210\310\203\257`\262\312 \210\202\337\344N\266\202\203\337.\203\320\315.!\203\337\212\334\225b\210\345 )\204\337.\203\331\334\225b\210`\262\312 \210\346N\266\202\203\276\310f\347=\203\325\310u\210\312 \210\310\211\211\314\310\311\"\211\262\203 \210`\202/\315\f!\203\316\317\311\"\202$ \203/\315)!\203/\320\311!\203/\210`\312 \210\202\372\321>\205N*\203F\211\203E\211*B*\210\211\203M\211b\210\311\266\202\203\276`\262\312 \210``\262\210`\312 \210\310f\322=\203\316\310u\266`\312 \210\310\211\211\314\310\311\"\211\262\203\204\210`\202\252\315\f!\203\221\316\317\311\"\202\237 \203\252\315)!\203\252\320\311!\203\252\210`\312 \210\202u\321>\205\311*\203\301\211\203\300\211*B*\210\211\203\310\211b\210\311\266\202\204Z\211b\266\202\276*\203\276b\210\312 \210\350 \203\276\312 \210\310\211\211\314\310\311\"\211\262\203\373\210`\202!\315\f!\203\316\317\311\"\202 \203!\315)!\203!\320\311!\203!\210`\312 \210\202\354\321>\205@*\2038\211\2037\211*B*\210\211\203?\211b\210\311\266\202\203\276`\210`\312 \210\310f\322=\203\267\310u\266`\312 \210\310\211\211\314\310\311\"\211\262\203m\210`\202\223\315\f!\203z\316\317\311\"\202\210 \203\223\315)!\203\223\320\311!\203\223\210`\312 \210\202^\321>\205\262*\203\252\211\203\251\211*B*\210\211\203\261\211b\210\311\266\202\204F\211b\210\312 \266b\210\204\310\312 \210\311*\207" [c-keywords-obarray c-restricted-<>-arglists c-parse-and-markup-<>-arglists c-last-identifier-range c-keywords-regexp c-opt-cpp-prefix 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 c-forward-over-colon-type-list c-noise-macro-with-parens-name-re c-record-type-identifiers c-record-ref-identifiers c-symbol-start c-symbol-key c-post-protection-token] 11 (#$ . 171534)])#@18 (fn ALL-TYPES) (defalias 'c-forward-<>-arglist #[257 "`\306 !??\307=\203\\\212\310 \311U\205\312\313!)\203\\\312\314!\205\225\315\224\205\225\f\203T`\316\211T\317\320$\266\315\224\316\211T\317\321$\266` ^^^\210\315\225b\210\322\202\225\3232f\324!\2110\203\215\n:\203\211\n\211\242:\203\204\325\326@@@A\"!\210A\202o\210\n\244\322\202\225\211b\210\327)\207" [c-record-type-identifiers c-found-types c-record-found-types c-buffer-is-cc-mode c-parse-and-markup-<>-arglists c-lit-pos-cache-limit copy-hash-table c++-mode c-backward-token-2 0 looking-at "import\\>\$?:[^_$]\\|$\$" "<\$?:\\\\.\\|[^\\\n >]\$*\$>\$?" 1 put-text-property category c-<-as-paren-syntax c->-as-paren-syntax t angle-bracket-arglist-escape c-forward-<>-arglist-recur c-fontify-new-found-type buffer-substring-no-properties nil c-semi-near-cache-limit c-full-near-cache-limit] 10 (#$ . 175536)]) (defalias 'c-forward-<>-arglist-recur #[257 "`\306\211\307`\310\"\306 \204E\203E\306u\210\3111#\312`\313\211#0\202%\210\306\211\205-\211b\210\314\262\203>`Sf\315=\203>\314\202\303b\210\306\202\303\306u\210\316\n!\203T\316!\203\272\317 \210\f\203`\204j \3205\321Q\232\204\303\317 \210\306f\322=\203z\306u\210\202\247\3166!\203\247\3167!\204\247\203\221\f\204\2308\323=\203\244\314\2119\324 *\210\202\247\325 \210\317 \210\316 !\203\303\313\225b\210\317 \210\314\2119\324 *\210\317 \210`\262\326:\306\314\211$\203\272`Sf\315=\203\205\212\327 \210\316;!)\203\353\330\225b\210\202T \203\211\203\211@S\331\332\211T\333$\266A\202\357\204W\307`S\310\"\203W\212\3341\312`\335\330#0\202 \210\306\211\205(\211b\210\211\262\203V\306f\336=\203V`<^<=^=>^\211>\262\203V`\337\211T\340#\266)\332\211T\341\342$\210`S\332\211T\341\343$\266<^<=^=>^>\210\314\262\202\272`Sf\336=\203b`\262\306\211\211\211\316\n!\203\250\316!\204\250\330\225b\266\202T\335u\210\212\344 \210`\262\345\346!\330W\204\3508\347=\203\350`\350\306x\330W\203\344\351\306x\330W\203\344\316?!\203\344\330\225Y\203\344\210\202\350\211b\266\316@!\211\262\204\372\3167!?\205\376`\211\262)\203 \314\2119\352\205\353\313!\354A\"\262\355N\266\202!*\262\204(b\210\203]\f\203]\211\204]B\203R\317 \210\316B!\203RBCBC\266\202TB\fB\266\202T\266\202T`Sf\356=\203\216\3571w\312`\313\211#0\202y\210\306\211\205\201\211b\210\314\262\203\216`Sf\360=\204TD\204\263`Sf\361=\203\242\306f\361=\203\252`Sf\362=\203\263`B\211\262\202\267\363\364\306\"\204T\205\303\206\303\314)\207" [c-record-found-types c-parse-and-markup-<>-arglists c-<-op-cont-regexp c-<-pseudo-digraph-cont-regexp c-record-type-identifiers c-inside-<>-type-key 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 (error) -1 60 remove-text-properties (category nil) category c-<-as-paren-syntax c->-as-paren-syntax 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 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 c-lit-pos-cache-limit c-semi-near-cache-limit c-full-near-cache-limit c-symbol-key c-opt-<>-sexp-key c-keywords-obarray c-opt-identifier-concat-key c-record-ref-identifiers c-restricted-<>-arglists] 16 (#$ . 175536)])#@54 (fn ALL-TYPES &optional LIMIT RESTRICTED-FUNCTION) (defalias 'c-backward-<>-arglist #[769 "`\302u\210\2048\303`\304\"\2038\3051\306`\302\307#0\202\210\310\211\205&\211b\210\311\262\2034\310f\312=\2034\311\207\211b\310\207\313\314\311#\210`Sf\312=\204L\211b\210\202\216`\315 \210`V\2048\302u\210`\203b \202c \316!\203\207`U\203w\211b\210\310\202\210`V\203\204b\210\310\202\210\211b\210\311)\262\2048`U?\207" [c-parse-and-markup-<>-arglists c-restricted-<>-arglists -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] 9 (#$ . 179218)]) (defalias 'c-forward-name #[256 "`\306\211`\306\211\211\211\307\310!`W\203\350\311 !\203\350\312\225\211\262b\210\313\314!\312W\204T\n\315=\203T`\316\306x\312W\203P\317\306x\312W\203P\311!\203P\312\225Y\203P\210\202T\211b\266`\262\311\f!\203\331\n\320=\203\350\311\321!\203\350\322\224\203\215\212\323 \210\3241~\325u\210\3260\202\203\210\306\202\211\205\211\311\327!)\202\216\326\203\350b\210`\206\232dW\203\253\214e\206\245d}\210\330 )\210\206\260`Sf\331=\203\310\332\326!\211\203\304`\262\n\211\262\210\202\350\311 !\203j\311)!\203\346\212\333 \312=\205\342\306f\334=?)\203j\335\306\326\"\203\350`\262 \336\262`W\203\350\311\337!\203\312\225b\210\202<\311 !\203\350\332 \203\350\311\327!\203\350\312\225b\210`\206!dW\2032\214e\206,d}\210\330 )\210\306f\340=\203\350\306u\210`\262 `\206EdW\203V\214e\206Pd}\210\330 )\210`X\203\363\311*!\203\363\341\225b\210\202<\311+!\203\350`\312\225B,\306f\342=\203\261`Tf\342=\203\261\312\225b\210`\262`\206\223dW\203\244\214e\206\236d}\210\330 )\210\343 \203\317\344\306\"\210\202\317\312\225b\210`\262`\206\276dW\203\317\214e\206\311d}\210\330 )\210\262 \336\262\202\350\203\350U\204\350B,b\210`\262 `\206\364dW\203\214e\206\377d}\210\330 )\210\326\211\262\203\350b\210`\206dW\203'\214e\206!d}\210\330 )\210`\262-\2044.\203\350-\203G\311-!\203G\312\225b\210\202 .\203\350\306f\345=\203\350\306,\346\306!)\203\350\307\310!\262`\262`\206kdW\203|\214e\206vd}\210\330 )\210\306f\334=\204\216\306,\347T\"\210\262 -\203\315\311-!\203\315/\203\257\203\257B0B0\312\225b\210`\206\271dW\203 \214e\206\304d}\210\330 )\210\202 /\203\345\203\345\306f\334=\204\345B/B/\350\262b\210 \204`\206\367dW\203\214e\206d}\210\330 )\210)\207" [c-promote-possible-types c-identifier-key c-buffer-is-cc-mode c-symbol-key c-keywords-regexp c-identifier-start nil c-determine-+ve-limit 500 looking-at 0 skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" c++-mode "\$operator\\|\\(template\$\\)\$[^[:alnum:]_$]\\|$\$" 2 c-backward-sws (error) -2 t "::" c-forward-sws 101 c-forward-name c-forward-token-2 40 c-forward-type operator "[*&]" 42 1 34 c-on-identifier c-forward-over-token 60 c-forward-<>-arglist c-add-type template 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] 13 (#$ . 170351)])#@46 (fn &optional BRACE-BLOCK-TOO STOP-AT-END) (defalias 'c-forward-type #[512 "\203\306\307!\203\310\311!\210\312 \210`\313\211\211\211\211\211\211\211 \203O\306 !\203O\314 \315\316\"\216\306\n!\2034\317\262)\210\320\225b\266``\262\312 \210\317=\204\321\262\202`\262\306!\203\226\320\225b\210`\262\312 \210\313f\322=\205\3231v\324`\320\"b0\202{\210\313\202\205\325\262\203\217`\262\312 \210\202\305b\210\202\305\306\f!\203g\320\225b\210`\262\312 \210\306 !\203\271\326\320\311\"\210`\262\312 \202\341\3062!\203\314\320\225b\210`\262\312 \202\3413\203\344\3064!\203\344\327\311!\210`\262\312 \204\246`\262\330\311!\262`\262??\262\311=\203\"\212b\210\3065!)\203\331`\"\2106\203\"7\203\"7\211\203!\2116B6\210\312 \210\n\203[\332>\203[\313f\333=\203[\212\3341K\324`\320\"b\210`\211\262 0\202M\210\313)\203[b\210\312 \210\311\262\204\305b\210\202\305\317=\204\332\313\2623\203\203\3064!\203\203\327 \210\202q\3068!\203\237\212`\262\330\311!\262\203\236`\2627\262)\3069!\203\255\311\211\262\202\307\335 \315\336\"\216\337:!\210\306;!)\262\203\332\340\211\262\203\332\203\360\212\314 \315\341\"\216\320\225b\210`\262 \312 *\266Y\204\360\313\211\262\203\332\320\225\2626\203<\204\311=\203\320\224\320\225B6B6=\203\226\314 \315\342\"\216\306=!)\262\203\226\313\326\320\311\"\266`\312 \210\306=!\203V6\203M\3069!\203M\320\224\320\225B6B6\326\320\311\"\266\202,\3069!\203\2116\203l\320\224\320\225B6B6\326\320\311\"\210\311\262\210`\312 \210\306=!\203\217\326\320\311\"\266\202u\211b\210\321\262`\262 \210\202\324\314 \315\343\"\216\326\320\311\")\262\203\301`\262\312 \210=\203\324\306=!\203\324\326\320\311\"\210\202\247\203\315b\210\202\324\320\225b\210`\262\312 \210\202\305\311=\203,\321=\203,>\344=\203,\212b\210`\262\312 \210\306?!?\205\306@!?\206\313f\322=\205\212\345 )?)\203,\211b\210`\262 \204&\312 \210\317\262\202\305\203\273\346\267\202\261b\210`\262\312 \210\204I<\203}<\347=\204U\331\"\2106\203h\203h\203h6B6\204p\350\262\321=\203\305\311\262\202\305\351!\203\207\350\202\210\352\262\202\305b\210`\262\312 \210\313f\322=\203\253\351!\203\247\350\202\254\352\202\254\311\262\202\305b\210\313\262\202\305\321=\203\305\313\262\353>\204\376A\203\350\306A!\203\350\320\225b\210`\262\312 \210\311\262\202\321B\203\306B!\203\320\225b\210`\262\312 \210\202\355\306C!\203\320\225b\210`\262\312 \210\311\262\202D\203\334`\262\354>\206)<<6\2053\203\376\203\376EBE\207" [c-recognize-<>-arglists c-maybe-typeless-specifier-re c-no-type-key c-typeof-key c-type-prefix-key c-decl-hangon-key looking-at "<" c-forward-<>-arglist t c-forward-sws nil match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] no-id 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 #[0 "\301\300!\207" [V0 set-syntax-table] 2] set-syntax-table known #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] c-mode c-forward-declarator #s(hash-table test eq purecopy t data (t 822 template 909)) just-one found c-check-qualified-type maybe (nil no-id) (t known) c-forward-type template c-fontify-new-found-type buffer-substring-no-properties (known found) c-pack-key c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-self-contained-typename-key c-record-type-identifiers c-last-identifier-range c-identifier-start c-primitive-type-key c-identifier-syntax-table c-known-type-key c-promote-possible-types c-opt-type-component-key c-buffer-is-cc-mode c-symbol-start c-type-decl-prefix-key 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] 17 (#$ . 182482)]) (defalias 'c-forward-annotation #[0 "`\302\303!\203C\302!\204C\304u\210\302 !\203C\305\225b\210\306 \210\302\307!\203?\31010\311`\312\305#0\2022\210\304\211\205:\211b\210\211\262\202@\313\206G\211b\210\304\207" [c-keywords-regexp c-symbol-key looking-at "@" nil 0 c-forward-sws "(" (error) scan-lists 1 t] 5])#@11 (fn PS) (defalias 'c-pull-open-brace '(macro . #[257 "\300\301\302\303DD\304\305DEE\306\303D\304\305DEEE\207" [progn while consp car setq cdr prog1] 9 (#$ . 187271)])) (put 'c-pull-open-brace 'edebug-form-spec '(symbolp)) (defalias 'c-forward-over-compound-identifier #[0 "\301 `=\205U\302\211`\303\211\211`\262\304 \210\305`\"P\262\210`\306 \210\203G\307!\203G`\262\304 \210`\262\306 \210\301 \203G\305\"P\211\262\204 \302\232\203Qb\303\207\211b\266\207" [c-opt-identifier-concat-key c-on-identifier "" nil c-forward-over-token buffer-substring-no-properties c-forward-sws looking-at] 11]) (defalias 'c-back-over-compound-identifier #[0 "\303\304 \205\220\305\306!\307W\204;\310=\203;`\311\303x\307W\2037\312\303x\307W\2037\313 !\2037\307\225Y\2037\266\202<\211b\266\210`\314 \210\315 \210\n\203\214\313\n!\203\214\314 \210\305\306!\307W\204\210\310=\203\214`\311\303x\307W\203\201\312\303x\307W\203\201\313 !\203\201\307\225Y\203\201\266\202<\211b\266\202\214\210\202<\211b\210\316\207" [c-buffer-is-cc-mode c-symbol-key c-opt-identifier-concat-key nil c-on-identifier skip-syntax-backward "w_" 0 pike-mode "-!%&*+/<=>^|~[]()" "`" looking-at c-backward-sws c-backward-token-2 t] 4])#@13 (fn FROM) (defalias 'c-check-qualified-type #[257 "\212\211b\210\302 \211\2055\203-\211G\303V\203-\304 \"\204-\305\"\203-\211\303\225\306O\262\202\n\304 \"\2055\211)\207" [c-opt-identifier-concat-key c-found-types c-forward-over-compound-identifier 0 gethash string-match nil] 5 (#$ . 188519)]) (defalias 'c-back-over-member-initializer-braces #[0 "`\300\3012\214\3021\303`\304\305#0\202\210\300\211\205\211b\210\211\262\204'\306\301\300\"\210\307 \210\310 \2044\306\301\300\"\210\307 \210`Sf\311=\203\206\304u\210\307 \210`Sf\312>\204R\306\301\300\"\210\3131_\303`\304\305#0\202a\210\300\211\205i\211b\210\211\262\204s\306\301\300\"\210\307 \210\310 \204\200\306\301\300\"\210\307 \210\2027`Sf\314=0\262\211\204\225b\210\207" [nil done (error) scan-lists -1 0 throw c-backward-sws c-back-over-compound-identifier 44 (41 125) (error) 58] 6])#@14 (fn LIMIT) (defalias 'c-back-over-list-of-member-inits '(macro . #[257 "\300\301\302\303D\304\305\303D\300\306\307\303DF\310\303\nD\257\n\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)) (eq (char-before) 62) (when (not (c-backward-<>-arglist nil)) (throw 'done nil)) (when (not (c-back-over-compound-identifier)) (throw 'level nil))] 13 (#$ . 189403)]))#@24 (fn &optional LIMIT) (put 'c-back-over-list-of-member-inits 'edebug-form-spec t) (defalias 'c-back-over-member-initializers #[256 "\214`\301 \302\211\211\211\203`}\210\3032\306\3042j`\206!eV\2033\214\206,ed}\210\305 )\210`Sf\306>\203u\3071H\310`\311\312#0\202J\210\302\211\205R\211b\210\211\262\204\\\313\303\302\"\210`\206ceV\203u\214\206ned}\210\305 )\210\314 \203\223`\206\201eV\203\223\214\206\214ed}\210\305 )\210`Sf\315=\203S\311u\210`\206\245eV\203\267\214\206\260ed}\210\305 )\210`Sf\316>\204\304\313\304\302\"\210\3171\321\310`\311\312#0\202\323\210\302\211\205\333\211b\210\211\262\204\345\313\303\302\"\210`\206\354eV\203\376\214\206\367ed}\210\305 )\210`Sf\320=\203-\321\302!\204\313\303\302\"\210`\206eV\203\376\214\206#ed}\210\305 )\210\202\376\314 \2047\313\304\302\"\210`\206>eV\203\223\214\206Ied}\210\305 )\210\202\223`Sf\322=\205i\212\323 \210\324!)?\205i\325 0\262\203x\326 \211\262\204\300@:\203\205A\262\202x@A\262\211\262\203\300\203\235Y\203\300\3042\273b\210`\206\253eV\203\275\214\206\266ed}\210\305 )\210\314 \204\307\313\304\302\"\210`\206\316eV\203\340\214\206\331ed}\210\305 )\210`Sf\315=\203\240\311u\210`\206\362eV\203\214\206\375ed}\210\305 )\210`Sf\316>\204\313\304\302\"\210\3271\310`\311\312#0\202 \210\302\211\205(\211b\210\211\262\2042\313\303\302\"\210`\2069eV\203K\214\206Ded}\210\305 )\210`Sf\320=\203z\321\302!\204^\313\303\302\"\210`\206eeV\203K\214\206ped}\210\305 )\210\202K\314 \204\204\313\304\302\"\210`\206\213eV\203\340\214\206\226ed}\210\305 )\210\202\340`Sf\322=\205\272\212\323\302\211 #\210\324!)?\205\272\325 0\262\202l\205\3050\262\211\204\317b\210)\207" [c-:$-multichar-token-regexp 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)] 11 (#$ . 189911)])#@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 #[0 "`\301!\203A\302 \303=\203A\304 \203A\302 \303=\203A\305f\306=\203A\3071.\310`\311\303#0\2020\210\305\211\2058\211b\210\211\262\203A\312 `\207\211b\305\207" [c-class-key looking-at c-forward-token-2 0 c-on-identifier nil 123 (error) scan-lists 1 c-forward-sws] 6 (#$ . 191999)])#@36 (fn &optional LIMIT STOP-AT-END) (defalias 'c-forward-primary-expression #[512 "`\305\306\307\n!\203-\310\225b\210\204\275`\206dW\203\275\214e\206$d}\210\311 )\210\202\275\306f\312=\203\213\214\203=e}\210\3131J\314`\310\315#0\202L\210\306)\211\205U\211b\210\211\262\203\301`Sf\316=\203\301``\206idW\203z\214e\206td}\210\311 )\210\306f\317=?\203\206b\210\262\202\272\320 \203``\206\227dW\203\250\214e\206\242d}\210\311 )\210\307\321!\203\324\322\306!\203\324`\211\262\203\324`\206\301dW\203\214e\206\314d}\210\311 )\202\376\307!\203\323\310\306#\315U\203\320 `\206\355dW\203\376\214e\206\370d}\210\311 )\210\204\250\211b\262\202\272\307\f!\203\301\315\225f\324=\204\301\310\225b\210`\206 dW\2031\214e\206+d}\210\311 )\210\306f\312=\203i\214\203Ae}\210\3251N\314`\310\315#0\202P\210\306)\211\205Y\211b\210\211\262\205c`Sf\316=\311 \210\203\301\306f\317=\203\301\214\203ye}\210\3261\206\314`\310\315#0\202\210\210\306)\211\205\221\211b\210\211\262\203\301`Sf\327=\203\301\204\271`\206\250dW\203\271\214e\206\263d}\210\311 )\210\305\203\301\305\202\305\211b\210\306*\207" [c-parse-and-markup-<>-arglists c-restricted-<>-arglists c-constant-key c-opt-identifier-concat-key c-fun-name-substitute-key t nil looking-at 1 c-forward-sws 40 (error) scan-lists 0 41 123 c-forward-over-compound-identifier "<" c-forward-<>-arglist c-forward-token-2 95 (error) (error) 125] 8 (#$ . 192545)]) (defalias 'c-forward-constraint-clause #[512 "`\300\204 d\262\301\302\"\203\205\210``\206dW\203)\214e\206#d}\210\303 )\210\304\305!\203e\306\225X\203e\306\225b\210`\206@dW\203Q\214e\206Kd}\210\303 )\210`X\203e\301\302\"\203e`\211\262\204)\211b\210\204\203`\206rdW\203\203\214e\206}d}\210\303 )\210\302\207b\300\207" [nil c-forward-primary-expression t c-forward-sws looking-at "\$?:&&\\|||\$" 0] 8 (#$ . 192545)]) (defalias 'c-forward-c++-requires-clause #[512 "\204d\262\300 \301U\205\302\"\207" [c-forward-token-2 0 c-forward-constraint-clause] 5 (#$ . 192545)])#@45 (fn NOT-TOP ID-IN-PARENS &optional LIMIT) (defalias 'c-forward-decl-arglist #[770 "`\304\305=\203\307\2032\2042\212\304u\210`\206dW\203+\214e\206%d}\210\306 )\210\307\310!)\203\212\304\211u\210`\206>dW\203O\214e\206Id}\210\306 )\210\3112\303\307\n!\203_\312\313!\202g\307!\203j\314 \204S\304f\315=\203\220\304u\210`\206zdW\203\213\214e\206\205d}\210\306 )\210\316\311\317\"\210\320 \262\211\204\240\316\311\304\"\210\202\253\211\321=\204\253\316\311\317\"\210\322\317\211#\210\304f\323=\203\301\304u\210\306 \210\202S\3170*\203\214\203\320e}\210\3241\335\325`\313\326#0\202\337\210\304)\211\205\350\211b\210\211\262\205\n`\206\363dW\203\214e\206\376d}\210\306 )\210\317\207b\210\304\207" [c-buffer-is-cc-mode c-last-identifier-range c-decl-hangon-key c-noise-macro-with-parens-name-re nil c++-mode c-forward-sws looking-at "[*&]" is-function c-forward-keyword-clause 1 c-forward-noise-clause 41 throw t c-forward-type maybe c-forward-declarator 44 (error) scan-lists 0] 10 (#$ . 194639)])#@44 (fn &optional LIMIT ACCEPT-ANON NOT-TOP) (defalias 'c-forward-declarator #[768 "`\306\211\211\211\211\211\211\211\211\f\204d\262 ` W\203k\306\307\262\310!\203)\311\312!\202$ \2038\310\n!\2038\313 \202$\203\245\310!\203\245\312\225b\210`\206MdW\203_\214e\206Yd}\210\314 )\210`\262\n\310\f!\203 \315=\203\200\306f\316=\203\200`Tf\316=\203\200\317\262\307\225b\210`\262`\206\216dW\203\240\214e\206\232d}\210\314 )\210\210\317\202'\3104!\203' \315=\203\361\320\224\203\361`\262\n\321\317!\203'`\262`\206\312dW\203\334\214e\206\326d}\210\314 )\210\322 \323\324\"\216\310\325!)\262\204\361\210\317\202'\322 \323\326\"\216\3105!)\262\203\317\262\306f\327=\203T\262\306u\210\202 \312\225\206\330\225b\210\314 \210\317\204\211\204.`\262\n\211\2048\321\317!\203\\\206=`\262 `\206FdW\203X\214e\206Rd}\210\314 )\210\210\202o\f\203k\306\262\n\306\262 \210\202o\210\202k` \206vdW\203\210\214e \206\202d}\210\314 )\210\203\230\331 \203\230\332\312\306#\210\307U\204\265\3331\255\334`\312#b0\202\257\210\306\314 \210\203k`d=\204\302` W\203k\310!\203\316\311\312!\202O\3106!\203C\322 \323\335\"\216\3107!\205\351\307\225f\336=?)\262\203\364\337 \202O\306f\327=\203=\340#\203\317\262\306\262\202\302\214\f\203e }\210\3411'\334`\312\307#0\202)\210\306)\211\2052\211b\210\211\262\204\302\317\262\202R\311\312!\202O \203R\310\n!\203R\313 \204\302` X\203k\306f\327=\204\\\306`W\203D`W\203\342 \343=\203z\344\202{\345\346\317$\211\262\205\211\312\224\262\203`Sf\347=\203 \350>\203\212\3511\252\334`\352\312#0\202\254\210\306\211\205\264\211b\210\317\262\205\306f\327=\205\353 \210\354\355!\307W\204\374 \356=\205`\357\306x\307W\203\364\360\306x\307W\203\364\3108!\203\364\307\225Y\203\364\210\202\374\211b\266\306\202\3109!)\204\310:!\203\307\225b\210\202h\203h\211\203D`Sf\361=\203D\317\262\36212\334`\312\211#0\2024\210\306\211\205<\211b\210\317\262\314 \210\204a\211\203S`Sf\363>\203S\352u\210`X\262\203k\257\207 b\306\207" [c-decl-hangon-key c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-opt-op-identifier-prefix c-overloadable-operators-regexp c-buffer-is-cc-mode nil 0 looking-at c-forward-keyword-clause 1 c-forward-noise-clause c-forward-sws c++-mode 34 t 4 c-forward-name match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] "\$::\$" #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] 40 2 c-on-identifier c-forward-token-2 (error) scan-lists #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] 95 c-forward-c++-requires-clause c-forward-decl-arglist (error) c-syntactic-re-search-forward objc-mode "\$?:@end\$\\|[;:,]\\|\$=\\|[[(]\$" "[;:,]\\|\$=\\|\\s(\$" limit 58 (c++-mode java-mode) (error) -1 c-backward-sws skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" 91 (error) (59 58 44 61 40 91 123) c-type-decl-prefix-key c-type-decl-operator-prefix-key c-type-decl-suffix-key c-fun-name-substitute-key c-symbol-key c-paren-stmt-key c-:-op-cont-regexp] 20 (#$ . 195691)])#@1600 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.). If CDD-ACCEPT-ANON is non-nil, we also process declarators without names, e.g. "int (*)(int)" in a function prototype. 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. (fn CDD-LIMIT CDD-LIST CDD-NOT-TOP CDD-COMMA-PROP CDD-FUNCTION &optional CDD-ACCEPT-ANON) (defalias 'c-do-declarators #[1541 "`\302\211\211\211\211\211\211\211\211\204S\303\f#\211\262\203S`\262 @\262A@\262AAAAA@\262AAA@\205=\302f\262\203\330\304=\203\203\305\306\302#\307U\203\203\302f\310=\203\203\214\203fe}\210\3111s\312`\306\307#0\202u\210\302)\211\205~\211b\210\211\262\204\302\310=\203\302 \203\302\212\214\203\231e}\210\3131\246\312`\306\307#0\202\250\210\302)\211\205\261\211b\210\211)\262\211\262\203\302\314 \204\302\211b\210\315\316\317\320$\203\322\321u\210\202\361\320\262\202\361`\206\337dW\203\361\214e\206\353d}\210\322 )\210\203 \212 &)\210\203M`W\203M\323\324!\203M\f\203+`\325\211T\326$\266\302u\210`\2065dW\203G\214e\206Ad}\210\322 )\210`\262\n\202\f\320\262\202\f`\nV\203^\320\202c b\210\302)\207" [c-last-identifier-range c-recognize-bare-brace-inits nil c-forward-declarator 61 c-forward-token-2 1 0 123 (error) scan-lists (error) c-looking-at-statement-block c-syntactic-re-search-forward "[;,{]" move t -1 c-forward-sws looking-at "," put-text-property c-type] 23 (#$ . 198829)])#@24 (fn &optional SHORT) (defalias 'c-fdoc-shift-type-backward '(macro . #[256 "\300\301?\205\302\303\304\305?\205\306\257\207" [progn (setq identifier-start type-start) (setq identifier-type at-type got-parens nil got-identifier t got-suffix t got-suffix-after-parens id-start paren-depth 0) (if (not (memq (setq at-type (if (eq backup-at-type 'prefix) t backup-at-type)) '(nil no-id))) (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)] 8 (#$ . 201558)])) (put 'c-fdoc-shift-type-backward 'edebug-form-spec nil) (defalias 'c-fdoc-assymetric-space-about-asterisk '(macro . #[0 "\300\207" [(let ((space-before-id (save-excursion (goto-char id-start) (and (> (skip-chars-forward "* \n ") 0) (memq (char-before) '(32 9 10 13))))) (space-after-type (save-excursion (goto-char type-start) (and (c-forward-type nil t) (or (eolp) (memq (char-after) '(32 9))))))) (not (eq (not space-before-id) (not space-after-type))))] 1]))#@73 (fn PRECEDING-TOKEN-END CONTEXT LAST-CAST-END &optional INSIDE-MACRO) (defalias 'c-forward-decl-or-cast-1 #[1027 "`\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211 \306\211\212b\210o\206.`\307 \210\310`\"\n\235\262)\262\311 \203<\312 \210\2021`\306\211\211\211\313!\203N\314\211\262\f\204`\313\f!\204` \315=\203\270\313\316!\203\270\317 \320\321\"\216\313@!\203q`\262)\210\322\323!\324A\"\262\262\212\325\323!\210 \326=\203\261\327N\266\202\203\261\317 \320\330\"\216\313B!\205\250\331\225f\332=?)\262\203\261\333 \210`)\262\202\325C\203\325\313D!\203\325\210`\334 \203\322\313D!\204\306`\262\335\314!\211\262\203O\336=\203\364\212\337 \205\355\313\340!)\203\364\314\262 \2034\341\262\342=\203\310\212b\210\343 \210`)\"B\nB\262\n \344=\205#\345>\262\2034\306f\346=\2034\314\262\262\262\262\262\262`\262\306\262\306\262\204W\211\203\310\347N\266\202\204e\211\203z\203p\262\202s\262b\266\205\202\322\306\262\262\203\244\350N\266\202\203\221\314\262\351N\266\202\205\320\314\211\262\266\205\202\322\350N\266\202\203\261\314\262\351N\266\202\203\276\314\262\314\262b\266\205\202\322\205\320\352>?\266\205\204<\353\267\202\313E!\203\351\325\323!\202\367C\203\372\313D!\203\372\334 \204\334`\262\202\335\314\262\202\335\314\262\202\335\262\202\335\354=\203\335 \326=\203\335\212\306\211\211b\210\355 \210`\262\356\357!\331W\204f \360=\203\331`\361\306x\331W\203_\362\306x\331W\203_\313F!\203_\331\225Y\203_\210\202f\211b\266\202\333\310`\"\262\363\306x\331W\203\331\210`\356\357!\331W\204\256 \360=\203\331`\361\306x\331W\203\247\362\306x\331W\203\247\313F!\203\247\331\225Y\203\247\210\202\256\211b\266\202\333`Y\203\331\310`\"\232\203\331b\210\312 \210\306f\364=\203\331b\210\306\262\306\262\262\266)\210`\331\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211G'b\210H\203IJ\232\203\306f\364=\203\321\323\262\306u\266`\202\321\313I!\203\321 \326=\203\214\365\224\203\214`\262\337 \211\262\f\203\321\262\317 \320\366\"\216\313\367!)\262\203L\306\262\202\214\212\355 \210\356\357!\331W\204\205 \360=\203\205`\361\306x\331W\203\201\362\306x\331W\203\201\313F!\203\201\331\225Y\203\201\210\202\205\211b\266`)\262'\202\321\306f\364=\203\240T\262\306u\266`\202\313\204\253\331U\262\314\262\317 \320\370\"\216\313K!)\262\203\302\314\262\323\225\206\311\371\225b\210\312 \210\202\331V\262\n\204|\313L!\2034`\262\337\314!\211\262\f\2034\212\356\357!\331W\204% \360=\203%`\361\306x\331W\203!\362\306x\331W\203!\313F!\203!\331\225Y\203!\210\202%\211b\266`)\262'\312 \210\211\262\204|\313\372!\203A\314\211\262\204|\203|)\354=\204j)\342=\203|(\203j(\236\211\203i\373\"\262\210\306\262*(\262(\262(\314\262(\262'C\203\215\313D!\203\215\334 \202\326\313M!\203\225 \374=\203\325\204\325-\375=\204\253\203\325\306f\376=\203\325\211\203\325)\377>\204\225\n\203\225\212\211b\210\312 \210\306\335 \201f>*\203\225\306f\376=\203\375\331V\203\337S\262\306u\210 \204\331\331=\203\331\314\262 \202\331\306f\364=\203+\201g1\201h`\323\"b\210\3140\202\210\306\203+`Sf\376=\203\337\314\211\262\202|\317 \320\201i\"\216\313\201j!)\262\203V\201k1R\201h`\323\"b\210\3140\202|\210\202\337\317 \320\201l\"\216\313B!\205l\331\225f\332=?)\262\203w\333 \202|\323\225b\210\314\203\337\204\216\331U\203\216\331\224\262\314\211\262\n\202\326\f\203\247\306f\346=\203\247\314\262\f\202\337\331V\203\337\204\337)\314=\204\337%\204\204\204H\203\337-\201m>\203\337\212\211b\210\312 \210C\203\357\313D!\203\357\334 \202\371\313E!\203\374\325\323!\204\336\335 \206 \374=\205-\375=\204\205\306f\376=)\203\337`\262\201n2g\211\331V\203e\201o1>\201p\323\211#0\202@\210\306\262\203T\206M`Sf\376=\204]\201q\201n\306\"\210b\210S\202&\3140\262\203\337(\262')\262\306\262\314\262\314\262 '\262\331\262%\201r=\203\221\314\202\223%\211\262+\201s>\204\250$\262)#\262(\202\260*\262)*\262(\"\204\271\262#\204\302\262 '\262 \204\325\331=\203\325\314\262 \314\203\337\312 \210\202|\n\204\210%\204\362-\201t>\204\210\203\376\313N!\204.\204\210)\203\210\204.\204.\203\210\212(b\210\313O!\205*\201u\322\331!!)\203\210(\262')\262\306\262\314\262\314\262 '\262\331\262%\201r=\203S\314\202U%\211\262+\201s>\204j$\262)#\262(\202r*\262)*\262(\"\204{\262#\204\204\262 '\262\203\244\313P!\203\244\212\331\225b\210\312 \210`\262)\335 )\262*\313Q!\203\265\323\225b\210\312 \210\202\244\201v2-\331V\203I\201w1\325\201p`\323#b0\202\327\210\306\204;\341=\203;(\262')\262\306\262\314\262\314\262 '\262\331\262%\201r=\203\314\202%\211\262+\201s>\204$\262)#\262(\202%*\262)*\262(\"\204.\262#\2047\262 '\262\201q\201v\201x>\"\210\313.\344=\203W\201y\202i.\201z>\204f\201{\202i\201|!\262\n\203M )\204{\203\235\204\235 \204\235\f\203\224)\354=\203\224\314\262\201q\201v\314\"\210 \2035\203\257\2045\2035%\204\360\204\360\204\360\314=\204\360\212(\205\354b\210\335 \201}>?\205\354'b\210\201u)\211b\210\335\306\314\"\210`{!)\2035(\262')\262\306\262\314\262\314\262 '\262\331\262%\201r=\203 \314\202 %\211\262+\201s>\204, $\262)#\262(\2024 *\262)*\262(\"\204= \262#\204F \262 '\262\2025%\203\377 `U\203\341 \306f\201~=\203\267 \315=\204\267 \314=\203{ \201q\201v\314\"\210\202\341 R\203\341 \341=\203\341 \212\306u\210\312 \210\313\201!\205\244 \201\200 \210\312 \210\306f\201\201>)\203\341 \314\262\201q\201v\314\"\210\202\341 -\201\202>\204\311 \306f\201\203>\203\330 \314\262\201q\201v\314\"\210\202\341 \201q\201v\306\"\210\203c\n\204c\n \204c\n\314\262\201q\201v\314\"\210\202c\n)\314=\203\n\201q\201v\314\"\210`U\203c\n\203Y\n-\201\204\267\202?\nS\204-\nT\203C\n)\201\205>\202@\n)\201\206>\202@\n\306\203Y\n)\354=\203M\n\314\262\201q\201v\314\"\210\202c\n\201q\201v\"\210 \203\372\n\204\372\n-\201\207>\203\372\n)\314=\204\372\n%\204\235\n\204\235\n\204\235\nH\203\372\n\203\235\n\313U!\203\372\n(\262')\262\306\262\314\262\314\262 '\262\331\262%\201r=\203\302\n\314\202\304\n%\211\262+\201s>\204\331\n$\262)#\262(\202\341\n*\262)*\262(\"\204\352\n\262#\204\363\n\262 '\262\2025\203 \204 \203\201q\201v\314\"\210)\2035\2045 \2045\2035f\364=\2035\201q\201v\306\"\210-\204X \326=\203X\341=\203X\211\203X\211Sb\210\201q\201v\314\"\210\203w)\354=\203n-\375=\204n\314\262\201q\201v\314\"\210\n\203\f\313V!\203\f-\375=\204\231\204\231-\204\f\323\224\203\f \203\f\f\204\f\f\204\f\f)\314=\204\f\f(\262')\262\306\262\314\262\314\262 '\262\331\262%\201r=\203\324\314\202\326%\211\262+\201s>\204\353$\262)#\262(\202\363*\262)*\262(\"\204\374\262#\204\f\262 '\262\202\f\203\f\201q\201v\314\"\210\204#\f \2045\f)\201\210>\2035\f\201q\201v\314\"\210)\201\211>\203G\f\201q\201v\314\"\210 \326=\203\260\f\203\260\f\201\212>\204\247\f&f\201\213=\203\260\f\212&Tb\210\312 \210\201\214 \320\201\215\"\216\201\216W!\210\313X!*\262\204\247\f\212&Tb\210`\335 \210`\201\217\201\220Y#Z\")\266\202\203\260\f\201q\201v\314\"\210\n\203\277 \203- )\203- -\201\221>\203- \203\322\f\203- \314\262[\203 \313\201\222!\204 \212'b\210\201\223\306w\331V\205\370\f`Sf\201\224>)\212)b\210\335\306\314\"\205 l\206 \306f\201\225>)??=\266\202\204- )\354=\203$ \314\262\201q\201v\314\"\210\2049 \313\201\226!\203U )\342=\203U -\201\227=\204U \314\262\201q\201v\314\"\210[\203\203)\203\203n \203\212'b\210\201\223\306w\331V\205\204 `Sf\201\224>)\212)b\210\335\306\314\"\205\233 l\206\233 \306f\201\225>)??=\266\202\204)\354=\203\260 \314\262\314\262\201q\201v\314\"\210\202\203-\201\230>\204\203\326 \203\356 -\201\231=\203T\204 \204\356 \203)\354=\203\370 \314\262\201q\201v\314\"\210-\201\231=\204 \374=\205,-\375=\204\205,)\354=\203+ \203+\314\262\3140)\262\266\212\\\205HeV\205H\206E`Sf\\>\205H\312 \210\313\201\232!\205H\306\211u\210\312 \210`\262\n\313]!\205\272\331\225\262\371\224\204\256\323\224\203\246^\224\203\206\201\233>\202\253_\224\204\256`\224\203\241\201\234>\204\256?\202\253\210\306\202H\313a!?\205\272\313b!?\206\272\331\225X\262\205HeV\205HSb\210`=\206H\355 \210\356\357!\331W\203\344\313c!\202H`Sf\201\235>\203CC\205H`Sf\376=\205H\212\201\2361\201p`\201\237\331#0\202\210\306\211\205\211b\210\211\262\205?\306\355 \210\201\240 \211\262\205.\211b\262\205?\307\371!\331U\205?\313d!)\205H\201\240 ?)\203{\203t\203t\314=\204t\354=\203i\201\241\202j\314eb\210\335 )\210b\201\242\207\n\203P \203\307\262\201r=\203\226\314\202\230\211\262\201s>\204\255\262\262\202\265\262\262\204\276\f\262 \204\307\262\201\231=\203\351\313\201\243!\203\351`\201\244\201\245\211T\201\246$\266\203\212\314e\211\203\211@\211@b\210\335 \266A\202\362*\210\203)\201\247>\204)\211\203\201\241\202\314e\212b\210\335 *\210\204:\204:\205AE\375=\206M \257\207\306\207" [c-record-type-identifiers c-record-ref-identifiers c-pre-start-tokens c-make-top-level-key c-prefix-spec-kwds-re c-buffer-is-cc-mode 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 make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] match-string 1 intern-soft c-forward-keyword-clause c++-mode c-<>-sexp-kwds #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] 0 95 c-forward-c++-requires-clause c-forward-noise-clause c-forward-type no-id c-forward-name "[=(]" ids found c-end-of-token <> (t known prefix found) 123 c-decl-hangon-kwds c-typedef-decl-kwds c-typeless-decl-kwds (t no-id) #s(hash-table test eq purecopy t data (t 476 prefix 512 no-id 518 nil 524)) maybe c-backward-sws skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" ":~ \n \f" 40 4 #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] "\$::\$" #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] 2 "[0-9]" remq c-mode top 41 (nil maybe) c-typedef-key c-keywords-obarray c-fun-name-substitute-key c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-decl-hangon-key c-symbol-key c-parse-and-markup-<>-arglists 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 c-auto-ops-re c-identifier-key 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-identifier-syntax-table c-known-type-key c-recognize-<>-arglists c-found-types c-asymmetry-fontification-flag c-cast-parens c-primary-expr-regexp c-per-&*+--match c-per-++---match c-per-$-match c-keywords-regexp c-nonsymbol-token-regexp c-simple-stmt-key c-opt-cpp-macro-define-start c-promote-possible-types (nil maybe) (error) scan-sexps #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] "\\s(" (error) #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] (nil top) pd (error) scan-lists throw prefix (nil no-id) (arglist decl) c-directly-in-class-called-p at-decl-or-cast (error) (t ids) "[,>]" (nil top) "[,)]" "[,;]" (nil maybe) 58 "[[:alnum:]]" c-forward-token-2 (59 44) (decl <>) (59 44 61 40 123 58) #s(hash-table test eq purecopy t data (decl 2595 <> 2614)) (known found) (known found) (nil top) (t known) (t known) (found known) 126 syntax-table #[0 "\301\300!\207" [V0 set-syntax-table] 2] set-syntax-table gethash c-syntactic-content (nil top) "=\\([^=]\\|$\$\\|;" "* \n " (32 9 10 13) (32 9) "=[^=]" arglist (nil top) decl "\\s)" (t known found) (t known found) (41 93) (error) -1 c-on-identifier just-one cast "," c-decl-arg-start put-text-property c-type (nil no-id)] 55 (#$ . 202693)])#@58 (fn &optional ASSUME-MARKUP PRECEDING-TOKEN-END LIMIT) (defalias 'c-forward-label #[768 "`\306\211\211\211\211\307!\203L\310\225 \203\310\224B\nB\211b\210\311\312 \313\211\306\310&\203B\314\224\203B\314\224b\210`S\315\316\211T\317$\266\313\202F\211b\210\313\262\210\202\232\203w\307!\203w\310\225b\210 \203e\310\224`B\nB`S\315\316\211T\317$\266\313\262\202\232\f\203\227\306f\320=\204\227\203\216eX\202\240\212\321 \210`\262o\206\237 \205\237 )\204R\203\335\322S\317\"\315=\204R\212Sb\210\323 \210\307/!\206\307\3070!)\204R\206\321`Sf\324=\203\227\325 \202O\212Sb\210\323 \210\307/!\206\361\3070!)\204R\206\373`Sf\324=\203\325 \202O\206 `Sf\320=\203\227\214\212Sb\210\212\326 \205\"`)\262\203-d}\210\327\330\306\313#\210`\3061\205?\3071!?\205L\331 \210\332\306 #+\262\203\2272\333=\203\215\334\335\306\313#\203\215\336u\210`\206kdW\203}\214e\206wd}\210\331 )\210\307\337!\203\215\306u\210\313\211\262\202$b\210\311\340\313\211$\203\227\336u\210`\2622\333=\205\256\341\342`{\"\262`\206\267dW\203\311\214e\206\303d}\210\331 )\210\307\337!\203\361\306u\210\343\"\211\262\344\230\204\346\211\345\230\203\352\346\202\353\347\211\262\202$\203\227\334\350\313#\203\227`\206dW\203\214e\206d}\210\331 )\210\307\337!\203\227\306u\210\351\211\262\203\227\214`}\210\3522\222b\210\3073!\203Eb\210\306\262\353\352\306\"\210\3541W\355`\310\"b\210\331 \210\3130\202[\210\202b\203bm\2033 \203\203b\210\307!\204\203\3114\306\313#\203\203\356\224\356\225B\nB\202odS\315\316\211T\317$\266db0)\210\202\232b\210\207" [c-label-kwds-regexp c-record-type-identifiers c-record-ref-identifiers c-opt-extra-label-key c-recognize-colon-labels c-at-vsemi-p-fn 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-prefix-re c-block-stmt-1-key c-opt-cpp-prefix c-buffer-is-cc-mode c-nonlabel-token-key c-symbol-key] 17 (#$ . 215074)]) (defalias 'c-forward-objc-directive #[0 "`\304\305\304\211\306\307!\203\310\225b\210\202\212\306\311!\203\270\312\225b\266`\313\304w\210\304f\314=\2036\304u\210l\204!\315u\210\316 \203\270\3172\207\306\320!\203q\304f\262\304u\210\321 \210\316 \204Y\322\317\304\"\210\323=\203q\304f\324=\204k\322\317\304\"\210\304u\210\321 \210\304f\325=\203\205\305\211\304\326\305!+\202\206\3050\203\270`\206\220eV\203\241\214\211\206\232ed}\210\327 )\210\330`S\331#\210`S\331\332\211T\333$\266\305\202\277\330`\331#\210\304*\207" [c-recognize-<>-arglists c-promote-possible-types c-restricted-<>-arglists c-parse-and-markup-<>-arglists nil t looking-at "\$\\(?:@\\(?:end\\|optional\\|p\\(?:ackage\\|r\\(?:ivate\\|otected\$\\|ublic\\)\\|required\\)\\)\\)\$[^[: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] 11])#@22 (fn &optional LIM) (defalias 'c-beginning-of-inheritance-list #[256 "\301\302\303#\210\304!\204\304\305!\205\301\306\303#\302U\205\202\207" [c-symbol-start c-backward-token-2 0 t looking-at "[<,]\\|::" 1] 5 (#$ . 218773)]) (defalias 'c-in-method-def-p #[0 "\212\301 \210\205\302!\205`)\207" [c-opt-method-key beginning-of-line looking-at] 2]) (defalias 'c-in-gcc-asm-p #[0 "\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 #[0 "\300 \301!?\206\f\302!\207" [c-parse-state c-most-enclosing-brace c-search-uplist-for-classkey] 3 (#$ . 219342)]) (defalias 'c-just-after-func-arglist-p #[256 "`\303\304\303\211\211\305%\306=\205\212\307=\205\310 ?\205\212\311 !\205(\212\214~\210\312!*?\205\212\313\212\314 \210`)\315\303#\242\211\262\205\212\211\247\205\212\211W\205\212`V\204U\311\316!?\205\212\212\211b\210\303f\317=\203i\320`\321\"b\210\202x\n\203x\311\n!\203x\322\323\305\"\210`W\205\211\324\325\305\211$\205\211`S)\207" [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 "("] 9 (#$ . 218773)])#@47 (fn ID-START ID-END NEXT NOT-TOP FUNC INIT) (defalias 'c-in-knr-argdecl #[256 "\212\214\212\301 \205 `)\212\211\205\302 \205`)\206e\206 e]\303\211`\304\303C\303\211\211\211\303 \2065d}\210\3052\306\306V\205\305S\262\307\310!\210`Sf\311=\203W`\262\202j`Sf\312=\203e\303\262\202j\313\305\303\"\210\203\241b\210\3141\200\315`\316\306#0\202\202\210\303\211\205\212\211b\210\211\262\204\224\313\305\303\"\210`\262 b\210\317 \210\303f\320>\204\232b\210\321 \210\322 `=\204\344\303f\311=\203\232\3231\307\315`\316\324#0\202\311\210\303\211\205\321\211b\210\325\262\203\232\321 \306=\203\232\322 `=\203\232b\210\326 \203\232\322 \211\262\203\232\3272,\303u\210\330 \210\331`\"\242B\240\210\317 \210\303f\332=\203'\326 \210\322 \211\262\204\371\313\327\303\"\210\202\371\303f\311=0\203\232\303u\210\262\317 \210\303f\333=\204\213\334\303\211#\211\262:\204S\313\305\303\"\203\213\303f\335>\203\213@b\210\212\336\337`\340\\\325#)\211\262\203\213\341\325\303\211\342\343\"%\203\213\303u\210`X\203\213\317 \210\2029\313\305 b\210\317 \210`\"\210\202;b\210\202;\3441\256\315`\316\306#0\202\260\210\303\211\205\270\211b\210\211\262\204;\313\305\303\"\210\202;0+\207" [c-last-identifier-range 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 123 c-forward-decl-or-cast-1 (59 44) c-syntactic-re-search-forward ";" 1000 c-do-declarators make-closure #[1542 "\301\"\300\242\235?\205\302\303\304\"\207" [V0 buffer-substring-no-properties throw knr nil] 9 (#$ . 221096)] (error)] 21 (#$ . 218773)]) (defalias 'c-skip-conditional #[0 "\300`\301\302!\203\f\303\202\301\304!\203\305\202\306\"b\207" [scan-sexps looking-at "\\\$[^_]\\|$\$" 3 "\\<\$do\\|else\\|try\\|finally\$\\>\$[^_]\\|$\$" 1 2] 4]) (defalias 'c-after-conditional #[256 "\212\306\307\310#\311U\205\202\312!\203\306\307\310#\311U\202\310\205\202\312 !\204\201\313f\314=\203V\306\307\310#\311U\203V\312!\203F\306\307\310#\311U\202G\310\203V\312\n!\204\201\312!\204\201\312\f!\205\202\306\307\310#\311U\205\202\312 !\203v\306\307\310#\311U\202w\310\205\202\312 !\205\202`)\207" [c-block-stmt-hangon-key c-block-stmt-1-key c-block-stmt-2-key c-block-stmt-1-2-key c-paren-clause-key c-negation-op-re c-backward-token-2 1 t 0 looking-at nil 40 c-block-stmt-with-key] 5 (#$ . 218773)]) (defalias 'c-after-special-operator-id #[256 "\212\205*\302\303\304#\305U\205*\306!\205* \203)\302\303\304#\305U\205*\306 !\205*`)\207" [c-overloadable-operators-regexp c-opt-op-identifier-prefix c-backward-token-2 1 nil 0 looking-at] 5 (#$ . 218773)]) (defalias 'c-backward-to-block-anchor #[256 "`\212\300 \210`)U?\205\301!\211\205\211b\262\207" [back-to-indentation c-after-conditional] 3 (#$ . 218773)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-backward-to-block-anchor speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-backward-to-decl-anchor #[256 "`\212\300 \210`)U?\205\301!\207" [back-to-indentation c-beginning-of-statement-1] 3 (#$ . 218773)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-backward-to-decl-anchor speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-search-decl-header-end #[0 "`\302=\203j\303\304\305\306\307\211%\205\310!\204e\212\3111'\312`\313\"b\210\3070\202,\210\305\2022\2052\314 !)\204e`Sf\315=\205\3161V\3171O\320`\321\211#0\202Q\210\305b0\202Z\210\202a\203a\210\202fdb\305\207\210`\202\303\322\305\306\307\211%\205\310!\205\210`\202j\207" [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 "[;{=]"] 8]) (defalias 'c-beginning-of-decl-1 #[256 "\3052F``\306\307\310#`\307\203\311!\204v`U\204v`\206$eV\2035\214\206.ed}\210\312 )\210`Sf\313>\204v \203F \204v\203Q`X\204v\212\314u\210\311\315!)\204v\306\307\310#\211\262\316=\204v\262`\262\211\262\202 b\266\n\203\302`\307\211f\317=\204\212b\210\320!\211\262\203\276\211W\203\276\211b\210\306\307\310#\316=\204\276\321\305f\317=\203\265\322\202\266\323B\"\266\202\302b\266\211\322=\203B\212\324\325\310\211\211%\203\365`Sf\326=\203\365\203\365\f\203\365\212\327 \210\311!\210\327 \210\311\f!)\204\311`Sf\326=\2057\324\330\310\211$\2057`Sf\317=\2057\3311(\3321\333`\334\211#0\202!\210\307b\210\3100\202-\210\307\2027\2057\324\335\310\211$?)\203B\266\323C\202E\266\202C0\207" [c-opt-method-key c-at-vsemi-p-fn c-recognize-knr-p c-overloadable-operators-regexp c-opt-op-identifier-prefix 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 ";"] 10 (#$ . 218773)]) (defalias 'c-end-of-decl-1 #[0 "`\3022\241\303 \210\203!`Sf\304=\203!\305!\203!\306\307\310\311\312$\210`Sf\313=\203\211\3141B\3151:\316`\317\211#0\202<\210\310b0\210\202K\210db\210\320\302\310\"\210 \203\204\212`b\210\306\321 \322Q\312\211\211%\205~\317\224\205~`Sf\323=?\205~\306\324\312\211\211%\205~`Sf\313=)\262\204\211\320\302\312\"\210`Sf\304=\203\226\320\302\312\"\210\306\325\310\311\312$\204\211\3100\207" [c-recognize-knr-p c-opt-block-decls-with-vars-key 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 "[;=([{]" ";"] 8])#@35 (fn GOTO-START &optional LIMIT) (defalias 'c-looking-at-decl-block #[513 "`\306\211\307\310#\210 \203`Sf\311=\203\310\312\306\")\204\242\203\253``Sf\313=\203\231\31419\315`\316\317#0\202;\210\306\211\205C\211b\210\211\262\205\235\306f\320=\205\235\321 \210\322\323!\317W\204\211\f\324=\205\235`\325\306x\317W\203\202\326\306x\317W\203\202\327 !\203\202\317\225Y\203\202\210\202\211\211b\266\202\253\327)!\206\224\327*!\262\202\237\211b\210\306\262\203\253\307\310#\210\202 \203\334\330+\310\211$\203\330\317\224b\210\327,!\204\313\327*!\203\320\331 \202\325\317\224\262\306\204\257\211\202\335\310\205\351\330-\310\211\211%\203C\317\224\211\262b\210./\232\204\332 \333\334\"\216\212\327.!\205\335\336\310\"\317U\205\3270!*\262?\205\351\336\224\204t\337 \203t\327+!\206?\3271!\206?\306f\340=\205?\341 ??\202q\f\324=\205\351b\210\335 \317U\205\351\3272!\205\351\342\336!\3433\"\262\344N\266\202\205\351`\262\310\205\351\203\345\211b\210`W\203\337\327,!\204\217\327*!\203\225\331 \210\202{\327 !\203\306\317\225\342\317!\3433\"\262\211\203\273\211\345N\266\202\204\273\346\317!\204\301b\210\347 \210\266\202{\330+\350\310$\203\332\317\224\211\262b\210\202{\210\211\202{\211b\210\202\350b\210\207" [c-block-prefix-charset c-recognize-<>-arglists c-parse-and-markup-<>-arglists c-opt-cpp-prefix c-buffer-is-cc-mode c-symbol-key nil c-syntactic-skip-backward t 62 c-backward-<>-arglist 41 (error) scan-lists -1 0 40 c-backward-sws skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" looking-at c-syntactic-re-search-forward c-forward-noise-clause match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data t] 3] c-backward-token-2 1 c-forward-type 123 c-looking-at-statement-block match-string intern-soft c-modifier-kwds c-protection-kwds c-forward-keyword-clause c-forward-sws move c-paren-nontype-key c-noise-macro-with-parens-name-re c-symbol-start c-noise-macro-name-re c-decl-block-key c-after-brace-list-key regexp-unmatchable c-brace-list-key c-type-decl-prefix-key c-specifier-key c-keywords-obarray] 11 (#$ . 226994)]) (defalias 'c-directly-in-class-called-p #[257 "\302 \211@:\203\fA\202\211@A\262\211f\303=\205<\211b\210\212\304\305!\205;\306!\205;\307\225b\210\310 \210\306 !\205;\311\312!\230)\207" [c-class-key c-identifier-key c-parse-state 123 c-looking-at-decl-block nil looking-at 1 c-forward-sws match-string 0] 5 (#$ . 141930)]) (defalias 'c-search-uplist-for-classkey #[257 "\300!\211\205 \212\211b\210\301f\302=\205\303\301!\205\304 \210\305`\")\207" [c-most-enclosing-brace nil 123 c-looking-at-decl-block back-to-indentation vector] 5 (#$ . 105197)]) (defalias 'c-most-enclosing-decl-block #[257 "\211@:\203\nA\202\211@A\262@:\203A\262\202@A\262\203M\212b\210\300\301!)\204M\211\262@:\203BA\262\2025@A\262\262\202#\207" [c-looking-at-decl-block nil] 5 (#$ . 105197)]) (defalias 'c-cheap-inside-bracelist-p #[257 "\300\212@:\203A\262\202@A\262\211\262\203*\211b\210\301 \210\302 \210\303\304!\203)\207" [nil c-backward-sws c-backward-token-2 looking-at "="] 4 (#$ . 105197)]) (defalias 'c-backward-typed-enum-colon #[0 "`\302\212\303 \304=\203t\305\306!\203,\3071\310`\311\312#0\202\210\302\211\205'\211b\210\313\262\203t\305\314!\204\302f\315=\203g\212\316 \210\317 \206H\303 \210\305!)\203g\210`\302u\210\320 \210\321 \203b\320 \210`=\204t\210\302\202t\302f\322=\204\305 !\204)\211\205}\211b\210\313\207" [c-brace-list-key c-symbol-key nil 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] 6]) (defalias 'c-backward-over-enum-header #[0 "`\306\203 \307 \210\310 \311=\203\240\312\313!\2032\3141#\315`\316\317#0\202%\210\306\211\205-\211b\210\320\262\203\240\312 !\203H\321 \203H\211\204H\320\211\262\202\235\211\203^\306f\322=\204Y\312\n!\203^\210\306\202 \312!\204 \312\f!\204\240\306f\323=\203\212\310 \311=\203\240\312 !\204 \203\240\312!\202\235\203\234\306f\324=\203\234\312\325!\204 \306\204 \312\f!\206\252b\210\306\207" [c-recognize-post-brace-list-type-p c-symbol-key c-postfix-decl-spec-key c-after-brace-list-key c-brace-list-key c-decl-hangon-key nil c-backward-typed-enum-colon c-backward-token-2 0 looking-at "\\s)" (error) scan-lists -1 1 t c-on-identifier 44 40 60 "\\s(" c-opt-cpp-prefix c-noise-macro-with-parens-name-re c-recognize-<>-arglists] 6])#@12 (fn LIM) (defalias 'c-laomib-loop #[257 "\306\307=\205 \306=\2036\310f\311=\204#\212\312 \210\n\205\n )\203)\310\262\202\351\211\2039\313!\2039\310\262\202\351\203I\313\f!\203I\314\262\202\351\310f\315=\203\313\316\262\316=\203\351\317\320\314#\321U\203\351 \203q\313 !\203q\310\202\306\307=\203\221\310f\322=\204\215\310f\323=\203\221`Sf\322=\203\221\310\202\306\313\324!\203\233\316\202\306\325=\203\305\212`\326\310x\210``Sf\327=\205\273\330\"?\205\273\331 ?)\266\202\203\305\310\202\306\314\262\202S\325=\203\351\310f\323=\203\351\212\317\320\310#\210\313 !)\204\351\314\262\306=\203\310f\332=\204 \212\312 \210`Sf\333=)\203 \310\262\202\317\320\314#\321U\204\212\205&\317\320\310#\321=\205&\310f\334=)\2030\314\262\202\310\262\202\207" [c-buffer-is-cc-mode c-decl-block-key c-at-vsemi-p-fn c-has-compound-literals c-return-key c-opt-op-identifier-prefix dontknow pike-mode nil 59 c-backward-sws looking-at t 61 maybe c-backward-token-2 1 0 96 91 "\\s." c++-mode "^<>" 60 c-crosses-statement-barrier-p c-in-literal 44 125 40] 8 (#$ . 231538)]) (defvar c-laomib-cache nil)#@30 (fn CONTAINING-SEXP START) (make-variable-buffer-local 'c-laomib-cache) (defalias 'c-laomib-get-cache #[514 "\301\203%@\211\262\203%\211@=\203AA@W\203%A\262\202\2053\302\"\211B\211\207" [c-laomib-cache nil delq] 7 (#$ . 232698)])#@29 (fn LIM START END RESULT) (defalias 'c-laomib-put-cache #[1028 "\205\307\301F\301\301\302\301\203@@\211\262\203@@=\2039 AA@V\2039 A@X\204@A\262\202\203O\203O\303\"G\304Y\203\300\211\203x\211@A@X\204pAA@V\203s\211\262\210A\202W\210\204\267\262A\203\246A@A@A@AA@Z\262\211V\203\237\211\262\262A\262\202\200AA\203\263\305!@\202\265@\262\303\"\211\202PB\211\266\207\207" [c-laomib-cache nil 0 delq 4 last] 16 (#$ . 232958)])#@28 (fn LWM ELT PAREN-STATE) (defalias 'c-laomib-fix-elt #[771 "\203\fA@V\203\207\3008X\203\301\207\211\203Y\211\2038\211@:\203,\211@@\202.\211@f\302=\2048A\202\211A@\203Y\211A@:\203L\211A@@\202O\211A@@V\203YA\202\211A@\205rA@:\203m@@\202o@\240\210\207" [2 nil 123] 6 (#$ . 233467)]) (defalias 'c-laomib-invalidate-cache #[514 "\212b\210\301 \211\205\211@\302#\204\303\"\210A\202)\207" [c-laomib-cache c-parse-state c-laomib-fix-elt delq] 9 (#$ . 40398)])#@38 (fn &optional CONTAINING-SEXP LIM)#@46 (fn ID-START ID-END TOK NOT-TOP FUNC INIT) (defalias 'c-looking-at-or-maybe-in-bracelist #[512 "\212`\306\307\211\211\211\211\211C\307\211\211\211\211\310 \210\311 \206\312\313\314#\262\315=\203a\316>\2033\307f\317=\203h\320 \211\262\203h@:\203HA\262\202;@A\262\211\262\203h\211f\321=\203h\211b\210\322\262\f\323\211\262\202\347\324 !\203u\307\211\262 \202\347\324\n!\203\212\325\225f\326=\204\212\307\211\262 \202\347\324!\204\352\324\f!\203\275\324 !\204\275\212\312\313\314#\325U\205\254\3247!)\203\267\322\211\262 \202\347`\240\202\347\307f\321=\203\346\314\262\212\312\313\307#\325U\205\337\324\n!\205\337\325\225f\326=?)\203\346\307\262\f\307\203a\212\327>\203\371\307f\317=\203)\320 \211\262\205Z@:\203A\262\202@A\262\211\262\205Z\211f\321=\205Z\323\262\211b\202Z\324 !\206Z\324!\206Z\324\f!\203U\324 !\204U\212\312\313\314#\325U\205Q\3247!)\206Z`\240\210\307)\203a\322\262\f8\203\241\307f\330=\203\241\306=\203\241\312\313\314#\325U\204\203\307\202\234\3248!\203\221\314\262\314\202\234\324\331!\203\233\306\202\234\307\262\f\202m`\262\204\255\307\202\333\242\203\321\242b\210\332 \211\262 \203\321b\210\333!@\334=\203\321`C\202\333\242\203\350\310 \210`Sf\321=\203\350\242\323B\202\333\203\212\312\313\314#\325U\205\372\335 )\203\307\202\333b\210\306=\203\232\205\336\"\211A@\206 \307\203\203`A@X\203<\3378b\210\3408\262\266\202\232`A@V\203~\341!\262`A@X\203n\342\3378\3408$\210\3408\262\3378b\266\202\232\342`$\210\262\266\202\232\266\202\232\341!\262\203\230\342`$\210\266\203\272`\262\343!\334=\203\257`\202\260\206\266B\202\333\242\203\216\212\307f\344=\203\313\345\314!\210`\262\n\3249!\203\345 \210\307f\346=\203\347`\350\"\203\214\242\211\203\361e}\210\3511\352`\313\325#0\262\202\266\307)\211\203\211b\210\210\353 \210`\242=\204u\324:!\203/\212\313\225b\210\353 \210`\242=)\204u\354\212\310 \210`)\307\211#\262:\205~@\242=\206~@\242V\203Y\307\202~\3552~\212@b\210\356d\314\307\211\357\360\f\"%)\210\3070\202~\212\fb\210\361 )?)\203\216 \206\212B\202\333\307f\344=\204\242\212\310 \210`Sf\362=)\203\246\307\202\333`\262 \363 \203\332` =\203\332\364 \210` b\210\307u\210\365\366\314\211$\205\316`Sf\344=?\205\325 C\262\202\333\314)\207" [c-buffer-is-cc-mode c-pre-brace-non-bracelist-key c-fun-name-substitute-key c-return-key c-symbol-start c-keywords-regexp dontknow nil c-backward-sws c-back-over-compound-identifier c-backward-token-2 1 t c++-mode (t 0) 44 c-parse-state 40 c++-noassign in-paren looking-at 0 95 (t 0) 91 "\\sw\\|\\s_\\|[.[]" c-back-over-member-initializers c-beginning-of-decl-1 same c-looking-at-c++-lambda-capture-list c-laomib-get-cache 2 3 c-laomib-loop c-laomib-put-cache c-beginning-of-statement-1 59 c-forward-over-token-and-ws 60 get-text-property syntax-table (error) scan-lists c-forward-sws c-forward-decl-or-cast-1 find-decl c-do-declarators make-closure #[1542 "\300\242V\203\f\301\302\303\"\207\300\242=\205\301\302\304\"\207" [V0 throw find-decl nil t] 9 (#$ . 234015)] c-looking-at-statement-block 125 c-forward-to-cpp-define-body c-end-of-macro c-syntactic-re-search-forward "[;,]" c-pre-id-bracelist-key c-opt-inexpr-brace-list-key c-opt-<>-sexp-key c-class-key] 24 (#$ . 233973)])#@52 (fn CONTAINING-SEXP PAREN-STATE ACCEPT-IN-PAREN) (defalias 'c-inside-bracelist-p #[771 "\212b\210\300 \205\n`)\206y\212\301\302\301=\203c\203c\2034@:\203,A\262\202@A\262\262b\210\303\211\"\203D\302\262\202\302f\304=\204Q\302\262\202\305\211\"\211\262\301=\203\262\302\202:\205v\204tA\306=?\205v@)\266\202\207" [c-backward-over-enum-header t nil c-looking-at-inexpr-block 123 c-looking-at-or-maybe-in-bracelist in-paren] 8 (#$ . 237444)]) (defalias 'c-looking-at-special-brace-list #[0 "\205\303\3011\301\212`\302\211\211\303 \210\302f\304=\203)\305u\210\303 \210`\262\302f\236\262\202F\302f\236\211\262\203F`\262\306 \210\307u\210\302f\304=\205D`\262\205\274\211\205\274\3101gb\210\311`\305\"b\210`\262`Sf\312U0\202k\210\202\270\203\270\3131\230b\210\314\315!\203\205\311`\305\"b\210\316\202\224b\210\307u\210\306 \210`SfAU0\202\232\210\302\203\270`Sfz\312U\203\260\303 \210`SU\205\274BB\202\274CB)\266\2040\207\210\302\207" [c-special-brace-lists (error) nil c-forward-sws 40 1 c-backward-sws -1 (error) scan-sexps 41 (error) looking-at "\\s(" t] 7]) (defalias 'c-looking-at-statement-block #[0 "`\3011\302`\303\304#0\202\210\305\211\205\211b\210\211\262\203Z`\306u\210\307\310\311#\210`Sf\312=\206U\313 \210`S=\206U\314\311#\206U\314\315\311\211$\203T\306u\210\316 \262\202\210\305\262\202\210\305u\210\314\317\305\311\211$\206\210\313 \210m\206\210\314\305\311\211$\206\210\314\315\305\311\211$\203\207\306u\210\316 \202\210\305b\210\207" [c-stmt-block-only-keywords-regexp (error) scan-lists 1 0 nil -1 c-syntactic-skip-backward "^;" t 59 c-forward-sws c-syntactic-re-search-forward "{" c-looking-at-statement-block ";"] 7]) (defalias 'c-forward-concept-fragment #[512 "`\304!\203{\305\225b\210`\206dW\203\"\214e\206d}\210\306 )\210\304 !\204{\304\n!\203{\305\225b\210`\2068dW\203I\214e\206Cd}\210\306 )\210\304!\203{\307\305!\310\232\203{\305\225b\203{`\206cdW\203t\214e\206nd}\210\306 )\210`\311\"\210\207\211b\312\207" [c-equals-nontype-decl-key c-keywords-regexp c-identifier-key c-operator-re looking-at 0 c-forward-sws match-string "=" c-forward-constraint-clause nil] 8 (#$ . 192545)]) (defalias 'c-looking-at-concept #[256 "\212\304\305!\205\235\306\225b\210`W\205\235`\206dW\203)\214e\206#d}\210\307 )\210\304f\310=\205\235\311\304\312\304!*\205\235`W\205\235`\206GdW\203X\214e\206Rd}\210\307 )\210\305!\205\235\313\224\211\262\205\235\313\225b\210`W\205\235\314\315\311\211$\205\235\313\225b\210`X\205\235`\206\211dW\203\232\214e\206\224d}\210\307 )\210\211`B)\207" [c-pre-concept-<>-key c-restricted-<>-arglists c-parse-and-markup-<>-arglists c-equals-nontype-decl-key nil looking-at 1 c-forward-sws 60 t c-forward-<>-arglist 0 c-syntactic-re-search-forward "="] 7 (#$ . 189911)]) (defalias 'c-in-requires-or-at-end-of-clause #[256 "\212\211\203\211b\210\202 \210``\301Ze]\302\211\211\211\211\211\303\304#\211\262\2039\305\225f\306=?\211\262\203\307 ?\211\262\203`\262\203\333\212\210\302`\262`W\203d\310\302\304\"\203d\210`\311 \210\312\313!\203d\314 \204C)\211\203x\211X\204\315B\262\202\333b\210\312!\203\212\316\302\304\"\262\202\222\317 \203\222`\262\203\250`Y\203\250` =B\262\202\333\203\324\214\203\267d}\210\3201\304\321\322\323#0\202\306\210\302)\211\205\317\211b\210\304\262\202\330b\210\304\204)\207" [c-fun-name-substitute-key 2000 nil re-search-backward t 0 95 c-in-literal c-forward-primary-expression c-forward-sws looking-at "&&\\|||" c-forward-over-token-and-ws expression c-forward-c++-requires-clause c-forward-concept-fragment (error) scan-lists -1 1] 12 (#$ . 142983)])#@51 (fn LIM CONTAINING-SEXP &optional CHECK-AT-END) (defalias 'c-looking-at-inexpr-block #[770 "\212\306\307\310\211\211\206\206e\310f\311=\205`\312=\203J\212\313\314\315#\210`Sf\316=\2039\317 \2039\320 !\203 \320 !\205@`)\211\262\203Jb\210\306=\203\323`\n\206XeV\203j\214 \206ced}\210\321 )\210`V\203\323o\204\323\322u\210\320\323!\203\323\3241\215\310u\210\325`\322\"b0\202\217\210\310\203\323\320\n!\203g\326\327!\330\"\262\203\211\331N\266\202\203\332=?\205b\320\f!\203\377`\317\327\310#\307U\203\325\310fz\333=\203\325\210`\202\275\211b\210\334 \262\203\377\212\205\373\335=\205\373b\210\336\327\315\"\307U\205\373\310f\337=)\205b\340`B\262\202\316\211\341N\266\202\203\310\262\307\262\310\262\210\306\202\316\211\342N\266\202\2036?\205b\343`B\262\202\316\211\344N\266\202\203R\203J\337=\205b\345`B\262\202\316\211\346N\266\202\203a\210\310\202\316\306\262\202\316\320\347!\203\315\203\267\332=\203\216\310f\332=\203\216`Tf\332=\204\216T\262\306\202\316\337=\203\263\310f\332=\203\263`Tf\332=\204\263\307=\203\263\327\262`\262\306\202\316\310\202\316\320\350!\204\315\310f\262\332=\203\315\327\262`\262\306\262\202J\306=\203\325\312=\203\211\203\327=\203\212b\210`\n\206\365eX\206\317\327\310\f#\210\351 \205\320 !?\205\3200!?)\203\345B\202\3271\205\327\211\205\327\205\327f\337=\205\327b\210\212`\n\206=eV\203O\214 \206Hed}\210\321 )\210`Sf\316=\203\243\352`S\353\"\203\243\214 \203j d}\210\3541w\355`\322\307#0\202y\210\310)\211\205\202\211b\210\211\262\203\243`\n\206\216eV\203O\214 \206\231ed}\210\321 )\210\202O`\n\206\252eV\205\260\351 )\206\3132\203\276\356 \206\3133\205\313\212\211b\210\357 )??\205\327\343`B\202\327)\207" [c-buffer-is-cc-mode c-haskell-op-re c-keywords-regexp c-keywords-obarray c-class-key c-symbol-char-key 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 c-opt-op-identifier-prefix c-recognize-paren-inexpr-blocks c-special-brace-lists c-has-compound-literals] 16 (#$ . 241196)]) (defalias 'c-looking-at-inexpr-block-backward #[257 "\212`\242\300:\205BAb\210`\206dW\203%\214e\206d}\210\301 )\210`U\205B@b\210A\211\262\203:\210\242\302\303\"\")\207" [nil c-forward-sws c-looking-at-inexpr-block c-safe-position] 8 (#$ . 105197)]) (defalias 'c-looking-at-c++-lambda-capture-list #[0 "\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-c++-vsemi-p #[256 "\300\301!\211\262\203\211\205\211A\302=\207\303 \207" [nil c-in-requires-or-at-end-of-clause t c-at-macro-vsemi-p] 4 (#$ . 142983)]) (defalias 'c-at-macro-vsemi-p #[256 "\212\214~\210\211\203\211b\210\202\210`\205\304\305\306x\307=\205\304\305\306w\210\310\311!\203I\307\225b\210\310 !\203<\312\313!\203I\305\306w\202F\310\n!\203E\306\210\306\204 l\205\304\211b\210\314 \210`=\205\304`Sf\315=\203\200\3161n\317`\320\307#0\202p\210\306\211\205x\211b\210\211\262\205\304\314 \210\321\322!\307W\204\270\323=\205\304`\324\306x\307W\203\260\325\306x\307W\203\260\310\f!\203\260\307\225Y\203\260\210\202\270\211b\266\306\202\304\310!\205\304\211b\210\326 ?*\207" [c-macro-with-semi-re c-block-comment-start-regexp c-line-comment-start-regexp c-buffer-is-cc-mode c-symbol-key " " nil 0 looking-at "\$\\\\[\n ][ ]*\$*" forward-comment 1 c-backward-sws 41 (error) scan-lists -1 skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" c-in-literal] 5 (#$ . 142983)]) (defalias 'c-macro-vsemi-status-unknown-p #[0 "\300\207" [t] 1]) (defvar c-auto-newline-analysis nil)#@17 (fn BRACEPOS) (defalias 'c-brace-anchor-point #[257 "\212\212\211b\210\301 \210`)b\210`V\203\302!\204\303 \210\202 `V\203'\210`)\207" [c-other-decl-block-key back-to-indentation looking-at c-backward-token-2] 4 (#$ . 245413)])#@26 (fn SYMBOL &rest ARGS) (defalias 'c-add-syntax #[385 "BB\211\207" [c-syntactic-context] 4 (#$ . 245657)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-add-syntax speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-append-syntax #[385 "BC\244\211\207" [c-syntactic-context] 5 (#$ . 245657)])#@108 (fn SYNTAX-SYMBOL SYNTAX-EXTRA-ARGS STOP-AT-BOI-ONLY CONTAINING-SEXP PAREN-STATE &optional FIXED-ANCHOR) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-append-syntax speed -1 put byte-optimizer byte-compile-inline-expand] 5) (defalias 'c-add-stmt-syntax #[1541 "`\212\306 \210`)U\203\307\310`$\207\212\306 \210`)\212\306 \210`)\311\307\310\312 \"\205/`\f$\210\3132\346`U\203G\211\204G\314\n!\205\345`\211U\204`\315 \203`\210`\212\306 \210`)\262\202H\211b\266`\316 !\212\306 \210`)\262\211\317=\262`U\203\206\320\313\321\"\266\2027\211\322=\203\243`Y\203\243\314\323!\203\243\212b\210\314\324!)\204\340\n\204\300U\204\300\211\325>\203\300b\210\320\313\311\"\266\2027\n\204\316\211\326>\203\316\321\262\211\322=\203\340\327\311CBB\211\266\266\20270\203\247\203\247\203\371V\203\247b\210\203\330 \211\203\211@@`W\203\211@@\262b\210\210\331\"\262\332!\262\212\306 \210`)\262`\311f\311\333=\203\253U\204\223\f\203\206`\n\206KeV\203]\214 \206Ved}\210\334 )\210\314\335!\203h\336 \204\206\212Tb\210\337 \210\311f\340=)\203\206\341\311BB\211\266\202\223\342\311DBB\211\266\n\203\237\nT\202\240e]b\266\343\311\262\202\214\316\n!\262\211\317=\262\211\343=\203\200`U\204\200\311\211\212b\210\344\345 \" \")\211\262\203\363@\346=\203\344\347\202\345\350\311CBB\211\266\202\214\314 !\203\351\352\353! \"A\212b\210\306 \210`)`]CBB\211\266\202\214\354\f\311#\203I\212b\210\355 )\203:\347\311CBB\211\266\202\214\356\311CBB\211\266\202\214\212b\210\357\f\211\"\262\211:\205]\211A\360=)\203q\356@CBB\211\266\202\214\347\311CBB\211\266\202\214\350\311CBB\211\266U\203\232b\266\2023\212\306 \210`)\262\266\2023\311=?\205\334\210\211@A\211\203\325\211@\204\321\211A\204\311\204\315`\202\317\240\210A\202\265A\262\202\251\207" [c-syntactic-context c-other-decl-block-key-in-symbols-alist c-comment-start-regexp c-special-brace-lists c-recognize-paren-inexpr-blocks c-other-decl-block-key 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] 19 (#$ . 246007)])#@89 (fn SYMBOL CONTAINING-DECL-OPEN CONTAINING-DECL-START CONTAINING-DECL-KWD &rest ARGS) (defalias 'c-add-class-syntax #[1156 "b\210\301=\203\"`\212\302 \210`)U\203\"CBB\211\266\207b\210\302 \210\303\304`$\210\305N\266\202\203S\212b\210\302 \210`)U\204S\306\307BB\211\266`\207" [c-syntactic-context inclass back-to-indentation apply c-add-syntax c-inexpr-class-kwds inexpr-class nil] 10 (#$ . 248768)])#@94 (fn INDENT-POINT CHAR-AFTER-IP BEG-OF-SAME-OR-CONTAINING-STMT CONTAINING-SEXP PAREN-STATE) (defalias 'c-guess-continued-construct #[1285 "\306\211b\210\307\306w\210\203\310 \206\311=\211\262\203\272\212\306f\311=\2051\312\313!\211\262\2051`\211\262)\203I\314\212b\210\315 \210`)DB B\211\207:\204X\316`B\306#\203n\317!\210\320\n\203e\321\202f\322\306\211%\207\323 \204\231\317\306\211\313$\324=\203\231\212\306\325\212\326 \210`)\306\211#*\203\231\320\327\306\313%\207b\210\330 \210\331\f!\203\260\320\322\306\313%\207\320\332\306\211%\207\331\333!\203\345\212b\210\334\333\335\313\211%\205\341\336\212\315 \210`)CB B\211\266\313)\206\357\212\337 \210\306f\311=)\203\323 \204\317\306\211\313$\324=\203\212\306\325\212\326 \210`)\306\211#*\203\320\340\306\313%\207 \341=\203R\210`\317 \203R\342 \203:`W\203:\337 \210\202)`Yb\210\203R\317!\210\343`CB B\211\207 \344=\203\342\212b\210\3451l\346`\347\350#0\262\202o\266\306\211\205\227\211f\351=\205\227\211\206`Sf\351U?\205\227\211Tb\210\331-!?\206\227\331.!)\203\342\211b\210\317\313\"\210\212`\206\252eV\203\273\214\206\264ed}\210\326 )\210`Sf\351=)\203\323\211b\210\352\353\313#\210\337 \210\202\326\315 \210\354`DB B\211\207\317!\210\320\322\306\211%\207" [c-special-brace-lists c-syntactic-context c-auto-newline-analysis c-recognize-typeless-decls c-return-key c-buffer-is-cc-mode nil " " c-looking-at-special-brace-list 123 c-looking-at-decl-block t class-open back-to-indentation 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 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 c-<-op-cont-regexp c-<-pseudo-digraph-cont-regexp] 13 (#$ . 249203)])#@51 Return the syntactic context of the current line. (defalias 'c-guess-basic-syntax #[0 "\212\306 \210\307 \310\211\310\311\312\"\216`\313\211\313\211\211\211\211\211\313\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\314 \315!\313 \316!\211\262\203pb\210\313f\317=\203p\320\310!\211\262\203p\262`\262\313\262b\210\321@!\205n\322\323!\324A\"\262\262\203\275@\262A\262:\203\266\212Ab\210B\325=\203\230\326 \203\230\327\330\313\310#\210`\262\203\252@\262A\262\202\262B\262\313\262)\202\302T\262\202\302\331\332!\262\203\317f\333=\203\317\310b\210`\206\331eV\203\352\214\206\343ed}\210\334 )\210`\262`Sf\262b\210\335\313w\210\313f\262\336!\262\337=\203\337\340\341!CB\fB\211\266\2027\342>\203<\343!\211\262\203<CB\fB\211\266\2027\212\344 \205F`\211\262)\203\236\212\345 \210`)U\204\236\346\262C\203\212\212b\210\347 \203\202\212b\210\345 \210`)`V\262\350\262`U\262\202\206\310\262\313)\203\236CB\fB\211\266\313\262\2027\321\351!\203\265\352!\210\353\354\313\310%\210\2027\321\355!\203\331\212\352!\356=`)\262\203\331b\210\353\357\313\310%\210\2027\212B\360\267\202\355\321\361!\202\356\321\362!\202\356\313\205U\3631\334 \210\364`\365\"b\210\3100\202\210\313\202U\205U\313f\317=\205U\3661$\334 \210\364`\365\"b\210\3100\202)\210\313\202U\205U\313f\333=\203G\3671B\364`\365\"b\210\3100\202H\210\313\202U\310\205U\321\370!\205U`\211\262)\203jb\210\353\371\313\310%\210\2027\212D\205\372=?\205E\205\202E!?\205\373>?\205\374=\203\233\375!\205``\262\352!\211\262\376=\204\237\377=\203\270b\210\202\354`\262\201b=\203\354\321D!\204\354\313\352!\211\262\376=\204\314\211\201c=\203\347`\262\210\202\354b\266V\205\321F!\203\201d\323\313\"\341U\205\313f\333=\202\321D!)\203v\201c=\203db\210\317=\2036\353\201e\313\211%\210\2027\212b\210\345 \210\201f )\203U\353\201g\313\211%\210\2027\353\201h\313\211%\210\2027\201i%\210\2027\212\321G!\205 B\201j=\206 \205 b\210\313f\317=\205 \334 \210`Sf\201k=\205 \201l1\263\201m`\365\341#0\202\265\210\313\211\205\275\211b\210\211\262\205 \334 \210\201n\201o!\341W\204 B\201p=\205 `\201q\313x\341W\203\201r\313x\341W\203\321H!\203\341\225Y\203\210\202 \211b\266\313\202 \321F!)\203[\203Jb\210\316\"\262`\212\345 \210`)U?\2059\201s!\211\2057\211b\262\266\353\201t\313\310%\210\2027\201teCB\fB\211\266\2027\212\345 \210\321I!?\205s\321G!?\205s\201f )\203\203\236\201u\201v $\262\201wC\fBC\244\211\266\2027\203\363b\210\316\"\262\212\352!\201c=\203\305\321\201x!\203\305\201t\202\306\376)\262`\212\345 \210`)U?\205\343\201s!\211\205\341\211b\262\266\353\313\310%\210\2027\201weCB\fB\211\266\2027\201y\201z\"\206\331\332\"\310#\211\262\203@\201{\236\262\2036A\262\202H\317=\203C\201|\202F\201}\262Ab\210\345 \210\353\211\201~=\205]`C\310\316`\"%\210`A=\2047@\313B\fB\211\266\2027\204\210\204\211J\203\224\201 \206\230\317=\211\262\203\323\212\313\317=\205\322\320\310!\211\262\205\322`\262\211b\210\321H!\205\322\322\341!\211\262\324A\"\262\201\200N\266\202)\262\203b\210\353\201\201\230\203\354\201\202\202\366\201\203\201\204P!\313\310%\210\2027\212b\210\335\313w\210\313f\317=\205\320\310!\211\262\205`\211\262)\203>\201~\212b\210\345 \210`)DB\fB\211\266\2027\212b\210\335\313w\210\201\205 \203Z\212\345 \210`)\211\262\202\200\201\206\"\211\262:\205\200A\205p\201\207\262\212@b\210\345 \210`)\211\262)\203\276K\204\254\201\207=\203\254\352!\210\201\207\212\345 \210`)CB\fB\211\266\2027\201\210CB\fB\211\266\2027\203\355\201\200N\266\202\204\355\201|\313B\fB\211\266\201u\201v $\210\2027\212b\210`\206\370eV\203 \214\206ed}\210\334 )\210`Sf\201k=\203=\214\203d}\210\201\2111-\201m`\365\341#0\202/\210\313)\211\2058\211b\210\211\262\205w`\206CeV\203T\214\206Med}\210\334 )\210\201\212\313\211#\341U\205w\321L!\205w\341\225f\201\213=?\205w`\211\262)\203\223b\210\345 \210\201\214`CB\fB\211\266\2027\212\201\215!\210\321M!\203\251\201\216\323!\202\271N\203\274\321O!\203\274\201\217 \204\232\201\214\212\345 \210`)CB\fB\211)\266\2027\212B\325=\205\352\201\220!\211\262\205\352`\211\262)\2030\212\334 \210`) TU\203b\210\201\221\212\345 \210`)CB\fB\211\266\2027\fTb\210\201\222 \210\201\223`CB\fB\211\266\2027\212\201\224\331\201\225!]!\211\262\205F`\211\262)\203\302\ff\201\226=\203nb\210\201\221\212\345 \210`)CB\fB\211\266\2027P\203\250\201\227!\203\250\352!\210\201\230\212\345 \210`)CB\fB\211\266\2037\201u\201v $\210\2027\352!\210\201\231\212\345 \210`)CB\fB\211\266\2027B\325=\203\340\201\232=\203\331\335\313w\210\313u\210\321Q!\204\233 \201\226=\204 \212\201\226=\205 \201\2331 \323u\210\3100\202 \210\313\202 \205 \313f\201\226=?)\203< \212\352!\210\321R!\2034 \323\225b\210\201\222 \210\201\234\313!\210\201\222 \210\321S!)\204\233 B\201\235=\203l\n\212\352!\210`)\313\211\212\211\204\210 \321Q!\203d `B\262\210\310\202\202 \201\2361u \364`\365\"b\210\3100\202w \210\313\203\200 `X\203\202 \210\310\310\262\202O )\266\203l\n\201\237A`\"\204l\n\201\226=\203\276 \352!\210\201\240\212\345 \210`)CB\fB\211\266\2027\201\226=\203\364 \352!\210\201\240\212\345 \210`)CB\fB\211\266\2037\201u\201v $\210\2027\203U\nA@b\210\321\201\241!\203%\n\201\231\352!\210\212\345 \210`)CB\fB\211\266\2027\211\203:\n\201\242CB\fB\211\266\2027\201\240Ab\210\352!\210`CB\fB\211\266\2027\201\243!\210\201\242`CB\fB\211\266\2027B\201\244=\203\235\n`\262\353\352 \201b=\203\217\n`U\204\217\n\201\207\202\222\n\201\245\313\211%\210\2027\374=\203\344\n\201\200N\266\202\203\344\nb\210\353\201\246!\201\201\230\203\310\n\201\247\202\326\n\201\203\201\246!\201\250P!\313\310\316`\"%\210\2027\212\352\313\310\"\201b=\205\371\n\201\251!\211\262)\203\201\252\n@CB\fB\211\266\2027\212\201\253 \262 T\203w\327\201\254\310#\210`V\203U\203A\201\255!\211\262\203Ab\210\202`Sf\201\256=\203Z\201\257\313\"\204\365u\210\202`Sf\201\260=\203\365u\210\212\201\234\313!)\203\313u\210\202\327\201\261\310#\210`\262\206\231`Sf\201\262>\205\231\201\237`\"?)\203\220 \212\206\244`Sf\201\263=\205\361b\210\201\212\323\313#\341=\205\361`S=\205\361\352!\201b=\205\361\321V!\205\361`\201d\323\313\211#\341=\205\357\201\264 \205\357\211\211\262\262)\203\f\201\265CB\fB\211\266\2027B\325=\203\217\f\212\214b\210\201\2661%\f\201m`\365\323#0\202'\f\210\313\262\2055\ff\201\260=*\203\217\fb\210\352\310\"\210\212`\206I\feV\203Z\f\214\206S\fed}\210\334 )\210`Sf\201\260=)\203y\fb\210\327\201\267\310#\210\201\222 \210\202|\f\345 \210\201\270`DB\fB\211\266\2027B\325=\203 \212\352!\210`\262\321\201\271!\203\257\f\201d\323\313#\210\321S!\205 \201d\201\272\313#\341U\205 \313f\201\260=\203\333\f\201d\323\310#\341U\202\334\f\310\205 `W\203\372\f\321W!\203\372\f\201d\323\313#\341U\204\337\f\313f\201\226=)\203 b\210\201\242\212\345 \210`)CB\fB\211\266\2027\203A A\201\273=\204A @b\210\353\201\252\313\211%\210\2027`\262\201\215!@\201b=\203e \212\334 \210`Sf\374=)\203e `W\204A \353`=\203s \201\274\202\205 \201\232=\203\202 \201\207\202\205 \201\265\313\211%\210\2027\203\310 \374=\203\310 =\203\310 \212b\210\320\310!)\262 \201u\201\275 \212b\210\345 \210`)%\210\2027P\203\204\374=\204\212\201\215!A\262\205\360 D\205\357 \321D!?)\203W\203b\210\201\276`CB\fB\211\266\2027X\203D\321X!\203D\352\331\332!\310\"\210`U\203.eb\210\201\277\212\345 \210`)CB\fB\211\266\2027`\206JeV\203[\214\206Ted}\210\334 )\210`Sf\374=\203\326\212`\203|@:\203|@A`=\203|@@b\210\201\215!\210`\262\211`U?\205\226\201\300 \210`Y)\262\203\326\212\205\244@:?\206\277b\210\201\301\201\302\310#\205\277`S@@=)\203\326b\210\353\201\207\313\211%\210\2027\203\343V\204I\212`\262\201\303>\206\260E\203\375E!\206\260\201\226=\203,\352!\376=\203,`\206eV\203%\214\206ed}\210\334 )\210`\211\262\206\260B\201\304=\203p\201\3052m\352!\210`\262\201\306 \203k`W\203k\201\222 \210`Y\203e\201\307\201\305\310\"\210`\262\202B\3130\206\260\205\260\352\313\211\211\310%?\205\260@\211:\203\252\211Ab\210`\206\222dW\205\253\214e\206\236d}\210\201\222 )\262\202\255e\262\211\262)\203Ib\210\201\245\340 CB\fB\211\266\203\201\200N\266\202\203\201\310!b\210\353\201\246!\201\201\230\203\364\201\311\202\201\203\201\312\201\246 !P!\313\310\316`\"%\210\202\201u\201v $\210C\2037\2037\212b\210\345 \210`)U\2047\350\313B\fB\211\266\313\262\2027X\203w\212\352!\210\306 \210\321X!\205a`\211\262)\203w\201\313CB\fB\211\266\2027T\203\270`Sf\201\260=\203\270U\203\223\201\255!\204\270\352\201z`\"\206\240\331\332!!\210\201\270\212\345 \210`)CB\fB\211\266\2027\203\347\212\352\206\306\331\332!\313\211\211\310%\210`)\211\262\203\347b\210\353\201\274\313\310%\210\2027B\201\235=\203;`\262\352!\203;`\262 `W\203\201\314 \203\201\222 \210\f\262\f\202\371`Yb\210\203;\201\315\212\fb\210\345 \210`)CB\fB\211\266\2027\352\201z`\"\206H\331\332!!\210B\201\304=\203s`\262\201\306 \203o`W\203o\201\222 \210`\262\202Vb\210\201\207\212\345 \210`)CB\fB\211\266\2027\201\253!\211\262\203\317 A\201\273=\204\317 @\211\262\203\317\317=\203\265\201e\202\270\201h\212b\210\345 \210`)CB\fB\211\266\2027Y\203\367f\333=\203\367\214`\201\316\\d^\211\203\353e}\210\201\3171\377\201m\323\341#0\262\202\266\313)\262 \212b\210\201\212 \341U\2052\321Y!\2052Tb\210\201\301\201\320\201\321\310\211%\2052`\211\262)\203\367\201\301\201\322\206H`\201\316\\d^\201\321\310\211%\211\203\227`Sf\201k=\203\227\212\365u\210`\206geV\203y\214\206red}\210\334 )\210`=)\203\227\353\201\323C\310\316 \"%\266\2027\211\203\245`Sf\201k=\203\324\365u\210\327\201\324\310#\210`Sf\201\226=\203\301\201\325\202\304\201tTCB\fB\211\266\2027`Sf\201\226=\203\344\201t\202\347\201\325TCB\fB\211\266\2027J\203\212b\210\201 )\204\345f\317=\204\345\201\326>\203db\210\212\345 \210`)\262\201\32714\201\330\323!\210\3100\2028\210\202L\203L`Y\203L\313u\210\335\313w\210\202Pb\210\353\201\323C\310\316`\"%\210\2027\317=\203\362f\333=\203\215\212Z\205\211\352\310\313\310$\201b=\205\211\321Z!)\203\362\201\331`\313#\262\203\244\201\332\211\262\202\302\201\333\262\201y\201z\"\206\273\331\332\"\"\243\211\262\203\362b\210\345 \210\353@\313\310\316`\"%\210`U\2047A\313B\fB\211\266\2027\201\334>\203Gb\210\212\345 \210`)\262\201\3351\201\330\323!\210\3100\202\210\202/\203/`Y\203/\313u\210\335\313w\210\2023b\210\353\201\336C\310\316`\"%\210\2027b\210\201\3371[\364`\365\"b\210\3100\202_\210\202\262\203\262\321\201\340!\203\262Tb\210`\206udW\203\211\214e\206\201d}\210\201\222 )\210\372=\203\241\201\274`CB\fB\211\266\2027\201\265`CB\fB\211\266\2027X\203Sf\201\341=\203SSb\210`\212\313\211[\\\201\342 *\210o\204\370]\203\370\321]\201\343P!\203\370\341\225\206\354`Sf\317=\203\306\341\225Sb\210`)V\203;\214\212\313\211[\\\201\342 *\210o\2042]\2032\321]\201\343P!\2032\341\225\206&`Sf\317=\203\341\225Sb\210`)d}\210\334 )\210\321H!\204S\201\344CB\fB\211\266\202\2047Tb\210\212\201\222 \210`)\340\201\272!W\203\264b\210\212\345 \210`)\262\201\3451\204\201\330\323!\210\3100\202\210\210\202\234\203\234`Y\203\234\313u\210\335\313w\210\202\240b\210\353\201\346C\310\316`\"%\210\2027`\206\273dW\203\317\214e\206\307d}\210\201\222 )\210\201\347\212\345 \210`)CB\fB\211\266\2027B\325=\203q\212b\210\335\313w\210\321Q!)\203qb\210\335\313w\210\201\226=\203;`\206eV\203%\214\206ed}\210\334 )\210\201\240\212\345 \210`)CB\fB\211\266\2027\201\226=\203Z\201\240\212\345 \210`)CB\fB\211\266\2027\201\243!\210\201\242`CB\fB\211\266\2027B\201\244=\204J\203\213\212b\210\201 )\206\222\201\331\310#\211\262\203 :\203(\212b\210\313f\333=)\203(A@=\203( @@b\210\335\313x\210n\203\326\201\265\201\350 \211\262\236\203\326\2027\352\201zS\"\206\350\331\332S\"!\210\201d\341!\210\321M!\203\377\201\216\323!\202N\203\321O!\203\201\217 \204\360\201\210\212\345 \210`)CB\fB\211\266\2027 :\203m @@b\210\212b\210\345 \210\313f\201k=\203O`T@A=\206i\313fAA=\205i\201d \341U\205i`T@A=)\202\236\374=\203\351\201\3511\224\201\3521\213\201m`\365\323#0\202\215\210\313b\210\3100\202\230\210\202\351\203\351`U\203\351`\212\345 \210`)=\203\275\201\353`CB\fB\211\266\2027\212\201\220\331\332!!\205\311`)\206\321\316`\"\262\352\313\211\310$\210\353\201\353\313\310%\210\2027b\210\352\313\211\310$\210`U\204U\212\345 \210`)V\203\212\345 \210`)b\210\202U :\203) @@b\210\201d\323\313#\210\202,b\210\313u\210\2065d\201\354w\210\313f\201\355=\203T`W\203T\313u\210l\2045\365u\210\210`U\203\266 :\203k @@b\210\202nb\210`\212\345 \210`)=\203\212\201\356`CB\fB\211\266\2027\212\201\220\331\332!!\205\226`)\206\236\316`\"\262\352\313\211\310$\210\353\201\356\313\310%\210\2027\317=\204\346J\203\367\212b\210`\201\357 W\203\336\214e\201\357 }\210\201\222 )\210\201 )\203\367\201\360`CB\fB\211\266\2027\353\201\361\313\310`&\210\2027\201\362>\204TE\203E!\204T\374=\203+\375!\203T`\212\352!\210`)\211\262V\203TU\204T\201i%\210\2027\374=\203\267\316!\262b\210\201s \203\225`\212\345 \210`)U?\205\204\201s!\211\205\202\211b\262\266\353\201\363\313\310%\210\2027\201y\201z\"\206\247\331\332\"\313\"\211\262\203@\201\364=\203\277\201\365\202\302\201\363\262b\210\345 \210`U\203\340`CB\fB\211\266\2027Ab\210\345 \210\353\313\310\316`\"%\210`AU\2047@\313B\fB\211\266\2027\212\205 b\210\320\313!\205 `\211\262)\203h`\212\345 \210`)U?\2054\352!\266\345 \210\212b\210\321^!)\203W\201\366`CB\fB\211\266\2027\201\365`CB\fB\211\266\2027\212`\206oeV\203\200\214\206yed}\210\334 )\210`Sf\201k=\203\264\214\203\223d}\210\201\3671\244\201m`\365\341#0\202\246\210\313)\211\205\257\211b\210\211\262\205\347`\206\272eV\203\313\214\206\304ed}\210\334 )\210\201\212\313\211#\341U\205\347\321L!\205\347\341\225f\201\213=?)\203b\210\345 \210\353\201\366\313\310%\210\2027\212\201\370 ?\205)\352\313\211\310$\201b=\205)`\262\313_\201\371\212\334 \210`)\313\211#))\203I\345 \210`U\204:b\210\353\201\366\313\310%\210\2027\203\221`\211\262\212\345 \210`)U\204c\352!\376=\204Mb\210\321G!\203\201\363`CB\fB\211\266\2027b\210\353\201\363\313\310%\210\2027b\210`\212\345 \210`)U?\205\244\352!\266\353\201\366\313\211\316!%\210\2027T\203\"\214\203\305d}\210\201\3721\327\201m\365\323#0\202\331\210\313)\211\262\f\203\"\nf\201\260=\203\"\212\nb\210\345 \210`)\262b\210`Y\203\n\313u\210\335\313w\210\202b\210\353\201\270\fC\310\316`\"%\210\2027b\210`\352!`U\203>\2067\211\262\266\202N\211\262`\212\345 \210`)U\266\202\203&\201b=\203m`U\204m\353\201\265\313\211%\210\2027\376=\203\203\321G!\204\203\352!\262\202m\376=\203\246\353\317=\203\230\201\373\202\233\201\325\313\310%\210\2027\376=\203\265\352!\262\202\246\377=\203\337\353\201\274\313\310%\210\317=\2037\201\374\313B\fB\211\266\2027b\210\316\"\262\201s \203/`\212\345 \210`)U?\205\n\201s!\211\205\211b\262\266\353\201\375\313\310%\210\317=\2037\201\374\313B\fB\211\266\2027\201y\201z\"\206A\331\332\"\313\"\211\262\203\271@\201\364=\203Y\201\376\202\\\201\375\262\345 \210`U\203w`CB\fB\211\266\202\242Ab\210\345 \210\353\313\310\316`\"%\210`AU\204\242@\313B\fB\211\266\317=\2037\201\374\313B\fB\211\266\2027\212b\210`\206\303eV\203\324\214\206\315ed}\210\334 )\210`Sf\201k=\203\214\203\347d}\210\201\3771\370\201m`\365\341#0\202\372\210\313)\211\205\211b\210\211\262\205;`\206eV\203\214\206ed}\210\334 )\210\201\212\313\211#\341U\205;\321L!\205;\341\225f\201\213=?)\203Vb\210\345 \210\201\376`CB\fB\211\266\2027\212\316!\211\262?\206ob\210\313f\317=\205o\320\313!)\203\231`\212\345 \210`)U?\205\203\352!\266\345 \210\201\376`CB\fB\211\266\2027\212\201\370 ?\205\302\352\313\211\310$\201b=\205\302`\262\313_\201\371\212\334 \210`)\313\211#))\203\342\345 \210`U\204\323b\210\353\201\376\313\310%\210\2027`\211\262\212\345 \210`)U\204\370\352!\376=\204\342b\210\321G!\203\201\375`CB\fB\211\266\202#b\210\353\201\375\313\310%\210\317=\2037\201\374\313B\fB\211\266b\210\335\313w\210\321`!\203c\201d\341\313\201\357 #\341U\204c\201\313\fBC\244\211\266a\203}\321a!\203}\201\313\fBC\244\211\266\f\211\203\255\211@\211A:\203\217A\242\202\220A\250\203\251\211@\211A:\203\243\266\202A\242\202\256\266\202A\202\256A\202~\210\203\344\212\345 \210`)=\203\344B\201p=\203\323Tf\201=\204\344\201\313\fBC\244\211\266\202_ C\203_ \203_ \203, \211W\204 \201\336\f\236\204_ \201\347\f\236\204_ \201\346\f\236\204_ \201\323\f\236\204_ \313\346CB\fB\211\266\202_ =\203_ \350\f\236\204_ \212b\210\347 ?\206P `\212b\210\345 \210`)X)\203_ \350\313B\fB\211\266\f.\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks case-fold-search c-syntactic-context c-commas-bound-stmts beginning-of-line buffer-modified-p t make-closure #[0 "\300\301>\205 \302\300!\207" [V0 (nil autosaved) restore-buffer-modified-p] 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 "^}" c-determine-limit 1000 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 test eq purecopy t data (c++-mode 481 java-mode 487)) "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 c-keywords-regexp c-keywords-obarray c-buffer-is-cc-mode c-syntactic-indentation-in-macros c-opt-block-stmt-key c-at-vsemi-p-fn c-block-stmt-2-key c-label-kwds-regexp c-symbol-key c-syntactic-ws-start c-special-brace-lists c-auto-newline-analysis c-fun-name-substitute-key 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 c-recognize-<>-arglists c-overloadable-operators-regexp c-equals-type-clause-key c-class-id-suffix-ws-ids-key c-opt-method-key c-generic-key c-opt-inexpr-brace-list-key end-of-defun-function beginning-of-defun-function defun-prompt-regexp c-other-decl-block-key c-recognize-typeless-decls c-comment-start-regexp c-opt-friend-key same up c-forward-token-2 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 class-open c-looking-at-special-brace-list c-other-block-decl-kwds "extern" extern-lang-open intern "-open" c-backward-over-enum-header c-looking-at-or-maybe-in-bracelist topmost-intro-cont brace-list-open (error) c-backward-token-2 95 defun-open c-beginning-of-decl-1 c-forward-keyword-clause c-forward-noise-clause c-back-over-member-initializers member-init-intro c-forward-sws member-init-cont c-just-after-func-arglist-p 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 symbol-name extern-lang-close "-close" c-looking-at-concept constraint-cont c-in-requires-or-at-end-of-clause "^;,=<>" c-after-special-operator-id 62 c-backward-<>-arglist 60 "^;,=" (44 61 60) 61 c-on-identifier statement-cont (error) "^,;" template-args-cont "static\\>[^_]" 2 expression statement 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 2000 (error) "," bound "[,:)]" arglist-close "^,:" statement-case-intro (41 93) (error) backward-up-list c-inside-bracelist-p (brace-list-open . inexpr-class) (block-open . inexpr-statement) (40 91) (error) arglist-intro (error) "\\[^_]" 91 beginning-of-defun "\\s(" objc-method-call-cont (error) arglist-cont-nonempty arglist-cont 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 (error) c-at-statement-start-p c-forward-decl-or-cast-1 (error) statement-case-open block-open statement-block-intro defun-block-intro (error) comment-intro friend 34 cpp-macro] 36 (#$ . 251299)])#@31 (fn OFFSET LANGELEM SYMBOL) (defalias 'c-evaluate-offset #[771 "\247\203 \202\250\301!\203\202\250\302\267\202@\303\202\250\202\250[\202\250\304_\202\250[\304_\202\250\304\245\202\250[\304\245\202\250\305!\203_\306@\211A:\203VA\242\202WAB!#\202\250<\203\216@\307=\203x\310\311#\210\312 \210\303\202\250@\313>\203\303\211@A\262\203\374\306@#\262\203\365\204\244\262\202\365\250\203\316\301!\203\305\310\314@&\210\312 \210\202\365\211\"\262\202\365\250\203\351\310\315@&\210\312 \210\202\365\316\317H\317H\"!\262A\262\202\207\266\202\250@\320=\203k\303\211A\262\203g\306@#\262\211\203`\204(\211\262\202`\211\250\203G\301!\203?\316\317H\\!\262\202`\\\262\202`\301!\203]\310\321@%\210\312 \210\202`\211\262A\262\202\210\202\250\303@\322=\203wA\262\211\204\250\203\250\306@#\262A\262\202w9\203\236\323!\203\236J\202\250\310\324#\210\312 \210\303\211\203\305\211\250\204\305\301!\203\306\211G\325Y\203\306\211\317H\250\203\306\207\310\326$\210\312 \303\207" [c-basic-offset vectorp #s(hash-table test eq purecopy t data (nil 25 + 29 - 33 ++ 38 -- 44 * 51 / 57)) nil 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"] 14 (#$ . 273832)])#@17 (fn LANGELEM) (defalias 'c-calc-offset #[257 "\211@\211\236\211\243\203\302#\262\202# \203!\303\304\"\210\305 \210\210\306\307!\204.\211\247\203/\207\2119\2039\211J\206:\306\207" [c-offsets-alist c-strict-syntax-p c-evaluate-offset message "No offset found for syntactic symbol %s" ding 0 vectorp] 8 (#$ . 275621)]) (defalias 'c-get-offset #[257 "\211\211A:\203\fA\242\202 A\203#\300@\211A:\203A\242\202 AD!\207\300!\207" [c-calc-offset] 5 (#$ . 275621)])#@18 (fn LANGELEMS) (defalias 'c-get-syntactic-indentation #[257 "\301\302\203?@\303!\304!\203\211\301\234\262e\262\2026\\\262\2046@\211A:\2033A\242\2024A\262A)\262\210\202\211\203L\212b\210i)\\\207\207" [c-syntactic-element 0 nil c-calc-offset vectorp] 6 (#$ . 276109)]) (provide 'cc-engine)