;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\306\307!\210\306\310!\210\306\311!\210\306\312!\210\306\313!\210\306\314!\210\306\315!\210\306\316!\210\306\317!\210\306\320!\210\321\322\323\324#\210\325\322\323\326#\210\327\330\331\332#\210\333\334\"\266\335\300\336\337\340DD\341\342\343\342\307\344\345\346\347&\210\350\351BC\352\330#\210\333\353\354\"\330\"\266\331\351\330\355!\324\204\207	\211\262\204\207\n\262\205\205\356\"\262
\203\262\211\204\262\303N\203\241\356\303N\"\211\262\204\207\211\332N\206\253\211\357N\262
\262\202\207\266\203\360\361#\210\331\351\330\300#\210\335\304\336\337\362DD\363\342\343\342\307\344\364&	\210\f\350\365BC\352\330#\210\333\353\366\"\330\"\266\331\365\330\355!\324\204

	\211\262\204

\n\262\205\377\356\"\262
\203,
\211\204,
\303N\203
\356\303N\"\211\262\204

\211\332N\206%
\211\357N\262
\262\202

\266\203\360\361#\210
\367>\203;
\370 \210\324\207" [semantic-c-dependency-system-include-path mode-local-active-mode major-mode mode-local-symbol-table semantic-default-c-path system-type require semantic semantic/analyze semantic/analyze/refs semantic/bovine semantic/bovine/gcc semantic/idle semantic/lex-spp semantic/bovine/c-by semantic/db-find hideif defalias semantic-c-end-of-macro c-end-of-macro nil make-obsolete "28.1" c++-mode c-mode put mode-local-parent mode-local-map-mode-buffers mode-local--activate-bindings custom-declare-variable funcall function #[0 "\300\207" [("/usr/include")] 1 #2=""] "The system include path used by the C language." :group c :type (repeat (directory :tag "Directory")) :set #[514 "\300\"\210\211\301\302BC\303\304#\210\305\306\307\"\304\"\266\310\311!\205\"\305\311\304\"\207" [set-default mode-local-bind semantic-dependency-system-include-path #1=(mode-variable-flag t) c-mode mode-local-map-mode-buffers make-closure #[0 "\302\301!\210\300\211\207" [V0 semantic-dependency-system-include-path make-local-variable] 2] fboundp semantic-decoration-unparsed-include-do-reset] 7 "\n\n(fn SYM VAL)"] mode-local-bind semantic-dependency-system-include-path #1# make-closure #[0 "\302\301!\210\300\211\207" [V0 semantic-dependency-system-include-path make-local-variable] 2] symbol-name intern-soft derived-mode-parent variable-documentation "System path to search for include files." #[0 "\300\207" [nil] 1 #2#] "Default set of include paths for C code.\nUsed by `semantic-dep' to define an include path.\nNOTE: In process of obsoleting this." (repeat (string :tag "Path")) semantic-dependency-include-path #[0 "\302\301!\210\300\211\207" [V0 semantic-dependency-include-path make-local-variable] 2] (gnu gnu/linux darwin cygwin) semantic-gcc-setup] 12)
#@40 List of symbols to include by default.
(defvar semantic-lex-c-preprocessor-symbol-map-builtin '(("__THROW" . #1="") ("__const" . "const") ("__restrict" . #1#) ("__attribute_pure__" . #1#) ("__attribute_malloc__" . #1#) ("__nonnull" . #1#) ("__wur" . #1#) ("__declspec" (spp-arg-list ("foo") 1 . 2)) ("__attribute__" (spp-arg-list ("foo") 1 . 2)) ("__asm" (spp-arg-list ("foo") 1 . 2))) (#$ . 2745))
#@145 Non-nil while resetting the preprocessor symbol map.
Used to prevent a reset while trying to parse files that are
part of the preprocessor map.
(defvar semantic-c-in-reset-preprocessor-table nil (#$ . 3151))
#@67 Reset the C preprocessor symbol map based on all input variables.
(defalias 'semantic-c-reset-preprocessor-symbol-map #[0 "\205\225\306\307!\205\225\310\311\312\"\210\313\314	\n\"!\315\316BC\317\320#\210\321\322\323\"\320\"\266\324\204x\306\325!\203x\326 \203x\324\327
\211\203v\211@\330
\327\"\211\203n\331
!\203e\3321]\333
\327\"0\210\202e\210\334\335\336!\"\210\314\337\340\"\"\262\210
A\266\202\202<\210*\313\314	\n#!\315\316BC\317\320#\210\321\322\341\"\320\"\210\211\262
\262
\207" [semantic-mode semantic-lex-c-preprocessor-symbol-map-builtin semantic-lex-c-preprocessor-symbol-map semantic-c-in-reset-preprocessor-table semanticdb-out-of-buffer-create-table-fcn semantic-lex-c-preprocessor-symbol-file featurep semantic/bovine/c remove-hook mode-local-init-hook semantic-c-reset-preprocessor-symbol-map semantic-lex-make-spp-table append mode-local-bind semantic-lex-spp-macro-symbol-obarray (mode-variable-flag t) c-mode mode-local-map-mode-buffers make-closure #[0 "\302\301!\210\300\211\207" [V0 semantic-lex-spp-macro-symbol-obarray make-local-variable] 2] nil semantic/db-mode semanticdb-minor-mode-p t semanticdb-file-table-object semanticdb-needs-refresh-p (error) semanticdb-refresh-table message "Error updating tables for %S" eieio-object-name eieio-oref lexical-table #[0 "\302\301!\210\300\211\207" [V0 semantic-lex-spp-macro-symbol-obarray make-local-variable] 2]] 9 (#$ . 3365)])
(byte-code "\300\301\302\"\210\303\304\305\306\307DD\310\311\312\313\314\315\316&	\210\303\317\305\306\320DD\321\311\312\313\322\315\323&	\210\303\324\305\306\325DD\326\311\312\313\327&\207" [add-hook mode-local-init-hook semantic-c-reset-preprocessor-symbol-map custom-declare-variable semantic-lex-c-preprocessor-symbol-map funcall function #[0 "\300\207" [nil] 1 #1=""] "Table of C Preprocessor keywords used by the Semantic C lexer.\nEach entry is a cons cell like this:\n  ( \"KEYWORD\" . \"REPLACEMENT\" )\nWhere KEYWORD is the macro that gets replaced in the lexical phase,\nand REPLACEMENT is a string that is inserted in its place.  Empty string\nimplies that the lexical analyzer will discard KEYWORD when it is encountered.\n\nAlternately, it can be of the form:\n  ( \"KEYWORD\" ( LEXSYM1 \"str\" 1 1 ) ... ( LEXSYMN \"str\" 1 1 ) )\nwhere LEXSYM is a symbol that would normally be produced by the\nlexical analyzer, such as `symbol' or `string'.  The string in the\nsecond position is the text that makes up the replacement.  This is\nthe way to have multiple lexical symbols in a replacement.  Using the\nfirst way to specify text like \"foo::bar\" would not work, because :\nis a separate lexical symbol.\n\nA quick way to see what you would need to insert is to place a\ndefinition such as:\n\n#define MYSYM foo::bar\n\ninto a C file, and do this:\n  \\[semantic-lex-spp-describe]\n\nThe output table will describe the symbols needed." :group c :type (repeat (cons (string :tag "Keyword") (sexp :tag "Replacement"))) :set #[514 "\300\"\210\3011
\302 0\207\210\303\207" [set-default (error) semantic-c-reset-preprocessor-symbol-map nil] 5 "\n\n(fn SYM VALUE)"] semantic-lex-c-preprocessor-symbol-file #[0 "\300\207" [nil] 1 #1#] "List of C/C++ files that contain preprocessor macros for the C lexer.\nEach entry is a filename and each file is parsed, and those macros\nare included in every C/C++ file parsed by semantic.\nYou can use this variable instead of `semantic-lex-c-preprocessor-symbol-map'\nto store your global macros in a more natural way." (repeat (file :tag "File")) #[514 "\300\"\210\3011
\302 0\207\210\303\207" [set-default (error) semantic-c-reset-preprocessor-symbol-map nil] 5 "\n\n(fn SYM VALUE)"] semantic-c-member-of-autocast #[0 "\300\207" [t] 1 #1#] "Non-nil means classes with a `->' operator will cast to its return type.\n\nFor Examples:\n\n  class Foo {\n    Bar *operator->();\n  }\n\n  Foo foo;\n\nif `semantic-c-member-of-autocast' is non-nil :\n  foo->[here completion will list method of Bar]\n\nif `semantic-c-member-of-autocast' is nil :\n  foo->[here completion will list method of Foo]" boolean] 10)
#@142 A #define of a symbol with some value.
Record the symbol in the semantic preprocessor.
Return the defined symbol as a special spp lex token.
(defconst semantic-lex-cpp-define '((looking-at "^\\s-*#\\s-*define\\s-+\\(\\(\\sw\\|\\s_\\)+\\)") (let ((#1=#:start (match-beginning 1)) (#2=#:end (match-end 1)) (#3=#:startpnt semantic-lex-end-point) (#4=#:val (save-match-data (goto-char (match-end 0)) (skip-chars-forward " 	") (if (eolp) nil (let* ((beginning-of-define (match-end 1)) (with-args (save-excursion (goto-char (match-end 0)) (looking-at "("))) (semantic-lex-spp-replacements-enabled nil) (semantic-lex-analyzer #'semantic-cpp-lexer) (raw-stream (semantic-lex-spp-stream-for-macro (save-excursion (c-end-of-macro) (if (looking-back "/\\*.*" beginning-of-define) (progn (goto-char (match-beginning 0)) (point)) (point)))))) (if with-args (semantic-lex-spp-first-token-arg-list (car raw-stream))) (setq semantic-lex-end-point (point)) (semantic-lex-spp-merge-streams raw-stream))))) (#5=#:endpnt semantic-lex-end-point)) (semantic-lex-spp-symbol-set (buffer-substring-no-properties #1# #2#) #4#) (semantic-lex-push-token (semantic-lex-token 'spp-macro-def #1# #2#)) (when (and (/= #3# #5#) (/= #5# semantic-lex-end-point)) (setq semantic-lex-end-point #5#)))) (#$ . 7462))
#@142 A #define of a symbol with some value.
Record the symbol in the semantic preprocessor.
Return the defined symbol as a special spp lex token.
(defalias 'semantic-lex-cpp-define #[0 "\306``dB\307\310\311!\203\244\312\224\312\225\f\313 \314\315\"\216\307\225b\210\316\306w\210l?\205d\312\225\212\307\225b\210\310\317!)\306\320\321\212\322 \210\323\324\"\203P\307\224b\210`\202Q`)!
\203\\\325
@!\210`\326
!*\266\203)\262
\f\327\330\"\"\210\331BB
B\211@\211\211A@\247\204\214\211AA\262
\202\220\211A\262
A\262

U\204\242\211\fU\204\242\211\266
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "^\\s-*#\\s-*define\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" 1 match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] " 	" "(" semantic-cpp-lexer semantic-lex-spp-stream-for-macro c-end-of-macro looking-back "/\\*.*" semantic-lex-spp-first-token-arg-list semantic-lex-spp-merge-streams semantic-lex-spp-symbol-set buffer-substring-no-properties spp-macro-def semantic-lex-spp-replacements-enabled semantic-lex-analyzer] 11 (#$ . 8747)])
#@127 A #undef of a symbol.
Remove the symbol from the semantic preprocessor.
Return the defined symbol as a special spp lex token.
(defconst semantic-lex-cpp-undef '((looking-at "^\\s-*#\\s-*undef\\s-+\\(\\(\\sw\\|\\s_\\)+\\)") (let ((#1=#:start (match-beginning 1)) (#2=#:end (match-end 1))) (semantic-lex-spp-symbol-remove (buffer-substring-no-properties #1# #2#)) (semantic-lex-push-token (semantic-lex-token 'spp-macro-undef #1# #2#)))) (#$ . 9956))
#@127 A #undef of a symbol.
Remove the symbol from the semantic preprocessor.
Return the defined symbol as a special spp lex token.
(defalias 'semantic-lex-cpp-undef #[0 "\306``dB\307\310\311!\203T\312\224\312\225\313\"\306\314\206-\206-\315\316\307\"\211\"\266\317BB
B\211@\211\211A@\247\204J\211AA\262
\202N\211A\262
A\262
\266
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "^\\s-*#\\s-*undef\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" 1 buffer-substring-no-properties unintern make-vector 13 spp-macro-undef semantic-lex-spp-dynamic-macro-symbol-obarray] 10 (#$ . 10412)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable semantic-c-obey-conditional-section-parsing-flag funcall function #[0 "\300\207" [t] 1 ""] "Non-nil means to interpret preprocessor #if sections.\nThis implies that some blocks of code will not be parsed based on the\nvalues of the conditions in the #if blocks." :group c :type boolean] 8)
#@132 Skip one section of a conditional.
Moves forward to a matching #elif, #else, or #endif.
Moves completely over balanced #if blocks.
(defalias 'semantic-c-skip-conditional-section #[0 "\301\302!\210\303\211\210\205_\211?\205_\304\305\303\306#\205_\307\224b\210\310\311!\2038\312\313!\2031\313\314!b\210\202\315\314!\210\202\310\316!\203G\317 \210\306\262
\202\310\320!\203Y\303\210\314u\210\306\262
\202\306\262
\202\207" [semantic-c-obey-conditional-section-parsing-flag require cc-cmds nil re-search-forward "^\\s-*#\\s-*\\(if\\(n?def\\)?\\|el\\(if\\|se\\)\\|endif\\)\\>" t 0 looking-at "^\\s-*#\\s-*if" fboundp c-scan-conditionals 1 c-forward-conditional "^\\s-*#\\s-*elif" beginning-of-line "^\\s-*#\\s-*\\(endif\\|else\\)\\>"] 5 (#$ . 11508)])
#@148 Convert an spp macro SYMBOL MACROVALUE, to something that hideif can use.
Take the first interesting thing and convert it.

(fn SYMBOL MACROVALUE)
(defalias 'semantic-c-convert-spp-value-to-hideif-value #[514 "\211G\300V\203\301\302\303\"\304\211#\210\211@\211\211@\262

\211A@;\203'\211A@\262
\202[\305
\211\211A@\247\2049\211AA\262
\202=\211A\262
@\262
\211\211A@\247\204Q\211AA\262
\202U\211A\262
A\262
\"\262

\306\267\202u\307
!\207\310
!\207\311\312\"\203t\307
!\207\207\301\302\313#\304\211#\210\314\207" [1 semantic-push-parser-warning format "Complex macro value (%s) may be improperly evaluated. " 0 buffer-substring-no-properties #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (number 97 symbol 101 string 105)) string-to-number semantic-c-evaluate-symbol-for-hideif string-match "^[0-9]+L?$" "Unknown macro value. Token class = %s value = %s. " nil] 10 (#$ . 12282)])
#@170 Lookup the symbol SPP-SYMBOL (a string) to something hideif can use.
Pull out the symbol list, and call
`semantic-c-convert-spp-value-to-hideif-value'.

(fn SPP-SYMBOL)
(defalias 'semantic-c-evaluate-symbol-for-hideif #[257 "\2119\203\n\304
!\262
\211\211\211;\205<\211\235?\205<\305	!\203%\306
	\"\206<\305\n!\2032\306
\n\"\206<\305!\205<\306
\"\262
\205B\307\262
\203\245\211\211\211;\205y\211\235?\205y\305	!\203b\306
	\"\206y\305\n!\203o\306
\n\"\206y\305!\205y\306
\"\262
\211\205\201\211J\266\202\211\204\211\307\207\211<\203\223\310\"\207\211;\203\244\311\312\"\203\243\313
!\207\207\207\314\315\316\"``#\210\317\207" [semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray symbol-name obarrayp intern-soft t semantic-c-convert-spp-value-to-hideif-value string-match "^[0-9]+L?$" string-to-number semantic-push-parser-warning format "SPP Symbol %s not available" nil] 6 (#$ . 13222) "sSymbol name: "])
#@99 Replacement for `hif-lookup'.
I think it just gets the value for some CPP variable VAR.

(fn VAR)
(defalias 'semantic-c-hideif-lookup #[257 "\300
;\203\n
\202
9\203\301!\202\302!\211\205\211\207" [semantic-c-evaluate-symbol-for-hideif symbol-name "Unable to determine var"] 4 (#$ . 14282)])
#@110 Replacement for `hif-defined'.
I think it just returns t/nil dependent on if VAR has been defined.

(fn VAR)
(defalias 'semantic-c-hideif-defined #[257 "\2119\203\304
!\202\211;\203\211\202\305\211\211\211;\205G\211\235?\205G\306	!\2030\307
	\"\206G\306\n!\203=\307
\n\"\206G\306!\205G\307
\"\262
\205M\310\262
\204d\311\312\313\314\315 \316 \"\"\315 \316 #\210\317\207\310\207" [semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray symbol-name "Not A Symbol" obarrayp intern-soft t semantic-push-parser-warning format "Skip %s" buffer-substring-no-properties point-at-bol point-at-eol nil] 8 (#$ . 14590)])
#@55 Non-nil when Semantic is taking over hideif features.
(defvar semantic-c-takeover-hideif nil (#$ . 15339))
#@107 Code blocks wrapped up in #if, or #ifdef.
Uses known macro tables in SPP to determine what block to skip.
(defconst semantic-lex-c-if '((looking-at "^\\s-*#\\s-*\\(if\\|elif\\).*$") (semantic-c-do-lex-if)) (#$ . 15453))
#@107 Code blocks wrapped up in #if, or #ifdef.
Uses known macro tables in SPP to determine what block to skip.
(defalias 'semantic-lex-c-if #[0 "\306``dB\307\310\311!\203\312 \210
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "^\\s-*#\\s-*\\(if\\|elif\\).*$" semantic-c-do-lex-if] 5 (#$ . 15680)])
#@185 Handle lexical CPP if statements.
Enables a takeover of some hideif functions, then uses hideif to
evaluate the #if expression and enables us to make decisions on which
code to parse.
(defalias 'semantic-c-do-lex-if #[0 "\304	\305P\3061\307\n!0\202\210\310\3111\312
\304\"0\202,\313\314\315\"``T#\210\310\262
\211\203;\211\247\203W\211\316=\203W\313\314\317\320\321 \322 \"\"\321 \322 #\210\323 \210\324 \210`\310\202]\310\210`\310\262
*\207" [semantic-c-takeover-hideif hif-cpp-prefix hif-ifx-regexp semantic-lex-end-point t "\\(elif\\|if\\(n?def\\)?\\)[ 	]+" (error) hif-canonicalize nil (error) eval semantic-push-parser-warning format "Hideif forms produced an error.  Assuming false.\n%S" 0 "Skip %s" buffer-substring-no-properties point-at-bol point-at-eol beginning-of-line semantic-c-skip-conditional-section] 8 (#$ . 16118)])
#@99 Code blocks wrapped up in #ifdef.
Uses known macro tables in SPP to determine what block to skip.
(defconst semantic-lex-c-ifdef '((looking-at "^\\s-*#\\s-*\\(ifndef\\|ifdef\\)\\s-+\\(\\(\\sw\\|\\s_\\)+\\)\\([ 	
].*\\)?$") (semantic-c-do-lex-ifdef)) (#$ . 16976))
#@99 Code blocks wrapped up in #ifdef.
Uses known macro tables in SPP to determine what block to skip.
(defalias 'semantic-lex-c-ifdef #[0 "\306``dB\307\310\311!\203\312 \210
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "^\\s-*#\\s-*\\(ifndef\\|ifdef\\)\\s-+\\(\\(\\sw\\|\\s_\\)+\\)\\([ 	
].*\\)?$" semantic-c-do-lex-ifdef] 5 (#$ . 17246)])
#@35 Handle lexical CPP if statements.
(defalias 'semantic-c-do-lex-ifdef #[0 "\305\306\224\306\225\"\305\307\224\307\225\"\211\310\230
\311\230
\203S\211\211;\205H\211\235?\205H\312	!\2031\313
	\"\206H\312\n!\203>\313
\n\"\206H\312!\205H\313
\"\262
\205N\314\262
\203\224\211\203\256\211\211;\205\211\211\235?\205\211\312	!\203r\313
	\"\206\211\312\n!\203\313
\n\"\206\211\312!\205\211\313
\"\262
\205\217\314\262
\203\256\315\316 \210`\262
\317 \210`\320\321\322#`#\210\315\207\315\210`\315\207" [semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray semantic-lex-end-point buffer-substring-no-properties 2 1 "ifdef" "ifndef" obarrayp intern-soft t nil beginning-of-line semantic-c-skip-conditional-section semantic-push-parser-warning format "Skip #%s %s"] 10 (#$ . 17727)])
#@195 Ignore an #else block.
We won't see the #else due to the macro skip section block
unless we are actively parsing an open #if statement.  In that
case, we must skip it since it is the ELSE part.
(defconst semantic-lex-c-macro-else '((looking-at "^\\s-*#\\s-*\\(else\\)") (let ((pt (point))) (semantic-c-skip-conditional-section) (setq semantic-lex-end-point (point)) (semantic-push-parser-warning "Skip #else" pt (point)) nil)) (#$ . 18658))
#@195 Ignore an #else block.
We won't see the #else due to the macro skip section block
unless we are actively parsing an open #if statement.  In that
case, we must skip it since it is the ELSE part.
(defalias 'semantic-lex-c-macro-else #[0 "\306``dB\307\310\311!\203`\312 \210`\313\314`#\266
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "^\\s-*#\\s-*\\(else\\)" semantic-c-skip-conditional-section semantic-push-parser-warning "Skip #else"] 5 (#$ . 19106)])
#@56 Ignore various forms of #if/#else/#endif conditionals.
(defconst semantic-lex-c-macrobits '((looking-at "^\\s-*#\\s-*\\(if\\(n?def\\)?\\|endif\\|elif\\|else\\)") (c-end-of-macro) (setq semantic-lex-end-point (point)) nil) (#$ . 19707))
#@56 Ignore various forms of #if/#else/#endif conditionals.
(defalias 'semantic-lex-c-macrobits #[0 "\306``dB\307\310\311!\203\312 \210`
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "^\\s-*#\\s-*\\(if\\(n?def\\)?\\|endif\\|elif\\|else\\)" c-end-of-macro] 5 (#$ . 19949)])
#@54 Identify include strings, and return special tokens.
(defconst semantic-lex-c-include-system '((looking-at "^\\s-*#\\s-*include\\s-*<\\([^ 	\n>]+\\)>") (let ((#1=#:start (match-beginning 0)) (#2=#:end (match-end 0)) (#3=#:startpnt semantic-lex-end-point) (#4=#:val (save-match-data (goto-char (match-end 0)) (setq semantic-lex-end-point (point)) (cons (buffer-substring-no-properties (match-beginning 1) (match-end 1)) 'system))) (#5=#:endpnt semantic-lex-end-point)) (semantic-lex-spp-merge-header (car #4#)) (semantic-lex-push-token (semantic-lex-token (if (eq (cdr #4#) 'system) 'spp-system-include 'spp-include) #1# #2# (car #4#))) (when (and (/= #3# #5#) (/= #5# semantic-lex-end-point)) (setq semantic-lex-end-point #5#)))) (#$ . 20362))
#@54 Identify include strings, and return special tokens.
(defalias 'semantic-lex-c-include-system #[0 "\306``dB\307\310\311!\203w\307\224\307\225\f\312 \313\314\"\216\307\225b\210`\315\316\224\316\225\")\317B\262
\f\320@!\210
A\317=\203@\321\202A\322@BBB
B\211@\211\211A@\247\204_\211AA\262
\202c\211A\262
A\262

U\204u\211\fU\204u\211\266
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "^\\s-*#\\s-*include\\s-*<\\([^ 	\n>]+\\)>" match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] buffer-substring-no-properties 1 system semantic-lex-spp-merge-header spp-system-include spp-include] 10 (#$ . 21112)])
#@54 Identify include strings, and return special tokens.
(defconst semantic-lex-c-include '((looking-at "^\\s-*#\\s-*include\\s-*\"\\([^ 	\n>]+\\)\"") (let ((#1=#:start (match-beginning 0)) (#2=#:end (match-end 0)) (#3=#:startpnt semantic-lex-end-point) (#4=#:val (save-match-data (goto-char (match-end 0)) (setq semantic-lex-end-point (point)) (cons (buffer-substring-no-properties (match-beginning 1) (match-end 1)) nil))) (#5=#:endpnt semantic-lex-end-point)) (semantic-lex-spp-merge-header (car #4#)) (semantic-lex-push-token (semantic-lex-token (if (eq (cdr #4#) 'system) 'spp-system-include 'spp-include) #1# #2# (car #4#))) (when (and (/= #3# #5#) (/= #5# semantic-lex-end-point)) (setq semantic-lex-end-point #5#)))) (#$ . 21902))
#@54 Identify include strings, and return special tokens.
(defalias 'semantic-lex-c-include #[0 "\306``dB\307\310\311!\203v\307\224\307\225\f\312 \313\314\"\216\307\225b\210`\315\316\224\316\225\")C\262
\f\317@!\210
A\320=\203?\321\202@\322@BBB
B\211@\211\211A@\247\204^\211AA\262
\202b\211A\262
A\262

U\204t\211\fU\204t\211\266
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "^\\s-*#\\s-*include\\s-*\"\\([^ 	\n>]+\\)\"" match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] buffer-substring-no-properties 1 semantic-lex-spp-merge-header system spp-system-include spp-include] 10 (#$ . 22643)])
#@52 Skip backslash ending a line.
Go to the next line.
(defconst semantic-lex-c-ignore-ending-backslash '((looking-at "\\\\\\s-*\n") (setq semantic-lex-end-point (match-end 0))) (#$ . 23424))
#@52 Skip backslash ending a line.
Go to the next line.
(defalias 'semantic-lex-c-ignore-ending-backslash #[0 "\306``dB\307\310\311!\203\307\225
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "\\\\\\s-*\n"] 5 (#$ . 23618)])
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defconst semantic-lex-c-namespace-begin-macro '((looking-at "\\(_GLIBCXX_BEGIN_NAMESPACE\\)(\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*)") (let* ((nsend (match-end 1)) (sym-start (match-beginning 2)) (sym-end (match-end 2)) (ms (buffer-substring-no-properties sym-start sym-end))) (semantic-lex-push-token (semantic-lex-token 'NAMESPACE (match-beginning 0) nsend "namespace")) (semantic-lex-push-token (semantic-lex-token 'symbol sym-start sym-end ms))) (goto-char (match-end 0)) (let ((start (point)) (end 0)) (when (re-search-forward "_GLIBCXX_END_NAMESPACE" nil t) (setq end (point)) (semantic-lex-push-token (semantic-lex-token 'semantic-list start end (list 'prefix-fake))))) (setq semantic-lex-end-point (point))) (#$ . 23981))
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defalias 'semantic-lex-c-namespace-begin-macro #[0 "\306``dB\307\310\311!\203\242\312\225\313\224\313\225\314\"\315\316\307\224BBB
B\211@\211\211A@\247\204:\211AA\262
\202>\211A\262
A\262
\317
BBB
B\211@\211\211A@\247\204^\211AA\262
\202b\211A\262
A\262
\266\307\225b\210`\307\320\321\306\322#\203\236`\262
\323\324CBBB
B\211@\211\211A@\247\204\226\211AA\262
\202\232\211A\262
A\262
\266`
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "\\(_GLIBCXX_BEGIN_NAMESPACE\\)(\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*)" 1 2 buffer-substring-no-properties NAMESPACE "namespace" symbol re-search-forward "_GLIBCXX_END_NAMESPACE" t semantic-list prefix-fake] 9 (#$ . 24782)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable semantic-lex-c-nested-namespace-ignore-second funcall function #[0 "\300\207" [t] 1 ""] "Should _GLIBCXX_BEGIN_NESTED_NAMESPACE ignore the second namespace?\nIt is really there, but if a majority of uses is to squeeze out\nthe second namespace in use, then it should not be included.\n\nIf you are having problems with smart completion and STL templates,\nit may be that this is set incorrectly.  After changing the value\nof this flag, you will need to delete any semanticdb cache files\nthat may have been incorrectly parsed." :group semantic :type boolean] 8)
#@48 Handle VC++'s definition of the std namespace.
(defconst semantic-lex-c-VC++-begin-std-namespace '((looking-at "\\(_STD_BEGIN\\)") (semantic-lex-push-token (semantic-lex-token 'NAMESPACE (match-beginning 0) (match-end 0) "namespace")) (semantic-lex-push-token (semantic-lex-token 'symbol (match-beginning 0) (match-end 0) "std")) (goto-char (match-end 0)) (let ((start (point)) (end 0)) (when (re-search-forward "_STD_END" nil t) (setq end (point)) (semantic-lex-push-token (semantic-lex-token 'semantic-list start end (list 'prefix-fake))))) (setq semantic-lex-end-point (point))) (#$ . 26326))
#@48 Handle VC++'s definition of the std namespace.
(defalias 'semantic-lex-c-VC++-begin-std-namespace #[0 "\306``dB\307\310\311!\203\230\312\313\307\224\307\225BBB
B\211@\211\211A@\247\2040\211AA\262
\2024\211A\262
A\262
\314\315\307\224\307\225BBB
B\211@\211\211A@\247\204V\211AA\262
\202Z\211A\262
A\262
\307\225b\210`\307\316\317\306\320#\203\224`\262
\321\322CBBB
B\211@\211\211A@\247\204\214\211AA\262
\202\220\211A\262
A\262
\266`
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "\\(_STD_BEGIN\\)" NAMESPACE "namespace" symbol "std" re-search-forward "_STD_END" t semantic-list prefix-fake] 7 (#$ . 26928)])
#@48 Handle VC++'s definition of the std namespace.
(defconst semantic-lex-c-VC++-end-std-namespace '((looking-at "\\(_STD_END\\)") (goto-char (match-end 0)) (setq semantic-lex-end-point (point))) (#$ . 27696))
#@48 Handle VC++'s definition of the std namespace.
(defalias 'semantic-lex-c-VC++-end-std-namespace #[0 "\306``dB\307\310\311!\203\307\225b\210`
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "\\(_STD_END\\)"] 5 (#$ . 27908)])
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defconst semantic-lex-c-namespace-begin-nested-macro '((looking-at "\\(_GLIBCXX_BEGIN_NESTED_NAMESPACE\\)(\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*,\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*)") (goto-char (match-end 0)) (let* ((nsend (match-end 1)) (sym-start (match-beginning 2)) (sym-end (match-end 2)) (ms (buffer-substring-no-properties sym-start sym-end)) (sym2-start (match-beginning 3)) (sym2-end (match-end 3)) (ms2 (buffer-substring-no-properties sym2-start sym2-end))) (semantic-lex-push-token (semantic-lex-token 'NAMESPACE (match-beginning 0) nsend "namespace")) (semantic-lex-push-token (semantic-lex-token 'symbol sym-start sym-end ms)) (goto-char (match-end 0)) (let ((start (point)) (end 0)) (when (re-search-forward "_GLIBCXX_END_NESTED_NAMESPACE" nil t) (setq end (point)) (if semantic-lex-c-nested-namespace-ignore-second (semantic-lex-push-token (semantic-lex-token 'semantic-list start end (list 'prefix-fake))) (semantic-lex-push-token (semantic-lex-token 'semantic-list start end (list 'prefix-fake-plus (semantic-lex-token 'NAMESPACE sym-end sym2-start "namespace") (semantic-lex-token 'symbol sym2-start sym2-end ms2) (semantic-lex-token 'semantic-list start end (list 'prefix-fake))))))))) (setq semantic-lex-end-point (point))) (#$ . 28275))
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defalias 'semantic-lex-c-namespace-begin-nested-macro #[0 "\306``dB\307\310\311!\203\372\307\225b\210\312\225\313\224\313\225\314\"\315\224\315\225\314\"\316\317\307\224	BBB
B\211@\211\211A@\247\204F\211AA\262
\202J\211A\262
A\262
\320BBB
B\211@\211\211A@\247\204l\211AA\262
\202p\211A\262
A\262
\307\225b\210`\307\321\322\306\323#\203\366`\262
\203\264\324\325CBBB
B\211@\211\211A@\247\204\247\211AA\262
\202\253\211A\262
A\262
\266	\202\370\324\326\316\317\n	BBB\320		BBB\324\325CBBBFBBB
B\211@\211\211A@\247\204\356\211AA\262
\202\362\211A\262
A\262
\266	`
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "\\(_GLIBCXX_BEGIN_NESTED_NAMESPACE\\)(\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*,\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*)" 1 2 buffer-substring-no-properties 3 NAMESPACE "namespace" symbol re-search-forward "_GLIBCXX_END_NESTED_NAMESPACE" t semantic-list prefix-fake prefix-fake-plus semantic-lex-c-nested-namespace-ignore-second] 18 (#$ . 29606)])
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defconst semantic-lex-c-namespace-end-macro '((looking-at "_GLIBCXX_END_\\(NESTED_\\)?NAMESPACE") (goto-char (match-end 0)) (setq semantic-lex-end-point (point))) (#$ . 30809))
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defalias 'semantic-lex-c-namespace-end-macro #[0 "\306``dB\307\310\311!\203\307\225b\210`
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "_GLIBCXX_END_\\(NESTED_\\)?NAMESPACE"] 5 (#$ . 31061)])
#@37 Detect and create a C string token.
(defconst semantic-lex-c-string '((looking-at "L?\\(\\s\"\\)") (semantic-lex-push-token (semantic-lex-token 'string (point) (save-excursion (goto-char (match-beginning 1)) (semantic-lex-unterminated-syntax-protection 'string (forward-sexp 1) (point)))))) (#$ . 31468))
#@37 Detect and create a C string token.
(defalias 'semantic-lex-c-string #[0 "\306``dB\307\310\311!\203i\312`\212\313\224b\210\203+\203+\314\313!\210`\202I\31518\314\313!\210`0\202I\210\312
@A#b\210`\211\262
)BB
B\211@\211\211A@\247\204a\211AA\262
\202e\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "L?\\(\\s\"\\)" string 1 forward-sexp (error) debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function] 8 (#$ . 31779)])
#@139 Detect and ignore newline tokens.
Use this ONLY if newlines are not whitespace characters (such as when
they are comment end characters).
(defconst semantic-c-lex-ignore-newline '((looking-at "\\s-*\\\\?\\s-*\\(\n\\|\\s>\\)") (setq semantic-lex-end-point (match-end 0))) (#$ . 32407))
#@139 Detect and ignore newline tokens.
Use this ONLY if newlines are not whitespace characters (such as when
they are comment end characters).
(defalias 'semantic-c-lex-ignore-newline #[0 "\306``dB\307\310\311!\203\307\225
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "\\s-*\\\\?\\s-*\\(\n\\|\\s>\\)"] 5 (#$ . 32699)])
#@170 Lexical Analyzer for C code.
Use semantic-cpp-lexer for parsing text inside a CPP macro.
See `semantic-lex' for more information.

(fn START END &optional DEPTH LENGTH)
(defalias 'semantic-c-lexer #[1026 "\306\307\310#\210`\306\211\211\311\206
@BA\306BdV\203.\312\313d#\210\314 p\315\316#\216\317C!\210b\210`W\203\261\203R	GX\203\261\320\321!\203\355\322\224\322\225\323 \315\324\"\216\311\225b\210\325\306w\210l?\205\252\322\225\212\311\225b\210\320\326!)\306D\327E\330\212\331 \210\332\333\"\203\226\311\224b\210`\202\227`)!
\203\242\334
@!\210`\335
!*\266\203)\262
\336\337\"\"\210\340BB	B\211@\211\211A@\247\204\322\211AA\262
\202\326\211A\262
A\262

U\204\350\211U\204\350\211\266\202?\320\341!\2038
\322\224\322\225\337\"\306\342\206
F\206
\343\344\311\"\211F\"\266\345BB	B\211@\211\211A@\247\204+
\211AA\262
\202/
\211A\262
A\262
\266\202?\320\346!\203D
\347 \210\202?\320\350!\203P
\351 \210\202?\320\352!\203f
`\353 \210`\354\355`#\266\202?\320\356!\203t
\331 \210`\202?\320\357!\203\341
\311\224\311\225\323 \315\360\"\216\311\225b\210`\337\322\224\322\225\")C\262
\361@!\210
A\362=\203\247
\363\202\250
\364@BBB	B\211@\211\211A@\247\204\306
\211AA\262
\202\312
\211A\262
A\262

U\204\334
\211U\204\334
\211\266\202?\320\365!\203O\311\224\311\225\323 \315\366\"\216\311\225b\210`\337\322\224\322\225\")\362B\262
\361@!\210
A\362=\203\363\202\364@BBB	B\211@\211\211A@\247\2044\211AA\262
\2028\211A\262
A\262

U\204J\211U\204J\211\266\202?\320\367!\203[\311\225\202?\320\370!\203g\311\225\202?\320\371!\203s\311\225\202?\320G!\203\241\372\311\224\311\225BB	B\211@\211\211A@\247\204\226\211AA\262
\202\232\211A\262
A\262
\202?\320\373!\203\374`\212\322\224b\210H\203\300I\203\300\375\322!\210`\202\340\3761\315\375\322!\210`0\202\340\210\374J
A@AA#b\210`\211\262
)BB	B\211@\211\211A@\247\204\370\211AA\262
\202\374\211A\262
A\262
\202?\320\377!\203\260\322\225\201P\224\201P\225\337\"\201Q\201R\311\224BBB	B\211@\211\211A@\247\2049\211AA\262
\202=\211A\262
A\262
\201S
BBB	B\211@\211\211A@\247\204_\211AA\262
\202c\211A\262
A\262
\266\311\225b\210`\311\201T\201U\306\201V#\203\251`\262
\201W\201XCBBB	B\211@\211\211A@\247\204\241\211AA\262
\202\245\211A\262
A\262
\266`\202?\320\201Y!\203\311\311\225b\210\322\225\201P\224\201P\225\337\"\201Z\224\201Z\225\337\"\201Q\201R\311\224	BBB	B\211@\211\211A@\247\204\370\211AA\262
\202\374\211A\262
A\262
\201SBBB	B\211@\211\211A@\247\204 \211AA\262
\202$\211A\262
A\262
\311\225b\210`\311\201T\201[\306\201V#\203\302`\262
K\203r\201W\201XCBBB	B\211@\211\211A@\247\204e\211AA\262
\202i\211A\262
A\262
\266	\202\304\201W\201\\\201Q\201R\n	BBB\201S		BBB\201W\201XCBBBFBBB	B\211@\211\211A@\247\204\272\211AA\262
\202\276\211A\262
A\262
\266	`\202?\320\201]!\203\332\311\225b\210`\202?\320\201^!\203}\201Q\201R\311\224\311\225BBB	B\211@\211\211A@\247\204\211AA\262
\202\211A\262
A\262
\201S\201_\311\224\311\225BBB	B\211@\211\211A@\247\204.\211AA\262
\2022\211A\262
A\262
\311\225b\210`\311\201T\201`\306\201V#\203v`\262
\201W\201XCBBB	B\211@\211\211A@\247\204n\211AA\262
\202r\211A\262
A\262
\266`\202?\320\201a!\203\216\311\225b\210`\202?\320\201b!\203\302\201c\311!\311\224\311\225\306\201d#\210\201e!\211\262\203\275\201f
\201g\"A\266\202?\320\201h!\203\363\201i\311\224\311\225BB	B\211@\211\211A@\247\204\350\211AA\262
\202\354\211A\262
A\262
\202?\320\201j!\203\226@\203\f@W\2033\fT\201k\311\224\311\225BB	B\211@\211\211A@\247\204(\211AA\262
\202,\211A\262
A\262
\202?\201W\311\224\212H\203MI\203M\201l\322!\210`\202s\201m1^\201l\322!\210`0\202s\210\201WJ
A@AA#b\210`\211\262
)BB	B\211@\211\211A@\247\204\213\211AA\262
\202\217\211A\262
A\262
\202?\320\201n!\203\312\fS\201o\311\224\311\225BB	B\211@\211\211A@\247\204\277\211AA\262
\202\303\211A\262
A\262
\202?\320L!\203`\201p\322!\210`
=\203\355\201q\201r\201s \"\210\202\366n\203\366\201tu\210`
=\203\312\201u!\210`\210\202?\320\201v!\2039\201w\311\224\311\225BB	B\211@\211\211A@\247\204.\211AA\262
\2022\211A\262
A\262
\202?\312\201x!\210=\203N\312\201y	@#\210\262b\210M\203\200\201z \204vr\201{N!q\210\212Nb\210\201| *\203\200\201}M\201~\"\210	@O\205\254\306C\315\201\"\216
\203\234\211\201\200!\240\210\201\201\201\202\201\203\f#!)\262
\266\202@)\266\n\203\354\n\211A\242\211\211\203\331\201\204\201\205@A@#\210\n\211A\242\262
\202\276
@J
A@AA#b\210`\211\266
b\210	\237.\207" [semantic-lex-block-streams semantic-lex-token-stream semantic-lex-block-stack semantic-lex-end-point semantic-lex-current-depth semantic-lex-depth nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-c-lexer: end (%d) > point-max (%d)" syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table looking-at "^\\s-*#\\s-*define\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" 1 match-data #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] " 	" "(" semantic-cpp-lexer semantic-lex-spp-stream-for-macro c-end-of-macro looking-back "/\\*.*" semantic-lex-spp-first-token-arg-list semantic-lex-spp-merge-streams semantic-lex-spp-symbol-set buffer-substring-no-properties spp-macro-def "^\\s-*#\\s-*undef\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" unintern make-vector 13 spp-macro-undef "^\\s-*#\\s-*\\(ifndef\\|ifdef\\)\\s-+\\(\\(\\sw\\|\\s_\\)+\\)\\([ 	
].*\\)?$" semantic-c-do-lex-ifdef "^\\s-*#\\s-*\\(if\\|elif\\).*$" semantic-c-do-lex-if "^\\s-*#\\s-*\\(else\\)" semantic-c-skip-conditional-section semantic-push-parser-warning "Skip #else" "^\\s-*#\\s-*\\(if\\(n?def\\)?\\|endif\\|elif\\|else\\)" "^\\s-*#\\s-*include\\s-*\"\\([^ 	\n>]+\\)\"" #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] semantic-lex-spp-merge-header system spp-system-include spp-include "^\\s-*#\\s-*include\\s-*<\\([^ 	\n>]+\\)>" #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] "\\\\\\s-*\n" "\\s-+" "\\s-*\\\\?\\s-*\\(\n\\|\\s>\\)" number "L?\\(\\s\"\\)" string forward-sexp (error) "\\(_GLIBCXX_BEGIN_NAMESPACE\\)(\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*)" semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties semantic-lex-syntax-table semantic-lex-spp-replacements-enabled semantic-lex-analyzer semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-number-expression debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function semantic-lex-c-nested-namespace-ignore-second semantic-lex-comment-regex semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug 2 NAMESPACE "namespace" symbol re-search-forward "_GLIBCXX_END_NAMESPACE" t semantic-list prefix-fake "\\(_GLIBCXX_BEGIN_NESTED_NAMESPACE\\)(\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*,\\s-*\\(\\(?:\\w\\|\\s_\\)+\\)\\s-*)" 3 "_GLIBCXX_END_NESTED_NAMESPACE" prefix-fake-plus "_GLIBCXX_END_\\(NESTED_\\)?NAMESPACE" "\\(_STD_BEGIN\\)" "std" "_STD_END" "\\(_STD_END\\)" "\\(\\sw\\|\\s_\\)+" match-string semantic-lex-spp-analyzer-push-tokens-for-symbol semantic-lex-spp-get-overlay overlay-get semantic-spp "\\s\\+" charquote "\\s(" open-paren forward-list (error) "\\s)" close-paren forward-comment skip-syntax-forward "-.'" point-at-eol -1 "Strange comment syntax prevents lexical analysis" "\\(\\s.\\|\\s$\\|\\s'\\)" punctuation "Unmatched Text during Lexical Analysis" "semantic-c-lexer: endless loop at %d, after %S" input-pending-p marker-buffer accept-process-output throw lex #[0 "\300\242\205	\301\300\242!\207" [V0 delete-overlay] 2] semantic-lex-highlight-token read-event format "%S :: Depth: %d :: SPC - continue" message "semantic-c-lexer: `%s' block from %S is unterminated"] 26 (#$ . 33160)])
#@41 Match ## inside a CPP macro as special.
(defconst semantic-lex-cpp-hashhash '((looking-at "##") (semantic-lex-push-token (semantic-lex-token 'spp-concat (match-beginning 0) (match-end 0)))) (#$ . 41077))
#@41 Match ## inside a CPP macro as special.
(defalias 'semantic-lex-cpp-hashhash #[0 "\306``dB\307\310\311!\2036\312\307\224\307\225BB
B\211@\211\211A@\247\204.\211AA\262
\2022\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "##" spp-concat] 6 (#$ . 41287)])
#@124 Lexical Analyzer for CPP macros in C code.
See `semantic-lex' for more information.

(fn START END &optional DEPTH LENGTH)
(defalias 'semantic-cpp-lexer #[1026 "\306\307\310#\210`\306\211\211\311\206
@BA\306BdV\203.\312\313d#\210\314 p\315\316#\216\317C!\210b\210`W\203\202\203R	GX\203\202\320\321!\203\322\311\224\311\225BB	B\211@\211\211A@\247\204t\211AA\262
\202x\211A\262
A\262
\202\320\323!\203
\324\224\324\225\325 \315\326\"\216\311\225b\210\327\306w\210l?\205\327\324\225\212\311\225b\210\320\330!)\306D\331E\332\212\333 \210\334\335\"\203\303\311\224b\210`\202\304`)!
\203\317\336
@!\210`\337
!*\266\203)\262
\340\341\"\"\210\342BB	B\211@\211\211A@\247\204\377\211AA\262
\202
\211A\262
A\262

U\204
\211U\204
\211\266\202\320\343!\203e
\324\224\324\225\341\"\306\344\206;
F\206;
\345\346\311\"\211F\"\266\347BB	B\211@\211\211A@\247\204X
\211AA\262
\202\\
\211A\262
A\262
\266\202\320\350!\203q
\351 \210\202\320\352!\203\207
`\353 \210`\354\355`#\266\202\320\356!\203\225
\333 \210`\202\320\357!\203\311\224\311\225\325 \315\360\"\216\311\225b\210`\341\324\224\324\225\")C\262
\361@!\210
A\362=\203\310
\363\202\311
\364@BBB	B\211@\211\211A@\247\204\347
\211AA\262
\202\353
\211A\262
A\262

U\204\375
\211U\204\375
\211\266\202\320\365!\203p\311\224\311\225\325 \315\366\"\216\311\225b\210`\341\324\224\324\225\")\362B\262
\361@!\210
A\362=\2036\363\2027\364@BBB	B\211@\211\211A@\247\204U\211AA\262
\202Y\211A\262
A\262

U\204k\211U\204k\211\266\202\320\367!\203|\311\225\202\320\370!\203\210\311\225\202\320\371!\203\224\311\225\202\320G!\203\302\372\311\224\311\225BB	B\211@\211\211A@\247\204\267\211AA\262
\202\273\211A\262
A\262
\202\320\373!\203$\374`\212\324\224b\210H\203\341I\203\341\375\324!\210`\202
\3761\356\375\324!\210`0\202
\210\374J
A@AA#b\210`\211\262
)BB	B\211@\211\211A@\247\204\211AA\262
\202\211A\262
A\262
\202\320\377!\203}\201P\311!\211\201QK!\205E\211;\205E\201R
K\"\262
\211\262\205O\211J\262
\206W\201S\311\224\311\225BB	B\211@\211\211A@\247\204r\211AA\262
\202v\211A\262
A\262
\202\320\201T!\203\256\201U\311\224\311\225BB	B\211@\211\211A@\247\204\243\211AA\262
\202\247\211A\262
A\262
\202\320\201V!\203g@\203\302\f@W\203\356\fT\201W\311\224\311\225BB	B\211@\211\211A@\247\204\343\211AA\262
\202\347\211A\262
A\262
\202\212\311\224\311\225\212\333 \210`)\201X1<\201Y\324!\210`
V\203\312\201Z!\210\201[`BB	B\211@\211\211A@\247\204-\211AA\262
\2021\211A\262
A\262
\2110\266\202c\210\201WBB	B\211@\211\211A@\247\204Y\211AA\262
\202]\211A\262
A\262
\266)\202\320\201\\!\203\233\fS\201]\311\224\311\225BB	B\211@\211\211A@\247\204\220\211AA\262
\202\224\211A\262
A\262
\202\320L!\203\331`\201^\324!\210`
=\203\276\201_\201`\201a \"\210\202\307n\203\307\201bu\210`
=\203\323\312\201c!\210`\210\202\320\201d!\203\n\201e\311\224\311\225BB	B\211@\211\211A@\247\204\377\211AA\262
\202\211A\262
A\262
\202\312\201f!\210=\203\312\201g	@#\210\262b\210M\203Q\201h \204Gr\201iN!q\210\212Nb\210\201j *\203Q\201kM\201l\"\210	@O\205}\306C\315\201m\"\216
\203m\211\201n!\240\210\201o\201p\201q\f#!)\262
\266\202@)\266\n\203\275\n\211A\242\211\211\203\252\201r\201s@A@#\210\n\211A\242\262
\202\217
@J
A@AA#b\210`\211\266
b\210	\237.\207" [semantic-lex-block-streams semantic-lex-token-stream semantic-lex-block-stack semantic-lex-end-point semantic-lex-current-depth semantic-lex-depth nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-cpp-lexer: end (%d) > point-max (%d)" syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table looking-at "##" spp-concat "^\\s-*#\\s-*define\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" 1 match-data #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] " 	" "(" semantic-cpp-lexer semantic-lex-spp-stream-for-macro c-end-of-macro looking-back "/\\*.*" semantic-lex-spp-first-token-arg-list semantic-lex-spp-merge-streams semantic-lex-spp-symbol-set buffer-substring-no-properties spp-macro-def "^\\s-*#\\s-*undef\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" unintern make-vector 13 spp-macro-undef "^\\s-*#\\s-*\\(if\\|elif\\).*$" semantic-c-do-lex-if "^\\s-*#\\s-*\\(else\\)" semantic-c-skip-conditional-section semantic-push-parser-warning "Skip #else" "^\\s-*#\\s-*\\(if\\(n?def\\)?\\|endif\\|elif\\|else\\)" "^\\s-*#\\s-*include\\s-*\"\\([^ 	\n>]+\\)\"" #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] semantic-lex-spp-merge-header system spp-system-include spp-include "^\\s-*#\\s-*include\\s-*<\\([^ 	\n>]+\\)>" #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] "\\\\\\s-*\n" "\\s-+" "\\s-*\\\\?\\s-*\\(\n\\|\\s>\\)" number "L?\\(\\s\"\\)" string forward-sexp (error) "\\(\\sw\\|\\s_\\)+" semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties semantic-lex-syntax-table semantic-lex-spp-replacements-enabled semantic-lex-analyzer semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-number-expression debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function semantic-flex-keywords-obarray semantic-lex-comment-regex semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug match-string obarrayp intern-soft symbol "\\s\\+" charquote "\\s(" open-paren (error) forward-list "" semantic-list "\\s)" close-paren forward-comment skip-syntax-forward "-.'" point-at-eol -1 "Strange comment syntax prevents lexical analysis" "\\(\\s.\\|\\s$\\|\\s'\\)" punctuation "Unmatched Text during Lexical Analysis" "semantic-cpp-lexer: endless loop at %d, after %S" input-pending-p marker-buffer accept-process-output throw lex #[0 "\300\242\205	\301\300\242!\207" [V0 delete-overlay] 2] semantic-lex-highlight-token read-event format "%S :: Depth: %d :: SPC - continue" message "semantic-cpp-lexer: `%s' block from %S is unterminated"] 19 (#$ . 41704)])
#@360 Calls `semantic-parse-region-default', except in a macro expansion.
MACRO expansion mode is handled through the nature of Emacs's non-lexical
binding of variables.
START, END, NONTERMINAL, DEPTH, and RETURNONERRORS are the same
as for the parent.
Override `semantic-parse-region' in `c-mode' buffers.

(fn START END &optional NONTERMINAL DEPTH RETURNONERROR)
(defalias 'semantic-parse-region-c-mode #[1282 "\301\300!\203}eU\203dU\204}\211\211@\262

A@A@;\211\203-\302$\207\203p\303U\203p\304=\203p
\203p
:\203p
@9\203p\305\262
:\203`
@\306=\203`
A\202g\307		\305#\310
	#\237\207\311					%\207\311%\207" [lse boundp semantic-c-parse-lexical-token 1 semantic-list 0 prefix-fake-plus semantic-lex semantic-repeat-parse-whole-stream semantic-parse-region-default] 15 (#$ . 47796)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-parse-region-c-mode definition-name semantic-parse-region mode-local-bind ((semantic-parse-region . semantic-parse-region-c-mode)) (override-flag t) c-mode] 4)
#@71 Current depth of recursive calls to `semantic-c-parse-lexical-token'.
(defvar semantic-c-parse-token-hack-depth 0 (#$ . 48854))
#@319 Do a region parse on the contents of LEXICALTOKEN.
Presumably, this token has a string in it from a macro.
The text of the token is inserted into a different buffer, and
parsed there.
Argument NONTERMINAL, DEPTH, and RETURNONERROR are passed into
the regular parser.

(fn LEXICALTOKEN NONTERMINAL DEPTH RETURNONERROR)
(defalias 'semantic-c-parse-lexical-token #[1028 "T\304\305\306\"!	\n\307\211\211A@\247\204\211AA\262
\202\"\211A\262
@\262
\211\211A@\247\2047\211AA\262
\202;\211A\262
A\262
	\211A@;\203O\211A@\262
\202\203\310
\211\211A@\247\204a\211AA\262
\202e\211A\262
@\262
\211\211A@\247\204y\211AA\262
\202}\211A\262
A\262
\"\262
\311\312\313#\314V\204p
rq\210\315 \210	=\204\343\316 \317\320\"\216\3211\260 0\210\202\315\210\322\305\323\n\324 #!\203\305\325!\210\202\315\326\327!\210\330\331!\210)\210\332 \210\333 \210\334\335 \210\336 \210\337\340\341\334#\210\211\211\203\372\211@\342
@A\"\210
A\266\202\202\346\210
c\210\343ed


%\262\211\211\203.
\211@\211@\307\344\206$
\n\206$
\345\346\312\"\211\"\266
A\266\202\202
\210\211\203n
\211@\211D
\347
\233\262

\240\266\350
!\211\203f
\211@\211D
\347
\233\262

\240\266
A\266\202\202I
\210
A\266\202\2020
\210))\207" [semantic-c-parse-token-hack-depth major-mode semantic-lex-spp-dynamic-macro-symbol-obarray semantic-new-buffer-fcn-was-run get-buffer-create format " *C parse hack %d*" nil buffer-substring-no-properties get-text-property 0 macros 5 erase-buffer match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] (error) y-or-n-p "There was an error initializing %s in buffer \"%s\".  Debug your hooks? " buffer-name semantic-c-debug-mode-init message "Macro parsing state may be broken..." sit-for 1 mode-local--activate-bindings semantic-default-c-setup t semantic-lex-init semantic-clear-toplevel-cache remove-hook semantic-lex-reset-functions semantic-lex-spp-reset-hook semantic-lex-spp-symbol-set semantic-parse-region-default unintern make-vector 13 4 semantic-tag-components-with-overlays] 21 (#$ . 48989)])
#@41 The most recent mode needing debugging.
(defvar semantic-c-debug-mode-init-last-mode nil (#$ . 51070))
#@74 Debug mode init for major mode MM after we're done parsing now.

(fn MM)
(defalias 'semantic-c-debug-mode-init #[257 "\302\303!\203\304\305\306!!\210\307\211 )\207\211\310\311\312\"\207" [debug-on-error semantic-c-debug-mode-init-last-mode called-interactively-p interactive switch-to-buffer get-buffer-create "*MODE HACK TEST*" t add-hook post-command-hook semantic-c-debug-mode-init-pch] 4 (#$ . 51179) (list semantic-c-debug-mode-init-last-mode)])
#@60 Notify user about needing to debug their major mode hooks.
(defalias 'semantic-c-debug-mode-init-pch #[0 "\301\302\303!!\210\304 \210\305\306!\307\261\210\310\311\312\"\207" [semantic-c-debug-mode-init-last-mode switch-to-buffer-other-window get-buffer-create "*MODE HACK TEST*" erase-buffer "A failure occurred while parsing your buffers.\n\nThe failure occurred while attempting to initialize " symbol-name " in a\nbuffer not associated with a file.  To debug this problem, type\n\nM-x semantic-c-debug-mode-init\n\nnow.\n" remove-hook post-command-hook semantic-c-debug-mode-init-pch] 4 (#$ . 51640)])
#@62 Expand TAG into a list of equivalent tags, or nil.

(fn TAG)
(defalias 'semantic-expand-c-tag #[257 "\300
\211A@\262
\301=\203\302!\262
\300\262
\303
\211A@\262

=\266\202\2042
\304
\211A@\262

=\266\202\203?\305!\262
@\262

A\262
\211@\262
:\203`\306!\211\204S\266\300\207\211:\203^\307
\"\262\210\207
\203n\211:\203n

B\262
\207" [nil extern semantic-expand-c-extern-C function variable semantic-expand-c-complex-type semantic-expand-c-tag-namelist append] 6 (#$ . 52254)])
#@152 Expand TAG containing an `extern "C"' statement.
This will return all members of TAG with `extern "C"' added to
the typemodifiers attribute.

(fn TAG)
(defalias 'semantic-expand-c-extern-C #[257 "\211\211A@\262
\300=\205\\\211\301\302\303
8\262
\"\266\202\211
\203X
@\304\302\303
8\262
\"\266\202\305\306BB\262
@\304\211AA\262
\211:\203N\211\307\310@#!\240\210\266
A\262\202\211\237\266\202\207" [extern :members plist-get 2 :typemodifiers "extern" "\"C\"" semantic-tag-make-plist plist-put] 14 (#$ . 52755)])
#@389 Check if TAG has a full :type with a name on its own.
If so, extract it, and replace it with a reference to that type.
Thus, `struct A { int a; } B;' will create 2 toplevel tags, one
is type A, and the other variable B where the :type of B is just
a type tag A that is a prototype, and the actual struct info of A
is its own toplevel tag.  This function will return (cons A B).

(fn TAG)
(defalias 'semantic-expand-c-complex-type #[257 "\211\211\300\301\302
8\262
\"\266\203\303\211:\205\211@\262
\211:\203$\211@@\262
\203\335\3041V\211:\205P\211@;\205P\211A@9\205P\211A@\205P\302
8<\205P\305
8<0\262
\202Z\210\303\262
\203\335\306!\204\335\211\203\335\211\307\230\204\335\211@\262
\211\300\301\302
8\262
\"\266\203\303\211\310\311D\312\313\314\300\315	\316\n@\317\fA\f&\f\266\205\262\320!\262\300\211AA\262
\211:\203\300\211\321\322@#!\240\210\266\323\"\210\324
8\262

\324
\233\262

\240\266C\262
B\207" [:type plist-get 2 nil (error) 3 semantic-tag-prototype-p "" :prototype t apply semantic-tag type :members :superclasses :interfaces semantic-tag-copy semantic-tag-make-plist plist-put semantic--tag-copy-properties 4] 23 (#$ . 53293)])
#@72 Expand TAG whose name is a list into a list of tags, or nil.

(fn TAG)
(defalias 'semantic-expand-c-tag-namelist #[257 "\211\300
\211A@\262

=\266\202\203\360\301
\211\302\303\304
8\262
\"\266\203\305\306\303\304
8\262
\"\266\202\305\211@\262
\301\211\203\354\305\262\305\262@\262
\304
8\203O\307\3048P\262G\310U\203_@\262\202c\262\311
8\262\211@\205}A<\205}\312@A@\"\313\f\211\313\303\304
8\262
\"\266\203\314	\306\f\315\3168G\317\fA@\320\320\303\304
8\262
\"\266\202\321\322!\257\323\324\300\302\325&\266\204B\262\326		@\"\210@	\311
8\262

\311
\233\262

\240\266A\262\2024\237\207\211\327
\211A@\262

=\266\202\203,\301
\211@\262
\330\303\304
8\262
\"\266\202\301\331\332\"\203\262

\327
\211A@\262

=\266\202\203\262

\211\333\303\304
8\262
\"\266\203\203\262

\262

\301\211\206H

\211@\262
\211A@\262
\334\304
8\262
!\334\316
8\262
!\311
8\262
\257\266\202\262
\211@\262
\305\230\204\225

\333\301\211AA\262
\211:\203\217
\211\335\336@#!\240\210\266\202\230
\301\262
\211\203\262
\326\"\210\211\311
8\262

\311
\233\262

\240\266\203!@A@\332\211\333\303\304
8\262
\"\266\203\301\317@@@\211\337U?\205\331
\211\262
\340\321\322!\257\323\324\327\302\333	\330\n@\341\fA\f&\f\266\205B\262\326@\"\210@\311
8\262

\311
\233\262

\240\266A\262\202\262
\211\203*\211B\262\207\211@<\203X\211@\300
\211A@\262

=\266\202\203X\301
\203W\342\343@!\"\262

A\262\202C\207\301\207" [variable nil :type plist-get 2 "" :typemodifiers ":" 1 4 buffer-substring-no-properties :constant-flag :suffix :dereference 3 :pointer :reference :documentation semantic-tag-docstring apply semantic-tag :default-value semantic--tag-copy-properties type :superclasses semantic-tag-of-type-p "typedef" :members copy-sequence semantic-tag-make-plist plist-put 0 :typedef :interfaces append semantic-tag-components] 29 (#$ . 54497)])
(byte-code "\303\304\305\303BC\306\307#\210\310\311\312\"\307\"\266\313\305\307\314!\315\2042\211\262\2042	\262\n\2050\316\n\"\262
\203]\211\204]\302N\203L\316\302N\"\211\262\2042\211\317N\206V\211\320N\262
\262\2022\266\203\321\322#\207" [mode-local-active-mode major-mode mode-local-symbol-table semantic-expand-c-tag mode-local-bind semantic-tag-expand-function (mode-variable-flag t) c-mode mode-local-map-mode-buffers make-closure #[0 "\302\301!\210\300\211\207" [V0 semantic-tag-expand-function make-local-variable] 2] put symbol-name nil intern-soft mode-local-parent derived-mode-parent variable-documentation "Function used to expand tags generated in the C bovine parser."] 9)
#@276 At parse time, assign a class or struct name text here.
It is picked up by `semantic-c-reconstitute-token' to determine
if something is a constructor.  Value should be:
  (TYPENAME .  TYPEOFTYPE)
where typename is the name of the type, and typeoftype is "class"
or "struct".
(defvar semantic-c-classname nil (#$ . 57156))
#@116 Split up tag names on colon (:) boundaries.
Override `semantic-analyze-split-name' in `c-mode' buffers.

(fn NAME)
(defalias 'semantic-analyze-split-name-c-mode #[257 "\300
\301\"\211G\302U\203

\207\303\304\"\207" [split-string ":" 1 delete ""] 5 (#$ . 57485)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-analyze-split-name-c-mode definition-name semantic-analyze-split-name mode-local-bind ((semantic-analyze-split-name . semantic-analyze-split-name-c-mode)) (override-flag t) c-mode] 4)
#@293 Analyze the references for TAG.
Returns a class with information about TAG.

Optional argument DB is a database.  It will be used to help
locate TAG.

Use `semantic-analyze-current-tag' to debug this fcn.
Override `semantic-analyze-tag-references' in `c-mode' buffers.

(fn TAG &optional DB)
(defalias 'semantic-analyze-tag-references-c-mode #[513 "
\3001.\211:\205(\211@;\205(\211A@9\205(\211A@\205(\301
8<\205(\302
8<0\262
\2022\210\303\262
\204<\304\305\306D\"\210\303\211\212\307\"\210\310 \262
\311\312#\262\313!\314U\204i\313!\315U\203\246\316\314\"@=\203\246\317
\320\321\320\"\303
\211\203\227\211@\211\211\322\323\301
8\262
\"\266\203\324\230\204\220\211B\262
A\266\202\202r\210\325
!\266\202#\210\311\312#\262\326\211@\262
\327\330\331\332\n&	)\207" [(error) 2 3 nil signal wrong-type-argument semantic-tag-p semantic-go-to-tag semantic-calculate-scope semantic--analyze-refs-full-lookup t semanticdb-find-result-length 0 1 semanticdb-find-result-nth eieio-oset parents eieio-oref :type plist-get "namespace" reverse semantic-analyze-references :tag :tagdb :scope :rawsearchdata] 18 (#$ . 58011)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-analyze-tag-references-c-mode definition-name semantic-analyze-tag-references mode-local-bind ((semantic-analyze-tag-references . semantic-analyze-tag-references-c-mode)) (override-flag t) c-mode] 4)
#@244 Reconstitute a token TOKENPART with DECLMODS and TYPEDECL.
This is so we don't have to match the same starting text several times.
Optional argument STAR and REF indicate the number of * and & in the typedef.

(fn TOKENPART DECLMODS TYPEDECL)
(defalias 'semantic-c-reconstitute-token #[771 "\211<\203\211G\301U\203\211@;\203\211@\262
A@\302=\203E@
\206%\303\304\305\306\235\205/\307\310\311\306	\"F\312\313\302\314\315&\207A@\316=\205n
\203Y@@\230\204q\3178@;\203k\3178@@\230\204q\3208\205v\3218@?@G\322V\205\204@\322H\323U\211\203\220@\301\304O\202\222@\324\325\"?\205\233\307
\206\361\3218@\203\254\326\202\361\203\360@\206\313\327\317	8@!\211;\203\305\211\202\311\330
!@\262
A\206\321\331\304\211\211\312\313\332\314\333	\334\n@\335\fA\f&\f\266\205\202\361\303\336\337\n8!\305\306\n\235\205
\307\310\311\306
\"\340\3178@\341\3218@\205
\307\342\205
\307\343\344\3458\346\347\3508\351\352\3538\235\2058
\307\354\306\353 8\235\205C
\307\355\356!8\205L
\307\357\356#8\357=\205W
\307\360\361%8\257\312\313\316\314\362&\266\210\207" [semantic-c-classname 1 variable "int" nil :constant-flag "const" t :typemodifiers delete apply semantic-tag :type :default-value function 2 10 3 0 42 string-match "[a-zA-Z]" "void" semantic-analyze-split-name-c-mode last "class" type :members :superclasses :interfaces semantic-c-reconstitute-function-arglist 4 :parent :destructor-flag :constructor-flag :function-pointer :pointer 7 :operator-flag :throws 5 :reentrant-flag "reentrant" 6 :methodconst-flag :prototype-flag 8 :pure-virtual-flag :template-specifier 9 :arguments] 39 (#$ . 59436)])
#@77 Reconstitute the token TAG with the template SPECIFIER.

(fn TAG SPECIFIER)
(defalias 'semantic-c-reconstitute-template #[514 "
\300\206\301\211AA\262
\211:\203\211\302\303@#!\240\210\266
\207" [:template "" semantic-tag-make-plist plist-put] 12 (#$ . 61123)])
#@144 Reconstitute the argument list of a function.
This currently only checks if the function expects a function
pointer as argument.

(fn ARGLIST)
(defalias 'semantic-c-reconstitute-function-arglist #[257 "\300
\211\203g\211@\211\211@\262
G\301V\203Y\211\211@\262
\301H\302U\203Y\303\211@\262
\304\300O\211\305\306\307
8\262
\"\266\203\307
8\262
A@\310\311D\312\313\314\305\315&\266\204C\"\262\202`\303C\"\262
A\266\202\202\210\207" [nil 0 42 append 1 :type plist-get 2 :function-pointer t apply semantic-tag function :arguments] 19 (#$ . 61404)])
#@186 Convert TAG to a string that is the print name for TAG.
Optional PARENT and COLOR are ignored.
Override `semantic-format-tag-name' in `c-mode' buffers.

(fn TAG &optional PARENT COLOR)
(defalias 'semantic-format-tag-name-c-mode #[769 "\300#\301\302\303
8\262
\"\266\202\211\204
\207\304\305Q\207" [semantic-format-tag-name-default :function-pointer plist-get 2 "(*" ")"] 10 (#$ . 61979)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-name-c-mode definition-name semantic-format-tag-name mode-local-bind ((semantic-format-tag-name . semantic-format-tag-name-c-mode)) (override-flag t) c-mode] 4)
#@311 Create a canonical name for TAG.
PARENT specifies a parent class.
COLOR indicates that the text should be type colorized.
Enhances the base class to search for the entire parent
tree to make the name accurate.
Override `semantic-format-tag-canonical-name' in `c-mode' buffers.

(fn TAG &optional PARENT COLOR)
(defalias 'semantic-format-tag-canonical-name-c-mode #[769 "\300#\207" [semantic-format-tag-canonical-name-default] 7 (#$ . 62626)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-canonical-name-c-mode definition-name semantic-format-tag-canonical-name mode-local-bind ((semantic-format-tag-canonical-name . semantic-format-tag-canonical-name-c-mode)) (override-flag t) c-mode] 4)
#@231 Convert the data type of TAG to a string usable in tag formatting.
Adds pointer and reference symbols to the default.
Argument COLOR adds color to the text.
Override `semantic-format-tag-type' in `c-mode' buffers.

(fn TAG COLOR)
(defalias 'semantic-format-tag-type-c-mode #[514 "
\211\300\301\302
8\262
\"\266\203\303\304\301\302
8\262
\"\266\202\305\301\302
8\262
\"\266\202\3061W\211:\205Q\211@;\205Q\211A@9\205Q\211A@\205Q\302
8<\205Q\307
8<0\262
\202[\210\303\262
\203\210\211\300\301\302
8\262
\"\266\203\211@\262

\310\230\203}\262\210\202\220
\311Q\262\266\202\220\312\"\262\203\232\313\314\"\262\211\203\241\315\262

\203\253\316\317\"\262\205\263
Q\207" [:type plist-get 2 nil :pointer :reference (error) 3 "class" " " semantic-format-tag-type-default semantic--format-colorize-text type "&" make-string 42] 13 (#$ . 63361)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-type-c-mode definition-name semantic-format-tag-type mode-local-bind ((semantic-format-tag-type . semantic-format-tag-type-c-mode)) (override-flag t) c-mode] 4)
#@289 Override the usual search for protection.
We can be more effective than the default by scanning through once,
and collecting tags based on the labels we see along the way.
Override `semantic-find-tags-by-scope-protection' in `c-mode'
buffers.

(fn SCOPEPROTECTION PARENT &optional TABLE)
(defalias 'semantic-find-tags-by-scope-protection-c-mode #[770 "\211\204
\211\300\301\302
8\262
\"\266\203\262
\204\207\303\304\305\267\202)\304\202*\302\202*\306\307\211\203b\211@\211\310
\211A@\262

=\266\202\203O\311
\211@\262
\"A\262\202[Y\203[\211B\262
A\266\202\202,\210\207" [:members plist-get 2 nil 1 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (public 33 protected 37)) 3 (("public" . 1) ("protected" . 2) ("private" . 3)) label assoc] 13 (#$ . 64491)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-find-tags-by-scope-protection-c-mode definition-name semantic-find-tags-by-scope-protection mode-local-bind ((semantic-find-tags-by-scope-protection . semantic-find-tags-by-scope-protection-c-mode)) (override-flag t) c-mode] 4)
#@173 Return the protection of TAG in PARENT.
Override function for `semantic-tag-protection'.
Override `semantic-tag-protection' in `c-mode' buffers.

(fn TAG &optional PARENT)
(defalias 'semantic-tag-protection-c-mode #[513 "
\211\300\301\302
8\262
\"\266\203\303\203\211A@\262
\304=\204)
\203)
A\262\202\203\223\211A@\262
\304=\203\223\211\305\301\302
8\262
\"\266\203\211\203\222\306
@\"\204\222\211@\211A@\262
\307=\203\213\211@\211@\262
\310\230\203n\311\202\211\211@\211@\262
\312\230\203}\313\202\211\211@\211@\262
\314\230\205\211\315\262\211A\262
\202F\210\211\204\323\211A@\262
\304=\203\323\211\316\301\302
8\262
\"\266\203\317\230\203\271\313\202\321\211\316\301\302
8\262
\"\266\203\320\230\203\320\311\202\321\321\262
\211\206\353\205\353\304
\211A@\262

=\266\202\205\353\311\207" [:typemodifiers plist-get 2 nil type :members semantic-equivalent-tag-p label "public" public "private" private "protected" protected :type "class" "struct" unknown] 11 (#$ . 65614)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-tag-protection-c-mode definition-name semantic-tag-protection mode-local-bind ((semantic-tag-protection . semantic-tag-protection-c-mode)) (override-flag t) c-mode] 4)
#@262 Find all tags in TABLE that are of the `include' class.
TABLE is a tag table.  See `semantic-something-to-tag-table'.
For C++, we also have to search namespaces for include tags.
Override `semantic-find-tags-included' in `c-mode' buffers.

(fn &optional TABLE)
(defalias 'semantic-find-tags-included-c-mode #[256 "\300
!\301
\203!
@\211A@\262
\302=\203
@
B\262

A\262\202\211\237\266\202\300!\301
\203B\303@\304\"\203;
@
B\262

A\262\202)\211\237\266\202\211\211\203\212\211@\305\300\306\307\310
8\262
\"\266\202!\301
\203|
@\211A@\262
\302=\203u
@
B\262

A\262\202_\211\237\266\202\"\262
A\266\202\202G\210
\207" [semantic-something-to-tag-table nil include semantic-tag-of-type-p "namespace" append :members plist-get 2] 14 (#$ . 66882)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-find-tags-included-c-mode definition-name semantic-find-tags-included mode-local-bind ((semantic-find-tags-included . semantic-find-tags-included-c-mode)) (override-flag t) c-mode] 4)
#@94 Return components for TAG.
Override `semantic-tag-components' in `c-mode' buffers.

(fn TAG)
(defalias 'semantic-tag-components-c-mode #[257 "\211\211A@\262
\300=\203d\211\211\301\302\303
8\262
\"\266\203\304\230\203d\211\305\302\303
8\262
\"\266\202\211\3061Y\211:\205S\211@;\205S\211A@9\205S\211A@\205S\303
8<\205S\307
8<0\262
\202]\210\310\262
\205c\311
!\207\312
!\207" [type :type plist-get 2 "typedef" :typedef (error) 3 nil semantic-tag-components semantic-tag-components-default] 8 (#$ . 67906)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-tag-components-c-mode definition-name semantic-tag-components mode-local-bind ((semantic-tag-components . semantic-tag-components-c-mode)) (override-flag t) c-mode] 4)
#@62 Return the template specification for TAG, or nil.

(fn TAG)
(defalias 'semantic-c-tag-template #[257 "\211\300\301\302
8\262
\"\207" [:template plist-get 2] 7 (#$ . 68669)])
#@72 Return the template specifier specification for TAG, or nil.

(fn TAG)
(defalias 'semantic-c-tag-template-specifier #[257 "\211\300\301\302
8\262
\"\207" [:template-specifier plist-get 2] 7 (#$ . 68852)])
#@101 Convert TEMPLATESPEC into a string.
This might be a string, or a list of tokens.

(fn TEMPLATESPEC)
(defalias 'semantic-c-template-string-body #[257 "\211;\203\207\211\30014\211:\205.\211@;\205.\211A@9\205.\211A@\205.\301
8<\205.\302
8<0\262
\2028\210\303\262
\203?\304
!\207\211<\205I\305\304\306#\207" [(error) 2 3 nil semantic-format-tag-abbreviate mapconcat ", "] 5 (#$ . 69066)])
#@263 Return a string representing the TEMPLATE attribute of TOKEN.
This string is prefixed with a space, or is the empty string.
Argument PARENT specifies a parent type.
Argument COLOR specifies that the string should be colorized.

(fn TOKEN &optional PARENT COLOR)
(defalias 'semantic-c-template-string #[769 "\300!\301!\203\301!\210\302\203\300!\210\302\203#\303\304!\305Q\207\203)\306\207\307\207" [semantic-c-tag-template-specifier semantic-c-tag-template nil " <" semantic-c-template-string-body ">" " <>" ""] 10 (#$ . 69470)])
#@253 Return an abbreviated string describing TOKEN for C and C++.
Optional PARENT and COLOR as specified with
`semantic-format-tag-abbreviate-default'.
Override `semantic-format-tag-concise-prototype' in `c-mode' buffers.

(fn TOKEN &optional PARENT COLOR)
(defalias 'semantic-format-tag-concise-prototype-c-mode #[769 "\300#\301#P\207" [semantic-format-tag-concise-prototype-default semantic-c-template-string] 8 (#$ . 70021)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-concise-prototype-c-mode definition-name semantic-format-tag-concise-prototype mode-local-bind ((semantic-format-tag-concise-prototype . semantic-format-tag-concise-prototype-c-mode)) (override-flag t) c-mode] 4)
#@234 Return an UML string describing TOKEN for C and C++.
Optional PARENT and COLOR as specified with
`semantic-abbreviate-tag-default'.
Override `semantic-format-tag-uml-prototype' in `c-mode' buffers.

(fn TOKEN &optional PARENT COLOR)
(defalias 'semantic-format-tag-uml-prototype-c-mode #[769 "\300#\301#P\207" [semantic-format-tag-uml-prototype-default semantic-c-template-string] 8 (#$ . 70752)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-uml-prototype-c-mode definition-name semantic-format-tag-uml-prototype mode-local-bind ((semantic-format-tag-uml-prototype . semantic-format-tag-uml-prototype-c-mode)) (override-flag t) c-mode] 4)
#@283 Return non-nil if TAG is considered abstract.
PARENT is tag's parent.
In C, a method is abstract if it is `virtual', which is already
handled.  A class is abstract only if its destructor is virtual.
Override `semantic-tag-abstract-p' in `c-mode' buffers.

(fn TAG &optional PARENT)
(defalias 'semantic-tag-abstract-p-c-mode #[513 "
\211A@\262
\300=\203H\301\302!\210\303\304\305!\"\206x\303\306\305!\"\303\307\305!\"
\205G\310@\211\311\312\313
8\262
\"\266\203\235\205G\211\205G\314
@\"\315=\207
\211A@\262
\316=\203t
\304\312\313
8\262
\"\266\202\206x\310\211\311\312\313
8\262
\"\266\203\235\207\317\"\207" [type require semantic/find semantic-brute-find-tag-by-attribute :pure-virtual-flag semantic-tag-components :destructor-flag :constructor-flag "virtual" :typemodifiers plist-get 2 semantic-tag-protection protected function semantic-tag-abstract-p-default] 12 (#$ . 71440)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-tag-abstract-p-c-mode definition-name semantic-tag-abstract-p mode-local-bind ((semantic-tag-abstract-p . semantic-tag-abstract-p-c-mode)) (override-flag t) c-mode] 4)
#@190 If TYPE is a typedef, get TYPE's type by name or tag, and return.
SCOPE is not used, and TYPE-DECLARATION is used only if TYPE is not a typedef.

(fn TYPE SCOPE &optional TYPE-DECLARATION)
(defalias 'semantic-c-dereference-typedef #[770 "\211A@\262
\300=\203\222\211\301\302\303
8\262
\"\266\203\304\230\203\222\305\302\303
8\262
\"\266\202\211\3061Y\211:\205S\211@;\205S\211A@9\205S\211A@\205S\303
8<\205S\307
8<0\262
\202]\210\310\262
\203r\311
!\204r\312!\313\310#\211
D\207\211;\203\210\211
\300\310\314!\310\211\257\266\203D\207\211:\205\221\211@
D\207
D\207" [type :type plist-get 2 "typedef" :typedef (error) 3 nil semantic-tag-prototype-p semantic-tag-file-name semantic-tag-copy semantic-tag-make-plist] 13 (#$ . 72589)])
#@188 Replace TAG name according to template specification.
DEF-LIST is the template information.
SPEC-LIST is the template specifier of the datatype instantiated.

(fn TAG DEF-LIST SPEC-LIST)
(defalias 'semantic-c--instantiate-template #[771 "
@\205@\211@\205@
@\211\300\301\302
8\262
\"\266\203\303\230\2039\211@\262
@\211@\262
\230\2039
@\211@\262


\240\266\304AA#\207" [:type plist-get 2 "class" semantic-c--instantiate-template] 10 (#$ . 73355)])
#@133 Return a string used to compute template class name.
Based on SPEC-LIST, for ref<Foo,Bar> it will return `Foo,Bar'.

(fn SPEC-LIST)
(defalias 'semantic-c--template-name-1 #[257 "\211@\205\300
A!\211\205\301@\211@\262

Q\266\202\207" [semantic-c--template-name-1 ","] 6 (#$ . 73822)])
#@167 Return a template class name for TYPE based on SPEC-LIST.
For a type `ref' with a template specifier of (Foo Bar) it will
return `ref<Foo,Bar>'.

(fn TYPE SPEC-LIST)
(defalias 'semantic-c--template-name #[514 "
\211@\262
\300\301A!\302R\207" ["<" semantic-c--template-name-1 ">"] 6 (#$ . 74119)])
#@217 Dereference any template specifiers in TYPE within SCOPE.
If TYPE is a template, return a TYPE copy with the templates types
instantiated as specified in TYPE-DECLARATION.

(fn TYPE SCOPE &optional TYPE-DECLARATION)
(defalias 'semantic-c-dereference-template #[770 "\211\3001.\211:\205(\211@;\205(\211A@9\205(\211A@\205(\301
8<\205(\302
8<0\262
\2022\210\303\262
\203\224\304\305\301
8\262
\"\266\202
\306\305\301
8\262
\"\266\202
\203\222\211\203\222\307\310\311#\"\262\312\"

\240\266\304\303\211AA\262
\211:\203\207\211\313\314@#!\240\210\266\315
\316\317#\266\266
D\207" [(error) 2 3 nil :template plist-get :template-specifier semantic-tag-deep-copy-one-tag make-closure #[257 "\211\302
\211A@\262

=\266\202\203\303
\300\301#\210\207" [V0 V1 type semantic-c--instantiate-template] 5 "\n\n(fn TAG)"] semantic-c--template-name semantic-tag-make-plist plist-put semantic--tag-put-property :faux-flag t] 15 (#$ . 74424)])
#@255 Dereference through the `->' operator of TYPE.
Uses the return type of the `->' operator if it is contained in TYPE.
SCOPE is the current local scope to perform searches in.
TYPE-DECLARATION is passed through.

(fn TYPE SCOPE &optional TYPE-DECLARATION)
(defalias 'semantic-c-dereference-member-of #[770 "\203R	\303\304!!\305
\203(
@\211@\262
\306\230\203!
@
B\262

A\262\202\f\211\237\266\202)@\211\203N\211\307\310\311
8\262
\"\266\202
\307\310\311
8\262
\"\266\202D\207D\207
D\207" [semantic-c-member-of-autocast semantic-case-fold case-fold-search semantic-something-to-tag-table semantic-analyze-scoped-type-parts nil "->" :type plist-get 2] 11 (#$ . 75395)])
#@256 Dereference namespace which might hold an `alias' for TYPE.
Such an alias can be created through `using' statements in a
namespace declaration.  This function checks the namespaces in
SCOPE for such statements.

(fn TYPE SCOPE &optional TYPE-DECLARATION)
(defalias 'semantic-c-dereference-namespace #[770 "\302\303\"\304\211\211\211\30516\211:\2050\211@;\2050\211A@9\2050\211A@\2050\306
8<\2050\307
8<0\262
\202:\210\304\262
\203\373\203I\310!\203\373\311\211@\262
!\262\312\313!!\304
\203}\242\206f@\211@\262
\230\203v
@
B\262

A\262\202\\\211\237\266\202)\204\373;\203\260\312!\304
\203\247\314@\315\"\203\240
@
B\262

A\262\202\216\211\237\266\202\262
\202\323\316@!\262
\211\211\317\320\306
8\262
\"\266\203\315\230\203\320\211C\262
\202\323\304\262
\304\262\211\203\373
\204\373\211@\262\321\"\262
\204\364\322\"\262\211A\262
\202\326
\203

\211D\207D\207" [semantic-case-fold case-fold-search eieio-oref scopetypes nil (error) 2 3 semantic-tag-prototype-p semantic-analyze-split-name semantic-something-to-tag-table semantic-flatten-tags-table semantic-tag-of-type-p "namespace" semanticdb-typecache-find :type plist-get semantic-c-dereference-namespace-alias semantic-c-check-type-namespace-using] 15 (#$ . 76083)])
#@247 Dereference TYPE in NAMESPACE, given that NAMESPACE is an alias.
Checks if NAMESPACE is an alias and if so, returns a new type
with a fully qualified name in the original namespace.  Returns
nil if NAMESPACE is not an alias.

(fn TYPE NAMESPACE)
(defalias 'semantic-c-dereference-namespace-alias #[514 "\211\302\303\304
8\262
\"\266\202\305=\205\315\306\211@\262
!\307\211\211<\203'\310!\202)C\262\311\303\304
8\262
\"\266\202@\211@\262
\211\262\205\313\312!\211\262\205\313\313\311\303\304
8\262
\"\266\202!\307
\203{@@\211@\262
\230\203t
@
B\262

A\262\202^\211\237\266\202)\211\262\205\313\306!\262\211@\314<\203\233\315\"\202\241\315C\"!\211\206\253
\211@\262
\211A@\262
\316\304
8\262
!\316\317
8\262
!\320
8\262
\257\266\202\266\204\207" [semantic-case-fold case-fold-search :kind plist-get 2 alias semantic-analyze-split-name nil last :members semanticdb-typecache-find semantic-something-to-tag-table semantic-analyze-unsplit-name append copy-sequence 3 4] 15 (#$ . 77378)])
#@186 Check if TYPE is accessible in NAMESPACE through a using statement.
Returns the original type from the namespace where it is defined,
or nil if it cannot be found.

(fn TYPE NAMESPACE)
(defalias 'semantic-c-check-type-namespace-using #[514 "\302\211\211\211\211\211\303\304\305
8\262
\"\266\202\211\262\2032
\306!\302
\203<
@\211A@\262
\307=\2035
@
B\262

A\262\202\211\237\266\202\211\262\2032
\310\211@\262
!\211\262<\203[\311!@\262\2032
\2042
\310@\211@\262
!\262@\211\312\304\305
8\262
\"\266\203\211\312\304\305
8\262
\"\266\203\262\313\230\204\227;\203
\314!\262\203\347\303\304\305
8\262
\"\266\202\211\262\203\347\306
!\302
\203\325@\211@\262
\230\203\316
@
B\262

A\262\202\271\211\237\266\202)\211\262\203\347\211@\262\202+
\315\"\262\203+
\211\312\304\305
8\262
\"\266\203\262\202+
\316\230\203+
<\203+

\311!@\230\203+
@\211\312\304\305
8\262
\"\266\203\262A\262\202[\207" [semantic-case-fold case-fold-search nil :members plist-get 2 semantic-something-to-tag-table using semantic-analyze-split-name last :type "namespace" semanticdb-typecache-find semantic-c-check-type-namespace-using "class"] 15 (#$ . 78416)])
#@248 Dereference TYPE as described in `semantic-analyze-dereference-metatype'.
Handle typedef, template instantiation, and `->' operator.
Override `semantic-analyze-dereference-metatype' in `c-mode' buffers.

(fn TYPE SCOPE &optional TYPE-DECLARATION)
(defalias 'semantic-analyze-dereference-metatype-c-mode #[770 "\300\211
A\262\242\301\2038#\262
@\262
A@\262
=\204-\301\262\202	\211A\262\242\262\202	\266
D\207" [(semantic-c-dereference-typedef semantic-c-dereference-template semantic-c-dereference-member-of semantic-c-dereference-namespace) nil] 11 (#$ . 79625)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-analyze-dereference-metatype-c-mode definition-name semantic-analyze-dereference-metatype mode-local-bind ((semantic-analyze-dereference-metatype . semantic-analyze-dereference-metatype-c-mode)) (override-flag t) c-mode] 4)
#@170 When TYPE is a tag for an enum, return its parts.
These are constants which are of type TYPE.
Override `semantic-analyze-type-constants' in `c-mode' buffers.

(fn TYPE)
(defalias 'semantic-analyze-type-constants-c-mode #[257 "\211\211A@\262
\300=\205,\211\211\301\302\303
8\262
\"\266\203\304\230\205,\211\211\305\302\303
8\262
\"\266\203\207" [type :type plist-get 2 "enum" :members] 8 (#$ . 80515)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-analyze-type-constants-c-mode definition-name semantic-analyze-type-constants mode-local-bind ((semantic-analyze-type-constants . semantic-analyze-type-constants-c-mode)) (override-flag t) c-mode] 4)
#@137 Assemble the list of names NAMELIST into a namespace name.
Override `semantic-analyze-unsplit-name' in `c-mode' buffers.

(fn NAMELIST)
(defalias 'semantic-analyze-unsplit-name-c-mode #[257 "\300\301\302#\207" [mapconcat identity "::"] 5 (#$ . 81200)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-analyze-unsplit-name-c-mode definition-name semantic-analyze-unsplit-name mode-local-bind ((semantic-analyze-unsplit-name . semantic-analyze-unsplit-name-c-mode)) (override-flag t) c-mode] 4)
#@187 Return a list of tags of CLASS type based on POINT.
DO NOT return the list of tags encompassing point.
Override `semantic-ctxt-scoped-types' in `c++-mode' buffers.

(fn &optional POINT)
(defalias 'semantic-ctxt-scoped-types-c++-mode #[256 "\211\203`b\210\302 \303\211\304p!\303
\203,
@\211A@\262
\305=\203%
@
B\262

A\262\202\211\237\266\202\262
\304
!\303
\203O\306@\307\"\203H
@
B\262

A\262\2026\211\237\266\202\262
\304
!\303
\203w
@\211@\262
\310\230\203p
@
B\262

A\262\202[\211\237\266\202)\262
\211\262\311\312!\262
\313\314!

W\203\257\315\316\"@\211\317\320\321
8\262
\"\266\203C\"\262
T\262\202\212\266\211\203f
\211@\211\211A@\262
\305=\203
\304\322@!!\303
\203\350
@\211A@\262
\312=\203\341
@
B\262

A\262\202\313\211\237\266\202\211\262\203
\211\203
\211@\211\211\317\320\321
8\262
\"\266\203B\262
A\266\202\202\363\210\202_
\323!@\324
\211A@\262

=\266\202\203_
\304\325 !\303
\203K

@\211A@\262
\312=\203D

@
B\262

A\262\202.
\211\237\266\202\211\262\203_
\315\326\327\"\"\262
A\266\202\202\262\210
\207" [semantic-case-fold case-fold-search semantic-find-tag-by-overlay nil semantic-something-to-tag-table type semantic-tag-of-type-p "namespace" "unnamed" semanticdb-find-tags-by-class using 0 semanticdb-find-result-length append semanticdb-find-result-nth :type plist-get 2 semantic-tag-components last function semantic-get-local-variables mapcar semantic-tag-type] 15 (#$ . 81723)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-ctxt-scoped-types-c++-mode definition-name semantic-ctxt-scoped-types mode-local-bind ((semantic-ctxt-scoped-types . semantic-ctxt-scoped-types-c++-mode)) (override-flag t) c++-mode] 4)
#@143 Return the list of using tag types in scope of POINT.
Override `semantic-ctxt-imported-packages' in `c++-mode' buffers.

(fn &optional POINT)
(defalias 'semantic-ctxt-imported-packages-c++-mode #[256 "\211\203`b\210\300 \301\211\302p!\301
\203,
@\211A@\262
\303=\203%
@
B\262

A\262\202\211\237\266\202\262
\211\211\203R\211@\211\211\304\305\306
8\262
\"\266\203B\262
A\266\202\2023\210A\203\252\302\307@!!\301
\203|
@\211A@\262
\303=\203u
@
B\262

A\262\202_\211\237\266\202\262
\211\211\203\242\211@\211\211\304\305\306
8\262
\"\266\203B\262
A\266\202\202\203\210A\262\202S
\207" [semantic-find-tag-by-overlay nil semantic-something-to-tag-table using :type plist-get 2 semantic-tag-components] 13 (#$ . 83447)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-ctxt-imported-packages-c++-mode definition-name semantic-ctxt-imported-packages mode-local-bind ((semantic-ctxt-imported-packages . semantic-ctxt-imported-packages-c++-mode)) (override-flag t) c++-mode] 4)
#@185 Expand TAG if it has a fully qualified name.
For types with a :parent, create faux namespaces to put TAG into.
Override `semanticdb-expand-nested-tag' in `c++-mode' buffers.

(fn TAG)
(defalias 'semanticdb-expand-nested-tag-c++-mode #[257 "\211\300\301\302
8\262
\"\266\202\211\203o
\303
\211A@\262

=\266\202\203o\304
!\305\306\307#\211\300\306\211AA\262
\211:\203C\211\310\311@#!\240\210\266
;\203P
C\202R
\237\262\312\313!\210
\211\203m\211@\314
C\"\262
A\266\202\202Y\210\207
\207" [:parent plist-get 2 type semantic-analyze-split-name semantic-tag-copy nil t semantic-tag-make-plist plist-put require semantic/db-typecache semanticdb-typecache-faux-namespace] 14 (#$ . 84474)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semanticdb-expand-nested-tag-c++-mode definition-name semanticdb-expand-nested-tag mode-local-bind ((semanticdb-expand-nested-tag . semanticdb-expand-nested-tag-c++-mode)) (override-flag t) c++-mode] 4)
#@525 For a single INCLUDETAG found in TABLE, find a `semanticdb-table' object.
INCLUDETAG is a semantic TAG of class `include'.
TABLE is a semanticdb table that identifies where INCLUDETAG came from.
TABLE is optional if INCLUDETAG has an overlay of :filename attribute.

For C++, we also have to check if the include is inside a
namespace, since this means all tags inside this include will
have to be wrapped in that namespace.
Override `semanticdb-find-table-for-include' in `c-mode' buffers.

(fn INCLUDETAG &optional TABLE)
(defalias 'semanticdb-find-table-for-include-c-mode #[513 "\302\"\303\304\305
8\262
\"\266\202\306\211\211\211\211\203'\203'\307\310\"\204*\207\311=\203\372\302	\312\304\313
8\262
\"\266\202\306\211\314\315\316\317&\266\203!\211\262\203\372\203\372\320!\306
\203w\321@\322\"\203p
@
B\262

A\262\202^\211\237\266\202\262\203\372\307\310\"\203\372\211\203\371\211@\320
\323\304\305
8\262
\"\266\202!\306
\203\303\f\211@\262
@\211@\262
\230\203\274
@
B\262

A\262\202\242\211\237\266\202)\203\362\211\211@\262
\262\n\303	\211AA\262
\211:\203\357\211\324\325@#!\240\210\266
A\266\202\202\212\210\320\211!\306
\203
\321@\322\"\203

@
B\262

A\262\202
\211\237\266\202!\306
\203>
@\211@\262
\230\2037

@
B\262

A\262\202!
\211\237\266\202)\204\216
\326\310\"\262\322\306\211\314\315\327\330\323	\331\n@\332\fA\f&\f\266\205C\262\333 \262
\334
\310#\210\334
\335\326\n\335\"#\210\334
\336\326\n\336\"#\210\207" [semantic-case-fold case-fold-search semanticdb-find-table-for-include-default :inside-ns plist-get 2 nil slot-boundp tags t :filename 3 apply semantic-tag include :system-flag semantic-something-to-tag-table semantic-tag-of-type-p "namespace" :members semantic-tag-make-plist plist-put eieio-oref type :type :superclasses :interfaces semanticdb-table eieio-oset parent-db file] 27 (#$ . 85449)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semanticdb-find-table-for-include-c-mode definition-name semanticdb-find-table-for-include mode-local-bind ((semanticdb-find-table-for-include . semanticdb-find-table-for-include-c-mode)) (override-flag t) c-mode] 4)
#@136 Do what `semantic-get-local-variables' does, plus add `this' if needed.
Override `semantic-get-local-variables' in `c++-mode' buffers.
(defalias 'semantic-get-local-variables-c++-mode #[0 "\300 \301 \211\302
\211A@\262

=\266\202\205H\211\211\211\303\304\305
8\262
\"\266\204\206H\306\307 !\310
\203C\311@\312\"\203<
@
B\262

A\262\202*\211\237\266\202\242\211\203e\313
\310\314\315D\316\317\320\321\322&\266\204B\207\207" [semantic-get-local-variables-default semantic-current-tag function :parent plist-get 2 semantic-something-to-tag-table semantic-find-tag-by-overlay nil semantic-tag-of-type-p "class" "this" :pointer 1 apply semantic-tag variable :type :default-value] 16 (#$ . 87659)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-get-local-variables-c++-mode definition-name semantic-get-local-variables mode-local-bind ((semantic-get-local-variables . semantic-get-local-variables-c++-mode)) (override-flag t) c++-mode] 4)
#@132 Handle the SPP keywords, then use the default mechanism.
Override `semantic-idle-summary-current-symbol-info' in `c-mode'
buffers.
(defalias 'semantic-idle-summary-current-symbol-info-c-mode #[0 "\304 @\211\211;\2054\211\235?\2054\305	!\203\306
	\"\2064\305\n!\203*\306
\n\"\2064\305!\2054\306
\"\262
\211\203\274\307P
J\310
!\211\203R\311\312\"P\262
A\262\3131\264
\211\205\255\211@\314\211A@;\203o\211A@\262
\202\243\315
\211\211A@\247\204\201\211AA\262
\202\205\211A\262
@\262
\211\211A@\247\204\231\211AA\262
\202\235\211A\262
A\262
\"\262
Q\262
A\266\202\202W\262
0\210\202\272\210\316P\262\207\317 \207" [semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray semantic-ctxt-current-thing obarrayp intern-soft "Macro: " semantic-lex-spp-macro-with-args format "%S" (error) " " buffer-substring-no-properties "  #error in summary fcn" semantic-idle-summary-current-symbol-info-default] 15 (#$ . 88643)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-idle-summary-current-symbol-info-c-mode definition-name semantic-idle-summary-current-symbol-info mode-local-bind ((semantic-idle-summary-current-symbol-info . semantic-idle-summary-current-symbol-info-c-mode)) (override-flag t) c-mode] 4)
#@278 Compare the names of TAG1 and TAG2.
If BLANKOK is false, then the names must exactly match.
If BLANKOK is true, then always return t, as for C, the names don't matter
for arguments compared.
Override `semantic--tag-similar-names-p' in `c-mode' buffers.

(fn TAG1 TAG2 BLANKOK)
(defalias 'semantic--tag-similar-names-p-c-mode #[771 "\211\203\300\207\301\302#\207" [t semantic--tag-similar-names-p-default nil] 7 (#$ . 90016)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic--tag-similar-names-p-c-mode definition-name semantic--tag-similar-names-p mode-local-bind ((semantic--tag-similar-names-p . semantic--tag-similar-names-p-c-mode)) (override-flag t) c-mode] 4)
#@351 For `c-mode', deal with TAG1 and TAG2 being used in different namespaces.
In this case, one type will be shorter than the other.  Instead
of fully resolving all namespaces currently in scope for both
types, we simply compare as many elements as the shorter type
provides.
Override `semantic--tag-similar-types-p' in `c-mode' buffers.

(fn TAG1 TAG2)
(defalias 'semantic--tag-similar-types-p-c-mode #[514 "\300\"\203	\301\207\302\303D\"\211@G
A@G

X\203%
A@\233@\232\207\211W\2053\211@\233A@\232\207" [semantic--tag-similar-types-p-default t mapcar #[257 "\211\211\300\301\302
8\262
\"\266\203\211;\204\211\211@\262
\262
\303
!\262
\211;\203(\211C\262
\207" [:type plist-get 2 semantic-analyze-split-name] 8 "\n\n(fn TAG)"]] 7 (#$ . 90715)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic--tag-similar-types-p-c-mode definition-name semantic--tag-similar-types-p mode-local-bind ((semantic--tag-similar-types-p . semantic--tag-similar-types-p-c-mode)) (override-flag t) c-mode] 4)
#@185 For `c-mode', allow function :arguments to ignore the :name attributes.
Override `semantic--tag-attribute-similar-p' in `c-mode' buffers.

(fn ATTR VALUE1 VALUE2 IGNORABLE-ATTRIBUTES)
(defalias 'semantic--tag-attribute-similar-p-c-mode #[1028 "\300=\203\301\302B$\207\301$\207" [:arguments semantic--tag-attribute-similar-p-default :name] 10 (#$ . 91742)])
(byte-code "\303\304\305\306#\210\307\310\311\312#\210\313\307\314\313BC\315\312#\210\316\317\320\"\312\"\266\303\314\312\321!\322\204>\211\262\204>	\262\n\205<\323\n\"\262
\203i\211\204i\302N\203X\323\302N\"\211\262\204>\211\324N\206b\211\325N\262
\262\202>\266\203\326\327#\210\330\307\331BC\315\312#\210\316\317\332\"\312\"\266\303\331\312\321!\322\204\241\211\262\204\241	\262\n\205\237\323\n\"\262
\203\314\211\204\314\302N\203\273\323\302N\"\211\262\204\241\211\324N\206\305\211\325N\262
\262\202\241\266\203\326\333#\210\334\307\335BC\315\312#\210\316\317\336\"\312\"\266\303\335\312\321!\322\204
\211\262\204
	\262\n\205
\323\n\"\262
\203/
\211\204/
\302N\203
\323\302N\"\211\262\204
\211\324N\206(
\211\325N\262
\262\202
\266\203\326\337#\210\340\307\341\340BC\315\312#\210\316\317\342\"\312\"\266\303\341\312\321!\322\204g
\211\262\204g
	\262\n\205e
\323\n\"\262
\203\222
\211\204\222
\302N\203\201
\323\302N\"\211\262\204g
\211\324N\206\213
\211\325N\262
\262\202g
\266\203\326\343#\210\344\307\345BC\315\312#\210\316\317\346\"\312\"\266\303\345\312\321!\322\204\312
\211\262\204\312
	\262\n\205\310
\323\n\"\262
\203\365
\211\204\365
\302N\203\344
\323\302N\"\211\262\204\312
\211\324N\206\356
\211\325N\262
\262\202\312
\266\203\326\347#\210\350\307\351\350BC\315\312#\210\316\317\352\"\312\"\266\303\351\312\321!\322\204-\211\262\204-	\262\n\205+\323\n\"\262
\203X\211\204X\302N\203G\323\302N\"\211\262\204-\211\324N\206Q\211\325N\262
\262\202-\266\203\326\353#\210\354\307\355BC\315\312#\210\316\317\356\"\312\"\266\303\355\312\321!\322\204\220\211\262\204\220	\262\n\205\216\323\n\"\262
\203\273\211\204\273\302N\203\252\323\302N\"\211\262\204\220\211\324N\206\264\211\325N\262
\262\202\220\266\203\326\357#\210\360\307\361BC\315\312#\210\316\317\362\"\312\"\266\303\361\312\321!\322\204\363\211\262\204\363	\262\n\205\361\323\n\"\262
\203\211\204\302N\203
\323\302N\"\211\262\204\363\211\324N\206\211\325N\262
\262\202\363\266\203\326\363#\207" [mode-local-active-mode major-mode mode-local-symbol-table put semantic--tag-attribute-similar-p-c-mode definition-name semantic--tag-attribute-similar-p mode-local-bind ((semantic--tag-attribute-similar-p . semantic--tag-attribute-similar-p-c-mode)) (override-flag t) c-mode "struct" semantic-orphaned-member-metaparent-type (mode-variable-flag t) mode-local-map-mode-buffers make-closure #[0 "\302\301!\210\300\211\207" [V0 semantic-orphaned-member-metaparent-type make-local-variable] 2] symbol-name nil intern-soft mode-local-parent derived-mode-parent variable-documentation "When lost members are found in the class hierarchy generator, use a struct." ((type . "Types") (variable . "Variables") (function . "Functions") (include . "Includes")) semantic-symbol->name-assoc-list #[0 "\302\301!\210\300\211\207" [V0 semantic-symbol->name-assoc-list make-local-variable] 2] "List of tag classes, and strings to describe them." ((type . "Types") (variable . "Attributes") (function . "Methods") (label . "Labels")) semantic-symbol->name-assoc-list-for-type-parts #[0 "\302\301!\210\300\211\207" [V0 semantic-symbol->name-assoc-list-for-type-parts make-local-variable] 2] "List of tag classes in a datatype decl, and strings to describe them." semantic-create-imenu-index imenu-create-index-function #[0 "\302\301!\210\300\211\207" [V0 imenu-create-index-function make-local-variable] 2] "Imenu index function for C." ("." "->" "::") semantic-type-relation-separator-character #[0 "\302\301!\210\300\211\207" [V0 semantic-type-relation-separator-character make-local-variable] 2] "Separator characters between something of a given type, and a field." ";" semantic-command-separation-character #[0 "\302\301!\210\300\211\207" [V0 semantic-command-separation-character make-local-variable] 2] "Command separation character for C." #'variable senator-step-at-tag-classes #[0 "\302\301!\210\300\211\207" [V0 senator-step-at-tag-classes make-local-variable] 2] "Tag classes where senator will stop at the end." (:prototype-flag :parent :typemodifiers) semantic-tag-similar-ignorable-attributes #[0 "\302\301!\210\300\211\207" [V0 semantic-tag-similar-ignorable-attributes make-local-variable] 2] "Tag attributes to ignore during similarity tests.\n:parent is here because some tags might specify a parent, while others are\nactually in their parent which is not accessible."] 9)
#@57 Set up a buffer for semantic parsing of the C language.
(defalias 'semantic-default-c-setup #[0 "\303 \210\304\305\306\307\310\311\312$\210\313\314!\205!\315\n\235\203\n\207\315\nB\211\207" [semantic-lex-syntax-modifications semantic-lex-analyzer semantic-lex-c-preprocessor-symbol-map semantic-c-by--install-parser ((62 ".") (60 ".")) semantic-c-lexer add-hook semantic-lex-reset-functions semantic-lex-spp-reset-hook nil t derived-mode-p c++-mode ("__cplusplus" . "")] 5 (#$ . 96639)])
#@79 Add a preprocessor symbol SYM with a REPLACEMENT value.

(fn SYM REPLACEMENT)
(defalias 'semantic-c-add-preprocessor-symbol #[514 "\301\"\211\203\211\241\266\202BB\210\302 \207" [semantic-lex-c-preprocessor-symbol-map assoc semantic-c-reset-preprocessor-symbol-map] 5 (#$ . 97139) "sSymbol: \nsReplacement: "])
#@62 Describe the Semantic features of the current C environment.
(defalias 'semantic-c-describe-environment #[0 "\306\307!\204\310\311\"\210\312\301!\205	\313 \210\nr\314\315!q\210p\316 \210
\317\211\320\211\3209:\321 \210\322\323!\210+\211;\203b\324\325!\210\211\203a\211@\324\326!\210\324
@!\210\324\327!\210\324
A!\210
A\266\202\202B\210\324\330!\210\312\331!\203\314\203\314\324\332\333!!\210<\203\202\202\205C\211\211\203\312\211@\324\334!\210\324\335!\210\336
!\211\204\243\324\337!\266\202\303\324\340!\210\211\211\203\301\211@\324\341!\210\324
!\210\324\342!\210
A\266\202\202\250\266
A\266\202\202\206\266<\203\363\324\332\343!!\210<\211\203\362\211@\324\341!\210\324
!\210\324\342!\210
A\266\202\202\331\210=\203
\324\332\344!!\210=\211\203
\211@\324\341!\210\324
!\210\324\342!\210
A\266\202\202
\210\324\345!\210>\203a
\324\346!\210>\211\203`
\211@\324\341!\210\324
!\210\324\342!\210\324\347!\210\350
!\211\203P
\324\351!!\266\202U
\324\352!\266\324\342!\210
A\266\202\202)
\210?\203\220
\324\353!\210?\211\203\217
\211@\324\341!\210\324
@!\210\324\327!\210\324
A!\210\324\342!\210
A\266\202\202l
\210@\203\277
\324\354!\210@\211\203\276
\211@\324\341!\210\324
@!\210\324\327!\210\324
A!\210\324\342!\210
A\266\202\202\233
\210\312\331!\203)\203)\324\355!\210\312\331!\203\344
\203\344
\324\356!\210\324\351!!\210\324\357!\210\360A!\203%\317C\361\362\363\"A\"\210\211\242\211\203 \211@\324\341!\210\324\364!!\210\324\327!\210\324
J!\210\324\342!\210
A\266\202\202\374
\266\202)\324\365!\210\324\366!\210\324\367!\370!\210)\207" [major-mode semantic-gcc-setup-data default-directory buffer-read-only buffer-file-name buffer-undo-list derived-mode-p c-mode error "Not useful to query C mode in %s mode" boundp semantic-fetch-tags get-buffer-create "*Semantic C Environment*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ "Calculated GCC Parameters:" "\n  " " = " "\n\nInclude Path Summary:\n" ede-object substitute-command-keys "\n  This file's project include is handled by:\n" "    EDE : " 0 ede-system-include-path "\n     with NO specified system include path.\n" "\n     with the system path:\n" "    " "\n" "\n  This file's generic include path is:\n" "\n  This file's system include path is:\n" "\n\nMacro Summary:\n" "\n  Your CPP table is primed from these system files:\n" "    in table: " semanticdb-file-table-object cl-prin1-to-string "No Table" "\n  Built-in symbol map:\n" "\n  User symbol map (primed from system files):\n" "\n  Project symbol map:\n" "      Your project symbol map is also derived from the EDE object:\n      " "\n\n" obarrayp mapatoms make-closure #[257 "\300
\300\242B\240\207" [V0] 4 "\n\n(fn SYMBOL)"] symbol-name "    No Symbols.\n" "\n\n  Use: M-x semantic-lex-spp-describe RET\n" "\n  to see the complete macro table.\n" internal-temp-output-buffer-show inhibit-modification-hooks inhibit-read-only standard-output semantic-dependency-include-path semantic-dependency-system-include-path semantic-lex-c-preprocessor-symbol-file semantic-lex-c-preprocessor-symbol-map-builtin semantic-lex-c-preprocessor-symbol-map semantic-lex-spp-project-macro-symbol-obarray] 12 (#$ . 97468) nil])
(byte-code "\300\301!\210\302 \207" [provide semantic/bovine/c semantic-c-reset-preprocessor-symbol-map] 2)