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



(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 (#$ . 160))
(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 (#$ . 456))
(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 (#$ . 751))
(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 (#$ . 1126))
(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 (#$ . 1348))
#@234 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.

(fn NAME &rest BODY)
(defalias 'semantic-lex-with-macro-used '(macro . #[385 "\300\301\302\303BBBB\304BB\207" [unwind-protect progn push (semantic-lex-spp-expanded-macro-stack) ((pop semantic-lex-spp-expanded-macro-stack))] 7 (#$ . 1468)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put semantic-lex-with-macro-used lisp-indent-function 1 put edebug-form-spec (symbolp def-body)] 5)
#@169 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.

(fn NAME)
(defalias 'semantic-lex-spp-symbol #[257 "\211;\2050\211\235?\2050\304	!\203\305
	\"\2060\304\n!\203&\305
\n\"\2060\304!\2050\305
\"\207" [semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray obarrayp intern-soft] 4 (#$ . 2092)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put semantic-lex-spp-symbol speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@79 Return non-nil if a keyword with NAME exists in any keyword table.

(fn NAME)
(defalias 'semantic-lex-spp-symbol-p #[257 "\211\211;\2051\211\235?\2051\304	!\203\305
	\"\2061\304\n!\203'\305
\n\"\2061\304!\2051\305
\"\262
\2057\306\207" [semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray obarrayp intern-soft t] 5 (#$ . 2771)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put semantic-lex-spp-symbol-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@54 Return the dynamic macro map for the current buffer.
(defalias 'semantic-lex-spp-dynamic-map #[0 "\206\n\301\302\303\"\211\207" [semantic-lex-spp-dynamic-macro-symbol-obarray make-vector 13 0] 3 (#$ . 3385)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put semantic-lex-spp-dynamic-map speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@54 Return the dynamic macro map for the current buffer.
(defalias 'semantic-lex-spp-dynamic-map-stack #[0 "\206\n\301\302\303\"\211\207" [semantic-lex-spp-dynamic-macro-symbol-obarray-stack make-vector 13 0] 3 (#$ . 3757)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put semantic-lex-spp-dynamic-map-stack speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@47 Return non-nil if VALUE is valid.

(fn VALUE)
(defalias 'semantic-lex-spp-value-valid-p #[257 "\211?\206\211;\206\211:\205\300
@!\206\211@@\301=\207" [semantic-lex-token-p spp-arg-list] 3 (#$ . 4147)])
#@52 A symbol to break on if it is being set somewhere.
(defvar semantic-lex-spp-debug-symbol nil (#$ . 4363))
#@83 Enable debugging for symbol SYM.
Disable debugging by entering nothing.

(fn SYM)
(defalias 'semantic-lex-spp-enable-debug-symbol #[257 "\211\301\230\203\n\302\211\207\211\211\207" [semantic-lex-spp-debug-symbol "" nil] 3 (#$ . 4475) "sSymbol: "])
#@75 Validate the NAME and VALUE of a macro before it is set.

(fn NAME VALUE)
(defalias 'semantic-lex-spp-validate-value '(macro . #[514 "\300\207" [nil] 3 (#$ . 4732)]))
#@185 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.

(fn NAME VALUE &optional OBARRAY-IN)
(defalias 'semantic-lex-spp-symbol-set #[770 "
;\203
\301\230\203\302\262\303\206\206\304\305\306\"\211\"L\207" [semantic-lex-spp-dynamic-macro-symbol-obarray "" nil intern make-vector 13 0] 8 (#$ . 4906)])
#@145 Remove the spp symbol with NAME.
If optional obarray MAP is non-nil, then use that obarray instead of
the dynamic map.

(fn NAME &optional MAP)
(defalias 'semantic-lex-spp-symbol-remove #[513 "\301\206\206\302\303\304\"\211\"\207" [semantic-lex-spp-dynamic-macro-symbol-obarray unintern make-vector 13 0] 7 (#$ . 5318)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put semantic-lex-spp-symbol-remove speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@103 Push macro NAME with VALUE into the map.
Reverse with `semantic-lex-spp-symbol-pop'.

(fn NAME VALUE)
(defalias 'semantic-lex-spp-symbol-push #[514 "\206\n\302\303\304\"\211	\206\302\303\304\"\211\305\"\305\"\306!\205$
J\306!\203;\306!\2044
\307L\210

JBL\210L\207" [semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-dynamic-macro-symbol-obarray-stack make-vector 13 0 intern boundp nil] 10 (#$ . 5810)])
#@108 Pop macro NAME from the stackmap into the orig map.
Reverse with `semantic-lex-spp-symbol-pop'.

(fn NAME)
(defalias 'semantic-lex-spp-symbol-pop #[257 "\206\n\302\303\304\"\211	\206\302\303\304\"\211\305\"\305\"\306
!\203*\211JG\304U\203/\307\"\207

J@L\210\211
JAL\207" [semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-dynamic-macro-symbol-obarray-stack make-vector 13 0 intern boundp unintern] 8 (#$ . 6255)])
#@58 Return replacement stream of macro with NAME.

(fn NAME)
(defalias 'semantic-lex-spp-symbol-stream #[257 "\211\211;\2051\211\235?\2051\304	!\203\305
	\"\2061\304\n!\203'\305
\n\"\2061\304!\2051\305
\"\262
\211\2059\211J\207" [semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray obarrayp intern-soft] 5 (#$ . 6703)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put semantic-lex-spp-symbol-stream speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@248 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.

(fn SPECS)
(defalias 'semantic-lex-make-spp-table #[257 "\301\302\303\"\304
\203@\262
A\262\305
@A#\210\202)\207" [semantic-lex-spp-macro-symbol-obarray make-vector 13 0 nil semantic-lex-spp-symbol-set] 7 (#$ . 7310)])
#@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 #[0 "\301C\302!\203\303\304\305\"\"\210\211\242\207" [semantic-lex-spp-dynamic-macro-symbol-obarray nil obarrayp mapatoms make-closure #[257 "\300\301!JB\300\242B\240\207" [V0 symbol-name] 4 "\n\n(fn SYMBOL)"]] 5 (#$ . 7784)])
#@98 Return a list of spp macros as Lisp symbols.
The value of each symbol is the replacement stream.
(defalias 'semantic-lex-spp-macros #[0 "\303C\304!\203\305\306\307\"\"\210\304	!\203\305\306\310\"	\"\210\304\n!\203,\305\306\311\"\n\"\210\211\242\207" [semantic-lex-spp-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-dynamic-macro-symbol-obarray nil obarrayp mapatoms make-closure #[257 "\300
\300\242B\240\207" [V0] 4 "\n\n(fn SYMBOL)"] #[257 "\300
\300\242B\240\207" [V0] 4 "\n\n(fn SYMBOL)"] #[257 "\300
\300\242B\240\207" [V0] 4 "\n\n(fn SYMBOL)"]] 5 (#$ . 8163)])
#@110 Set the dynamic symbol table to NEW-ENTRIES.
For use with semanticdb restoration of state.

(fn NEW-ENTRIES)
(defalias 'semantic-lex-spp-set-dynamic-table #[257 "\211\211\205\211@\300
@A\"\210
A\266\202\202
\207" [semantic-lex-spp-symbol-set] 6 (#$ . 8784)])
#@152 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.

(fn START END)
(defalias 'semantic-lex-spp-reset-hook #[514 "
eU\205
\303\211\303\211\207" [semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-dynamic-macro-symbol-obarray-stack semantic-lex-spp-expanded-macro-stack nil] 5 (#$ . 9054)])
#@109 Extract a regexp from an ANALYZER and use to match VALUE.
Return non-nil if it matches

(fn ANALYZER VALUE)
(defalias 'semantic-lex-spp-extract-regex-and-compare #[514 "
@\211@\300=\203\211A@\202\301\211\205\302
\"\207" [looking-at nil string-match] 7 (#$ . 9450)])
#@531 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.

(fn VAL BEG END ARGVALUES)
(defalias 'semantic-lex-spp-simple-macro-to-macro-stream #[1028 "\306\"\203M\211\307	!\205\211;\205\310
	\"\262
\211\262\205\"\211J\262
\206(\311BBB\nB\211@\211\211A@\247\204C\211AA\262
\202G\211A\262
A\262
\211\207\306\f\"\203\\\312BBB\207\306
\"\203k\313BBB\207\306\"\203{\314BBB\207\306\"\203\213\315BBB\207\316\207" [semantic-lex-symbol-or-keyword semantic-flex-keywords-obarray semantic-lex-token-stream semantic-lex-end-point semantic-lex-punctuation semantic-lex-number semantic-lex-spp-extract-regex-and-compare obarrayp intern-soft symbol punctuation number semantic-list string nil semantic-lex-paren-or-list semantic-lex-string] 10 (#$ . 9730)])
#@392 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.

(fn TOK &optional BLOCKTOK)
(defalias 'semantic-lex-spp-one-token-to-txt #[513 "
\211A@;\203\211A@\262
\202D\304
\211\211A@\247\204\"\211AA\262
\202&\211A\262
@\262
\211\211A@\247\204:\211AA\262
\202>\211A\262
A\262
\"\262
\305;\203R
\230\203R\207@\306=\203\314
\211;\205\212\211\235?\205\212\307	!\203s\310
	\"\206\212\307\n!\203\200\310
\n\"\206\212\307!\205\212\310
\"\262
\211\262\203\314\311
J!\204\314\211J\211:\203\253\211@9\203\253\312
\"\207\211:\203\303\211@:\203\303\211@@9\203\303\313\314\315#\207\211\204\311\315\207\316 \207
;\203\323
\207\305\207" [semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray buffer-substring-no-properties nil symbol obarrayp intern-soft semantic-lex-spp-macro-with-args semantic-lex-spp-one-token-to-txt mapconcat #[257 "\300
!\207" [semantic-lex-spp-one-token-to-txt] 3 "\n\n(fn SUBTOK)"] "" debug] 9 (#$ . 10966)])
#@76 If the macro value VAL has an argument list, return the arglist.

(fn VAL)
(defalias 'semantic-lex-spp-macro-with-args #[257 "\211\205\211:\205\211@:\205\211@@\300=\205\211@A@\207" [spp-arg-list] 3 (#$ . 12347)])
#@431 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.

(fn VAL BEG END ARGVALUES)
(defalias 'semantic-lex-spp-token-macro-to-macro-stream #[1028 "\306!\307\211\211\310!\211\205\311
\312\"\211\203g\211@\247\2035	\2035\211@\313@!@Y\2035	A\262\n\202\314\315\n\211TBBBB\211@\211\211A@\247\204S\211AA\262
\202W\211A\262
A\262
\nT	\204g\316!\210	\203\245\203\245	@@\317=\203~	A\262\n\211\203\243\211@@\320\"\210

B	B\262	A\262\210
A\266\202\202\202\266	\262\203\210@\262A\262A@\211\211;\205\353\211\235?\205\353\321\f!\203\322\322
\f\"\206\353\321
!\203\337\322

\"\206\353\321#!\205\353\322
#\"\262
\211\205\365\306
J!@\211@\262
\211@\262
\323=\2035
\324!\325
BBBB\211@\211\211A@\247\204(
\211AA\262
\202,
\211A\262
A\262
\266\202\251\211@\262
\325=\203y
\203y

\203N
\211\326=\204R

\204y
\307\203c
\327	@!\262
A\262	\330\216B\331J$\210)\266\202\251\211@\262
\326=\203\310
\203\230
\260
\262\332\333\334\335\f%\210\211@\262
BBBB\211@\211\211A@\247\204\273
\211AA\262
\202\277
\211A\262
A\262
\266\202\251\211@\262
\314=\203\336 \211\205\344
\206\344
\337\"\211\203\326BBB\211@\211\211A@\247\204\211AA\262
\202\211A\262
A\262
\307\262\n\340
\312\313\f!@B#\210\266\202\251\211@\262
\341=\203X\341BBBB\211@\211\211A@\247\204H\211AA\262
\202L\211A\262
A\262
\nS\266\202\251\211@\262
BBBB\211@\211\211A@\247\204{\211AA\262
\202\211A\262
A\262
\266\202\251\211\205\232\211@\342
!\210
A\266\202\202\211\207" [semantic-lex-token-stream semantic-lex-end-point semantic-lex-current-depth semantic-lex-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-with-args nil semantic-lex-spp-get-overlay overlay-get semantic-spp last open-paren "{" delete-overlay spp-arg-list semantic-lex-spp-symbol-push obarrayp intern-soft spp-symbol-merge semantic-lex-spp-symbol-merge symbol semantic-list semantic-lex-spp-stream-for-arglist #[0 "\211A\242\207" [semantic-lex-spp-expanded-macro-stack] 2] semantic-lex-spp-macro-to-macro-stream put-text-property 0 1 macros semantic-lex-spp-find-closing-macro make-overlay overlay-put close-paren semantic-lex-spp-symbol-pop semantic-lex-spp-macro-symbol-obarray] 22 (#$ . 12575)])
#@123 Merge the tokens listed in TXT.
TXT might contain further `spp-symbol-merge', which will
be merged recursively.

(fn TXT)
(defalias 'semantic-lex-spp-symbol-merge #[257 "\300\301\302#\207" [mapconcat #[257 "\211@\300=\203\301
!\207\211@\302=\203\303
A@!\207\304\305!\210\306\207" [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 "\n\n(fn TOK)"] #1#] 5 (#$ . 15296)])
#@106 Find next macro which closes a scope through a close-paren.
Returns position with the end of that macro.
(defalias 'semantic-lex-spp-find-closing-macro #[0 "\301 \302\303
\211\203K\211@\211J\211<\203C\211@<\203C\211\203C\211@@\304=\203<\211@A@\305\230\203<\306!\307Q\262\303\262
\202\211\243\262
\202\210
A\266\202\202\210\211\205`\212\310
\311\312O\313P\303\314#\205_`))\207" [case-fold-search semantic-lex-spp-macros "\\(" nil close-paren "}" symbol-name "\\|" re-search-forward 0 -2 "\\)[^0-9a-zA-Z_]" t] 8 (#$ . 15801)])
#@80 Return first overlay which has a 'semantic-spp property.

(fn &optional POINT)
(defalias 'semantic-lex-spp-get-overlay #[256 "\300
\206`!\211\203\301
@\302\"\204\211A\262
\202\211\242\207" [overlays-at overlay-get semantic-spp] 5 (#$ . 16350)])
#@163 Merge elements from the RAW-STREAM together.
Handle spp-concat symbol concatenation.
Handle Nested macro replacements.
Return the cooked stream.

(fn RAW-STREAM)
(defalias 'semantic-lex-spp-merge-streams #[257 "\300
\203g
@\211@\262
\301=\203Z
A\262\211@@A\262\302D\211\211A@\247\2041\211AA\262
\2025\211A\262
@\262
\211\211A@\247\204I\211AA\262
\202M\211A\262
A\262
BBBB\266\203\202`
@
B\262

A\262\202
\211\237\207" [nil spp-concat spp-symbol-merge] 10 (#$ . 16610)])
#@325 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.

(fn VAL BEG END ARGVALUES)
(defalias 'semantic-lex-spp-macro-to-macro-stream #[1028 "\204\302\207:\203\200@\203\200@9\203\200@\211A@;\203(\211A@\262
\202\\\303
\211\211A@\247\204:\211AA\262
\202>\211A\262
@\262
\211\211A@\247\204R\211AA\262
\202V\211A\262
A\262
\"\262
BBBB\211@\211\211A@\247\204v\211AA\262
\202z\211A\262
A\262
\211\207:\203\237@:\203\237@@\203\237@@9\203\237\304$\207;\205\252\305$\207" [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] 12 (#$ . 17105)])
#@130 Do the lexical replacement for SYM with VAL.
Argument BEG and END specify the bounds of SYM in the buffer.

(fn SYM VAL BEG END)
(defalias 'semantic-lex-spp-analyzer-do-replace #[1028 "\204\211\211\207\301\211\211\302!\262\203J\212b\210\303d!\262
\211\211A@\247\204/\211AA\262
\2023\211A\262
A\262
\262
<\203I
@\304=\203I\305!\262
)\306$\210\211\207" [semantic-lex-end-point 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] 12 (#$ . 18051)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias semantic-lex-spp-anlyzer-do-replace semantic-lex-spp-analyzer-do-replace nil make-obsolete "25.1"] 4)
#@111 Non-nil means do replacements when finding keywords.
Disable this only to prevent recursive expansion issues.
(defvar semantic-lex-spp-replacements-enabled t (#$ . 18818))
#@124 Push lexical tokens for the symbol or keyword STR.
STR occurs in the current buffer between BEG and END.

(fn STR BEG END)
(defalias 'semantic-lex-spp-analyzer-push-tokens-for-symbol #[771 "\306\211\211\203\306
\211\211;\2059\211	\235?\2059\307\n!\203\"\310
\n\"\2069\307!\203/\310
\"\2069\307\f!\2059\310
\f\"\262
\205?\311\262
\203\306
\211;\205u\211	\235?\205u\307\n!\203^\310
\n\"\206u\307!\203k\310
\"\206u\307\f!\205u\310
\f\"\262
\262J\262\312\262
	\313\216	B
\203\274

:\203\274
\314@!\203\274

G\315=\203\274

@\211@\262
\316=\203\274

@\211A@;\203\273\211A@\262
\202\357\317
\211\211A@\247\204\315\211AA\262
\202\321\211A\262
@\262
\211\211A@\247\204\345\211AA\262
\202\351\211A\262
A\262
\"\262
\211\211;\205 
\211	\235?\205 
\307\n!\203	
\310
\n\"\206 
\307!\203
\310
\"\206 
\307\f!\205 
\310
\f\"\262
\205&
\311\262
\203\274
\211\320W\203\274

@\211A@;\203B
\211A@\262
\202v
\317
\211\211A@\247\204T
\211AA\262
\202X
\211A\262
@\262
\211\211A@\247\204l
\211AA\262
\202p
\211A\262
A\262
\"\262
\262\211;\205\251
\211	\235?\205\251
\307\n!\203\222
\310
\n\"\206\251
\307!\203\237
\310
\"\206\251
\307\f!\205\251
\310
\f\"\262
\262J\262\211T\262
	B\202\210\321$*\207\211\307
!\205\327
\211;\205\327
\310

\"\262
\211\262\205\341
\211J\262
\206\347
\316BBB\211@\211\211A@\247\204\211AA\262
\202\211A\262
A\262
\211\207" [semantic-lex-spp-replacements-enabled 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-flex-keywords-obarray nil obarrayp intern-soft t 0 #[0 "\211A\242\207" [semantic-lex-spp-expanded-macro-stack] 2] semantic-lex-token-p 1 symbol buffer-substring-no-properties 10 semantic-lex-spp-analyzer-do-replace semantic-lex-token-stream semantic-lex-end-point] 13 (#$ . 18997)])
#@76 Like `semantic-lex-symbol-or-keyword' plus preprocessor macro replacement.
(defconst semantic-lex-spp-replace-or-symbol-or-keyword '((looking-at "\\(\\sw\\|\\s_\\)+") (let ((str (match-string 0)) (beg (match-beginning 0)) (end (match-end 0)) sppov) (semantic-lex-spp-analyzer-push-tokens-for-symbol str beg end) (when (setq sppov (semantic-lex-spp-get-overlay beg)) (setq semantic-lex-end-point (cdr (overlay-get sppov 'semantic-spp)))))) (#$ . 20904))
#@76 Like `semantic-lex-symbol-or-keyword' plus preprocessor macro replacement.
(defalias 'semantic-lex-spp-replace-or-symbol-or-keyword #[0 "\306``dB\307\310\311!\2031\312\307!\307\224\307\225\306\313#\210\314!\211\262\203/\315
\316\"A\266
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "\\(\\sw\\|\\s_\\)+" match-string semantic-lex-spp-analyzer-push-tokens-for-symbol semantic-lex-spp-get-overlay overlay-get semantic-spp] 8 (#$ . 21363)])
#@235 Detect open parenthesis.
Contrary to `semantic-lex-paren-or-list', this will push a single
open-paren onto the stream if no closing paren can be found.
This is important for macros which open a scope which is closed
by another macro.
(defconst semantic-lex-spp-paren-or-list '((looking-at "\\s(") (if (or (not semantic-lex-maximum-depth) (< semantic-lex-current-depth semantic-lex-maximum-depth)) (progn (setq semantic-lex-current-depth (1+ semantic-lex-current-depth)) (semantic-lex-push-token (semantic-lex-token 'open-paren (match-beginning 0) (match-end 0)))) (save-excursion (let ((start (match-beginning 0)) (end (match-end 0)) (peom (save-excursion (c-end-of-macro) (point)))) (condition-case nil (progn (forward-list 1) (when (> (point) peom) (error "")) (semantic-lex-push-token (semantic-lex-token 'semantic-list start (point)))) (error (semantic-lex-push-token (semantic-lex-token 'open-paren start end)))))))) (#$ . 21952))
#@235 Detect open parenthesis.
Contrary to `semantic-lex-paren-or-list', this will push a single
open-paren onto the stream if no closing paren can be found.
This is important for macros which open a scope which is closed
by another macro.
(defalias 'semantic-lex-spp-paren-or-list #[0 "\306``dB\307\310\311!\203\262	\203\n	W\203F\nT\312\307\224\307\225BB
B\211@\211\211A@\247\204;\211AA\262
\202?\211A\262
A\262
\202\262\212\307\224\307\225\212\313 \210`)\3141\214\315\316!\210`
V\203c\317\320!\210\321`BB
B\211@\211\211A@\247\204}\211AA\262
\202\201\211A\262
A\262
\2110\266\202\261\210\312BB
B\211@\211\211A@\247\204\247\211AA\262
\202\253\211A\262
A\262
\266)
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at "\\s(" open-paren c-end-of-macro (error) forward-list 1 error "" semantic-list] 7 (#$ . 22895)])
#@72 If TOKEN is a semantic-list, turn it into an SPP ARG LIST.

(fn TOKEN)
(defalias 'semantic-lex-spp-first-token-arg-list #[257 "\211:\205d\211@9\205d\211@\300=\205d\301
\211A@;\203#\211A@\262
\202W\302
\211\211A@\247\2045\211AA\262
\2029\211A\262
@\262
\211\211A@\247\204M\211AA\262
\202Q\211A\262
A\262
\"\262
\303\304#
\305\240\210
A
\240\262
\207" [semantic-list split-string buffer-substring-no-properties "[(), ]" t spp-arg-list] 8 (#$ . 23864)])
#@79 Lex up one token, and move to end of that token.
Don't go past MAX.

(fn MAX)
(defalias 'semantic-lex-spp-one-token-and-move-for-macro #[257 "\300`\301\211$\211\204
b\210\302\207\211@\211\211A@\247\204!\211AA\262
\202%\211A\262
A\262
V\203G\211@\211A@\247\204>\211AA\262
\202B\211A\262
\211\241\266\211@\211\211A@\247\204Y\211AA\262
\202]\211A\262
A\262
b\210\211@\207" [semantic-lex 0 nil] 6 (#$ . 24331)])
#@119 Lex up the contents of the arglist TOKEN.
Parsing starts inside the parens, and ends at the end of TOKEN.

(fn TOKEN)
(defalias 'semantic-lex-spp-stream-for-arglist #[257 "\211\211\211A@\247\204\211AA\262
\202\211A\262
A\262
\300\211\212A@;\203s\211A@;\2032\211A@\262
\202f\301
\211\211A@\247\204D\211AA\262
\202H\211A\262
@\262
\211\211A@\247\204\\\211AA\262
\202`\211A\262
A\262
\"\262
\302
\303GSO!\262
\202\266\211\211A@\247\204\204\211AA\262
\202\210\211A\262
@\262
b\210\303u\210\304S!\262
\211\203\263\211@\211\211@\262
\305=\204\254\211B\262
A\266\202\202\227\210\211\237)\207" [nil buffer-substring-no-properties semantic-lex-spp-lex-text-string 1 semantic-lex-spp-stream-for-macro punctuation] 10 (#$ . 24759)])
#@73 Current depth of recursive calls to `semantic-lex-spp-lex-text-string'.
(defvar semantic-lex-spp-hack-depth 0 (#$ . 25513))
#@314 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.

(fn TEXT)
(defalias 'semantic-lex-spp-lex-text-string #[257 "T\304\305\306\"!	\307\211p\310\311V\204\225rq\210\312 \210	=\204S\313 \314\315\"\216\31613 0\210\2024\210\317 \210	\n\236\211\203B\211A \210\210\320\321 \210\322 \210\323\324\325\320#\210)\210\211\211\203i\211@\211\326\"L\210
A\266\202\202T\210c\210eb\210\327d!\262)\211\203\224\211@\211\211@\262
\330>\203\215\211B\262
A\266\202\202x\210\237)\207" [semantic-lex-spp-hack-depth major-mode semantic-new-buffer-setup-functions semantic-new-buffer-fcn-was-run 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 make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] (error) mode-local--activate-bindings t semantic-lex-init semantic-clear-toplevel-cache remove-hook semantic-lex-reset-functions semantic-lex-spp-reset-hook buffer-local-value semantic-lex-spp-stream-for-macro (symbol semantic-list)] 13 (#$ . 25644)])
#@160 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.

(fn EOS)
(defalias 'semantic-lex-spp-stream-for-macro #[257 "\300`W\203\230\301!\211\205R\211\211A@;\203\211A@\262
\202R\302
\211\211A@\247\2040\211AA\262
\2024\211A\262
@\262
\211\211A@\247\204H\211AA\262
\202L\211A\262
A\262
\"\262
\211\203\223
\211@\262

\211\211A@\247\204m\211AA\262
\202q\211A\262
@\262
\211\211A@\247\204\205\211AA\262
\202\211\211A\262
A\262
BBBB\262\266\202

b\210\211\237\207" [nil semantic-lex-spp-one-token-and-move-for-macro buffer-substring-no-properties] 10 (#$ . 27124)])
#@600 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.

(fn NAME DOC REGEXP TOKIDX &rest VALFORM)
(defalias 'define-lex-spp-macro-declaration-analyzer '(macro . #[1156 "\300\301!\300\302!\300\303!\300\304!\300\305!\306\n\n\n\307	\310
DD	\311DD\312B\n\313BD	\314B\257\315\316\f\fE\nE\317\320\321FD\322\323\324\f\fE\324\f\325BBE\326\327\fEE\257\257\207" [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] 24 (#$ . 27808)]))
(put 'define-lex-spp-macro-declaration-analyzer 'edebug-form-spec '(&define name stringp stringp form def-body))
#@375 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.

(fn NAME DOC REGEXP TOKIDX)
(defalias 'define-lex-spp-macro-undeclaration-analyzer '(macro . #[1028 "\300\301!\300\302!\303\304\305	DD\306\nDDD\307\310		ED\311\312\313FDF\257\207" [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] 18 (#$ . 29186)]))
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315&\207" [put define-lex-spp-macro-undeclaration-analyzer edebug-form-spec (&define name stringp stringp form) custom-declare-variable semantic-lex-spp-use-headers-flag funcall function #[0 "\300\207" [nil] 1 ""] "Non-nil means to pre-parse headers as we go.\nFor languages that use the Semantic pre-processor, this can\nimprove the accuracy of parsed files where include files\ncan change the state of what's parsed in the current file.\n\nNote: Not implemented yet." :group semantic :type boolean] 8)
#@198 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.

(fn NAME)
(defalias 'semantic-lex-spp-merge-header #[257 "\300\207" [nil] 2 (#$ . 30540)])
#@789 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.

(fn NAME DOC REGEXP TOKIDX &rest VALFORM)
(defalias 'define-lex-spp-include-analyzer '(macro . #[1156 "\300\301!\300\302!\300\303!\300\304!\300\305!\306\n\n\n\307	\310
DD	\311DD\312B\n\313BD	\314B\257\315\316\nDD\317\320\321\322\323D\324BB\325BB\316D\257D\326\327\330\f\fE\330\f\331BBE\332\333\fEE\257\257\207" [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] 24 (#$ . 30825)]))
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315&\207" [put define-lex-spp-include-analyzer edebug-form-spec (&define name stringp stringp form def-body) custom-declare-variable semantic-lex-spp-macro-max-length-to-save funcall function #[0 "\300\207" [200] 1 ""] "Maximum length of an SPP macro before we opt to not save it." :type integer :group semantic] 8)
#@88 Write out the VALUE of a slot for EIEIO.
The VALUE is a spp lexical table.

(fn VALUE)
(defalias 'semantic-lex-spp-table-write-slot-value #[257 "\211\204\301\302!\207\301\303!\210\211\211\203\231\211@\301\304!\210\305
@!\210\211A@
A
<\204-\306c\266\202\216
@\307=\203@\301\310!\210\305!\210\211A\262
\211\203\214\301\311!\210\211AG\211\312W\203g\3131^\305!0\266\202\216\210\301\314!\266\202\216\211W\203\207\301\315!\210\3161~\305!0\266\202\216\210\301\317!\266\202\216\301\320!\266\266\301\321!\210
A\266\202\202
\210\301\322!\207" [semantic-lex-spp-macro-max-length-to-save princ "nil" "\n        '(" "(" prin1 "nil ;; bogus macro found.\n" spp-arg-list " " " . " 2 (error) "nil ;; Error writing macro\n" "\n              " (error) "nil ;; Error writing macro\n          " "nil ;; Too Long!\n          " ")\n          " ")\n"] 8 (#$ . 32700)])
#@127 Describe the current list of spp macros for BUFFER.
If BUFFER is not provided, use the current buffer.

(fn &optional BUFFER)
(defalias 'semantic-lex-spp-describe #[256 "\212\211\203\211q\210\306 )\307r\310\311!q\210p\312 \210
\307\211\313\211\313\314 \210\315\316!\210+\211\317\320!\210\205a@\262A\262\317\321!!\210\317\322!\210\321!G\323W\203U\317\322!\210\324J!\210\317\325!\210\2022\326!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-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 standard-output] 9 (#$ . 33580) nil])
(provide 'semantic/lex-spp)