WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/cedet/semantic
Viewing File: /usr/share/emacs/24.3/lisp/cedet/semantic/lex-spp.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:57:05 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/cedet/semantic/lex-spp.el
;;; in Emacs version 24.3.1
;;; 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 "\300\301!\210\300\302!\207" [require semantic semantic/lex] 2)
#@160 Table of macro keywords used by the Semantic Preprocessor.
These symbols will be used in addition to those in
`semantic-lex-spp-dynamic-macro-symbol-obarray'.
(defvar semantic-lex-spp-macro-symbol-obarray nil (#$ . 641))
(make-variable-buffer-local 'semantic-lex-spp-macro-symbol-obarray)
#@143 Table of macro keywords for this project.
These symbols will be used in addition to those in
`semantic-lex-spp-dynamic-macro-symbol-obarray'.
(defvar semantic-lex-spp-project-macro-symbol-obarray nil (#$ . 937))
(make-variable-buffer-local 'semantic-lex-spp-project-macro-symbol-obarray)
#@224 Table of macro keywords used during lexical analysis.
Macros are lexical symbols which are replaced by other lexical
tokens during lexical analysis.  During analysis symbols can be
added and removed from this symbol table.
(defvar semantic-lex-spp-dynamic-macro-symbol-obarray nil (#$ . 1232))
(make-variable-buffer-local 'semantic-lex-spp-dynamic-macro-symbol-obarray)
#@58 A stack of obarrays for temporarily scoped macro values.
(defvar semantic-lex-spp-dynamic-macro-symbol-obarray-stack nil (#$ . 1608))
(make-variable-buffer-local 'semantic-lex-spp-dynamic-macro-symbol-obarray-stack)
#@51 The stack of lexical SPP macros we have expanded.
(defvar semantic-lex-spp-expanded-macro-stack nil (#$ . 1830))
#@212 With the macro NAME currently being expanded, execute BODY.
Pushes NAME into the macro stack.  The above stack is checked
by `semantic-lex-spp-symbol' to not return true for any symbol
currently being expanded.
(defalias 'semantic-lex-with-macro-used '(macro . #[(name &rest body) "\302\303\304\305BB	BB\306BB\207" [name body unwind-protect progn push (semantic-lex-spp-expanded-macro-stack) ((pop semantic-lex-spp-expanded-macro-stack))] 5 (#$ . 1950)]))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put semantic-lex-with-macro-used lisp-indent-function 1 add-hook edebug-setup-hook #[nil "\300\301\302\303#\207" [put semantic-lex-with-macro-used edebug-form-spec (symbolp def-body)] 4]] 4)
#@158 Return spp symbol with NAME or nil if not found.
The search priority is:
  1. DYNAMIC symbols
  2. PROJECT specified symbols.
  3. SYSTEM specified symbols.
(defalias 'semantic-lex-spp-symbol #[(name) ";\2050	\235?\2050\305\n!\203\306\n\"\2060\305!\203&\306\"\2060\305\f!\2050\306\f\"\207" [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 arrayp intern-soft] 3 (#$ . 2659)])
(put 'semantic-lex-spp-symbol 'byte-optimizer 'byte-compile-inline-expand)
#@68 Return non-nil if a keyword with NAME exists in any keyword table.
(defalias 'semantic-lex-spp-symbol-p #[(name) "\211;\2052	\235?\2052\305\n!\203\306\n\"\2062\305!\203(\306\"\2062\305\f!\2052\306\f\")\2057\307\207" [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 arrayp intern-soft t] 4 (#$ . 3255)])
(put 'semantic-lex-spp-symbol-p 'byte-optimizer 'byte-compile-inline-expand)
#@54 Return the dynamic macro map for the current buffer.
(defalias 'semantic-lex-spp-dynamic-map #[nil "\206\n\301\302\303\"\211\207" [semantic-lex-spp-dynamic-macro-symbol-obarray make-vector 13 0] 3 (#$ . 3783)])
(put 'semantic-lex-spp-dynamic-map 'byte-optimizer 'byte-compile-inline-expand)
#@54 Return the dynamic macro map for the current buffer.
(defalias 'semantic-lex-spp-dynamic-map-stack #[nil "\206\n\301\302\303\"\211\207" [semantic-lex-spp-dynamic-macro-symbol-obarray-stack make-vector 13 0] 3 (#$ . 4083)])
(put 'semantic-lex-spp-dynamic-map-stack 'byte-optimizer 'byte-compile-inline-expand)
#@35 Return non-nil if VALUE is valid.
(defalias 'semantic-lex-spp-value-valid-p #[(value) "?\206;\206:\205\301@!\206@@\302=\207" [value semantic-lex-token-p spp-arg-list] 2 (#$ . 4401)])
#@52 A symbol to break on if it is being set somewhere.
(defvar semantic-lex-spp-debug-symbol nil (#$ . 4603))
#@73 Enable debugging for symbol SYM.
Disable debugging by entering nothing.
(defalias 'semantic-lex-spp-enable-debug-symbol #[(sym) "\302\230\203\n\303\211\207\211\207" [sym semantic-lex-spp-debug-symbol "" nil] 2 (#$ . 4715) "sSymbol: "])
#@58 Validate the NAME and VALUE of a macro before it is set.
(defalias 'semantic-lex-spp-validate-value '(macro . #[(name value) "\300\207" [nil] 1 (#$ . 4962)]))
#@147 Set value of spp symbol with NAME to VALUE and return VALUE.
If optional OBARRAY-IN is non-nil, then use that obarray instead of
the dynamic map.
(defalias 'semantic-lex-spp-symbol-set #[(name value &optional obarray-in) ";\203
\304\230\203
\305\306	\n\206\206\307\310\311\"\211\"L\207" [value name obarray-in semantic-lex-spp-dynamic-macro-symbol-obarray "" nil intern make-vector 13 0] 5 (#$ . 5128)])
#@116 Remove the spp symbol with NAME.
If optional OBARRAY is non-nil, then use that obarray instead of
the dynamic map.
(defalias 'semantic-lex-spp-symbol-remove #[(name &optional obarray) "\303	\206\n\206\304\305\306\"\211\"\207" [name obarray semantic-lex-spp-dynamic-macro-symbol-obarray unintern make-vector 13 0] 5 (#$ . 5551)])
(put 'semantic-lex-spp-symbol-remove 'byte-optimizer 'byte-compile-inline-expand)
#@86 Push macro NAME with VALUE into the map.
Reverse with `semantic-lex-spp-symbol-pop'.
(defalias 'semantic-lex-spp-symbol-push #[(name value) "\206\n\306\307\310\"\211\n\206\306\307\310\"\211\311\f	\"\311\f\"\f\312
!\205)
J
\312
!\203G\312\f!\204=\f\313L\210\f
\fJBL\210
L-\207" [semantic-lex-spp-dynamic-macro-symbol-obarray map semantic-lex-spp-dynamic-macro-symbol-obarray-stack stack name mapsym make-vector 13 0 intern boundp nil stacksym mapvalue value] 3 (#$ . 5974)])
#@97 Pop macro NAME from the stackmap into the orig map.
Reverse with `semantic-lex-spp-symbol-pop'.
(defalias 'semantic-lex-spp-symbol-pop #[(name) "\206\n\306\307\310\"\211\n\206\306\307\310\"\211\311\f	\"\311\f\"
\312\313
!\2034
JG\310U\203;\314\f	\"\202H

J@L\210
\211JAL-\207" [semantic-lex-spp-dynamic-macro-symbol-obarray map semantic-lex-spp-dynamic-macro-symbol-obarray-stack stack name mapsym make-vector 13 0 intern nil boundp unintern stacksym oldvalue] 3 (#$ . 6476)])
#@47 Return replacement stream of macro with NAME.
(defalias 'semantic-lex-spp-symbol-stream #[(name) "\211;\2052	\235?\2052\306\n!\203\307\n\"\2062\306!\203(\307\"\2062\306\f!\2052\307\f\")\211\205:
J)\207" [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 spp arrayp intern-soft] 4 (#$ . 6979)])
(put 'semantic-lex-spp-symbol-stream 'byte-optimizer 'byte-compile-inline-expand)
#@236 Convert spp macro list SPECS into an obarray and return it.
SPECS must be a list of (NAME . REPLACEMENT) elements, where:

NAME is the name of the spp macro symbol to define.
REPLACEMENT a string that would be substituted in for NAME.
(defalias 'semantic-lex-make-spp-table #[(specs) "\303\304\305\"\306\n\203\n@\nA\307@A	#\210\202	*\207" [spec semantic-lex-spp-macro-symbol-obarray specs make-vector 13 0 nil semantic-lex-spp-symbol-set] 4 (#$ . 7503)])
#@101 Return a list of spp macros and values.
The return list is meant to be saved in a semanticdb table.
(defalias 'semantic-lex-spp-save-table #[nil "\302\303	!\203
\304\305	\"\210)\207" [macros semantic-lex-spp-dynamic-macro-symbol-obarray nil arrayp mapatoms #[(symbol) "\302!JB	B\211\207" [symbol macros symbol-name] 2]] 3 (#$ . 7975)])
#@98 Return a list of spp macros as Lisp symbols.
The value of each symbol is the replacement stream.
(defalias 'semantic-lex-spp-macros #[nil "\304\305	!\203
\306\307	\"\210\305\n!\203\306\310\n\"\210\305!\203#\306\311\"\210)\207" [macros semantic-lex-spp-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-dynamic-macro-symbol-obarray nil arrayp mapatoms #[(symbol) "	B\211\207" [symbol macros] 2] #[(symbol) "	B\211\207" [symbol macros] 2] #[(symbol) "	B\211\207" [symbol macros] 2]] 3 (#$ . 8323)])
#@92 Set the dynamic symbol table to NEW-ENTRIES.
For use with semanticdb restoration of state.
(defalias 'semantic-lex-spp-set-dynamic-table #[(new-entries) "\303\211\205\n@\304	@	A\"\210\nA\211\204\303*\207" [new-entries e --dolist-tail-- nil semantic-lex-spp-symbol-set] 4 (#$ . 8874)])
#@136 Reset anything needed by SPP for parsing.
In this case, reset the dynamic macro symbol table if
START is (point-min).
END is not used.
(defalias 'semantic-lex-spp-reset-hook #[(start end) "eU\205
\304\211\304\211\207" [start semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-dynamic-macro-symbol-obarray-stack semantic-lex-spp-expanded-macro-stack nil] 3 (#$ . 9175)])
#@88 Extract a regexp from an ANALYZER and use to match VALUE.
Return non-nil if it matches
(defalias 'semantic-lex-spp-extract-regex-and-compare #[(analyzer value) "@\211@\304=\203	A@\202\305\211\205\306\n\"*\207" [analyzer condition regex value looking-at nil string-match] 4 (#$ . 9568)])
#@503 Convert lexical macro contents VAL into a macro expansion stream.
These are for simple macro expansions that a user may have typed in directly.
As such, we need to analyze the input text, to figure out what kind of real
lexical token we should be inserting in its place.

Argument VAL is the value of some macro to be converted into a stream.
BEG and END are the token bounds of the macro to be expanded
that will somehow gain a much longer token stream.
ARGVALUES are values for any arg list, or nil.
(defalias 'semantic-lex-spp-simple-macro-to-macro-stream #[(val beg end argvalues) "\306	\"\203Q	\211\307!\205\n;\205\310\n\")\211\205\"\nJ)\206'\311	\f
BBBB\211@\211\211A@\247\204GAA\202JA)A)\211\207\306	\"\203a\312	\f
BBB\207\306	\"\203q\313	\f
BBB\207\306	\"\203\201\314	\f
BBB\207\306	\"\203\221\315	\f
BBB\207\316\207" [semantic-lex-symbol-or-keyword val name semantic-flex-keywords-obarray beg end semantic-lex-spp-extract-regex-and-compare arrayp intern-soft symbol punctuation number semantic-list string nil semantic-lex-token-stream token semantic-lex-end-point semantic-lex-punctuation semantic-lex-number semantic-lex-paren-or-list semantic-lex-string] 5 (#$ . 9872)])
#@363 Convert the token TOK into a string.
If TOK is made of multiple tokens, convert those to text.  This
conversion is needed if a macro has a merge symbol in it that
combines the text of two previously distinct symbols.  For
example, in c:

#define (a,b) a ## b;

If optional string BLOCKTOK matches the expanded value, then do not
continue processing recursively.
(defalias 'semantic-lex-spp-one-token-to-txt #[(tok &optional blocktok) "\211A@;\203	A@\202=\306	\211\211A@\247\204!	AA\202#	A)@)	\211\211A@\247\2047	AA\2029	A)A)\")\307\f;\203P\f\230\203P\f\202\354@\310=\203\342\211;\205\220
\235?\205\220\311!\203u\312
\"\206\220\311!\203\204\312
\"\206\220\311!\205\220\312
\")\211\203\342\313\nJ!\204\342\nJ\211:\203\265@9\203\265\314\"\202\336:\203\323@:\203\323@@9\203\323\315\316\317#\202\336\204\334\317\202\336\320 )\202\354;\203\353\202\354\307*\207" [tok token sym txt blocktok name buffer-substring-no-properties nil symbol arrayp intern-soft semantic-lex-spp-macro-with-args semantic-lex-spp-one-token-to-txt mapconcat #[(subtok) "\301!\207" [subtok semantic-lex-spp-one-token-to-txt] 2] "" debug 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 val] 5 (#$ . 11103)])
#@66 If the macro value VAL has an argument list, return the arglist.
(defalias 'semantic-lex-spp-macro-with-args #[(val) "\205:\205@:\205@@\301=\205@A@\207" [val spp-arg-list] 2 (#$ . 12483)])
#@403 Convert lexical macro contents VAL into a macro expansion stream.
Argument VAL is the value of some macro to be converted into a stream.
BEG and END are the token bounds of the macro to be expanded
that will somehow gain a much longer token stream.
ARGVALUES are values for any arg list, or nil.
See comments in code for information about how token streams are processed
and what valid VAL values are.
(defalias 'semantic-lex-spp-token-macro-to-macro-stream #[(val beg end argvalues) "\306!\307\211\211\211\203GA
\f\307\211\203F@@\310\"\210BBA)A\211\204+\n\203\300\n@\nA	A@\211\211;\205\226\235?\205\226\311!\203y\312\"\206\226\311!\203\211\312\"\206\226\311 !\205\226\312 \")\211!\205\242\306!J!\"\n@\211#@)$	\211#@)\313=\203\356\314!%\315%&'BBB(B\211(@\211#\211#A@\247\204\342#AA\202\345#A)A)))\202\274	\211#@)\315=\2039!\2039\"\203\n$\316=\204\"\2049\307\"\203 \317\n@!\nA\320\216B\321!J&'$\210*\202\274	\211#@)\316=\203\213\203W\260\322\323\324\325%\210	\211#@)&'BBB(B\211(@\211#\211#A@\247\204\200#AA\202\203#A)A))\202\274	\211#@)&'BBB(B\211(@\211#\211#A@\247\204\264#AA\202\267#A)A)),\202I\f\307\211\205\336@\326!\210A\211\204\312\307.\207" [val v val-tmp argalist arglist argvalues semantic-lex-spp-macro-with-args nil semantic-lex-spp-symbol-push arrayp intern-soft spp-symbol-merge semantic-lex-spp-symbol-merge symbol semantic-list semantic-lex-spp-stream-for-arglist ((byte-code "\210A\301\207" [semantic-lex-spp-expanded-macro-stack nil] 1)) semantic-lex-spp-macro-to-macro-stream put-text-property 0 1 macros semantic-lex-spp-symbol-pop AV A --dolist-tail-- argval txt 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 txt-macro-or-nil macro-and-args token next-tok-class newsym beg end semantic-lex-token-stream semantic-lex-end-point] 7 (#$ . 12692)])
#@112 Merge the tokens listed in TXT.
TXT might contain further 'spp-symbol-merge, which will
be merged recursively.
(defalias 'semantic-lex-spp-symbol-merge #[(txt) "\301\302\303#\207" [txt mapconcat #[(tok) "@\302=\203\303!\207@\304=\203\305\211A@)!\207\306\307!\210\310\207" [tok x symbol semantic-lex-spp-one-token-to-txt spp-symbol-merge semantic-lex-spp-symbol-merge message "Invalid merge macro encountered; will return empty string instead." #1=""] 3] #1#] 4 (#$ . 14784)])
#@146 Merge elements from the RAW-STREAM together.
Handle spp-concat symbol concatenation.
Handle Nested macro replacements.
Return the cooked stream.
(defalias 'semantic-lex-spp-merge-streams #[(raw-stream) "\305	\203c	@\211@)\306=\203W	A@	@A\307\fD\f\211\211A@\247\2042\nAA\2024\nA)@)\211\211A@\247\204H\nAA\202J\nA)A)BBBB*\202\\	@B	A\211\204\237)\207" [cooked-stream raw-stream token next-tok prev-tok nil spp-concat spp-symbol-merge] 5 (#$ . 15277)])
#@297 Convert lexical macro contents VAL into a macro expansion stream.
Argument VAL is the value of some macro to be converted into a stream.
BEG and END are the token bounds of the macro to be expanded
that will somehow gain a much longer token stream.
ARGVALUES are values for any arg list, or nil.
(defalias 'semantic-lex-spp-macro-to-macro-stream #[(val beg end argvalues) "\204\306\207:\203x@\203x@9\203x@\211A@;\203'	A@\202U\307	\211\211A@\247\2049	AA\202;	A)@)	\211\211A@\247\204O	AA\202Q	A)A)\")\nBBB\fB\211@\211\211A@\247\204p	AA\202r	A)A)\211\207:\203\230@:\203\230@@\203\230@@9\203\230\310\n\n$\207;\205\244\311\n\n$\207" [val token beg end semantic-lex-token-stream semantic-lex-end-point t buffer-substring-no-properties semantic-lex-spp-token-macro-to-macro-stream semantic-lex-spp-simple-macro-to-macro-stream argvalues] 6 (#$ . 15762)])
#@108 Do the lexical replacement for SYM with VAL.
Argument BEG and END specify the bounds of SYM in the buffer.
(defalias 'semantic-lex-spp-anlyzer-do-replace #[(sym val beg end) "\204	\211\207\306\211\211\307!\211\203J\212	b\210\310d!\211\211\f\211\fA@\247\2042\fAA\2025\fA)A)\f<\203I\f@\311=\203I\312\f!)\313
	$\210	\211+\207" [val end semantic-lex-end-point arg-split arg-parsed arg-in nil semantic-lex-spp-macro-with-args semantic-lex-spp-one-token-and-move-for-macro semantic-list semantic-lex-spp-stream-for-arglist semantic-lex-spp-macro-to-macro-stream token beg] 6 (#$ . 16662)])
#@111 Non-nil means do replacements when finding keywords.
Disable this only to prevent recursive expansion issues.
(defvar semantic-lex-spp-replacements-enabled t (#$ . 17278))
#@106 Push lexical tokens for the symbol or keyword STR.
STR occurs in the current buffer between BEG and END.
(defalias 'semantic-lex-spp-analyzer-push-tokens-for-symbol #[(str beg end) "\306\211\211\203\363\f\211\211;\205E
\235?\205E\307!\203*\310
\"\206E\307!\2039\310
\"\206E\307!\205E\310
\")\205J\311)\203\363\f\211;\205\207
\235?\205\207\307!\203l\310
\"\206\207\307!\203{\310
\"\206\207\307!\205\207\310
\")\211J\312\313\216\fB	\203\347	:\203\347\314	@!\203\347	G\315=\203\347	@\211@)\316=\203\347	@\211A@;\203\317A@\202\317\211\211A@\247\204\345AA\202\350A)@)\211\211A@\247\204AA\202A)A)\")\211\211;\205B
\235?\205B\307!\203'\310
\"\206B\307!\2036\310
\"\206B\307!\205B\310
\")\205G\311)\203\347\320W\203\347	@\211A@;\203cA@\202\233\317\211\211A@\247\204yAA\202|A)@)\211\211A@\247\204\224AA\202\227A)A)\")\211\211;\205\326
\235?\205\326\307!\203\273\310
\"\206\326\307!\203\312\310
\"\206\326\307!\205\326\310
\")\211JT\fB\202\232\321\n	$*\202>\f\211\307!\205
;\205\310
\")\211\205
J)\206\316BBB\211@\211\211A@\247\2045AA\2028A)A)\211+\207" [count val sym semantic-lex-spp-replacements-enabled str name nil arrayp intern-soft t 0 ((byte-code "\210A\301\207" [semantic-lex-spp-expanded-macro-stack nil] 1)) semantic-lex-token-p 1 symbol buffer-substring-no-properties 10 semantic-lex-spp-anlyzer-do-replace 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 token beg end semantic-flex-keywords-obarray semantic-lex-token-stream semantic-lex-end-point] 6 (#$ . 17457)])
#@76 Like 'semantic-lex-symbol-or-keyword' plus preprocessor macro replacement.
(defvar semantic-lex-spp-replace-or-symbol-or-keyword nil (#$ . 19287))
(defalias 'semantic-lex-spp-replace-or-symbol-or-keyword #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-spp-replace-or-symbol-or-keyword ((looking-at #1="\\(\\sw\\|\\s_\\)+") (let ((str (match-string 0)) (beg (match-beginning 0)) (end (match-end 0))) (semantic-lex-spp-analyzer-push-tokens-for-symbol str beg end))) #[nil "\306``dB\307\310\311!\203)\312\307!\307\224\307\225\f
\313
\f#\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# match-string semantic-lex-spp-analyzer-push-tokens-for-symbol end beg str] 5 "Like 'semantic-lex-symbol-or-keyword' plus preprocessor macro replacement."]] 2)
#@60 If TOKEN is a semantic-list, turn it into an SPP ARG LIST.
(defalias 'semantic-lex-spp-first-token-arg-list #[(token) ":\205^@9\205^@\302=\205^\303\211A@;\203\"A@\202P\304\211\211A@\247\2044AA\2026A)@)\211\211A@\247\204JAA\202LA)A)\")\305\306#\307\240\210A	\240)\207" [token argsplit semantic-list split-string buffer-substring-no-properties "[(), ]" t spp-arg-list] 5 (#$ . 20211)])
#@69 Lex up one token, and move to end of that token.
Don't go past MAX.
(defalias 'semantic-lex-spp-one-token-and-move-for-macro #[(max) "\304`\305\211$\211\204b\210\306\202b	@\211\211A@\247\204$\nAA\202&\nA)A)V\203G	@\211A@\247\204>\nAA\202@\nA)\211\241\210)	@\211\211A@\247\204Y\nAA\202[\nA)A)b\210	@)\207" [max ans token bounds semantic-lex 0 nil] 6 (#$ . 20629)])
#@107 Lex up the contents of the arglist TOKEN.
Parsing starts inside the parens, and ends at the end of TOKEN.
(defalias 'semantic-lex-spp-stream-for-arglist #[(token) "\211\211A@\247\204AA\202A)A)\306\211\212A@;\203n\211A@;\2032A@\202`\307\211\211A@\247\204DAA\202FA)@)\211\211A@\247\204ZAA\202\\A)A)\")\310\f\311\fGSO!)\202\265\211\211A@\247\204AA\202\201A)@)b\210\311u\210\312S!\211\306\211\f\203\262\f@\211\211@)\313=\204\251
	B\fA\211\f\204\227*	\237,\207" [token toks fresh-toks end txt tok nil buffer-substring-no-properties semantic-lex-spp-lex-text-string 1 semantic-lex-spp-stream-for-macro punctuation --dolist-tail--] 5 (#$ . 21021)])
#@73 Current depth of recursive calls to `semantic-lex-spp-lex-text-string'.
(defvar semantic-lex-spp-hack-depth 0 (#$ . 21725))
#@303 Lex the text string TEXT using the current buffer's state.
Use this to parse text extracted from a macro as if it came from
the current buffer.  Since the lexer is designed to only work in
a buffer, we need to create a new buffer, and populate it with rules
and variable state from the current buffer.
(defalias 'semantic-lex-spp-lex-text-string #[(text) "T\306\307\310\"!\n\311\211p\312\313V\204\263r	q\210\314 \210\n=\204[\315 \316\216\311\317\320\217\210\321 \210\n \236\211!\203J!A \210)\322\"\323 \210\324 \210\325\326\327\322#\210*\311#\211$\203}$@\211#\330#\"L\210$A\211$\204f*%c\210eb\210\331d!)\f\311&\211$\203\262$@\211&\211'@)\332>\203\251&
B$A\211$\204\224*
\237.\207" [semantic-lex-spp-hack-depth buf major-mode mode fresh-toks toks get-buffer-create format " *SPP parse hack %d*" nil (semantic-lex-spp-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-dynamic-macro-symbol-obarray-stack semantic-lex-spp-expanded-macro-stack) 5 erase-buffer match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) (funcall mode) ((error)) activate-mode-local-bindings t semantic-lex-init semantic-clear-toplevel-cache remove-hook semantic-lex-reset-functions semantic-lex-spp-reset-hook semantic-buffer-local-value semantic-lex-spp-stream-for-macro (symbol semantic-list) origbuff semantic-lex-analyzer analyzer important-vars save-match-data-internal semantic-new-buffer-setup-functions entry semantic-new-buffer-fcn-was-run V --dolist-tail-- text tok token] 5 (#$ . 21856)])
#@150 Lex up a stream of tokens for a #define statement.
Parsing starts at the current point location.
EOS is the end of the stream to lex for this macro.
(defalias 'semantic-lex-spp-stream-for-macro #[(eos) "\305`	W\203\217\306	!\211\205N\n\211A@;\203A@\202M\307\211\211A@\247\2041AA\2023A)@)\211\211A@\247\204GAA\202IA)A)\")\211\203\213\n\211@)\f\n\211\211A@\247\204jAA\202lA)@)\n\211\211A@\247\204\200AA\202\202A)A)BBBB*\202	b\210\237)\207" [stream eos tok token str nil semantic-lex-spp-one-token-and-move-for-macro buffer-substring-no-properties] 5 (#$ . 23512)])
#@557 Define a lexical analyzer for defining new MACROS.
NAME is the name of the analyzer.
DOC is the documentation for the analyzer.
REGEXP is a regular expression for the analyzer to match.
See `define-lex-regex-analyzer' for more on regexp.
TOKIDX is an index into REGEXP for which a new lexical token
of type `spp-macro-def' is to be created.
VALFORM are forms that return the value to be saved for this macro, or nil.
When implementing a macro, you can use `semantic-lex-spp-stream-for-macro'
to convert text into a lexical stream for storage in the macro.
(defalias 'define-lex-spp-macro-declaration-analyzer '(macro . #[(name doc regexp tokidx &rest valform) "\306\307!\306\310!\306\311!\306\312!\306\313!\314
\315\f\316 DD\317 DD	\320B\n\321!BD\322B\257\323\324\fE\nE\325\326\327\fFD\330\331\332	E\332\333BBE\334\335EE\257\257-\207" [endpnt startpnt val end start name make-symbol "start" "end" "val" "startpnt" "endpnt" define-lex-regex-analyzer let match-beginning match-end (semantic-lex-end-point) save-match-data (semantic-lex-end-point) semantic-lex-spp-symbol-set buffer-substring-no-properties semantic-lex-push-token semantic-lex-token 'spp-macro-def when and /= (semantic-lex-end-point) setq semantic-lex-end-point doc regexp tokidx valform] 14 (#$ . 24125)]))
#@346 Undefine a lexical analyzer for defining new MACROS.
NAME is the name of the analyzer.
DOC is the documentation for the analyzer.
REGEXP is a regular expression for the analyzer to match.
See `define-lex-regex-analyzer' for more on regexp.
TOKIDX is an index into REGEXP for which a new lexical token
of type `spp-macro-undef' is to be created.
(defalias 'define-lex-spp-macro-undeclaration-analyzer '(macro . #[(name doc regexp tokidx) "\306\307!\306\310!\311\n\f\312	\313
DD\314
DDD\315\316	ED\317\320\321	FDF\257*\207" [end start name doc regexp tokidx make-symbol "start" "end" define-lex-regex-analyzer let match-beginning match-end semantic-lex-spp-symbol-remove buffer-substring-no-properties semantic-lex-push-token semantic-lex-token 'spp-macro-undef] 12 (#$ . 25427)]))
#@251 *Non-nil means to pre-parse headers as we go.
For languages that use the Semantic pre-processor, this can
improve the accuracy of parsed files where include files
can change the state of what's parsed in the current file.

Note: Note implemented yet
(custom-declare-variable 'semantic-lex-spp-use-headers-flag nil '(#$ . -26221) :group 'semantic :type 'boolean)
#@187 Extract and merge any macros from the header with NAME.
Finds the header file belonging to NAME, gets the macros
from that file, and then merge the macros with our current
symbol table.
(defalias 'semantic-lex-spp-merge-header #[(name) "\210\301\207" [semantic-lex-spp-use-headers-flag nil] 1 (#$ . 26590)])
#@745 Define a lexical analyzer for defining a new INCLUDE lexical token.
Macros defined in the found include will be added to our running table
at the time the include statement is found.
NAME is the name of the analyzer.
DOC is the documentation for the analyzer.
REGEXP is a regular expression for the analyzer to match.
See `define-lex-regex-analyzer' for more on regexp.
TOKIDX is an index into REGEXP for which a new lexical token
of type `spp-macro-include' is to be created.
VALFORM are forms that return the name of the thing being included, and the
type of include.  The return value should be of the form:
  (NAME . TYPE)
where NAME is the name of the include, and TYPE is the type of the include,
where a valid symbol is 'system, or nil.
(defalias 'define-lex-spp-include-analyzer '(macro . #[(name doc regexp tokidx &rest valform) "\306\307!\306\310!\306\311!\306\312!\306\313!\314
\"#\315\f\316$DD\317$DD	\320B\n\321%BD\322B\257\323\324\nDD\325\326\327\330\331\nD\332BB\333BB\f\324\nD\257D\334\335\336	E\336\337BBE\340\341EE\257\257-\207" [endpnt startpnt val end start name make-symbol "start" "end" "val" "startpnt" "endpnt" define-lex-regex-analyzer let match-beginning match-end (semantic-lex-end-point) save-match-data (semantic-lex-end-point) semantic-lex-spp-merge-header car semantic-lex-push-token semantic-lex-token if eq cdr ('system) ('spp-system-include 'spp-include) when and /= (semantic-lex-end-point) setq semantic-lex-end-point doc regexp tokidx valform] 14 (#$ . 26906)]))
#@63 *Maximum length of an SPP macro before we opt to not save it.
(defvar semantic-lex-spp-macro-max-length-to-save 200 (#$ . -28432))
#@76 Write out the VALUE of a slot for EIEIO.
The VALUE is a spp lexical table.
(defalias 'semantic-lex-spp-table-write-slot-value #[(value) "\204\306\307!\207\306\310!\210\311\211\203\202\n@\306\312!\210\313	@!\210	A@	A<\2042\314c\210\202v@\315=\203D\306\316!\210\313!\210\fA\f\203v\306\317!\210\fAG\211\320W\203^\311\321\322\217\210\202u
W\203q\306\323!\210\311\324\325\217\210\202u\306\326!\210)*\306\327!\210\nA\211\204*\306\330!\207" [value sym --dolist-tail-- first rest len princ "nil" "\n        '(" nil "(" prin1 "nil ;; bogus macro found.\n" spp-arg-list " " " . " 2 (prin1 rest) ((error (princ "nil ;; Error writing macro\n"))) "\n              " (prin1 rest) ((error (princ "nil ;; Error writing macro\n          "))) "nil ;; Too Long!\n          " ")\n          " ")\n" semantic-lex-spp-macro-max-length-to-save] 4 (#$ . 28569)])
#@104 Describe the current list of spp macros for BUFFER.
If BUFFER is not provided, use the current buffer.
(defalias 'semantic-lex-spp-describe #[(&optional buffer) "\212\203q\210\306 )\307r\310\311!q\210p\312 \210\f\307\211\313\211\313\314 \210\315\316!\210+\211\317\320!\210\n\205h\n@\nA\317\321	!!\210\317\322!\210\321	!G\323W\203\\\317\322!\210\324	J!\210\317\325!\210\202;\326!\210-\207" [buffer sym syms default-directory #1=#:old-dir buffer-read-only semantic-lex-spp-macros nil get-buffer-create "*SPP MACROS*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook princ "Macro		Value\n" symbol-name "	" 8 prin1 "\n" internal-temp-output-buffer-show buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output] 4 (#$ . 29442) nil])
(byte-code "\300\301\302\"\210\303\304!\207" [add-hook edebug-setup-hook #[nil "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\207" [put define-lex-spp-macro-declaration-analyzer edebug-form-spec (&define name stringp stringp form def-body) define-lex-spp-macro-undeclaration-analyzer (&define name stringp stringp form) define-lex-spp-include-analyzer (&define name stringp stringp form def-body)] 4] provide semantic/lex-spp] 3)
F1l3 Manager
