%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/cedet/semantic/
Current File : //usr/local/share/emacs/27.2/lisp/cedet/semantic/lex-spp.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 "\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 (#$ . 484))
(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 (#$ . 780))
(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 (#$ . 1075))
(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 (#$ . 1451))
(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 (#$ . 1673))
#@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 (#$ . 1793)]))
(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 obarrayp intern-soft] 3 (#$ . 2502)])
(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 obarrayp intern-soft t] 4 (#$ . 3100)])
(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 (#$ . 3630)])
(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 (#$ . 3930)])
(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 (#$ . 4248)])
#@52 A symbol to break on if it is being set somewhere.
(defvar semantic-lex-spp-debug-symbol nil (#$ . 4450))
#@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 (#$ . 4562) "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 (#$ . 4809)]))
#@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 (#$ . 4975)])
#@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 (#$ . 5398)])
(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 (#$ . 5821)])
#@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 (#$ . 6323)])
#@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 obarrayp intern-soft] 4 (#$ . 6826)])
(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 (#$ . 7352)])
#@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 obarrayp mapatoms #[(symbol) "\302!JB	B\211\207" [symbol macros symbol-name] 2]] 3 (#$ . 7824)])
#@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 obarrayp mapatoms #[(symbol) "	B\211\207" [symbol macros] 2] #[(symbol) "	B\211\207" [symbol macros] 2] #[(symbol) "	B\211\207" [symbol macros] 2]] 3 (#$ . 8174)])
#@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 (#$ . 8727)])
#@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 (#$ . 9028)])
#@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 (#$ . 9421)])
#@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	\"\203N	\211\307\n!\205\211;\205\310\n\"\262\211\262\205\"\211J\262\206(\311	\fBBB
B\211@\211\211A@\247\204C\211AA\262\202G\211A\262A\262\211\207\306	\"\203^\312	\fBBB\207\306	\"\203n\313	\fBBB\207\306	\"\203~\314	\fBBB\207\306	\"\203\216\315	\fBBB\207\316\207" [semantic-lex-symbol-or-keyword val semantic-flex-keywords-obarray beg end semantic-lex-token-stream semantic-lex-spp-extract-regex-and-compare obarrayp intern-soft symbol punctuation number semantic-list string nil semantic-lex-end-point semantic-lex-punctuation semantic-lex-number semantic-lex-paren-or-list semantic-lex-string] 6 (#$ . 9725)])
#@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) "\211A@;\203\211A@\262\202D\306\211\211A@\247\204\"\211AA\262\202&\211A\262@\262\211\211A@\247\204:\211AA\262\202>\211A\262A\262\"\262\307;\203V\n\230\203V\202\361@\310=\203\347\n\211;\205\225\f
\235?\205\225\311!\203z\312\f\"\206\225\311!\203\211\312\f\"\206\225\311!\205\225\312\f\")\211\203\347\313	J!\204\347	J\211:\203\272@9\203\272\314\n\"\202\343:\203\330@:\203\330@@9\203\330\315\316\317#\202\343\204\341\317\202\343\320 )\202\361\n;\203\360\n\202\361\307*\207" [tok sym txt blocktok name semantic-lex-spp-expanded-macro-stack buffer-substring-no-properties nil symbol obarrayp 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-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray val] 7 (#$ . 10970)])
#@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 (#$ . 12395)])
#@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\307\310
!\211#\205\311#\312\"\211$\203r$@\247\203<\203<$@\313@!@Y\203<A\211\204)\314\315
\211TBBB%B\211%@\211\211A@\247\204[\211AA\262\202_\211A\262A\262&'T'\204r\316#!\210\203\274	\203\274@@\317=\203\205A()	\307*\211+\203\273+@*)@,\320*,\"\210*,B\nB)A))+A\211+\204\223+\203\273@A\fA@\211-\211.;\205./\235?\205\3210!\203\356\322.0\"\206\3211!\203\376\322.1\"\206\3212!\205\322.2\")\2113\205\3063J!4@\211@\2625\f\211@\262\323=\203^\324-!6\3256
7BBB%B\211%@\211\211A@\247\204Q\211AA\262\202U\211A\262A\262&)\202\267\f\211@\262\325=\203\2473\203\2474\203y5\326=\204~4\204\247\307)4\203\217\327@!)A\330\216-/B/\3313J
7)$\210*\202\267\f\211@\262\326=\203\364\n\203\304-\260-\332\333\334\335\n-%\210\f\211@\262-
7BBB%B\211%@\211\211A@\247\204\350\211AA\262\202\354\211A\262A\262&\202\267\f\211@\262\314=\203O\336 \2118\205#\206\337
7\"\2119\203K\326
8BB%B\211%@\211\211A@\247\2043\211AA\262\2027\211A\262A\262&\307\3409\312\313\f!@8B#\210*\202\267\f\211@\262\341=\203\212\341-
7BBB%B\211%@\211\211A@\247\204y\211AA\262\202}\211A\262A\262&'S'\202\267\f\211@\262-
7BBB%B\211%@\211\211A@\247\204\256\211AA\262\202\262\211A\262A\262&,\202\276	\307*\211+\205\331+@*\342*!\210+A\211+\204\305\307.\207" [val arglist argalist val-tmp v beg 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 #[nil "\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 sppov sppinfo semantic-lex-token-stream semantic-lex-end-point semantic-lex-current-depth argvalues 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 next-tok-class newsym end endpoint ov] 7 (#$ . 12604)])
#@113 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) "@\301=\203\302!\207@\303=\203\304A@!\207\305\306!\210\307\207" [tok 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=""] 2] #1#] 4 (#$ . 15478)])
#@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 #[nil "\306 \307\310\211\310\211\203Q\f@\211J\211<\203I
@<\203I
\203I
@@\311=\203B
@A@\312\230\203B	\313!\314Q\310\211\202!
\243\211\204$)\fA\211\204*	\205g\212\315\316	\317\320#\321P\310\322#\205f`)+\207" [case-fold-search cmacro-regexp macros cur --dolist-tail-- stream semantic-lex-spp-macros "\\(" nil close-paren "}" symbol-name "\\|" re-search-forward substring 0 -2 "\\)[^0-9a-zA-Z_]" t] 6 (#$ . 15964)])
#@58 Return first overlay which has a 'semantic-spp property.
(defalias 'semantic-lex-spp-get-overlay #[(&optional point) "\302\206`!\211\203\303	@\304\"\204	A\211\204\f	\242)\207" [point overlays overlays-at overlay-get semantic-spp] 4 (#$ . 16558)])
#@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) "\304	\203g	@\211@\262\305=\203[	A@	@A\306\nD\211\211A@\247\2042\211AA\262\2026\211A\262@\262\n\211\211A@\247\204J\211AA\262\202N\211A\262A\262BBBB*\202`	@B	A\211\204\237)\207" [cooked-stream raw-stream next-tok prev-tok nil spp-concat spp-symbol-merge] 7 (#$ . 16822)])
#@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:\203\200@\203\200@9\203\200@\211A@;\203(\211A@\262\202\\\307\211\211A@\247\204:\211AA\262\202>\211A\262@\262\211\211A@\247\204R\211AA\262\202V\211A\262A\262\"\262	\nBBBB\211@\211\211A@\247\204v\211AA\262\202z\211A\262A\262\211\207:\203\237@:\203\237@@\203\237@@9\203\237\310	\n
$\207;\205\252\311	\n
$\207" [val beg end semantic-lex-token-stream semantic-lex-end-point argvalues t buffer-substring-no-properties semantic-lex-spp-token-macro-to-macro-stream semantic-lex-spp-simple-macro-to-macro-stream] 8 (#$ . 17333)])
#@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-analyzer-do-replace #[(sym val beg end) "\204	\211\207\306\211\211\307!\211\203H\212	b\210\310d!\211\211\211A@\247\204/\211AA\262\2023\211A\262A\262\f<\203G\f@\311=\203G\312\f!)\313\f	$\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 beg] 6 (#$ . 18294)])
(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 (#$ . 19083))
#@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\346\f\211\211;\205E
\235?\205E\307!\203*\310
\"\206E\307!\2039\310
\"\206E\307!\205E\310
\")\205J\311)\203\346\f\211;\205\207
\235?\205\207\307!\203l\310
\"\206\207\307!\203{\310
\"\206\207\307!\205\207\310
\")\211J\312\313\216\fB	\203\332	:\203\332\314	@!\203\332	G\315=\203\332	@\211@\262\316=\203\332	@\211A@;\203\315\211A@\262\202\317\211\211A@\247\204\337\211AA\262\202\343\211A\262@\262\211\211A@\247\204\367\211AA\262\202\373\211A\262A\262\"\262\211\211;\205;
\235?\205;\307!\203 \310
\"\206;\307!\203/\310
\"\206;\307!\205;\310
\")\205@\311)\203\332\320W\203\332	@\211A@;\203[\211A@\262\202\217\317\211\211A@\247\204m\211AA\262\202q\211A\262@\262\211\211A@\247\204\205\211AA\262\202\211\211A\262A\262\"\262\211\211;\205\311
\235?\205\311\307!\203\256\310
\"\206\311\307!\203\275\310
\"\206\311\307!\205\311\310
\")\211JT\fB\202\232\321\n	$*\2020\f\211\307!\205\371\211;\205\371\310\"\262\211\262\205\211J\262\206	\316BBB\211@\211\211A@\247\204&\211AA\262\202*\211A\262A\262\211+\207" [count val sym semantic-lex-spp-replacements-enabled str name nil obarrayp intern-soft t 0 #[nil "\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-spp-expanded-macro-stack semantic-lex-spp-dynamic-macro-symbol-obarray semantic-lex-spp-project-macro-symbol-obarray semantic-lex-spp-macro-symbol-obarray beg end semantic-flex-keywords-obarray semantic-lex-token-stream semantic-lex-end-point] 7 (#$ . 19262)])
#@76 Like `semantic-lex-symbol-or-keyword' plus preprocessor macro replacement.
(defvar semantic-lex-spp-replace-or-symbol-or-keyword nil (#$ . 21186))
(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)) 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)))))) #[nil "\306``dB\307\310\311!\203=\312\307!\307\224\307\225\306\313#\210\314!\211\203<\315\316\"A,
-\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 semantic-lex-spp-get-overlay overlay-get semantic-spp sppov end beg str] 5 "Like `semantic-lex-symbol-or-keyword' plus preprocessor macro replacement."]] 2)
#@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.
(defvar semantic-lex-spp-paren-or-list nil (#$ . 22339))
(defalias 'semantic-lex-spp-paren-or-list #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-spp-paren-or-list ((looking-at #1="\\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 (semantic-c-end-of-macro) (point)))) (condition-case nil (progn (forward-list 1) (when (> (point) peom) (error #2="")) (semantic-lex-push-token (semantic-lex-token 'semantic-list start (point)))) (error (semantic-lex-push-token (semantic-lex-token 'open-paren start end)))))))) #[nil "\306``dB\307\310\311!\203\272	\203\n	W\203F\nT\312\307\224\307\225BB
B\211@\211\211A@\247\204;\211AA\262\202?\211A\262A\262\202\272\212\307\224\307\225\212\313 \210`)\3141\222\315\316!\210`V\203j\317\320!\210\321`BB
B\211@\211\211A@\247\204\205\211AA\262\202\211\211A\262A\262\2110\202\270\210\312BB
B\211@\211\211A@\247\204\257\211AA\262\202\263\211A\262A\262\211\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# open-paren semantic-c-end-of-macro (error) forward-list 1 error #2# semantic-list peom end start] 6 "Detect open parenthesis.\nContrary to `semantic-lex-paren-or-list', this will push a single\nopen-paren onto the stream if no closing paren can be found.\nThis is important for macros which open a scope which is closed\nby another macro."]] 2)
#@60 If TOKEN is a semantic-list, turn it into an SPP ARG LIST.
(defalias 'semantic-lex-spp-first-token-arg-list #[(token) ":\205d@9\205d@\302=\205d\303\211A@;\203#\211A@\262\202W\304\211\211A@\247\2045\211AA\262\2029\211A\262@\262\211\211A@\247\204M\211AA\262\202Q\211A\262A\262\"\262\305\306#\307\240\210A	\240)\207" [token argsplit semantic-list split-string buffer-substring-no-properties "[(), ]" t spp-arg-list] 7 (#$ . 24382)])
#@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) "\303`\304\211$\211\204b\210\305\202h	@\211\211A@\247\204$\211AA\262\202(\211A\262A\262V\203K	@\211A@\247\204A\211AA\262\202E\211A\262\211\241\210)	@\211\211A@\247\204]\211AA\262\202a\211A\262A\262b\210	@)\207" [max ans bounds semantic-lex 0 nil] 6 (#$ . 24844)])
#@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\211A@\247\204\211AA\262\202\211A\262A\262\306\211\212A@;\203w\211A@;\2035\211A@\262\202i\307\211\211A@\247\204G\211AA\262\202K\211A\262@\262\211\211A@\247\204_\211AA\262\202c\211A\262A\262\"\262\310\311\f\312\fGS#!)\202\300\211\211A@\247\204\210\211AA\262\202\214\211A\262@\262b\210\312u\210\313S!\211\306\211
\203\275
@\211\211@\262\314=\204\264
	B
A\211
\204\242*	\237,\207" [token toks fresh-toks end txt tok nil buffer-substring-no-properties semantic-lex-spp-lex-text-string substring 1 semantic-lex-spp-stream-for-macro punctuation --dolist-tail--] 7 (#$ . 25272)])
#@73 Current depth of recursive calls to `semantic-lex-spp-lex-text-string'.
(defvar semantic-lex-spp-hack-depth 0 (#$ . 26070))
#@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\211p\312\313V\204\274r	q\210\314 \210\n=\204e\315 \316\216\3171= 0\202A\210\202B\210\320 \210\n\236\211 \203T A \210)\321!\322 \210\323 \210\324\325\326\321#\210*\311\"\211#\203\207#@\211\"\327\"\"L\210#A\211#\204p*$c\210eb\210\330d!)\f\311%\211#\203\273#@\211%\211@\262\331>\203\262%
B#A\211#\204\236*
\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 #[nil "\301\302\"\207" [save-match-data-internal 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) 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] 5 (#$ . 26201)])
#@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) "\304`	W\203\231\305	!\211\205T\n\211A@;\203 \211A@\262\202T\306\211\211A@\247\2042\211AA\262\2026\211A\262@\262\211\211A@\247\204J\211AA\262\202N\211A\262A\262\"\262\211\203\225\n\211@\262\n\211\211A@\247\204p\211AA\262\202t\211A\262@\262\n\211\211A@\247\204\210\211AA\262\202\214\211A\262A\262BBBB*\202	b\210\237)\207" [stream eos tok str nil semantic-lex-spp-one-token-and-move-for-macro buffer-substring-no-properties] 7 (#$ . 27836)])
#@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\fE\nE\325\326\327\fFD\330\331\332	E\332\333BBE\334\335EE\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 (#$ . 28524)]))
#@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 (#$ . 29826)]))
#@250 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: Not implemented yet.
(custom-declare-variable 'semantic-lex-spp-use-headers-flag nil '(#$ . 30620) :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) "\300\207" [nil] 1 (#$ . 30987)])
#@746 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\257D\334\335\336	E\336\337BBE\340\341EE\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 (#$ . 31264)]))
#@62 Maximum length of an SPP macro before we opt to not save it.
(custom-declare-variable 'semantic-lex-spp-macro-max-length-to-save 200 '(#$ . 32791) :type 'integer :group 'semantic)
#@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\230\n@\306\312!\210\313	@!\210	A@	A<\2042\314c\210\202\214@\315=\203D\306\316!\210\313!\210\fA\f\203\214\306\317!\210\fAG\211\320W\203i\3211a\313\f!0\202e\210\306\322!\210\202\213
W\203\207\306\323!\210\3241\313\f!0\202\203\210\306\325!\210\202\213\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 (error) "nil ;; Error writing macro\n" "\n              " (error) "nil ;; Error writing macro\n          " "nil ;; Too Long!\n          " ")\n          " ")\n" semantic-lex-spp-macro-max-length-to-save] 3 (#$ . 32977)])
#@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\203q\210\306 )\307r\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 (#$ . 33858) 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)
Zerion Mini Shell 1.0