%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/cedet/semantic/bovine/
Current File : //usr/local/share/emacs/27.2/lisp/cedet/semantic/bovine/c.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(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!\2036\323\324\322\"\210\202;\323\324\325\"\210\326\327\330\331#\210\332\333\"\266\334\300\335\336\337\340\337\307\341\342\343\344&\210\345\346	BC\347\327#\210\332\350\327\"\210)\330\346\327\351!\352\204\210\n\211\262\204\210\262\f\205\206\353\f\"\262\203\263\211\204\263\304N\203\242\353\304N\"\211\262\204\210\211\331N\206\254\211\354N\262\262\202\210\266\203\355\356#\210\330\346\327\300#\210\334\305\352\357\337\340\337\307\341\360&	\210
5\345\3615BC\347\327#\210\332\362\327\"\210)\330\361\327\351!\352\204\376\n\211\262\204\376\262\f\205\374\353\f\"\262\203)\211\204)\304N\203\353\304N\"\211\262\204\376\211\331N\206\"\211\354N\262\262\202\376\266\203\355\356#\2106\363>\2039\364 \210\352\207" [semantic-c-dependency-system-include-path #3=#:tmp0 mode-local-active-mode major-mode mode-local-symbol-table semantic-default-c-path 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 fboundp c-end-of-macro defalias semantic-c-end-of-macro #[nil "\300\210`Sf\301=\205m?\205\300u\210\202\207" [nil 92] 2 "Go to the end of a preprocessor directive.\nMore accurately, move point to the end of the closest following line\nthat doesn't end with a line continuation backslash.\n\nThis function does not do any hidden buffer changes."] c++-mode c-mode put mode-local-parent mode-local-map-mode-buffers mode-local--activate-bindings custom-declare-variable '("/usr/include") "The system include path used by the C language." :group c :type (repeat (directory :tag "Directory")) :set #[(sym val) "\303	\"\210	\304\305\nBC\306\307#\210\310\311\307\"\210)\312\313!\205 \310\313\307\"\207" [sym val #1=#:tmp0 set-default mode-local-bind semantic-dependency-system-include-path #2=(mode-variable-flag t) c-mode mode-local-map-mode-buffers #[nil "\302\301!\210\211\207" [#1# semantic-dependency-system-include-path make-local-variable] 2] fboundp semantic-decoration-unparsed-include-do-reset] 4] mode-local-bind semantic-dependency-system-include-path #2# #[nil "\302\301!\210\211\207" [#3# semantic-dependency-system-include-path make-local-variable] 2] symbol-name nil intern-soft derived-mode-parent variable-documentation "System path to search for include files." "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 #[nil "\302\301!\210\211\207" [#4=#:tmp0 semantic-dependency-include-path make-local-variable] 2] (gnu gnu/linux darwin cygwin) semantic-gcc-setup #4# system-type] 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))) (#$ . 3274))
#@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 (#$ . 3680))
#@67 Reset the C preprocessor symbol map based on all input variables.
(defalias 'semantic-c-reset-preprocessor-symbol-map #[nil "\205\242\306\307!\205\242\310\311\312\"\210\313\314	\n\"!\315\316BC\317\320#\210\321\322\320\"\210)\323
\204\207\306\324!\203\207\325 \203\207\323\326!\"\323#\211$\203\206$@#\327#\326\"\211%\203|\330%!\203s\3311j\332%\326\"0\202r\210\333\334\335%!\"\210\314\f\336%\337\"\")$A\211$\204F,\313\314	\n\f#!&\315\316&BC\317\320#\210\321\340\320\"\210&*\207" [semantic-mode semantic-lex-c-preprocessor-symbol-map-builtin semantic-lex-c-preprocessor-symbol-map #1=#:tmp0 filemap semantic-c-in-reset-preprocessor-table 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 #[nil "\302\301!\210\211\207" [#1# 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 #[nil "\302\301!\210\211\207" [#2=#:tmp0 semantic-lex-spp-macro-symbol-obarray make-local-variable] 2] semanticdb-out-of-buffer-create-table-fcn semantic-lex-c-preprocessor-symbol-file sf --dolist-tail-- table #2#] 6 (#$ . 3894)])
(byte-code "\300\301\302\"\210\303\304\305\306\307\310\311\312\313\314&	\210\303\315\305\316\307\310\311\317\313\320&	\210\303\321\322\323\307\310\311\324&\207" [add-hook mode-local-init-hook semantic-c-reset-preprocessor-symbol-map custom-declare-variable semantic-lex-c-preprocessor-symbol-map nil "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 #[(sym value) "\302	\"\210\3031
\304 0\207\210\305\207" [sym value set-default (error) semantic-c-reset-preprocessor-symbol-map nil] 3] semantic-lex-c-preprocessor-symbol-file "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")) #[(sym value) "\302	\"\210\3031
\304 0\207\210\305\207" [sym value set-default (error) semantic-c-reset-preprocessor-symbol-map nil] 3] semantic-c-member-of-autocast 't "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.
(defvar semantic-lex-cpp-define nil (#$ . 7899))
(defalias 'semantic-lex-cpp-define #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-cpp-define ((looking-at #6="^\\s-*#\\s-*define\\s-+\\(\\(\\sw\\|\\s_\\)+\\)") (let ((#1=#:start (match-beginning 1)) (#2=#:end (match-end 1)) (#4=#:startpnt semantic-lex-end-point) (#3=#:val (save-match-data (goto-char (match-end 0)) (skip-chars-forward #7=" 	") (if (eolp) nil (let* ((name (buffer-substring-no-properties (match-beginning 1) (match-end 1))) (beginning-of-define (match-end 1)) (with-args (save-excursion (goto-char (match-end 0)) (looking-at #8="("))) (semantic-lex-spp-replacements-enabled nil) (semantic-lex-analyzer #'semantic-cpp-lexer) (raw-stream (semantic-lex-spp-stream-for-macro (save-excursion (semantic-c-end-of-macro) (if (looking-back #9="/\\*.*" 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#) #3#) (semantic-lex-push-token (semantic-lex-token 'spp-macro-def #1# #2#)) (when (and (/= #4# #5#) (/= #5# semantic-lex-end-point)) (setq semantic-lex-end-point #5#)))) #[nil "\306``dB\307\310\311!\203\302\312\224\312\225\f\313 \314\216\307\225b\210\315\306w\210l?\205t\316\312\224\312\225\"\312\225\212\307\225b\210\310\317!)\306\320\321\212\322 \210\323\324\"\203\\\307\224b\210`\202]`)!\203l\325@!\210`\326!.*\f !\"#$\327\316$#\"!\"\210\330$#BB
B\211@\211\211A@\247\204\247\211AA\262\202\253\211A\262A\262\" U\204\301 \fU\204\301 -
-\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 #6# 1 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] #7# buffer-substring-no-properties #8# semantic-cpp-lexer semantic-lex-spp-stream-for-macro semantic-c-end-of-macro looking-back #9# semantic-lex-spp-first-token-arg-list semantic-lex-spp-merge-streams semantic-lex-spp-symbol-set spp-macro-def save-match-data-internal name beginning-of-define with-args semantic-lex-spp-replacements-enabled semantic-lex-analyzer raw-stream #5# #3# #4# #2# #1#] 8 "A #define of a symbol with some value.\nRecord the symbol in the semantic preprocessor.\nReturn the defined symbol as a special spp lex token."]] 2)
#@127 A #undef of a symbol.
Remove the symbol from the semantic preprocessor.
Return the defined symbol as a special spp lex token.
(defvar semantic-lex-cpp-undef nil (#$ . 10644))
(defalias 'semantic-lex-cpp-undef #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\210\303\304\305\306\307\310\311\312&\207" [semantic-lex-cpp-undef ((looking-at #3="^\\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#)))) #[nil "\306``dB\307\310\311!\203a\312\224\312\225\313\"\306\314\2069\2069\315\316\307\"\211\"*\210\317BB
B\211@\211\211A@\247\204X\211AA\262\202\\\211A\262A\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 #3# 1 buffer-substring-no-properties unintern make-vector 13 spp-macro-undef #2# #1# obarray name semantic-lex-spp-dynamic-macro-symbol-obarray] 6 "A #undef of a symbol.\nRemove the symbol from the semantic preprocessor.\nReturn the defined symbol as a special spp lex token."] custom-declare-variable semantic-c-obey-conditional-section-parsing-flag t "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 #[nil "\302\303!\210\304\211\210	\205]?\205]\305\306\304\307#\205]\310\224b\210\311\312!\2039\313\314!\2032\314\315!b\210\202	\316\315!\210\202	\311\317!\203G\320 \210\307\202	\311\321!\203X\304\210\315u\210\307\202	\307\202	)\207" [done 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 (#$ . 12190)])
#@124 Convert an spp macro SYMBOL MACROVALUE, to something that hideif can use.
Take the first interesting thing and convert it.
(defalias 'semantic-c-convert-spp-value-to-hideif-value #[(symbol macrovalue) "G\305V\203\306\307\310	\"\311\211#\210@\211\211@\262\n\211A@;\203)\211A@\262\202]\312\211\211A@\247\204;\211AA\262\202?\211A\262@\262\211\211A@\247\204S\211AA\262\202W\211A\262A\262\"\262\313\267\202\201\314\f!\202\214\315\f!\202\214\316\317\f\"\203}\314\f!\202\214\f\202\214\306\307\320\f#\311\211#\210\321+\207" [macrovalue symbol lextoken key value 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 100 symbol 106 string 112)) string-to-number semantic-c-evaluate-symbol-for-hideif string-match "^[0-9]+L?$" "Unknown macro value. Token class = %s value = %s. " nil] 7 (#$ . 12958)])
#@154 Lookup the symbol SPP-SYMBOL (a string) to something hideif can use.
Pulls out the symbol list, and call `semantic-c-convert-spp-value-to-hideif-value'.
(defalias 'semantic-c-evaluate-symbol-for-hideif #[(spp-symbol) "9\203	\306!\211\211;\205=	\n\235?\205=\307!\203&\310	\"\206=\307\f!\2033\310	\f\"\206=\307
!\205=\310	
\")\205B\311)\203\273\211\211;\205z	\n\235?\205z\307!\203c\310	\"\206z\307\f!\203p\310	\f\"\206z\307
!\205z\310	
\")\211\205\204J*\211\204\217\311\202\271<\203\235\312\"\202\271;\203\267\313\314\"\203\262\315!\202\271\202\271)\207\316\317\320\"``#\210\321\207" [spp-symbol name 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 spp stream] 5 (#$ . 13956) "sSymbol name: "])
#@89 Replacement for `hif-lookup'.
I think it just gets the value for some CPP variable VAR.
(defalias 'semantic-c-hideif-lookup #[(var) "\302;\203\n\2029\203\303!\202\304!\211\205	)\207" [var val semantic-c-evaluate-symbol-for-hideif symbol-name "Unable to determine var"] 4 (#$ . 15029)])
#@100 Replacement for `hif-defined'.
I think it just returns t/nil dependent on if VAR has been defined.
(defalias 'semantic-c-hideif-defined #[(var) "9\203\306!\202;\203\202\307\211\211\211;\205L\n\235?\205L\310\f!\2033\311\n\f\"\206L\310
!\203@\311\n
\"\206L\310!\205L\311\n\")\205Q\312)\204i\313\314\315\316\317 \320 \"\"\317 \320 #\210\321\202j\312)\207" [var var-symbol-name name semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-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 semantic-lex-spp-macro-symbol-obarray] 7 (#$ . 15336)])
#@55 Non-nil when Semantic is taking over hideif features.
(defvar semantic-c-takeover-hideif nil (#$ . 16094))
#@107 Code blocks wrapped up in #if, or #ifdef.
Uses known macro tables in SPP to determine what block to skip.
(defvar semantic-lex-c-if nil (#$ . 16208))
(defalias 'semantic-lex-c-if #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-if ((looking-at #1="^\\s-*#\\s-*\\(if\\|elif\\).*$") (semantic-c-do-lex-if)) #[nil "\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 #1# semantic-c-do-lex-if] 5 "Code blocks wrapped up in #if, or #ifdef.\nUses known macro tables in SPP to determine what block to skip."]] 2)
#@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 #[nil "\306	\307P\3101\311\n!0\202\210\312\3131\314!0\202,\315\316\317\f\"``T#\210)\312\211\203<
\247\203`
\320\232\203`\312\315\316\321\322\323 \324 \"\"\323 \324 #\210\325 \210`\326 \210`)\312\202g\312\210`\312,\207" [semantic-c-takeover-hideif hif-cpp-prefix hif-ifx-regexp parsedtokelist err eval-form 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 pt semantic-lex-end-point] 7 (#$ . 16914)])
#@99 Code blocks wrapped up in #ifdef.
Uses known macro tables in SPP to determine what block to skip.
(defvar semantic-lex-c-ifdef nil (#$ . 17805))
(defalias 'semantic-lex-c-ifdef #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-ifdef ((looking-at #1="^\\s-*#\\s-*\\(ifndef\\|ifdef\\)\\s-+\\(\\(\\sw\\|\\s_\\)+\\)\\([ 	
].*\\)?$") (semantic-c-do-lex-ifdef)) #[nil "\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 #1# semantic-c-do-lex-ifdef] 5 "Code blocks wrapped up in #ifdef.\nUses known macro tables in SPP to determine what block to skip."]] 2)
#@35 Handle lexical CPP if statements.
(defalias 'semantic-c-do-lex-ifdef #[nil "\306\307\224\307\225\"\306\310\224\310\225\"\211\311\230	\312\230\n\203]\211\211;\205T\f
\235?\205T\313!\2039\314\f\"\206T\313!\203H\314\f\"\206T\313!\205T\314\f\")\205Y\315)\203\244\203\303\211\211;\205\233\f
\235?\205\233\313!\203\200\314\f\"\206\233\313!\203\217\314\f\"\206\233\313!\205\233\314\f\")\205\240\315)\203\303\316\317 \210`\320 \210`\321\322\323	#`#\210)\316\202\312\316\210`\316,\207" [sym ift ifdef ifndef name semantic-lex-spp-expanded-macro-stack 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" semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray pt semantic-lex-end-point] 6 (#$ . 18555)])
#@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.
(defvar semantic-lex-c-macro-else nil (#$ . 19529))
(defalias 'semantic-lex-c-macro-else #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-macro-else ((looking-at #1="^\\s-*#\\s-*\\(else\\)") (let ((pt (point))) (semantic-c-skip-conditional-section) (setq semantic-lex-end-point (point)) (semantic-push-parser-warning #2="Skip #else" pt (point)) nil)) #[nil "\306``dB\307\310\311!\203\"`
\312 \210`\313\314
`#\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 #1# semantic-c-skip-conditional-section semantic-push-parser-warning #2# pt] 5 "Ignore an #else block.\nWe won't see the #else due to the macro skip section block\nunless we are actively parsing an open #if statement.  In that\ncase, we must skip it since it is the ELSE part."]] 2)
#@56 Ignore various forms of #if/#else/#endif conditionals.
(defvar semantic-lex-c-macrobits nil (#$ . 20638))
(defalias 'semantic-lex-c-macrobits #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-macrobits ((looking-at #1="^\\s-*#\\s-*\\(if\\(n?def\\)?\\|endif\\|elif\\|else\\)") (semantic-c-end-of-macro) (setq semantic-lex-end-point (point)) nil) #[nil "\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 #1# semantic-c-end-of-macro] 5 "Ignore various forms of #if/#else/#endif conditionals."]] 2)
#@54 Identify include strings, and return special tokens.
(defvar semantic-lex-c-include-system nil (#$ . 21335))
(defalias 'semantic-lex-c-include-system #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-include-system ((looking-at #6="^\\s-*#\\s-*include\\s-*<\\([^ 	\n>]+\\)>") (let ((#2=#:start (match-beginning 0)) (#3=#:end (match-end 0)) (#4=#:startpnt semantic-lex-end-point) (#1=#: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 #1#)) (semantic-lex-push-token (semantic-lex-token (if (eq (cdr #1#) 'system) 'spp-system-include 'spp-include) #2# #3# (car #1#))) (when (and (/= #4# #5#) (/= #5# semantic-lex-end-point)) (setq semantic-lex-end-point #5#)))) #[nil "\306``dB\307\310\311!\203\204\307\224\307\225\f\312 \313\216\307\225b\210`\314\315\224\315\225\"*\316B\f\317@!\210A\316=\203I\320\202J\321@BBB
B\211@\211\211A@\247\204i\211AA\262\202m\211A\262A\262U\204\203\fU\204\203-
-\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 #6# match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] buffer-substring-no-properties 1 system semantic-lex-spp-merge-header spp-system-include spp-include save-match-data-internal #5# #1# #4# #3# #2#] 7 "Identify include strings, and return special tokens."]] 2)
#@54 Identify include strings, and return special tokens.
(defvar semantic-lex-c-include nil (#$ . 22975))
(defalias 'semantic-lex-c-include #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-include ((looking-at #6="^\\s-*#\\s-*include\\s-*\"\\([^ 	\n>]+\\)\"") (let ((#2=#:start (match-beginning 0)) (#3=#:end (match-end 0)) (#4=#:startpnt semantic-lex-end-point) (#1=#: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 #1#)) (semantic-lex-push-token (semantic-lex-token (if (eq (cdr #1#) 'system) 'spp-system-include 'spp-include) #2# #3# (car #1#))) (when (and (/= #4# #5#) (/= #5# semantic-lex-end-point)) (setq semantic-lex-end-point #5#)))) #[nil "\306``dB\307\310\311!\203\204\307\224\307\225\f\312 \313\216\307\225b\210`\314\315\224\315\225\"*\306B\f\316@!\210A\317=\203I\320\202J\321@BBB
B\211@\211\211A@\247\204i\211AA\262\202m\211A\262A\262U\204\203\fU\204\203-
-\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 #6# match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] buffer-substring-no-properties 1 semantic-lex-spp-merge-header system spp-system-include spp-include save-match-data-internal #5# #1# #4# #3# #2#] 7 "Identify include strings, and return special tokens."]] 2)
#@52 Skip backslash ending a line.
Go to the next line.
(defvar semantic-lex-c-ignore-ending-backslash nil (#$ . 24592))
(defalias 'semantic-lex-c-ignore-ending-backslash #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-ignore-ending-backslash ((looking-at #1="\\\\\\s-*\n") (setq semantic-lex-end-point (match-end 0))) #[nil "\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 #1#] 5 "Skip backslash ending a line.\nGo to the next line."]] 2)
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defvar semantic-lex-c-namespace-begin-macro nil (#$ . 25231))
(defalias 'semantic-lex-c-namespace-begin-macro #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\210\303\304\305\306\307\310\311\312&\207" [semantic-lex-c-namespace-begin-macro ((looking-at #1="\\(_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 #2="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 #3="_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))) #[nil "\306``dB\307\310\311!\203\263\312\225\313\224\313\225\314\"\315\316\307\224BBB
B\211@\211\211A@\247\204D\211AA\262\202H\211A\262A\262\317BBB
B\211@\211\211A@\247\204k\211AA\262\202o\211A\262A\262,\307\225b\210`\307\320\321\306\322#\203\260`\323\324CBBB
B\211@\211\211A@\247\204\250\211AA\262\202\254\211A\262A\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 #1# 1 2 buffer-substring-no-properties NAMESPACE #2# symbol re-search-forward #3# t semantic-list prefix-fake nsend sym-start sym-end ms end start] 6 "Handle G++'s namespace macros which the pre-processor can't handle."] custom-declare-variable semantic-lex-c-nested-namespace-ignore-second t "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.
(defvar semantic-lex-c-VC++-begin-std-namespace nil (#$ . 27552))
(defalias 'semantic-lex-c-VC++-begin-std-namespace #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-VC++-begin-std-namespace ((looking-at #1="\\(_STD_BEGIN\\)") (semantic-lex-push-token (semantic-lex-token 'NAMESPACE (match-beginning 0) (match-end 0) #2="namespace")) (semantic-lex-push-token (semantic-lex-token 'symbol (match-beginning 0) (match-end 0) #3="std")) (goto-char (match-end 0)) (let ((start (point)) (end 0)) (when (re-search-forward #4="_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))) #[nil "\306``dB\307\310\311!\203\235\312\313\307\224\307\225BBB
B\211@\211\211A@\247\2040\211AA\262\2024\211A\262A\262\314\315\307\224\307\225BBB
B\211@\211\211A@\247\204V\211AA\262\202Z\211A\262A\262\307\225b\210`\307\316\317\306\320#\203\232`\321\322CBBB
B\211@\211\211A@\247\204\222\211AA\262\202\226\211A\262A\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 #1# NAMESPACE #2# symbol #3# re-search-forward #4# t semantic-list prefix-fake end start] 6 "Handle VC++'s definition of the std namespace."]] 2)
#@48 Handle VC++'s definition of the std namespace.
(defvar semantic-lex-c-VC++-end-std-namespace nil (#$ . 29000))
(defalias 'semantic-lex-c-VC++-end-std-namespace #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-VC++-end-std-namespace ((looking-at #1="\\(_STD_END\\)") (goto-char (match-end 0)) (setq semantic-lex-end-point (point))) #[nil "\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 #1#] 5 "Handle VC++'s definition of the std namespace."]] 2)
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defvar semantic-lex-c-namespace-begin-nested-macro nil (#$ . 29656))
(defalias 'semantic-lex-c-namespace-begin-nested-macro #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-namespace-begin-nested-macro ((looking-at #1="\\(_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 #2="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 #3="_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))) #[nil "\306``dB\307\310\311!\203\307\225b\210\312\225\313\224\313\225\314\"\315\224\315\225\314\"\316\317\307\224BBB
B\211@\211\211A@\247\204X\211AA\262\202\\\211A\262A\262\320BBB
B\211@\211\211A@\247\204\211AA\262\202\203\211A\262A\262\307\225b\210`\307\321\322\306\323#\203` \203\313\324\325CBBB
B\211@\211\211A@\247\204\300\211AA\262\202\304\211A\262A\262\202\324\326\316\317BBB\320BBB\324\325CBBBFBBB
B\211@\211\211A@\247\204\211AA\262\202\211A\262A\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 #1# 1 2 buffer-substring-no-properties 3 NAMESPACE #2# symbol re-search-forward #3# t semantic-list prefix-fake prefix-fake-plus nsend sym-start sym-end ms sym2-start sym2-end ms2 end start semantic-lex-c-nested-namespace-ignore-second] 9 "Handle G++'s namespace macros which the pre-processor can't handle."]] 2)
#@69 Handle G++'s namespace macros which the pre-processor can't handle.
(defvar semantic-lex-c-namespace-end-macro nil (#$ . 32211))
(defalias 'semantic-lex-c-namespace-end-macro #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-namespace-end-macro ((looking-at #1="_GLIBCXX_END_\\(NESTED_\\)?NAMESPACE") (goto-char (match-end 0)) (setq semantic-lex-end-point (point))) #[nil "\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 #1#] 5 "Handle G++'s namespace macros which the pre-processor can't handle."]] 2)
#@37 Detect and create a C string token.
(defvar semantic-lex-c-string nil (#$ . 32922))
(defalias 'semantic-lex-c-string #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-c-string ((looking-at #1="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)))))) #[nil "\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\262A\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 #1# string 1 forward-sexp (error) debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function] 8 "Detect and create a C string token."]] 2)
#@139 Detect and ignore newline tokens.
Use this ONLY if newlines are not whitespace characters (such as when
they are comment end characters).
(defvar semantic-c-lex-ignore-newline nil (#$ . 33923))
(defalias 'semantic-c-lex-ignore-newline #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-c-lex-ignore-newline ((looking-at #1="\\s-*\\\\?\\s-*\\(\n\\|\\s>\\)") (setq semantic-lex-end-point (match-end 0))) #[nil "\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 #1#] 5 "Detect and ignore newline tokens.\nUse this ONLY if newlines are not whitespace characters (such as when\nthey are comment end characters)."]] 2)
#@131 Lexical Analyzer for C code.
Use semantic-cpp-lexer for parsing text inside a CPP macro.
See `semantic-lex' for more information.
(defalias 'semantic-c-lexer #[(start end &optional depth length) "\306\307\310	\n#\210`\306\211	@	A\311BC\206DE	\nBF\306G\ndV\2034\312\313\nd#\210\314 pHI\315\216\316J!\210	b\210`\nW\203nK\203X\fGKX\203n\317\320!\203\321\224\321\225A\322 L\323\216\311\225b\210\324\306w\210l?\205\302\325\321\224\321\225\"M\321\225N\212\311\225b\210\317\326!)O\306P\327Q\330\212\331 \210\332\333N\"\203\251\311\224b\210`\202\252`)!RO\203\271\334R@!\210`A\335R!.*ASTUVW\336\325WV\"T\"\210\337WVBB\fB\211@\211\211A@\247\204\366\211AA\262\202\372\211A\262A\262AUSU\204SAU\204SA-\202\347\317\340!\203p\321\224\321\225XY\325YX\"\306ZM\341MZ\206D[\206D\342\343\311\"\211[\"*\210\344YXBB\fB\211@\211\211A@\247\204c\211AA\262\202g\211A\262A\262A*\202\347\317\345!\203|\346 \210\202\347\317\347!\203\210\350 \210\202\347\317\351!\203\242`\\\352 \210`A\353\354\\`#\210)\202\347\317\355!\203\261\331 \210`A\202\347\317\356!\2032\311\224\311\225A\322 L\357\216\311\225b\210`A\325\321\224\321\225\"*\306BA]^_`a\360^@!\210^A\361=\203\361\362\202\362\363^@a`BBB\fB\211@\211\211A@\247\204\211AA\262\202\211A\262A\262A_]U\204.]AU\204.]A-\202\347\317\364!\203\263\311\224\311\225A\322 L\365\216\311\225b\210`A\325\321\224\321\225\"*\361BAbcdef\360c@!\210cA\361=\203r\362\202s\363c@feBBB\fB\211@\211\211A@\247\204\222\211AA\262\202\226\211A\262A\262AdbU\204\257bAU\204\257bA-\202\347\317\366!\203\300\311\225A\202\347\317\367!\203\315\311\225A\202\347\317\370!\203\332\311\225A\202\347\317g!\203	\371\311\224\311\225BB\fB\211@\211\211A@\247\204\375\211AA\262\202\211A\262A\262A\202\347\317\372!\203m\373`\212\321\224b\210h\203(i\203(\374\321!\210`\202I\37515\374\321!\210`0\202I\210\373jF@FA#b\210`\211A\262)BB\fB\211@\211\211A@\247\204a\211AA\262\202e\211A\262A\262A\202\347\317\376!\203&\321\225k\377\224l\377\225m\325lm\"n\201}\201~\311\224kBBB\fB\211@\211\211A@\247\204\251\211AA\262\202\255\211A\262A\262A\201nlmBBB\fB\211@\211\211A@\247\204\323\211AA\262\202\327\211A\262A\262A,\311\225b\210`\311\201\200\201\201\306\201\202#\203`\201\203\201\204C	\nBBB\fB\211@\211\211A@\247\204\211AA\262\202\211A\262A\262A*`A\202\347\317\201\205!\203P\311\225b\210\321\225k\377\224l\377\225m\325lm\"n\201\206\224o\201\206\225p\325op\"q\201}\201~\311\224kBBB\fB\211@\211\211A@\247\204|\211AA\262\202\200\211A\262A\262A\201nlmBBB\fB\211@\211\211A@\247\204\246\211AA\262\202\252\211A\262A\262A\311\225b\210`\311\201\200\201\207\306\201\202#\203H`r\203\371\201\203\201\204C	\nBBB\fB\211@\211\211A@\247\204\355\211AA\262\202\361\211A\262A\262A\202H\201\203\201\210\201}\201~moBBB\201qopBBB\201\203\201\204C	\nBBBF	\nBBB\fB\211@\211\211A@\247\204?\211AA\262\202C\211A\262A\262A.	`A\202\347\317\201\211!\203b\311\225b\210`A\202\347\317\201\212!\203	\201}\201~\311\224\311\225BBB\fB\211@\211\211A@\247\204\214\211AA\262\202\220\211A\262A\262A\201\201\213\311\224\311\225BBB\fB\211@\211\211A@\247\204\267\211AA\262\202\273\211A\262A\262A\311\225b\210`\311\201\200\201\214\306\201\202#\203`\201\203\201\204C	\nBBB\fB\211@\211\211A@\247\204\371\211AA\262\202\375\211A\262A\262A*`A\202\347\317\201\215!\203\311\225b\210`A\202\347\317\201\216!\203Z\201\217\311!\311\224\311\225\306stu\201\220ut\n#\210\201\221t!\211s\203V\201\222s\201\223\"AA,\202\347\317\201\224!\203\214\201\225\311\224\311\225BB\fB\211@\211\211A@\247\204\200\211AA\262\202\204\211A\262A\262A\202\347\317\201\226!\2035E\203\241BEW\203\320BTB\201\227\311\224\311\225BB\fB\211@\211\211A@\247\204\304\211AA\262\202\310\211A\262A\262A\202\347\201\203\311\224\212h\203\352i\203\352\201\230\321!\210`\202\201\2311\373\201\230\321!\210`0\202\210\201\203jF@FA#b\210`\211A\262)BB\fB\211@\211\211A@\247\204)\211AA\262\202-\211A\262A\262A\202\347\317\201\232!\203lBSB\201\233\311\224\311\225BB\fB\211@\211\211A@\247\204`\211AA\262\202d\211A\262A\262A\202\347\317v!\203\257`w\201\234\321!\210`w=\203\222\201\235\201\236\201\237 \"\210\202\233n\203\233\201\240u\210`w=\203\250\312\201\241!\210`A)\202\347\317\201\242!\203\341\201\243\311\224\311\225BB\fB\211@\211\211A@\247\204\325\211AA\262\202\331\211A\262A\262A\202\347\312\201\244!\210A@=\203\371\312\201\245@\f@#\210A@Ab\210x\203-\201\246 \204#r\201\247y!q\210\212yb\210\201\250 *\203-\201\251x\201\252\"\210\f@z\205i\306C\201\253\311\201\254\201\255\201\256!\201\257\"\377$\216\203X\211\201\260!\240\210\201\261\201\262\201\263B#!)\262\266\202E+
\203\261
\211A\242\211{\211|\203\233\201\264\201\265|@|A@#\210
\211A\242\211|\204\201{@jF@FA#b\210`\211A\266*b\210\f\237.	\207" [semantic-lex-block-streams start end starting-position semantic-lex-token-stream semantic-lex-block-stack nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-c-lexer: end (%d) > point-max (%d)" syntax-table #[nil "rq\210\302	!)\207" [#1=#:buffer #2=#:table set-syntax-table] 2] set-syntax-table looking-at "^\\s-*#\\s-*define\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" 1 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] " 	" buffer-substring-no-properties "(" semantic-cpp-lexer semantic-lex-spp-stream-for-macro semantic-c-end-of-macro looking-back "/\\*.*" semantic-lex-spp-first-token-arg-list semantic-lex-spp-merge-streams semantic-lex-spp-symbol-set 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>]+\\)\"" #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] semantic-lex-spp-merge-header system spp-system-include spp-include "^\\s-*#\\s-*include\\s-*<\\([^ 	\n>]+\\)>" #[nil "\301\302\"\207" [save-match-data-internal 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-*)" 2 tmp-start semantic-lex-end-point semantic-lex-current-depth depth semantic-lex-depth semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties #1# #2# semantic-lex-syntax-table length save-match-data-internal name beginning-of-define with-args semantic-lex-spp-replacements-enabled semantic-lex-analyzer raw-stream #3=#:endpnt #4=#:val #5=#:startpnt #6=#:end #7=#:start #8=#:end #9=#:start obarray semantic-lex-spp-dynamic-macro-symbol-obarray pt #10=#:endpnt #11=#:val #12=#:startpnt #13=#:end #14=#:start #15=#:endpnt #16=#:val #17=#:startpnt #18=#:end #19=#:start semantic-lex-number-expression debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function nsend sym-start sym-end ms sym2-start sym2-end ms2 semantic-lex-c-nested-namespace-ignore-second sppov beg str semantic-lex-comment-regex comment-start-point semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug last blk 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 make-byte-code "\300\242\205	\301\300\242!\207" vconcat vector [delete-overlay] semantic-lex-highlight-token read-event format "%S :: Depth: %d :: SPC - continue" message "semantic-c-lexer: `%s' block from %S is unterminated"] 9 (#$ . 34730)])
#@41 Match ## inside a CPP macro as special.
(defvar semantic-lex-cpp-hashhash nil (#$ . 43569))
(defalias 'semantic-lex-cpp-hashhash #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-cpp-hashhash ((looking-at #1="##") (semantic-lex-push-token (semantic-lex-token 'spp-concat (match-beginning 0) (match-end 0)))) #[nil "\306``dB\307\310\311!\2036\312\307\224\307\225BB
B\211@\211\211A@\247\204.\211AA\262\2022\211A\262A\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 #1# spp-concat] 6 "Match ## inside a CPP macro as special."]] 2)
#@85 Lexical Analyzer for CPP macros in C code.
See `semantic-lex' for more information.
(defalias 'semantic-cpp-lexer #[(start end &optional depth length) "\306\307\310	\n#\210`\306\211	@	A\311BC\206DE	\nBF\306G\ndV\2034\312\313\nd#\210\314 pHI\315\216\316J!\210	b\210`\nW\203K\203X\fGKX\203\317\320!\203\206\321\311\224\311\225BB\fB\211@\211\211A@\247\204z\211AA\262\202~\211A\262A\262A\202\215\317\322!\203E\323\224\323\225A\324 L\325\216\311\225b\210\326\306w\210l?\205\360\327\323\224\323\225\"M\323\225N\212\311\225b\210\317\330!)O\306P\331Q\332\212\333 \210\334\335N\"\203\327\311\224b\210`\202\330`)!RO\203\347\336R@!\210`A\337R!.*ASTUVW\340\327WV\"T\"\210\341WVBB\fB\211@\211\211A@\247\204$\211AA\262\202(\211A\262A\262AUSU\204ASAU\204ASA-\202\215\317\342!\203\236\323\224\323\225XY\327YX\"\306ZM\343MZ\206r[\206r\344\345\311\"\211[\"*\210\346YXBB\fB\211@\211\211A@\247\204\221\211AA\262\202\225\211A\262A\262A*\202\215\317\347!\203\252\350 \210\202\215\317\351!\203\304`\\\352 \210`A\353\354\\`#\210)\202\215\317\355!\203\323\333 \210`A\202\215\317\356!\203T\311\224\311\225A\324 L\357\216\311\225b\210`A\327\323\224\323\225\"*\306BA]^_`a\360^@!\210^A\361=\203\362\202\363^@a`BBB\fB\211@\211\211A@\247\2043\211AA\262\2027\211A\262A\262A_]U\204P]AU\204P]A-\202\215\317\364!\203\325\311\224\311\225A\324 L\365\216\311\225b\210`A\327\323\224\323\225\"*\361BAbcdef\360c@!\210cA\361=\203\224\362\202\225\363c@feBBB\fB\211@\211\211A@\247\204\264\211AA\262\202\270\211A\262A\262AdbU\204\321bAU\204\321bA-\202\215\317\366!\203\342\311\225A\202\215\317\367!\203\357\311\225A\202\215\317\370!\203\374\311\225A\202\215\317g!\203+\371\311\224\311\225BB\fB\211@\211\211A@\247\204\211AA\262\202#\211A\262A\262A\202\215\317\372!\203\217\373`\212\323\224b\210h\203Ji\203J\374\323!\210`\202k\3751W\374\323!\210`0\202k\210\373jF@FA#b\210`\211A\262)BB\fB\211@\211\211A@\247\204\203\211AA\262\202\207\211A\262A\262A\202\215\317\376!\203\347\377\311!\211\201tk!\205\256\211;\205\256\201uk\"\262\211\262\205\270\211J\262\206\300\201v\311\224\311\225BB\fB\211@\211\211A@\247\204\333\211AA\262\202\337\211A\262A\262A\202\215\317\201w!\203\201x\311\224\311\225BB\fB\211@\211\211A@\247\204
\211AA\262\202\211A\262A\262A\202\215\317\201y!\203\333E\203.BEW\203]BTB\201z\311\224\311\225BB\fB\211@\211\211A@\247\204Q\211AA\262\202U\211A\262A\262A\202\215\212\311\224\311\225\212\333 \210`)l\201{1\257\201|\323!\210`lV\203\205\312\201}!\210\201~	`BB\fB\211@\211\211A@\247\204\241\211AA\262\202\245\211A\262A\262\211A0\202\326\210\201z	\nBB\fB\211@\211\211A@\247\204\314\211AA\262\202\320\211A\262A\262\211A\210,\202\215\317\201!\203BSB\201\200\311\224\311\225BB\fB\211@\211\211A@\247\204\211AA\262\202\n\211A\262A\262A\202\215\317m!\203U`n\201\201\323!\210`n=\2038\201\202\201\203\201\204 \"\210\202An\203A\201\205u\210`n=\203N\312\201\206!\210`A)\202\215\317\201\207!\203\207\201\210\311\224\311\225BB\fB\211@\211\211A@\247\204{\211AA\262\202\211A\262A\262A\202\215\312\201\211!\210A@=\203\237\312\201\212@\f@#\210A@Ab\210o\203\323\201\213 \204\311r\201\214p!q\210\212pb\210\201\215 *\203\323\201\216o\201\217\"\210\f@q\205\306C\201\220\311\201\221\201\222\201\223!\201\224\"\201\225$\216\203\211\201\226!\240\210\201\227\201\230\201\231B#!)\262\266\202E+
\203Y
\211A\242\211r\211s\203C\201\232\201\233s@sA@#\210
\211A\242\211s\204)r@jF@FA#b\210`\211A\266*b\210\f\237.	\207" [semantic-lex-block-streams start end starting-position semantic-lex-token-stream semantic-lex-block-stack nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-cpp-lexer: end (%d) > point-max (%d)" syntax-table #[nil "rq\210\302	!)\207" [#1=#:buffer #2=#:table set-syntax-table] 2] set-syntax-table looking-at "##" spp-concat "^\\s-*#\\s-*define\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" 1 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] " 	" buffer-substring-no-properties "(" semantic-cpp-lexer semantic-lex-spp-stream-for-macro semantic-c-end-of-macro looking-back "/\\*.*" semantic-lex-spp-first-token-arg-list semantic-lex-spp-merge-streams semantic-lex-spp-symbol-set 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>]+\\)\"" #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] semantic-lex-spp-merge-header system spp-system-include spp-include "^\\s-*#\\s-*include\\s-*<\\([^ 	\n>]+\\)>" #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] "\\\\\\s-*\n" "\\s-+" "\\s-*\\\\?\\s-*\\(\n\\|\\s>\\)" number "L?\\(\\s\"\\)" string forward-sexp (error) "\\(\\sw\\|\\s_\\)+" match-string tmp-start semantic-lex-end-point semantic-lex-current-depth depth semantic-lex-depth semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties #1# #2# semantic-lex-syntax-table length save-match-data-internal name beginning-of-define with-args semantic-lex-spp-replacements-enabled semantic-lex-analyzer raw-stream #3=#:endpnt #4=#:val #5=#:startpnt #6=#:end #7=#:start #8=#:end #9=#:start obarray semantic-lex-spp-dynamic-macro-symbol-obarray pt #10=#:endpnt #11=#:val #12=#:startpnt #13=#:end #14=#:start #15=#:endpnt #16=#:val #17=#:startpnt #18=#:end #19=#:start semantic-lex-number-expression debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function semantic-flex-keywords-obarray peom semantic-lex-comment-regex comment-start-point semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug last blk 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 make-byte-code "\300\242\205	\301\300\242!\207" vconcat vector [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"] 9 (#$ . 44272)])
#@301 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.
(defalias 'semantic-parse-region-c-mode #[(start end &optional nonterminal depth returnonerror) "\306\302!\203\211\307U\203	dU\204\211\n\211\211@\262A@A@;\211\2034\310\n$\202\207\203}\307U\203}\f\311=\203}
\203}
:\203}
@9\203}\312
:\203i
@\313=\203i
A\202n\314	\312#\315#\237)\202\207\316	%,\207\316	%\207" [start end lse last-lexical-token llt-class llt-fakebits boundp 1 semantic-c-parse-lexical-token semantic-list 0 prefix-fake-plus semantic-lex semantic-repeat-parse-whole-stream semantic-parse-region-default macroexpand nonterminal depth returnonerror tokstream] 7 (#$ . 51103)])
(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 (#$ . 52286))
#@268 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.
(defalias 'semantic-c-parse-lexical-token #[(lexicaltoken nonterminal depth returnonerror) "T\306\307\310\"!\n\f\311*+\211\211A@\247\204#\211AA\262\202'\211A\262@\262,+\211\211A@\247\204>\211AA\262\202B\211A\262A\262-+\211A@;\203X\211A@\262\202\214\312\211\211A@\247\204j\211AA\262\202n\211A\262@\262\211\211A@\247\204\202\211AA\262\202\206\211A\262A\262\"\262.\313\314\315.#
\316V\204\270r	q\210\317 \210\n=\204\351\320 /\321\216\3221\271 0\202\322\210\323\307\324\325 #!\203\313\326!\202\322\327\330!\210\331\332!\210*\333 \210\334 \210\3350\336 \210\337 \210\340\341\342\335#\210

\3111\2112\203
2@1\3431@1A\"\2102A\2112\204\366*.c\210\344ed345%*
\3111\2112\203S2@\2111@\31167\34576\206G\f\206G\346\347\314\"\211\"*\2102A\2112\204)**\3118\2112\203\2672@\2118,-D9\21188\3508\233)9\240*\210\3518!\311:\2112\203\2552@\211:,-D9\21188\3508\233)9\240*\2102A\2112\204\210*2A\2112\204_+*.	\207" [semantic-c-parse-token-hack-depth buf major-mode mode semantic-lex-spp-dynamic-macro-symbol-obarray spp-syms get-buffer-create format " *C parse hack %d*" nil buffer-substring-no-properties get-text-property 0 macros 5 erase-buffer match-data #[nil "\301\302\"\207" [save-match-data-internal 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 stream lexicaltoken start end symtext save-match-data-internal semantic-new-buffer-fcn-was-run sym --dolist-tail-- nonterminal depth returnonerror obarray name tag overlay stag] 7 (#$ . 52421)])
#@41 The most recent mode needing debugging.
(defvar semantic-c-debug-mode-init-last-mode nil (#$ . 54706))
#@65 Debug mode init for major mode MM after we're done parsing now.
(defalias 'semantic-c-debug-mode-init #[(mm) "\303\304!\203\305\306\307!!\210\310	 )\207	\311\312\313\"\207" [debug-on-error mm 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] 3 (#$ . 54815) (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 #[nil "\302\303\304!!\210\305 \210\306\307	!\310\261\210\311\312\313\")\207" [semantic-c-debug-mode-init-last-mode mm 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] 3 (#$ . 55265)])
#@52 Expand TAG into a list of equivalent tags, or nil.
(defalias 'semantic-expand-c-tag #[(tag) "\304	\211A@)\305=\203\306	!\304	\307\211\211A@)\n*=\2043	\310\211\211A@)\n*=\203=\311	!\211@	A	\211@):\203a\312	!\211\204S\304\202]:\203]\313\")\202n	\203n:\203n	B)\207" [return-list tag class rl nil extern semantic-expand-c-extern-C function variable semantic-expand-c-complex-type semantic-expand-c-tag-namelist append] 4 (#$ . 55886)])
#@142 Expand TAG containing an `extern "C"' statement.
This will return all members of TAG with `extern "C"' added to
the typemodifiers attribute.
(defalias 'semantic-expand-c-extern-C #[(tag) "\211A@)\306=\205e\307\310\3118)	\"*\211\n\203b\n@\312\310\3118)	\"*\313\314\fBB\n@\312\f\211\211AA)\211:\203W\315\316@	
#!\240\210,\210)\nA\211\204 \237*\207" [tag attribute mb ret mods value extern :members plist-get 2 :typemodifiers "extern" "\"C\"" semantic-tag-make-plist plist-put plist-cdr] 7 (#$ . 56360)])
#@379 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).
(defalias 'semantic-expand-c-complex-type #[(tag) "\211\306\307\3108)	\"+\311\211\n:\205\n\211@)\211:\203)
@@\n\203\364\n\3121Z:\205V@;\205VA@9\205VA@\205V\3108<\205V\3138<0\202\\\210\311)\203\364\314\n!\204\364
\203\364
\315\230\204\364\n\211@)\n\211\306\307\3108)	\"+\311\211\316\317D\320\321\322\306\323\324@\325A&\f-\326!\211\306\211\211AA)\211 :\203\323 \327\330 @	#!\240\210,\210\331\n\"\210\n\3328)!\211\332\233)!\240*\210\n\fB\f,B\207" [tag attribute basetype typeref ret tname :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 attributes parents members name value plist-cdr overlay] 14 (#$ . 56903)])
#@62 Expand TAG whose name is a list into a list of tags, or nil.
(defalias 'semantic-expand-c-tag-namelist #[(tag) "\306\211\211A@)	*=\203	\307\211\310\311\3128)\n\"+\313\314\311\3128)\n\"*\313\211@)\307\211*+,-.
\203\313\211*,
@\3128\203_\315\3128P*-G\316U\203o-@,\202s-,\3178@,\f\205\214\fA<\205\214\320\f@\fA@\"\321\211\321\311\3128)\n\"+\322*\314+\323\3248G\325A@\326\326\311\3128)\n\"*\327\330!\257/01\331\3321\306\310\3330/&,.B.\334.@\"\210.@\3178)2\211\317\233)2\240*\210
A\211\204I.\237.\207\335\211\211A@)	*=\203\203\307\211@)\336\311\3128)\n\"*\307345.\337\340\"\203\3564\335\211\211A@)	*=\203\3564\211\341\311\3128)\n\"+\203\356434\30711\206v\211@)\211A@)\342\3128)!\342\3248)!\3178)\257*\2114\211@)\313\230\204\3124\341\3076\211\211AA)\2117:\203\3047\343\3447@\n6#!\240\210,\210\202\315\30733\203\356\3343\"\2103\3178)2\211\317\233)2\240*\2105\203s5@A@\340\211\341\311\3128)\n\"+\307\3255@@@\2118\345U?\2058)\3464\327\330!\257/9:1\331\3321\335\310\341:\3369@\3479A/&\f-.B.\334.@\"\210.@\3178)2\211\317\233)2\240*\2105A\2115\204\3633\2033.B..,\207@<\203\267@\306\211\211A@)	*=\203\267\307.\203\263\350\351.@!.\".A\211\204\241.)\207\307\207" [tag class attribute cur default lst 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 suffix mods ty basety vl attributes default-value name overlay addlast super names value plist-cdr stars parents members] 19 (#$ . 58155)])
(byte-code "\304\305\306BC\307\310#\210\311\312\310\"\210)\313\306\310\314!\315\2040	\211\262\2040\n\262\205.\316\"\262\203[\211\204[\303N\203J\316\303N\"\211\262\2040\211\317N\206T\211\320N\262\262\2020\266\203\321\322#\207" [#1=#:tmp0 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 #[nil "\302\301!\210\211\207" [#1# 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 (#$ . 60847))
#@104 Split up tag names on colon (:) boundaries.

Override semantic-analyze-split-name in `c-mode' buffers.
(defalias 'semantic-analyze-split-name-c-mode #[(name) "\302\303\"\211G\304U\203\202\305\306	\")\207" [name ans split-string ":" 1 delete ""] 4 (#$ . 61176)])
(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)
#@269 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.
(defalias 'semantic-analyze-tag-references-c-mode #[(tag &optional db) "\3061-:\205)@;\205)A@9\205)A@\205)\3078<\205)\3108<0\202/\210\311)\204:\312\313\314D\"\210\311\211\211\212\315\f\"\210\316 \317\n\320#\321!\322U\204i\321!\323U\203\265\324\322\"@=\203\265\325\n\326\327\n\326\"\311\211\311!\211\"\203\250\"@\211!\211\330#\331\3078)#\"+\332\230\204\237!
B\"A\211\"\204~*\333
!*#\210\317\n\320#\334\211@)\335\336\f\337\n\340&	\211,\207" [tag refs scope allhits db newparents (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 cur --dolist-tail-- attribute] 11 (#$ . 61706)])
(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)
#@210 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.
(defalias 'semantic-c-reconstitute-token #[(tokenpart declmods typedecl) "<\203G\306U\203@;\203@	A@\307=\203F	@\206$\310\311\312\313\n\235\205-\314\315\316\313\n\"F8\317\3208\307\321
\322\f&,\207	A@\323=\205}9\203\\9@	@\230\204t\324	8@;\203n\324	8@	@\230\204t\325	8\205y\326	8@?:	@G\327V\205\211	@\327H\330U\211;\203\227\331	@\306\"\202\231	@<\332\333<\"?\205\245\314=<\206\326	8@\203\270\334\202:\2039@\206\333\335\324	8@!\211>;\203\325>\202\332\336>!@)9A\206\342\337\311\211\211?@8\317\3208\305\321
\340@\341?@\342?A&\f-\202\310\343\344	8!\312\313\n\235\205\314\315\316\313\n\"\345\324	8@\346\326	8@\205'\314\347:\205.\314\350;\351\352	8\353=\354\355	8\356\357\360	8\235\205F\314\361\313\360	8\235\205P\314\362\363	8\205X\314\364\363	8\364=\205b\314\365\366	8\257A8\317\3208\323\321
\367A&.\207" [typedecl tokenpart declmods attributes default-value type 1 variable "int" nil :constant-flag "const" t :typemodifiers delete apply semantic-tag :type :default-value function 2 10 3 0 42 substring string-match "[a-zA-Z]" "void" semantic-analyze-split-name-c-mode last "class" :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 name semantic-c-classname constructor fcnpointer fnname operator split parents members arg-list] 33 (#$ . 63164)])
#@57 Reconstitute the token TAG with the template SPECIFIER.
(defalias 'semantic-c-reconstitute-template #[(tag specifier) "\305	\206\306\211\211AA)\211:\203!\f\307\310\f@\n#!\240\210,\210\207" [tag specifier value attribute plist-cdr :template "" semantic-tag-make-plist plist-put] 7 (#$ . 64953)])
#@130 Reconstitute the argument list of a function.
This currently only checks if the function expects a function
pointer as argument.
(defalias 'semantic-c-reconstitute-function-arglist #[(arglist) "\306	\306\211\203t@\211\211@)G\307V\203g\n\211@)\307H\310U\203g\311\312\n\211@)\313\"\n\211\314\315\f\316\f8)
\"+\n\316\f8)A@\317\320D\321\322\323\314\324&,C\"\202m\311\nC\"A\211\204\n*)\207" [result arglist arg --dolist-tail-- tag attribute nil 0 42 append substring 1 :type plist-get 2 :function-pointer t apply semantic-tag function :arguments attributes arg-list type name] 12 (#$ . 65267)])
#@152 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.
(defalias 'semantic-format-tag-name-c-mode #[(tag &optional parent color) "\306	\n#\307\310\3118)\"*\f\204
\202!\312
\313Q*\207" [tag parent color attribute fnptr name semantic-format-tag-name-default :function-pointer plist-get 2 "(*" ")"] 4 (#$ . 65906)])
(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)
#@277 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.
(defalias 'semantic-format-tag-canonical-name-c-mode #[(tag &optional parent color) "\303	\n#\207" [tag parent color semantic-format-tag-canonical-name-default] 4 (#$ . 66577)])
(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)
#@214 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.
(defalias 'semantic-format-tag-type-c-mode #[(tag color) "\211\306\307\3108)	\"+\311\312\307\3108)	\"*\313\307\3108)	\"*\n\3141^:\205Z@;\205ZA@9\205ZA@\205Z\3108<\205Z\3158<0\202`\210\311)\203\224\n\211\306\307\3108)	\"+\n\211@)\211\316\230\203\211\202\220\317Q*\202\232\320\"\203\244\321\302\"
\203\252\322\f\203\263\323\f\324\"\n\205\273
\fQ,\207" [tag attribute type defaulttype point ref :type plist-get 2 nil :pointer :reference (error) 3 "class" " " semantic-format-tag-type-default semantic--format-colorize-text "&" make-string 42 typename typetype color] 4 (#$ . 67321)])
(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)
#@243 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.
(defalias 'semantic-find-tags-by-scope-protection-c-mode #[(scopeprotection parent &optional table) "\204	\211\306\307\n\310\n8)\"+\f\204\207\311\312\f\313\267\202+\312\202,\310\202,\314\315\311\211\203x@\211\316\211\211A@)*=\203a\317\n\211@)
\"A\202oY\203o\nBA\211\204=*,\207" [table parent tag attribute scopeprotection alist :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 35 protected 39)) 3 (("public" . 1) ("protected" . 2) ("private" . 3)) label assoc targetprot curprot ans --dolist-tail-- class] 5 (#$ . 68439)])
(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)
#@145 Return the protection of TAG in PARENT.
Override function for `semantic-tag-protection'.

Override semantic-tag-protection in `c-mode' buffers.
(defalias 'semantic-tag-protection-c-mode #[(tag &optional parent) "\211\306\307\3108)	\"+\311\f\203\"\f\211A@)\312=\2040\n\2040\2030A\202\"\f\203\233\f\211A@)\312=\203\233\f\211\313\307\3108)	\"+\211\203\232\314
@\"\204\232
@\211A@)\315=\203\223
@\211@)\316\230\203w\317\202\222
@\211@)\320\230\203\206\321\202\222
@\211@)\322\230\205\222\323
A\211\204T)\n\204\336\f\211A@)\312=\203\336\f\211\324\307\3108)	\"+\325\230\203\303\321\202\335\f\211\324\307\3108)	\"+\326\230\203\334\317\202\335\327\n\206\371\f\205\371\f\312\211\211A@)*=\205\371\317*\207" [tag attribute prot mods parent pp :typemodifiers plist-get 2 nil type :members semantic-equivalent-tag-p label "public" public "private" private "protected" protected :type "class" "struct" unknown class] 4 (#$ . 69637)])
(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)
#@239 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.
(defalias 'semantic-find-tags-included-c-mode #[(&optional table) "\306!\307\211\203\"\n@\211A@)\310=\203\n@	B\nA\211\204\n	\237*\306!\307\211\203C\311\n@\312\"\203<\n@	B\nA\211\204/	\237*\f\307\211\203\226@\313\n\306
\314\315\3168)\"*!\307\211\203\210\n@\211A@)\310=\203\201\n@	B\nA\211\204p	\237*\"A\211\204Q*\n*\207" [table result tags tag namespaces cur semantic-something-to-tag-table nil include semantic-tag-of-type-p "namespace" append :members plist-get 2 --dolist-tail-- attribute] 7 (#$ . 70875)])
(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)
#@83 Return components for TAG.

Override semantic-tag-components in `c-mode' buffers.
(defalias 'semantic-tag-components-c-mode #[(tag) "\211A@)\303=\203g\211\304\305\3068)	\"+\307\230\203g\310\305\3068)	\"*\211\3111\\:\205X@;\205XA@9\205XA@\205X\3068<\205X\3128<0\202^\210\313)\205e\314\n!)\207\315!\207" [tag attribute sc type :type plist-get 2 "typedef" :typedef (error) 3 nil semantic-tag-components semantic-tag-components-default] 4 (#$ . 71931)])
(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)
#@52 Return the template specification for TAG, or nil.
(defalias 'semantic-c-tag-template #[(tag) "\302\303\3048)	\"*\207" [tag attribute :template plist-get 2] 3 (#$ . 72659)])
#@62 Return the template specifier specification for TAG, or nil.
(defalias 'semantic-c-tag-template-specifier #[(tag) "\302\303\3048)	\"*\207" [tag attribute :template-specifier plist-get 2] 3 (#$ . 72845)])
#@82 Convert TEMPLATESPEC into a string.
This might be a string, or a list of tokens.
(defalias 'semantic-c-template-string-body #[(templatespec) ";\203\207\30214	:\2050	@;\2050	A@9\2050	A@\2050\303	8<\2050\304	8<0\2026\210\305)\203>\306!\207<\205H\307\306\310#\207" [templatespec tag (error) 2 3 nil semantic-format-tag-abbreviate mapconcat ", "] 4 (#$ . 73061)])
#@228 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.
(defalias 'semantic-c-template-string #[(token &optional parent color) "\306!\307!	\205
\307	!	\205\306	!\211\203%\310\311
!\312Q\202.\f\203-\313\202.\314,\207" [token parent pt2 pt1 t1 t2 semantic-c-tag-template-specifier semantic-c-tag-template " <" semantic-c-template-string-body ">" " <>" ""] 6 (#$ . 73446)])
#@217 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.
(defalias 'semantic-format-tag-concise-prototype-c-mode #[(token &optional parent color) "\303	\n#\304	\n#P\207" [token parent color semantic-format-tag-concise-prototype-default semantic-c-template-string] 5 (#$ . 74008)])
(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)
#@198 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.
(defalias 'semantic-format-tag-uml-prototype-c-mode #[(token &optional parent color) "\303	\n#\304	\n#P\207" [token parent color semantic-format-tag-uml-prototype-default semantic-c-template-string] 5 (#$ . 74751)])
(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)
#@255 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.
(defalias 'semantic-tag-abstract-p-c-mode #[(tag &optional parent) "\211A@)\305=\203M\306\307!\210\310\311\312!\"\206\200\310\313\312!\"\310\314\312!\"	\205K\315	@\211\316\317\3208)\"+\235\205K\n\205K\321\n@\"\322=*\207\211A@)\323=\203|\311\317\3208)\"*\206\200\315\211\316\317\3208)\"+\235\207\324\f\"\207" [tag ds cs attribute parent 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] 5 (#$ . 75451)])
(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)
#@146 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.
(defalias 'semantic-c-dereference-typedef #[(type scope &optional type-declaration) "\211A@)\300=\203\237\211\306\307	\310	8)\n\"+\311\230\203\237\312\307	\310	8)\n\"*\211\3131\\	:\205X	@;\205X	A@9\205X	A@\205X\310	8<\205X\314	8<0\202^\210\315)\203w\316!\204w\317!\320\315\f#)\211D\202\235;\203\224\211\300\315\211\321
!\315\211\257+D\202\235:\205\235@D)\207D\207" [type tag attribute dt fname attributes :type plist-get 2 "typedef" :typedef (error) 3 nil semantic-tag-prototype-p semantic-tag-file-name semantic-tag-copy semantic-tag-make-plist class name type-declaration] 7 (#$ . 76598)])
#@159 Replace TAG name according to template specification.
DEF-LIST is the template information.
SPEC-LIST is the template specifier of the datatype instantiated.
(defalias 'semantic-c--instantiate-template #[(tag def-list spec-list) "@\205D	@\205D@\211\305\306\n\307\n8)\"+\310\230\203=\n\211@)@\211@)\230\203=\n	@\211@)\211\f\240*\210\311\nA	A#\207" [def-list spec-list tag attribute name :type plist-get 2 "class" semantic-c--instantiate-template] 5 (#$ . 77390)])
#@117 Return a string used to compute template class name.
Based on SPEC-LIST, for ref<Foo,Bar> it will return `Foo,Bar'.
(defalias 'semantic-c--template-name-1 #[(spec-list) "@\205\304A!\211\205\305@\211@)\n	Q*\207" [spec-list endpart separator tag semantic-c--template-name-1 ","] 4 (#$ . 77878)])
#@146 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>'.
(defalias 'semantic-c--template-name #[(type spec-list) "\211@)\303\304\nA!\305R\207" [type tag spec-list "<" semantic-c--template-name-1 ">"] 5 (#$ . 78189)])
#@173 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.
(defalias 'semantic-c-dereference-template #[(type scope &optional type-declaration) "\3061-	:\205)	@;\205)	A@9\205)	A@\205)\307	8<\205)\310	8<0\202/\210\311)\203\233\n\312\313	\307	8)\"*\314\313	\307	8)\"*\211\203\232\f\203\232\315\n\316\"\211\317\n\f\"\211\240*\210\n\312\311\211\211AA)\211:\203\216\320\321@#!\240\210	,\210\n\322	\323\324#)\210*\nD\207" [type-declaration tag type attribute spec-list def-list (error) 2 3 nil :template plist-get :template-specifier semantic-tag-deep-copy-one-tag #[(tag) "\304\211\211A@)	*=\203\305\n#\210\207" [tag class def-list spec-list type semantic-c--instantiate-template] 5] semantic-c--template-name semantic-tag-make-plist plist-put semantic--tag-put-property :faux-flag t name value plist-cdr] 7 (#$ . 78503)])
#@211 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.
(defalias 'semantic-c-dereference-member-of #[(type scope &optional type-declaration) "\203h	\306\307!!\310\211\203*
@\211
@)\311\230\203#
@\fB
A\211\204\f\237+@\211\203b\312
\313

\314
8)\"*\312
\313

\314
8)\"*D\202fD)\207D\207" [semantic-c-member-of-autocast semantic-case-fold case-fold-search type result tags semantic-something-to-tag-table semantic-analyze-scoped-type-parts nil "->" :type plist-get 2 tag operator attribute type-declaration] 5 (#$ . 79496)])
#@212 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.
(defalias 'semantic-c-dereference-namespace #[(type scope &optional type-declaration) "\306\307\"\310\211\211\211\211\211\3111H:\205D@;\205DA@9\205DA@\205D\3128<\205D\3138<0\202J\210\310)\203\203Z\314!\203\315\211@)!\316\317!!\310\211\203\232\242\206@\211@)\230\203\221@\nBA\211\204w\n\237+\204;\203\321\316!\310\211\203\312\320@\321\"\203\301@\nBA\211\204\262\n\237*\202\373\322@!\211\211\323\324\3128)\"+\321\230\203\371	C\202\373\310\310	\203\n\204	@\325
\"\211\204\326
\"	A\211\204\n\203)\n\211D\202.D.\207" [scope namespaces result usingname tmp currentns 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 typename type-declaration tag type semantic-case-fold case-fold-search tags attribute] 8 (#$ . 80223)])
#@226 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.
(defalias 'semantic-c-dereference-namespace-alias #[(type namespace) "\306\307\n\310\n8)	\"*\311=\205\361\312\211@)!\313\211\211\211\211<\2034\314!\2029C\315\307\n\310\n8)	\"*@\211@)\211\205\360\316!\211\205\360\317\315\307\n\310\n8)	\"*!\313\211\203\231@@\211@)\230\203\220@BA\211\204z\237+\211\205\360\312!
@\320<\203\272\321\"\202\301\321C\"!\206\317\n\211@)\n\211A@)\322\n\310\n8)!\322\n\323\n8)!\n\324\n8)\257*\211-\207" [namespace attribute tag type newtype originaltype :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 nstype ns typename semantic-case-fold case-fold-search result tags name] 7 (#$ . 81557)])
#@165 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.
(defalias 'semantic-c-check-type-namespace-using #[(type namespace) "\306\211\211\211\211\211\211\211\307\310\3118)\"*\211\203\211\312!\306\211\203Y@\211A@)\313=\203P@BA\211\204:\237*\211\203\211\314\211@)!\211<\203w\315!@\203\211\204\211\314@\211@)!@\211\316\310\3118)\"+\211\316\310\3118)\"+\211\317\230\204\307
;\203Q\320
!\211\203(\307\310\3118)\"*\211\203(\312\n!\306\211\203@\211@)\230\203@BA\211\204\372\237+\211\203(\n@\202\200\321\"\211\203\200\211\316\310\3118)\"+\202\200\f\322\230\203\200
<\203\200\315
!@\230\203\200@\211\316\310\3118)\"+A\211\204|.\207" [tmp shortname members unqualifiedname usingtype usingname 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" result usings namespace attribute tag tags type semantic-case-fold case-fold-search] 9 (#$ . 82641)])
#@203 Dereference TYPE as described in `semantic-analyze-dereference-metatype'.
Handle typedef, template instantiation, and `->' operator.

Override semantic-analyze-dereference-metatype in `c-mode' buffers.
(defalias 'semantic-analyze-dereference-metatype-c-mode #[(type scope &optional type-declaration) "\306\211A\242\307	\2035	
#\211@\nA@\f=\204+\307\211\202
\211A\242\211\204,D\207" [dereferencer-list dereferencer type-tuple type original-type scope (semantic-c-dereference-typedef semantic-c-dereference-template semantic-c-dereference-member-of semantic-c-dereference-namespace) nil type-declaration] 5 (#$ . 83944)])
(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)
#@158 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.
(defalias 'semantic-analyze-type-constants-c-mode #[(type) "\211A@)\300=\2050\211\303\304	\305	8)\n\"+\306\230\2050\211\307\304	\305	8)\n\"+\207" [type tag attribute :type plist-get 2 "enum" :members] 4 (#$ . 84892)])
(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)
#@121 Assemble the list of names NAMELIST into a namespace name.

Override semantic-analyze-unsplit-name in `c-mode' buffers.
(defalias 'semantic-analyze-unsplit-name-c-mode #[(namelist) "\301\302\303#\207" [namelist mapconcat identity "::"] 4 (#$ . 85558)])
(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)
#@164 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.
(defalias 'semantic-ctxt-scoped-types-c++-mode #[(&optional point) "\203`b\210\306 \307\211\310p!\307\211\2031
@\211A@)\311=\203*
@\fB
A\211\204\f\237*\310	!\307\211\203S\312
@\313\"\203L
@\fB
A\211\204?\f\237*\310	!\307\211\203}
@\211@)\314\230\203v
@\fB
A\211\204e\f\237+\211\315\316!\317\320	!\211 W\203\300\321\n\322	 \"@\211\323!\324\3258)!\"+C\" T\211 \202\220*\307\"\211#\203\224#@\211\"\211A@)\311=\203@\310\326@!!\307\211\203
@\211A@)\316=\203\373
@\fB
A\211\204\351\f\237*\211\203@	\307$\211#\203<#@\211$\211\323!\324\3258)!\"+\nB#A\211#\204*\202\213\327!@\330%\211\211A@)%*=\203\213\310\331 !\307\211\203{
@\211A@)\316=\203t
@\fB
A\211\204b\f\237*\211\203\213\321\n\332\333	\"\"#A\211#\204\313*\n+\207" [point tmp tagreturn tagsaroundpoint result tags 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 tag semantic-case-fold case-fold-search len idx attribute cur --dolist-tail-- T class] 6 (#$ . 86081)])
(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)
#@120 Return the list of using tag types in scope of POINT.

Override semantic-ctxt-imported-packages in `c++-mode' buffers.
(defalias 'semantic-ctxt-imported-packages-c++-mode #[(&optional point) "\203`b\210\306 \307\211\310p!\307\211\2031
@\211A@)\311=\203*
@\fB
A\211\204\f\237*\211\307\211\203g@\211\211\312\313\3148)\"+\nBA\211\204?*A\203\321\310\315@!!\307\211\203\223
@\211A@)\311=\203\214
@\fB
A\211\204z\f\237*\211\307\211\203\311@\211\211\312\313\3148)\"+\nBA\211\204\241*A\211\202i\n+\207" [point tmp namereturn tagsaroundpoint result tags semantic-find-tag-by-overlay nil semantic-something-to-tag-table using :type plist-get 2 semantic-tag-components tag T --dolist-tail-- attribute] 4 (#$ . 87833)])
(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)
#@174 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.
(defalias 'semanticdb-expand-nested-tag-c++-mode #[(tag) "\306\307\3108)	\"*\211\203\210\311\211\211A@)*=\203\210\312\n!\313\314\315#\f\306\314\211\211AA)\211:\203O\316\317@	#!\240\210,\210
;\203\\
C\202^
\237\320\321!\210
\314\211\203\202@\322\fC\"A\211\204m*\f*\202\211)\207" [tag attribute p class newtag s :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 value plist-cdr namespace --dolist-tail--] 7 (#$ . 88915)])
(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)
#@490 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.
(defalias 'semanticdb-find-table-for-include-c-mode #[(includetag &optional table) "\306	\"\307\310\3118)\n\"*\312\211\211\211\211\211#$%\f&'&\2038'\2038\313'\314\"\204='\202\353&\315=\203:\306\316(\310\3178)(\"*\312\211)*+\320\321+\322\323*)&+!\211\203:	\203:\324
!\312,\211\f\203\232\325\f@\326\"\203\221\f@,B,\fA\211\f\204\200,\237*\211$\203:\313'\314\"\203:$\312-\211.\2039.@-/0\324-\327\310\3118)\n\"*!\312,\211\f\203\373\211@)\f@\211@)\230\203\362\f@,B,\fA\211\f\204\332,\237+\2030-\211@)&\307&1\211\211AA)\2112:\203-2\330\3312@\n1#!\240\210,\210.A\211.\204\267*/0\324\211'!\312,\211\f\203f\325\f@\326\"\203]\f@,B,\fA\211\f\204L,\237*!\312,\211\f\203\222&\f@\211@)\230\203\211\f@,B,\fA\211\f\204t,\237+\204\352\332'\314\"\f&\326\f\312\211)34+\320\321+\333\334\3274\3353@\3363A)&\f-C%\337 \340\f\314%#\210\340\f\341\332'\341\"#\210\340\f\342\332'\342\"#\210\f.\207" [includetag table attribute tag newtable parenttable 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 prefix namespaces newtags inside-ns inctable property attributes system-flag name result cur --dolist-tail-- semantic-case-fold case-fold-search value plist-cdr parents members] 14 (#$ . 89960)])
(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)
#@135 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 #[nil "\306 \307 \211\310\211\211A@)\n*=\205S	\211\211\311\312\3138)\f\",\206S\314\315 !\316\211\203O\317@\320\"\203F@
BA\211\2047
\237*\242\211\203}\321\316\322\323D\324\325\326\327\330&,B\202~+\207" [origvar ct class tag attribute result 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 tags p attributes default-value type name] 10 (#$ . 92354)])
(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)
#@131 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 #[nil "\306 @\211\211;\2056	\n\235?\2056\307!\203\310	\"\2066\307\f!\203,\310	\f\"\2066\307
!\2056\310	
\")\211\203\335\311PJ\312!\211\203`\313\314\"PA\3151\316\316\211\205\311@\317\211A@;\203\210\211A@\262\202\274\320\211\211A@\247\204\232\211AA\262\202\236\211A\262@\262\211\211A@\247\204\262\211AA\262\202\266\211A\262A\262\"\262QA\211\204o\316*0\202\326\210\321P\211\210+\202\337\322 *\207" [sym name 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) nil " " buffer-substring-no-properties "  #error in summary fcn" semantic-idle-summary-current-symbol-info-default spp-sym txt sv arg lt --dolist-tail--] 9 (#$ . 93413)])
(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)
#@253 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.
(defalias 'semantic--tag-similar-names-p-c-mode #[(tag1 tag2 blankok) "\203\303\207\304	\n\305#\207" [blankok tag1 tag2 t semantic--tag-similar-names-p-default nil] 4 (#$ . 94860)])
(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)
#@332 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.
(defalias 'semantic--tag-similar-types-p-c-mode #[(tag1 tag2) "\305	\"\203	\306\207\307\310	D\"\211@G\nA@G\fX\203*\nA@\233\n@\232\2028\fW\2058\f\n@\233\nA@\232+\207" [tag1 tag2 names len1 len2 semantic--tag-similar-types-p-default t mapcar #[(tag) "\211\303\304\3058)	\"+\211;\204\n\211@)\306\n!\211;\203(\nC\n)\207" [tag attribute type :type plist-get 2 semantic-analyze-split-name] 4]] 5 (#$ . 95566)])
(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)
#@136 For c-mode, allow function :arguments to ignore the :name attributes.

Override semantic--tag-attribute-similar-p in `c-mode' buffers.
(defalias 'semantic--tag-attribute-similar-p-c-mode #[(attr value1 value2 ignorable-attributes) "\304=\203\305	\n\306B$\207\305	\n$\207" [attr value1 value2 ignorable-attributes :arguments semantic--tag-attribute-similar-p-default :name] 6 (#$ . 96598)])
(byte-code "\306\307\310\311#\210\312\313\314\315#\210\316\312\317BC\320\315#\210\321\322\315\"\210)\306\317\315\323!\324\204<	\211\262\204<\n\262\205:\325\"\262\203g\211\204g\303N\203V\325\303N\"\211\262\204<\211\326N\206`\211\327N\262\262\202<\266\203\330\331#\210\332\312\333\fBC\320\315#\210\321\334\315\"\210)\306\333\315\323!\324\204\235	\211\262\204\235\n\262\205\233\325\"\262\203\310\211\204\310\303N\203\267\325\303N\"\211\262\204\235\211\326N\206\301\211\327N\262\262\202\235\266\203\330\335#\210\336\312\337
BC\320\315#\210\321\340\315\"\210)\306\337\315\323!\324\204\376	\211\262\204\376\n\262\205\374\325\"\262\203)\211\204)\303N\203\325\303N\"\211\262\204\376\211\326N\206\"\211\327N\262\262\202\376\266\203\330\341#\210\3426\312\3436BC\320\315#\210\321\344\315\"\210)\306\343\315\323!\324\204a	\211\262\204a\n\262\205_\325\"\262\203\214\211\204\214\303N\203{\325\303N\"\211\262\204a\211\326N\206\205\211\327N\262\262\202a\266\203\330\345#\210\3467\312\3477BC\320\315#\210\321\350\315\"\210)\306\347\315\323!\324\204\304	\211\262\204\304\n\262\205\302\325\"\262\203\357\211\204\357\303N\203\336\325\303N\"\211\262\204\304\211\326N\206\350\211\327N\262\262\202\304\266\203\330\351#\210\3528\312\3538BC\320\315#\210\321\354\315\"\210)\306\353\315\323!\324\204'	\211\262\204'\n\262\205%\325\"\262\203R\211\204R\303N\203A\325\303N\"\211\262\204'\211\326N\206K\211\327N\262\262\202'\266\203\330\355#\210\3569\312\3579BC\320\315#\210\321\360\315\"\210)\306\357\315\323!\324\204\212	\211\262\204\212\n\262\205\210\325\"\262\203\265\211\204\265\303N\203\244\325\303N\"\211\262\204\212\211\326N\206\256\211\327N\262\262\202\212\266\203\330\361#\210\362:\312\363:BC\320\315#\210\321\364\315\"\210)\306\363\315\323!\324\204\355	\211\262\204\355\n\262\205\353\325\"\262\203\211\204\303N\203\325\303N\"\211\262\204\355\211\326N\206\211\327N\262\262\202\355\266\203\330\365#\207" [#1=#:tmp0 mode-local-active-mode major-mode mode-local-symbol-table #2=#:tmp0 #3=#:tmp0 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 #[nil "\302\301!\210\211\207" [#1# 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 #[nil "\302\301!\210\211\207" [#2# 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 #[nil "\302\301!\210\211\207" [#3# 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 #[nil "\302\301!\210\211\207" [#4=#:tmp0 imenu-create-index-function make-local-variable] 2] "Imenu index function for C." ("." "->" "::") semantic-type-relation-separator-character #[nil "\302\301!\210\211\207" [#5=#:tmp0 semantic-type-relation-separator-character make-local-variable] 2] "Separator characters between something of a given type, and a field." ";" semantic-command-separation-character #[nil "\302\301!\210\211\207" [#6=#:tmp0 semantic-command-separation-character make-local-variable] 2] "Command separation character for C." #'variable senator-step-at-tag-classes #[nil "\302\301!\210\211\207" [#7=#:tmp0 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 #[nil "\302\301!\210\211\207" [#8=#:tmp0 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." #4# #5# #6# #7# #8#] 9)
#@57 Set up a buffer for semantic parsing of the C language.
(defalias 'semantic-default-c-setup #[nil "\304 \210\305\306\307\310\311\312\313$\210\n\314=\205!\315\235\203\207\315B\211\207" [semantic-lex-syntax-modifications semantic-lex-analyzer major-mode 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 c++-mode ("__cplusplus" . "")] 5 (#$ . 101550)])
#@57 Add a preprocessor symbol SYM with a REPLACEMENT value.
(defalias 'semantic-c-add-preprocessor-symbol #[(sym replacement) "\304	\"\211\203\n\241\210\202B	B)\305 \207" [sym semantic-lex-c-preprocessor-symbol-map SA replacement assoc semantic-c-reset-preprocessor-symbol-map] 4 (#$ . 102044) "sSymbol: \nsReplacement: "])
#@62 Describe the Semantic features of the current C environment.
(defalias 'semantic-c-describe-environment #[nil "\306\307!>\204
\310\311\"\210\312\301!\205	\313 \210r\314\315!q\210p\316 \210\f\317\2118\320\2119\320:;\321 \210\322\323!\210+\211<=\n\203v\324\325!\210\n\317>\211?\203u?@>\324\326!\210\324>@!\210\324\327!\210\324>A!\210?A\211?\204S*\324\330!\210\312\331!\203\371\203\371\324\332\333!!\210<\203\226\202\231C\211@\317A\211?\203\370?@A\324\334!\210\324\335!\210\336A!\211B\204\303\324\337!\210\202\356\324\340!\210B\317C\211?\203\355?@C\324\341!\210\324C!\210\324\342!\210?A\211?\204\322*)?A\211?\204\245+D\203+\324\332\343!!\210D\317C\211?\203*?@C\324\341!\210\324C!\210\324\342!\210?A\211?\204*E\203]\324\332\344!!\210E\317C\211?\203\\?@C\324\341!\210\324C!\210\324\342!\210?A\211?\204A*\324\345!\210F\203\262\324\346!\210F\317G\211?\203\261?@G\324\341!\210\324G!\210\324\342!\210\324\347!\210\350G!\211H\203\237\324\351H!!\210\202\243\324\352!\210)\324\342!\210?A\211?\204u*I\203\355\324\353!\210I\317J\211?\203\354?@J\324\341!\210\324J@!\210\324\327!\210\324JA!\210\324\342!\210?A\211?\204\306*K\203(\324\354!\210K\317J\211?\203'?@J\324\341!\210\324J@!\210\324\327!\210\324JA!\210\324\342!\210?A\211?\204*\312\331!\203\233\203\233\324\355!\210\312\331!\203M\203M\324\356!\210\324\351!!\210\324\357!\210\360L!\203\227\317M\361\362L\"\210M\317J\211?\203\223?@J\324\341!\210\324\363J!!\210\324\327!\210\324JJ!\210\324\342!\210?A\211?\204l+\202\233\324\364!\210\324\365!\210\324\366!\367<!\210,\207" [major-mode semantic-gcc-setup-data gcc default-directory #1=#:old-dir buffer-read-only c-mode mode-local-equivalent-mode-p 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 #[(symbol) "	B\211\207" [symbol macros] 2] 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 buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output P --dolist-tail-- objs O ipath dir semantic-dependency-include-path semantic-dependency-system-include-path semantic-lex-c-preprocessor-symbol-file file fto semantic-lex-c-preprocessor-symbol-map-builtin S semantic-lex-c-preprocessor-symbol-map semantic-lex-spp-project-macro-symbol-obarray macros] 4 (#$ . 102380) nil])
(byte-code "\300\301!\210\302 \207" [provide semantic/bovine/c semantic-c-reset-preprocessor-symbol-map] 2)
Zerion Mini Shell 1.0