ikan Uploader :
Directory : /proc/thread-self/root/usr/share/emacs/25.2/lisp/cedet/semantic/
Upload File : |
| Current File : //proc/thread-self/root/usr/share/emacs/25.2/lisp/cedet/semantic/lex.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'semantic/fw)
#@171 Call function FUN on every symbol in TABLE.
If optional PROPERTY is non-nil, call FUN only on every symbol which
as a PROPERTY value. FUN receives a symbol as argument.
(defalias 'semantic-lex-map-symbols #[(fun table &optional property) "\301!\205\n \302\303\"\207" [table arrayp mapatoms #[(symbol) "\203\n N\205
\n !\207" [property symbol fun] 2]] 3 (#$ . 434)])
#@131 Buffer local keyword obarray for the lexical analyzer.
These keywords are matched explicitly, and converted into special symbols.
(defvar semantic-flex-keywords-obarray nil (#$ . 814))
(make-variable-buffer-local 'semantic-flex-keywords-obarray)
#@46 Signal that NAME is an invalid keyword name.
(defalias 'semantic-lex-keyword-invalid '(macro . #[(name) "\301\302\303\304DDE\207" [name signal 'wrong-type-argument quote semantic-lex-keyword-p] 5 (#$ . 1066)]))
#@54 Return keyword symbol with NAME or nil if not found.
(defalias 'semantic-lex-keyword-symbol #[(name) "\302!\205 ;\205 \303 \"\207" [semantic-flex-keywords-obarray name arrayp intern-soft] 3 (#$ . 1284)])
(put 'semantic-lex-keyword-symbol 'byte-optimizer 'byte-compile-inline-expand)
#@90 Return non-nil if a keyword with NAME exists in the keyword table.
Return nil otherwise.
(defalias 'semantic-lex-keyword-p #[(name) "\302 !\205 ;\205 \303 \")\211\205 J\207" [name semantic-flex-keywords-obarray arrayp intern-soft] 3 (#$ . 1578)])
(put 'semantic-lex-keyword-p 'byte-optimizer 'byte-compile-inline-expand)
#@59 Set value of keyword with NAME to VALUE and return VALUE.
(defalias 'semantic-lex-keyword-set #[(name value) "\303 \"\nL\207" [name semantic-flex-keywords-obarray value intern] 3 (#$ . 1914)])
(put 'semantic-lex-keyword-set 'byte-optimizer 'byte-compile-inline-expand)
#@91 Return value of keyword with NAME.
Signal an error if a keyword with NAME does not exist.
(defalias 'semantic-lex-keyword-value #[(name) "\303 !\205 ;\205 \304 \")\211\203 \nJ\202 \305\306\307\")\207" [name semantic-flex-keywords-obarray keyword arrayp intern-soft signal wrong-type-argument (semantic-lex-keyword-p name)] 4 (#$ . 2190)])
(put 'semantic-lex-keyword-value 'byte-optimizer 'byte-compile-inline-expand)
#@51 For keyword with NAME, set its PROPERTY to VALUE.
(defalias 'semantic-lex-keyword-put #[(name property value) "\305 !\205 ;\205 \306 \")\211\203 \307\n \f#\202# \310\311\312\")\207" [name semantic-flex-keywords-obarray keyword property value arrayp intern-soft put signal wrong-type-argument (semantic-lex-keyword-p name)] 5 (#$ . 2622)])
(put 'semantic-lex-keyword-put 'byte-optimizer 'byte-compile-inline-expand)
#@51 For keyword with NAME, return its PROPERTY value.
(defalias 'semantic-lex-keyword-get #[(name property) "\304 !\205 ;\205 \305 \")\211\203 \n N\202! \306\307\310\")\207" [name semantic-flex-keywords-obarray keyword property arrayp intern-soft signal wrong-type-argument (semantic-lex-keyword-p name)] 4 (#$ . 3051)])
(put 'semantic-lex-keyword-get 'byte-optimizer 'byte-compile-inline-expand)
#@369 Convert keyword SPECS into an obarray and return it.
SPECS must be a list of (NAME . TOKSYM) elements, where:
NAME is the name of the keyword symbol to define.
TOKSYM is the lexical token symbol of that keyword.
If optional argument PROPSPECS is non nil, then interpret it, and
apply those properties.
PROPSPECS must be a list of (NAME PROPERTY VALUE) elements.
(defalias 'semantic-lex-make-keyword-table #[(specs &optional propspecs) "\306\307\310\"\311\n\203\" \n@\nA@A \312\f \" L*\210\202
\203c
@
A@A@\3138 \211 \314 !\205I \f;\205I \315\f \")\211 \203Z \316 #\202^ \317\320\321\",\210\202\" *\207" [spec semantic-flex-keywords-obarray specs value name propspecs make-vector 13 0 nil intern 2 arrayp intern-soft put signal wrong-type-argument (semantic-lex-keyword-p name) property keyword] 5 (#$ . 3459)])
#@181 Call function FUN on every lexical keyword.
If optional PROPERTY is non-nil, call FUN only on every keyword which
as a PROPERTY value. FUN receives a lexical keyword as argument.
(defalias 'semantic-lex-map-keywords #[(fun &optional property) "\303 \n#\207" [fun semantic-flex-keywords-obarray property semantic-lex-map-symbols] 4 (#$ . 4307)])
(put 'semantic-lex-map-keywords 'byte-optimizer 'byte-compile-inline-expand)
#@117 Return a list of lexical keywords.
If optional PROPERTY is non-nil, return only keywords which have a
PROPERTY set.
(defalias 'semantic-lex-keywords #[(&optional property) "\304\305 \306\n #*\210)\207" [keywords property fun semantic-flex-keywords-obarray nil #[(symbol) " B\211\207" [symbol keywords] 2] semantic-lex-map-symbols] 4 (#$ . 4738)])
#@92 Fetch the start and end locations of the lexical token TOKEN.
Return a pair (START . END).
(defalias 'semantic-lex-token-bounds #[(token) "A@\247\204 AA\207A\207" [token] 1 (#$ . 5098)])
(put 'semantic-lex-token-bounds 'byte-optimizer 'byte-compile-inline-expand)
#@98 Fetch the start position of the lexical token TOKEN.
See also the function `semantic-lex-token'.
(defalias 'semantic-lex-token-start #[(token) "\211A@\247\204 AA\202 A)@\207" [token] 2 (#$ . 5372)])
(put 'semantic-lex-token-start 'byte-optimizer 'byte-compile-inline-expand)
#@96 Fetch the end position of the lexical token TOKEN.
See also the function `semantic-lex-token'.
(defalias 'semantic-lex-token-end #[(token) "\211A@\247\204 AA\202 A)A\207" [token] 2 (#$ . 5659)])
(put 'semantic-lex-token-end 'byte-optimizer 'byte-compile-inline-expand)
#@254 Inside a lexical analyzer, use this when unterminated syntax was found.
Argument SYNTAX indicates the type of syntax that is unterminated.
The job of this function is to move (point) to a new logical location
so that analysis can continue, if possible.
(defalias 'semantic-lex-unterminated-syntax-detected #[(syntax) " \n@\nA#b\210`\211\207" [semantic-lex-unterminated-syntax-end-function syntax semantic-lex-analysis-bounds semantic-lex-end-point] 4 (#$ . 5941)])
(put 'semantic-lex-unterminated-syntax-detected 'byte-optimizer 'byte-compile-inline-expand)
#@54 Buffer local types obarray for the lexical analyzer.
(defvar semantic-lex-types-obarray nil (#$ . 6507))
(make-variable-buffer-local 'semantic-lex-types-obarray)
#@51 Signal that TYPE is an invalid lexical type name.
(defalias 'semantic-lex-type-invalid '(macro . #[(type) "\301\302\303\304DDE\207" [type signal 'wrong-type-argument quote semantic-lex-type-p] 5 (#$ . 6675)]))
#@46 Return symbol with TYPE or nil if not found.
(defalias 'semantic-lex-type-symbol #[(type) "\302!\205 ;\205 \303 \"\207" [semantic-lex-types-obarray type arrayp intern-soft] 3 (#$ . 6892)])
(put 'semantic-lex-type-symbol 'byte-optimizer 'byte-compile-inline-expand)
#@51 Return non-nil if a symbol with TYPE name exists.
(defalias 'semantic-lex-type-p #[(type) "\302 !\205 ;\205 \303 \")\211\205 J\207" [type semantic-lex-types-obarray arrayp intern-soft] 3 (#$ . 7168)])
(put 'semantic-lex-type-p 'byte-optimizer 'byte-compile-inline-expand)
#@63 Set value of symbol with TYPE name to VALUE and return VALUE.
(defalias 'semantic-lex-type-set #[(type value) "\303 \"\nL\207" [type semantic-lex-types-obarray value intern] 3 (#$ . 7455)])
(put 'semantic-lex-type-set 'byte-optimizer 'byte-compile-inline-expand)
#@162 Return value of symbol with TYPE name.
If optional argument NOERROR is non-nil return nil if a symbol with
TYPE name does not exist. Otherwise signal an error.
(defalias 'semantic-lex-type-value #[(type &optional noerror) "\304 !\205 ;\205 \305 \")\211\203 \nJ\202% ?\205% \306\307\310\")\207" [type semantic-lex-types-obarray sym noerror arrayp intern-soft signal wrong-type-argument (semantic-lex-type-p type)] 4 (#$ . 7726)])
(put 'semantic-lex-type-value 'byte-optimizer 'byte-compile-inline-expand)
#@185 For symbol with TYPE name, set its PROPERTY to VALUE.
If optional argument ADD is non-nil, create a new symbol with TYPE
name if it does not already exist. Otherwise signal an error.
(defalias 'semantic-lex-type-put #[(type property value &optional add) "\306 !\205 ;\205 \307 \")\211\204? \204 \310\311\312\"\210\313 \314 \"\fL*\210\306 !\205= ;\205= \307 \")\315\n
\f#)\207" [type semantic-lex-types-obarray sym add value property arrayp intern-soft signal wrong-type-argument (semantic-lex-type-p type) nil intern put] 5 (#$ . 8247)])
(put 'semantic-lex-type-put 'byte-optimizer 'byte-compile-inline-expand)
#@177 For symbol with TYPE name, return its PROPERTY value.
If optional argument NOERROR is non-nil return nil if a symbol with
TYPE name does not exist. Otherwise signal an error.
(defalias 'semantic-lex-type-get #[(type property &optional noerror) "\305 !\205 ;\205 \306 \")\211\203 \n N\202& \f?\205& \307\310\311\")\207" [type semantic-lex-types-obarray sym property noerror arrayp intern-soft signal wrong-type-argument (semantic-lex-type-p type)] 4 (#$ . 8883)])
(put 'semantic-lex-type-get 'byte-optimizer 'byte-compile-inline-expand)
#@57 Install useful default properties for well known types.
(defalias 'semantic-lex-preset-default-types #[nil "\306\307\310\311\211\312\f!\205 ;\205 \313 \f\")\211 \204G \204( \314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205E ;\205E \313 \f\")\321
\n #-\210\306\322\323\317\211\312\f!\205g ;\205g \313 \f\")\211 \204\225 \204v \314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205\223 ;\205\223 \313 \f\")\321
\n #-\210\324\307\325\311\211\312\f!\205\265 ;\205\265 \313 \f\")\211 \204\343 \204\304 \314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205\341 ;\205\341 \313 \f\")\321
\n #-\210\324\322\326\317\211\312\f!\205 ;\205\313 \f\")\211 \2041\204\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205/ ;\205/\313 \f\")\321
\n #-\210\327\307\330\311\211\312\f!\205Q ;\205Q\313 \f\")\211 \204\204`\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205} ;\205}\313 \f\")\321
\n #-\210\327\322\326\317\211\312\f!\205\237 ;\205\237\313 \f\")\211 \204\315\204\256\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205\313 ;\205\313\313 \f\")\321
\n #-\210\331\307\332\311\211\312\f!\205\355 ;\205\355\313 \f\")\211 \204\204\374\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205 ;\205\313 \f\")\321
\n #-\210\331\322\333\317\211\312\f!\205; ;\205;\313 \f\")\211 \204i\204J\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205g ;\205g\313 \f\")\321
\n #-\210\334\307\330\311\211\312\f!\205\211 ;\205\211\313 \f\")\211 \204\267\204\230\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205\265 ;\205\265\313 \f\")\321
\n #-\210\334\322\335\317\211\312\f!\205\327 ;\205\327\313 \f\")\211 \204\204\346\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205 ;\205\313 \f\")\321
\n #-\210\336\307\337\311\211\312\f!\205% ;\205%\313 \f\")\211 \204S\2044\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205Q ;\205Q\313 \f\")\321
\n #-\210\336\322\340\317\211\312\f!\205s ;\205s\313 \f\")\211 \204\241\204\202\314\315\316\"\210 \317\320 \f\" L*\210 \312\f!\205\237 ;\205\237\313 \f\")\321
\n #-\207" [add value property type semantic-lex-types-obarray sym "punctuation" matchdatatype string t arrayp intern-soft signal wrong-type-argument (semantic-lex-type-p type) nil intern put syntax "\\(\\s.\\|\\s$\\|\\s'\\)+" "keyword" keyword "\\(\\sw\\|\\s_\\)+" "symbol" regexp "string" sexp "\\s\"" "number" semantic-lex-number-expression "block" block "\\s(\\|\\s)"] 5 (#$ . 9434)])
#@484 Convert type SPECS into an obarray and return it.
SPECS must be a list of (TYPE . TOKENS) elements, where:
TYPE is the name of the type symbol to define.
TOKENS is an list of (TOKSYM . MATCHER) elements, where:
TOKSYM is any lexical token symbol.
MATCHER is a string or regexp a text must match to be a such
lexical token.
If optional argument PROPSPECS is non nil, then interpret it, and
apply those properties.
PROPSPECS must be a list of (TYPE PROPERTY VALUE).
(defalias 'semantic-lex-make-type-table #[(specs &optional propspecs) "\306\307\310\"\311\211\311\211 \311\211 \203l @A @ A\311\211 \203W @ A\fA\203A \f
B\202+ \f@\203Q \312\313\n\f$\210\f\202+ \n
\237B \314\n\"L*\210\202 \315 \210\203\336 @A @ A@\316 8\317 \211\320!\205\236 \n;\205\236 \321\n\")\211 \204\321 \204\257 \322\323\324\"\210\n\311 \314\n\"L*\210\n\320!\205\316 \n;\205\316 \321\n\") \325 #-\210\202o .\207" [semantic-lex-types-obarray spec type tokens token alist make-vector 13 0 nil message "*Warning* default value of <%s> tokens changed to %S, was %S" intern semantic-lex-preset-default-types 2 t arrayp intern-soft signal wrong-type-argument (semantic-lex-type-p type) put default specs value propspecs add property sym] 6 (#$ . 11978)])
#@178 Call function FUN on every lexical type.
If optional PROPERTY is non-nil, call FUN only on every type symbol
which as a PROPERTY value. FUN receives a type symbol as argument.
(defalias 'semantic-lex-map-types #[(fun &optional property) "\303 \n#\207" [fun semantic-lex-types-obarray property semantic-lex-map-symbols] 4 (#$ . 13301)])
(put 'semantic-lex-map-types 'byte-optimizer 'byte-compile-inline-expand)
#@123 Return a list of lexical type symbols.
If optional PROPERTY is non-nil, return only type symbols which have
PROPERTY set.
(defalias 'semantic-lex-types #[(&optional property) "\304\305 \306\n #*\210)\207" [types property fun semantic-lex-types-obarray nil #[(symbol) " B\211\207" [symbol types] 2] semantic-lex-map-symbols] 4 (#$ . 13720)])
#@153 The lexical analyzer used for a given buffer.
See `semantic-lex' for documentation.
For compatibility with Semantic 1.x it defaults to `semantic-flex'.
(defvar semantic-lex-analyzer 'semantic-flex (#$ . 14075))
(make-variable-buffer-local 'semantic-lex-analyzer)
#@3101 An alist of semantic token types.
As of December 2001 (semantic 1.4beta13), this variable is not used in
any code. The only use is to refer to the doc-string from elsewhere.
The key to this alist is the symbol representing token type that
\[semantic-flex] returns. These are
- bol: Empty string matching a beginning of line.
This token is produced with
`semantic-lex-beginning-of-line'.
- charquote: String sequences that match `\s\+' regexp.
This token is produced with `semantic-lex-charquote'.
- close-paren: Characters that match `\s)' regexp.
These are typically `)', `}', `]', etc.
This token is produced with
`semantic-lex-close-paren'.
- comment: A comment chunk. These token types are not
produced by default.
This token is produced with `semantic-lex-comments'.
Comments are ignored with `semantic-lex-ignore-comments'.
Comments are treated as whitespace with
`semantic-lex-comments-as-whitespace'.
- newline Characters matching `\s-*\(
\|\s>\)' regexp.
This token is produced with `semantic-lex-newline'.
- open-paren: Characters that match `\s(' regexp.
These are typically `(', `{', `[', etc.
If `semantic-lex-paren-or-list' is used,
then `open-paren' is not usually generated unless
the `depth' argument to \[semantic-lex] is
greater than 0.
This token is always produced if the analyzer
`semantic-lex-open-paren' is used.
- punctuation: Characters matching `{\(\s.\|\s$\|\s'\)'
regexp.
This token is produced with `semantic-lex-punctuation'.
Always specify this analyzer after the comment
analyzer.
- semantic-list: String delimited by matching parenthesis, braces,
etc. that the lexer skipped over, because the
`depth' parameter to \[semantic-flex] was not high
enough.
This token is produced with `semantic-lex-paren-or-list'.
- string: Quoted strings, i.e., string sequences that start
and end with characters matching `\s"'
regexp. The lexer relies on @code{forward-sexp} to
find the matching end.
This token is produced with `semantic-lex-string'.
- symbol: String sequences that match `\(\sw\|\s_\)+'
regexp.
This token is produced with
`semantic-lex-symbol-or-keyword'. Always add this analyzer
after `semantic-lex-number', or other analyzers that
match its regular expression.
- whitespace: Characters that match `\s-+' regexp.
This token is produced with `semantic-lex-whitespace'.
(defvar semantic-lex-tokens '((bol) (charquote) (close-paren) (comment) (newline) (open-paren) (punctuation) (semantic-list) (string) (symbol) (whitespace)) (#$ . 14346))
#@322 Changes to the syntax table for this buffer.
These changes are active only while the buffer is being flexed.
This is a list where each element has the form:
(CHAR CLASS)
CHAR is the char passed to `modify-syntax-entry',
and CLASS is the string also passed to `modify-syntax-entry' to define
what syntax class CHAR has.
(defvar semantic-lex-syntax-modifications nil (#$ . 17624))
(make-variable-buffer-local 'semantic-lex-syntax-modifications)
#@86 Syntax table used by lexical analysis.
See also `semantic-lex-syntax-modifications'.
(defvar semantic-lex-syntax-table nil (#$ . 18075))
(make-variable-buffer-local 'semantic-lex-syntax-table)
#@200 Regular expression for identifying comment start during lexical analysis.
This may be automatically set when semantic initializes in a mode, but
may need to be overridden for some special languages.
(defvar semantic-lex-comment-regex nil (#$ . 18275))
(make-variable-buffer-local 'semantic-lex-comment-regex)
#@553 Regular expression for matching a number.
If this value is nil, no number extraction is done during lex.
This expression tries to match C and Java like numbers.
DECIMAL_LITERAL:
[1-9][0-9]*
;
HEX_LITERAL:
0[xX][0-9a-fA-F]+
;
OCTAL_LITERAL:
0[0-7]*
;
INTEGER_LITERAL:
<DECIMAL_LITERAL>[lL]?
| <HEX_LITERAL>[lL]?
| <OCTAL_LITERAL>[lL]?
;
EXPONENT:
[eE][+-]?[09]+
;
FLOATING_POINT_LITERAL:
[0-9]+[.][0-9]*<EXPONENT>?[fFdD]?
| [.][0-9]+<EXPONENT>?[fFdD]?
| [0-9]+<EXPONENT>[fFdD]?
| [0-9]+<EXPONENT>?[fFdD]
;
(defvar semantic-lex-number-expression "\\(\\<[0-9]+[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>\\|\\<[0-9]+[.][eE][-+]?[0-9]+[fFdD]?\\>\\|\\<[0-9]+[.][fFdD]\\>\\|\\<[0-9]+[.]\\|[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>\\|\\<[0-9]+[eE][-+]?[0-9]+[fFdD]?\\>\\|\\<0[xX][0-9a-fA-F]+[lL]?\\>\\|\\<[0-9]+[lLfFdD]?\\>\\)" (#$ . 18591))
(make-variable-buffer-local 'semantic-lex-number-expression)
#@74 Default lexing depth.
This specifies how many lists to create tokens in.
(defvar semantic-lex-depth 0 (#$ . 19537))
(make-variable-buffer-local 'semantic-lex-depth)
#@466 Function called when unterminated syntax is encountered.
This should be set to one function. That function should take three
parameters. The SYNTAX, or type of syntax which is unterminated.
SYNTAX-START where the broken syntax begins.
LEX-END is where the lexical analysis was asked to end.
This function can be used for languages that can intelligently fix up
broken syntax, or the exit lexical analysis via `throw' or `signal'
when finding unterminated syntax.
(defvar semantic-lex-unterminated-syntax-end-function #[(syntax syntax-start lex-end) "\207" [lex-end] 1] (#$ . 19709))
#@102 Test the semantic lexer in the current buffer.
If universal argument ARG, then try the whole buffer.
(defalias 'semantic-lex-test #[(arg) "\304\305!\210\306 \307 \203 e\202 `d\"\306 \310\311\312 \"\"\210\313\314!\210\304\315!\210\316 \210\317\n!c\210eb+\207" [start arg result end require semantic current-time semantic-lex message "Elapsed Time: %.2f seconds." semantic-elapsed-time pop-to-buffer "*Lexer Output*" pp erase-buffer pp-to-string] 5 (#$ . 20302) "P"])
#@49 When non-nil, debug the local lexical analyzer.
(defvar semantic-lex-debug nil (#$ . 20780))
#@335 Debug the semantic lexer in the current buffer.
Argument ARG specifies of the analyze the whole buffer, or start at point.
While engaged, each token identified by the lexer will be highlighted
in the target buffer A description of the current token will be
displayed in the minibuffer. Press SPC to move to the next lexical token.
(defalias 'semantic-lex-debug #[(arg) "\302\303!\210\304\305 !)\207" [semantic-lex-debug arg require semantic/debug t semantic-lex-test] 2 (#$ . 20880) "P"])
#@106 Highlight the lexical TOKEN.
TOKEN is a lexical token with a START And END position.
Return the overlay.
(defalias 'semantic-lex-highlight-token #[(token) "\302\211\211A@\247\204 AA\202 A)@)\211\211A@\247\204( AA\202* A)A)\"\303 \304\305#\210 )\207" [token o semantic-make-overlay semantic-overlay-put face highlight] 5 (#$ . 21380)])
#@159 Calculate one token from the current buffer at point.
Uses locally bound variables from `define-lex'.
Argument ANALYZERS is the list of analyzers being used.
(defalias 'semantic-lex-one-token '(macro . #[(analyzers) "\301\302\303\"B\207" [analyzers cond mapcar symbol-value] 4 (#$ . 21735)]))
#@53 The end point as tracked through lexical functions.
(defvar semantic-lex-end-point nil (#$ . 22035))
#@57 The current depth as tracked through lexical functions.
(defvar semantic-lex-current-depth nil (#$ . 22142))
#@72 The maximum depth of parenthesis as tracked through lexical functions.
(defvar semantic-lex-maximum-depth nil (#$ . 22257))
#@45 The current token stream we are collecting.
(defvar semantic-lex-token-stream nil (#$ . 22387))
#@37 The bounds of the current analysis.
(defvar semantic-lex-analysis-bounds nil (#$ . 22489))
#@188 Streams of tokens inside collapsed blocks.
This is an alist of (ANCHOR . STREAM) elements where ANCHOR is the
start position of the block, and STREAM is the list of tokens in that
block.
(defvar semantic-lex-block-streams nil (#$ . 22587))
(byte-code "\302\303\304\305#\210\306\305\211\203, @\303N\203% \304N\204% \307\304\303N#\210 A\211\204 *\310\303\304\311#\207" [prop --dolist-tail-- defvaralias semantic-lex-reset-hooks semantic-lex-reset-functions nil (saved-value saved-variable-comment) put make-obsolete-variable "24.3"] 6)
#@204 Abnormal hook used by major-modes to reset lexical analyzers.
Hook functions are called with START and END values for the
current lexical pass. Should be set with `add-hook', specifying
a LOCAL option.
(defvar semantic-lex-reset-functions nil (#$ . 23138))
(defvar semantic-lex-block-stack nil)
#@41 Break during lexical analysis at TOKEN.
(defalias 'semantic-lex-debug-break #[(token) "\205 \304\305\216\n\203 \306\n!\307\310\311\n #!*\207" [semantic-lex-debug o token semantic-lex-current-depth nil #[nil "\205 \301!\207" [o semantic-overlay-delete] 2] semantic-lex-highlight-token semantic-read-event format "%S :: Depth: %d :: SPC - continue"] 5 (#$ . 23440)])
(put 'semantic-lex-debug-break 'byte-optimizer 'byte-compile-inline-expand)
#@649 Create a new lexical analyzer with NAME.
DOC is a documentation string describing this analyzer.
ANALYZERS are small code snippets of analyzers to use when
building the new NAMED analyzer. Only use analyzers which
are written to be used in `define-lex'.
Each analyzer should be an analyzer created with `define-lex-analyzer'.
Note: The order in which analyzers are listed is important.
If two analyzers can match the same text, it is important to order the
analyzers so that the one you want to match first occurs first. For
example, it is good to put a number analyzer in front of a symbol
analyzer which might mistake a number for as a symbol.
(defalias 'define-lex '(macro . #[(name doc &rest analyzers) "\303\304 \305P\306\307\310\311\312\313\314\315\316\"\317BBE\320\321\322\323\324\325\nD\312\326\314\315\327\"\330BBE\331BBBBF\312\332\310\333\323\334\335\315\336\"\337BB\340BBB\341BBBE\342BBBBB\257\207" [name doc analyzers defun (start end &optional depth length) "\nSee `semantic-lex' for more information." (setq semantic-lex-block-streams nil) (run-hook-with-args 'semantic-lex-reset-functions start end) let* ((starting-position (point)) (semantic-lex-token-stream nil) (semantic-lex-block-stack nil) (tmp-start start) (semantic-lex-end-point start) (semantic-lex-current-depth 0) (semantic-lex-maximum-depth (or depth semantic-lex-depth)) (semantic-lex-analysis-bounds (cons start end)) (parse-sexp-lookup-properties nil)) when (> end (point-max)) error format "%s: end (%%d) > point-max (%%d)" (end (point-max)) with-syntax-table semantic-lex-syntax-table (goto-char start) while (and (< (point) end) (or (not length) (<= (length semantic-lex-token-stream) length))) semantic-lex-one-token (eq semantic-lex-end-point tmp-start) "%s: endless loop at %%d, after %%S" (tmp-start (car semantic-lex-token-stream)) ((setq tmp-start semantic-lex-end-point) (goto-char semantic-lex-end-point) (semantic-throw-on-input 'lex) (semantic-lex-debug-break (car semantic-lex-token-stream))) semantic-lex-block-stack ((last (pop semantic-lex-block-stack)) (blk last)) blk message "%s: `%%s' block from %%S is unterminated" ((car blk) (cadr blk)) ((setq blk (pop semantic-lex-block-stack))) ((semantic-lex-unterminated-syntax-detected (car last))) ((goto-char starting-position) (nreverse semantic-lex-token-stream))] 21 (#$ . 23896)]))
#@294 Create a lexical token.
SYMBOL is a symbol representing the class of syntax found.
START and END define the bounds of the token in the current buffer.
Optional STR is the string for the token only if the bounds in
the buffer do not cover the string they represent. (As from
macro expansion.)
(defalias 'semantic-lex-token '(macro . #[(symbol start end &optional str) "\203 \304 \304\304\n EEE\207\304 \304\n EE\207" [str symbol start end cons] 7 (#$ . 26243)]))
#@88 Return non-nil if THING is a semantic lex token.
This is an exhaustively robust check.
(defalias 'semantic-lex-token-p #[(thing) ":\205+ @9\205+ A@\247\203 AA\247\206+ A@;\205+ \3018\247\205+ \302\233\247\207" [thing 2 3] 2 (#$ . 26715)])
#@88 Return non-nil if THING is a semantic lex token.
This is an exhaustively robust check.
(defalias 'semantic-lex-token-with-text-p #[(thing) ":\205$ @9\205$ G\301U\205$ A@;\205$ \3028\247\205$ \3038\247\207" [thing 4 2 3] 2 (#$ . 26968)])
#@88 Return non-nil if THING is a semantic lex token.
This is an exhaustively robust check.
(defalias 'semantic-lex-token-without-text-p #[(thing) ":\205 @9\205 G\301U\205 A@\247\205 \3028\247\207" [thing 3 2] 2 (#$ . 27217)])
#@561 Expand block specifications SPECS into a Lisp form.
SPECS is a list of (BLOCK BEGIN END) elements where BLOCK, BEGIN, and
END are token class symbols that indicate to produce one collapsed
BLOCK token from tokens found between BEGIN and END ones.
BLOCK must be a non-nil symbol, and at least one of the BEGIN or END
symbols must be non-nil too.
When BEGIN is non-nil, generate a call to `semantic-lex-start-block'
when a BEGIN token class is encountered.
When END is non-nil, generate a call to `semantic-lex-end-block' when
an END token class is encountered.
(defalias 'semantic-lex-expand-block-specs #[(specs) "\305\306!\307\n\307\211 \203M \f@\211@\203F A@\203. \310\311 A@D E\312\311 @DDDB\313 8\203F \310\311\313 8D E\314\311 @DDDB\fA\211\204 *\205] \315 \316BC\317\237BEC*\207" [form class specs spec --dolist-tail-- make-symbol "class" nil eq quote semantic-lex-start-block 2 semantic-lex-end-block let ((semantic-lex-token-class (car semantic-lex-token-stream))) cond] 5 (#$ . 27455)])
#@555 Push TOKEN in the lexical analyzer token stream.
Return the lexical analysis current end point.
If optional arguments BLOCKSPECS is non-nil, it specifies to process
collapsed block tokens. See `semantic-lex-expand-block-specs' for
more details.
This macro should only be called within the bounds of
`define-lex-analyzer'. It changes the values of the lexical analyzer
variables `token-stream' and `semantic-lex-end-point'. If you need to
move `semantic-lex-end-point' somewhere else, just modify this
variable after calling `semantic-lex-push-token'.
(defalias 'semantic-lex-push-token '(macro . #[(token &rest blockspecs) "\302\303\304BB\305\306 !\307\"BB\207" [token blockspecs progn push (semantic-lex-token-stream) append semantic-lex-expand-block-specs ((setq semantic-lex-end-point (semantic-lex-token-end (car semantic-lex-token-stream))))] 5 (#$ . 28470)]))
#@89 Fetch the class of the lexical token TOKEN.
See also the function `semantic-lex-token'.
(defalias 'semantic-lex-token-class #[(token) "@\207" [token] 1 (#$ . 29346)])
(put 'semantic-lex-token-class 'byte-optimizer 'byte-compile-inline-expand)
#@101 Fetch the text associated with the lexical token TOKEN.
See also the function `semantic-lex-token'.
(defalias 'semantic-lex-token-text #[(token) "A@;\203 A@\207\301\211\211A@\247\204 AA\202 A)@)\211\211A@\247\2043 AA\2025 A)A)\"\207" [token buffer-substring-no-properties] 5 (#$ . 29597)])
(put 'semantic-lex-token-text 'byte-optimizer 'byte-compile-inline-expand)
#@47 Initialize any lexical state for this buffer.
(defalias 'semantic-lex-init #[nil "\204 \203 \306 \307Q\202 \310\311\312 ! \313 \211 \2052
@\314\f@\fA@\n#\210
A\211\204 \313*\207" [semantic-lex-comment-regex comment-start-skip semantic-lex-syntax-table semantic-lex-syntax-modifications mod --dolist-tail-- "\\(\\s<\\|" "\\)" "\\(\\s<\\)" copy-syntax-table syntax-table nil modify-syntax-entry] 5 (#$ . 29983)])
#@697 Lexically analyze text in the current buffer between START and END.
Optional argument DEPTH indicates at what level to scan over entire
lists. The last argument, LENGTH specifies that `semantic-lex'
should only return LENGTH tokens. The return value is a token stream.
Each element is a list, such of the form
(symbol start-expression . end-expression)
where SYMBOL denotes the token type.
See `semantic-lex-tokens' variable for details on token types. END
does not mark the end of the text scanned, only the end of the
beginning of text scanned. Thus, if a string extends past END, the
end of the return token will be larger than END. To truly restrict
scanning, use `narrow-to-region'.
(defalias 'semantic-lex #[(start end &optional depth length) "\306\211\307\310\211\n\311 !\307 \n\204+ \211\204+ \205* \312
\"\n\203U \f\204U \n\313N\203D \312
\n\313N\"\211\204+ \n\211\314N\206O \n\315N)\211\204/ \f,\211\205h \203f N\205h J+\206\341 \211\316N)\205\341 \211\316N)\307\310\211\n\311 !\307 \n\204\243 \211\204\243 \205\242 \312
\"\n\203\315 \f\204\315 \n\313N\203\274 \312
\n\313N\"\211\204\243 \n\211\314N\206\307 \n\315N)\211\204\247 \f,\211\205\340 \203\336 N\205\340 J+)\211 \203\366 $\202$)\207" [overload property mode symbol bind name semantic-lex nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete mode-local-active-mode major-mode #1=#:override start end depth length semantic-lex-analyzer] 6 (#$ . 30412)])
(put 'semantic-lex 'mode-local-overload t)
#@82 Lex the current buffer.
Optional argument DEPTH is the depth to scan into lists.
(defalias 'semantic-lex-buffer #[(&optional depth) "\301ed#\207" [depth semantic-lex] 4 (#$ . 32038)])
(put 'semantic-lex-buffer 'byte-optimizer 'byte-compile-inline-expand)
#@35 Lex the body of SEMLIST to DEPTH.
(defalias 'semantic-lex-list #[(semlist depth) "\303\211\211A@\247\204 AA\202 A)@)\211\211A@\247\204( AA\202* A)A)\n#\207" [semlist token depth semantic-lex] 5 (#$ . 32300)])
(put 'semantic-lex-list 'byte-optimizer 'byte-compile-inline-expand)
#@62 Mark the last read token as the beginning of a SYNTAX block.
(defalias 'semantic-lex-start-block #[(syntax) "\203\n W\203 T\211\207\n @D\fB\211\207" [semantic-lex-maximum-depth semantic-lex-current-depth syntax semantic-lex-token-stream semantic-lex-block-stack] 2 (#$ . 32596)])
#@402 Process the end of a previously marked SYNTAX block.
That is, collapse the tokens inside that block, including the
beginning and end of block tokens, into a high level block token of
class SYNTAX.
The token at beginning of block is the one marked by a previous call
to `semantic-lex-start-block'. The current token is the end of block.
The collapsed tokens are saved in `semantic-lex-block-streams'.
(defalias 'semantic-lex-end-block #[(syntax) "\204 S\211\207\n\211A\242\211 A\211 @ \211A\242 \n\306 \f@\f=\204C \f@ \f
\f@A#b\210`\211)\202\332 \203] \211A\242\211 =\204]
B\202C =\204m \307\310 \f#\210\f \211 \211 A@\247\204\203 AA\202\206 A)@)\240\210\f
\237\241\210\fB \f\f@\n\211 \211 A@\247\204\261 AA\202\264 A)A)BB\nB\211@\211 \211 A@\247\204\321 AA\202\324 A)A)\211.\207" [semantic-lex-block-stack semantic-lex-current-depth semantic-lex-token-stream stream blk bstream nil error "Token %S not found at beginning of block `%s'" first last tok syntax semantic-lex-unterminated-syntax-end-function semantic-lex-analysis-bounds semantic-lex-end-point token semantic-lex-block-streams] 5 (#$ . 32890)])
#@110 Non nil means to debug analyzers with syntax protection.
Only in effect if `debug-on-error' is also non-nil.
(custom-declare-variable 'semantic-lex-debug-analyzers nil '(#$ . 34071) :group 'semantic :type 'boolean)
#@442 For SYNTAX, execute FORMS with protection for unterminated syntax.
If FORMS throws an error, treat this as a syntax problem, and
execute the unterminated syntax code. FORMS should return a position.
Irregardless of an error, the cursor should be moved to the end of
the desired syntax, and a position returned.
If `debug-on-error' is set, errors are not caught, so that you can
debug them.
Avoid using a large FORMS since it is duplicated.
(defalias 'semantic-lex-unterminated-syntax-protection '(macro . #[(syntax &rest forms) "\302\303\304B\305\306\304B\307\310 DDFF\207" [forms syntax if (and debug-on-error semantic-lex-debug-analyzers) progn condition-case nil error semantic-lex-unterminated-syntax-detected] 9 (#$ . 34293)]))
(put 'semantic-lex-unterminated-syntax-protection 'lisp-indent-function 1)
#@1339 Create a single lexical analyzer NAME with DOC.
When an analyzer is called, the current buffer and point are
positioned in a buffer at the location to be analyzed.
CONDITION is an expression which returns t if FORMS should be run.
Within the bounds of CONDITION and FORMS, the use of backquote
can be used to evaluate expressions at compile time.
While forms are running, the following variables will be locally bound:
`semantic-lex-analysis-bounds' - The bounds of the current analysis.
of the form (START . END)
`semantic-lex-maximum-depth' - The maximum depth of semantic-list
for the current analysis.
`semantic-lex-current-depth' - The current depth of `semantic-list' that has
been descended.
`semantic-lex-end-point' - End Point after match.
Analyzers should set this to a buffer location if their
match string does not represent the end of the matched text.
`semantic-lex-token-stream' - The token list being collected.
Add new lexical tokens to this list.
Proper action in FORMS is to move the value of `semantic-lex-end-point' to
after the location of the analyzed entry, and to add any discovered tokens
at the beginning of `semantic-lex-token-stream'.
This can be done by using `semantic-lex-push-token'.
(defalias 'define-lex-analyzer '(macro . #[(name doc condition &rest forms) "\304\305\306 F\307\310BB\311\312\n BDE\313\312D\314\306 \315\316\317\n BB\320BBBFE\257\207" [name doc condition forms eval-and-compile defvar nil defun (nil) setq quote fset lambda let ((semantic-lex-token-stream nil) (semantic-lex-end-point (point)) (semantic-lex-analysis-bounds (cons (point) (point-max))) (semantic-lex-current-depth 0) (semantic-lex-maximum-depth semantic-lex-depth)) when (semantic-lex-token-stream)] 14 (#$ . 35112)]))
#@166 Create a lexical analyzer with NAME and DOC that will match REGEXP.
FORMS are evaluated upon a successful match.
See `define-lex-analyzer' for more about analyzers.
(defalias 'define-lex-regex-analyzer '(macro . #[(name doc regexp &rest forms) "\304 \305\nD BBBB\207" [name doc regexp forms define-lex-analyzer looking-at] 5 (#$ . 36981)]))
#@445 Create a lexical analyzer with NAME and DOC that match REGEXP.
TOKSYM is the symbol to use when creating a semantic lexical token.
INDEX is the index into the match that defines the bounds of the token.
Index should be a plain integer, and not specified in the macro as an
expression.
FORMS are evaluated upon a successful match BEFORE the new token is
created. It is valid to ignore FORMS.
See `define-lex-analyzer' for more about analyzers.
(defalias 'define-lex-simple-regex-analyzer '(macro . #[(name doc regexp toksym &optional index &rest forms) "\306 \307\nD\310 \311\312\f\313
\206 \314D\315
\206 \314DFDC\"BBBB\207" [name doc regexp forms toksym index define-lex-analyzer looking-at append semantic-lex-push-token semantic-lex-token match-beginning 0 match-end] 12 (#$ . 37330)]))
#@673 Create a lexical analyzer NAME for paired delimiters blocks.
It detects a paired delimiters block or the corresponding open or
close delimiter depending on the value of the variable
`semantic-lex-current-depth'. DOC is the documentation string of the lexical
analyzer. SPEC1 and SPECS specify the token symbols and open, close
delimiters used. Each SPEC has the form:
(BLOCK-SYM (OPEN-DELIM OPEN-SYM) (CLOSE-DELIM CLOSE-SYM))
where BLOCK-SYM is the symbol returned in a block token. OPEN-DELIM
and CLOSE-DELIM are respectively the open and close delimiters
identifying a block. OPEN-SYM and CLOSE-SYM are respectively the
symbols returned in open and close tokens.
(defalias 'define-lex-block-analyzer '(macro . #[(name doc spec1 &rest specs) " B\306\211\211\211 \203. @ A
A@\211@\fA@
@E B\307
8\nB\202\f \310\311\312\313\314\315\316\317\320\321\322 DEE\323B\316\317\320\321\322\nDEE\324BEEEF-\207" [spec1 specs clist olist open spec nil 2 define-lex-analyzer and (looking-at "\\(\\s(\\|\\s)\\)") let ((text (match-string 0)) match) cond setq match assoc text quote ((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 (nth 1 match) (match-beginning 0) (match-end 0)))) (semantic-lex-push-token (semantic-lex-token (nth 2 match) (match-beginning 0) (save-excursion (semantic-lex-unterminated-syntax-protection (nth 2 match) (forward-list 1) (point))))))) ((if (> semantic-lex-current-depth 0) (progn (setq semantic-lex-current-depth (1- semantic-lex-current-depth)) (semantic-lex-push-token (semantic-lex-token (nth 1 match) (match-beginning 0) (match-end 0)))))) name doc] 16 (#$ . 38131)]))
#@100 The default action when no other lexical actions match text.
This action will just throw an error.
(defvar semantic-lex-default-action nil (#$ . 39920))
(defalias 'semantic-lex-default-action #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-default-action (t (error #1="Unmatched Text during Lexical Analysis")) #[nil "\306``dB\307 \310\311!\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 error #1#] 5 "The default action when no other lexical actions match text.\nThis action will just throw an error."]] 2)
#@52 Detect and create a beginning of line token (BOL).
(defvar semantic-lex-beginning-of-line nil (#$ . 40586))
(defalias 'semantic-lex-beginning-of-line #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-beginning-of-line ((and (bolp) (semantic-lex-push-token (semantic-lex-token 'bol (point) (point))) nil) nil) #[nil "\306``dB\307 n\2034 \310``BB
B\211@\211 \211 A@\247\204- AA\2020 A)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 bol token] 6 "Detect and create a beginning of line token (BOL)."]] 2)
#@35 Detect and create newline tokens.
(defvar semantic-lex-newline nil (#$ . 41250))
(defalias 'semantic-lex-newline #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-newline ((looking-at #1="\\s-*\\(\n\\|\\s>\\)") (semantic-lex-push-token (semantic-lex-token 'newline (match-beginning 1) (match-end 1)))) #[nil "\306``dB\307 \310\311!\2038 \312\313\224\313\225BB
B\211@\211 \f\211 \fA@\247\2041 \fAA\2024 \fA)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# newline 1 token] 6 "Detect and create newline tokens."]] 2)
#@175 Detect and create newline tokens.
Use this ONLY if newlines are not whitespace characters (such as when
they are comment end characters) AND when you want whitespace tokens.
(defvar semantic-lex-newline-as-whitespace nil (#$ . 41938))
(defalias 'semantic-lex-newline-as-whitespace #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-newline-as-whitespace ((looking-at #1="\\s-*\\(\n\\|\\s>\\)") (if (eq (semantic-lex-token-class (car semantic-lex-token-stream)) 'whitespace) (setcdr (semantic-lex-token-bounds (car semantic-lex-token-stream)) (match-end 0)) (semantic-lex-push-token (semantic-lex-token 'whitespace (match-beginning 0) (match-end 0))))) #[nil "\306``dB\307 \310\311!\203a
@\211 @)\312=\203;
@\211 A@\247\2040 AA\2023 A)\307\225\241\210\202a \312\307\224\307\225BB
B\211@\211 \211 A@\247\204Z AA\202] A)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# whitespace token] 6 "Detect and create newline tokens.\nUse this ONLY if newlines are not whitespace characters (such as when\nthey are comment end characters) AND when you want whitespace tokens."]] 2)
#@139 Detect and ignore newline tokens.
Use this ONLY if newlines are not whitespace characters (such as when
they are comment end characters).
(defvar semantic-lex-ignore-newline nil (#$ . 43191))
(defalias 'semantic-lex-ignore-newline #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-ignore-newline ((looking-at #1="\\s-*\\(\n\\|\\s>\\)") (setq semantic-lex-end-point (match-end 0))) #[nil "\306``dB\307 \310\311!\203 \307\225
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1#] 5 "Detect and ignore newline tokens.\nUse this ONLY if newlines are not whitespace characters (such as when\nthey are comment end characters)."]] 2)
#@38 Detect and create whitespace tokens.
(defvar semantic-lex-whitespace nil (#$ . 43981))
(defalias 'semantic-lex-whitespace #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-whitespace ((looking-at #1="\\s-+") (if (eq (semantic-lex-token-class (car semantic-lex-token-stream)) 'whitespace) (progn (setq semantic-lex-end-point (match-end 0)) (setcdr (semantic-lex-token-bounds (car semantic-lex-token-stream)) semantic-lex-end-point)) (semantic-lex-push-token (semantic-lex-token 'whitespace (match-beginning 0) (match-end 0))))) #[nil "\306``dB\307 \310\311!\203c
@\211 @)\312=\203= \307\225
@\211 A@\247\2043 AA\2026 A)\f\241\210\202c \312\307\224\307\225BB
B\211@\211 \211 A@\247\204\\ AA\202_ A)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# whitespace token] 6 "Detect and create whitespace tokens."]] 2)
#@41 Detect and skip over whitespace tokens.
(defvar semantic-lex-ignore-whitespace nil (#$ . 44974))
(defalias 'semantic-lex-ignore-whitespace #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-ignore-whitespace ((looking-at #1="\\s-+") (setq semantic-lex-end-point (match-end 0))) #[nil "\306``dB\307 \310\311!\203 \307\225
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1#] 5 "Detect and skip over whitespace tokens."]] 2)
#@124 Detect and create number tokens.
See `semantic-lex-number-expression' for details on matching numbers,
and number formats.
(defvar semantic-lex-number nil (#$ . 45561))
(defalias 'semantic-lex-number #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-number ((looking-at semantic-lex-number-expression) (semantic-lex-push-token (semantic-lex-token 'number (match-beginning 0) (match-end 0)))) #[nil "\306``dB\307 \310\n!\2039 \311\307\224\307\225BB
B\211@\211 \211 A@\247\2042 AA\2025 A)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 number semantic-lex-number-expression token] 6 "Detect and create number tokens.\nSee `semantic-lex-number-expression' for details on matching numbers,\nand number formats."]] 2)
#@46 Detect and create symbol and keyword tokens.
(defvar semantic-lex-symbol-or-keyword nil (#$ . 46448))
(defalias 'semantic-lex-symbol-or-keyword #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-symbol-or-keyword ((looking-at #1="\\(\\sw\\|\\s_\\)+") (semantic-lex-push-token (semantic-lex-token (or (semantic-lex-keyword-p (match-string 0)) 'symbol) (match-beginning 0) (match-end 0)))) #[nil "\306``dB\307 \310\311!\203a \312\307!\211 \313!\205- ;\205- \314\")\211\2057 J)\206< \315\307\224\307\225BB
B\211@\211 \211 A@\247\204Z AA\202] A)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 arrayp intern-soft symbol name semantic-flex-keywords-obarray token] 6 "Detect and create symbol and keyword tokens."]] 2)
#@37 Detect and create charquote tokens.
(defvar semantic-lex-charquote nil (#$ . 47364))
(defalias 'semantic-lex-charquote #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-charquote ((looking-at #1="\\s\\+") (semantic-lex-push-token (semantic-lex-token 'charquote (match-beginning 0) (match-end 0)))) #[nil "\306``dB\307 \310\311!\2038 \312\307\224\307\225BB
B\211@\211 \211 A@\247\2041 AA\2024 A)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# charquote token] 6 "Detect and create charquote tokens."]] 2)
#@39 Detect and create punctuation tokens.
(defvar semantic-lex-punctuation nil (#$ . 48045))
(defalias 'semantic-lex-punctuation #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-punctuation ((looking-at #1="\\(\\s.\\|\\s$\\|\\s'\\)") (semantic-lex-push-token (semantic-lex-token 'punctuation (match-beginning 0) (match-end 0)))) #[nil "\306``dB\307 \310\311!\2038 \312\307\224\307\225BB
B\211@\211 \211 A@\247\2041 AA\2024 A)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# punctuation token] 6 "Detect and create punctuation tokens."]] 2)
#@164 Detect and create a punctuation type token.
Recognized punctuation is defined in the current table of lexical
types, as the value of the `punctuation' token type.
(defvar semantic-lex-punctuation-type nil (#$ . 48759))
(defalias 'semantic-lex-punctuation-type #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-punctuation-type ((and (looking-at #1="\\(\\s.\\|\\s$\\|\\s'\\)+") (let* ((key (match-string 0)) (pos (match-beginning 0)) (end (match-end 0)) (len (- end pos)) (lst (semantic-lex-type-value #2="punctuation" t)) (def (car lst)) (lst (cdr lst)) (elt nil)) (if lst (while (and (> len 0) (not (setq elt (rassoc key lst)))) (setq len (1- len) key (substring key 0 len)))) (if elt (semantic-lex-push-token (semantic-lex-token (car elt) pos (+ pos len))) (if def (semantic-lex-push-token (semantic-lex-token def pos end))))))) #[nil "\306``dB\307 \310\311!\203\357 \312\307! \307\224 \307\225\211 Z \313\314 \211 \315!\205A ;\205A \316\")\211 \203N J\202X ?\205X \317\320\321\"+\211 @ A \306 \203\217 \307V\203\217 \322\"\211 \204\217 S\307O\202l \203\301 @\211\\BB
B\211@\211 \211 A@\247\204\267 AA\202\272 A)A)\202\355 \203\355 BB
B\211@\211 \211 A@\247\204\346 AA\202\351 A)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 #2# t arrayp intern-soft signal wrong-type-argument (semantic-lex-type-p type) rassoc key pos end len noerror type semantic-lex-types-obarray sym lst def elt token] 6 "Detect and create a punctuation type token.\nRecognized punctuation is defined in the current table of lexical\ntypes, as the value of the `punctuation' token type."]] 2)
#@122 Detect open parenthesis.
Return either a paren token or a semantic list token depending on
`semantic-lex-current-depth'.
(defvar semantic-lex-paren-or-list nil (#$ . 50592))
(defalias 'semantic-lex-paren-or-list #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-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)))) (semantic-lex-push-token (semantic-lex-token 'semantic-list (match-beginning 0) (save-excursion (semantic-lex-unterminated-syntax-protection 'semantic-list (forward-list 1) (point))))))) #[nil "\306``dB\307 \310\311!\203\240 \203 \n W\203H \nT\312\307\224\307\225BB
B\211@\211 \211 A@\247\204> AA\202A A)A)\202\240 \313\307\224\212\203^ \203^ \314\315!\210`\202~ \3161k \314\315!\210`0\202~ \210\313 @ A#b\210`\211))BB
B\211@\211 \211 A@\247\204\231 AA\202\234 A)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# open-paren semantic-list forward-list 1 (error) token debug-on-error semantic-lex-debug-analyzers syntax semantic-lex-unterminated-syntax-end-function] 7 "Detect open parenthesis.\nReturn either a paren token or a semantic list token depending on\n`semantic-lex-current-depth'."]] 2)
#@46 Detect and create an open parenthesis token.
(defvar semantic-lex-open-paren nil (#$ . 52153))
(defalias 'semantic-lex-open-paren #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-open-paren ((looking-at #1="\\s(") (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)))) #[nil "\306``dB\307 \310\311!\203; \nT\312\307\224\307\225BB
B\211@\211 \211 A@\247\2044 AA\2027 A)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# open-paren token] 6 "Detect and create an open parenthesis token."]] 2)
#@46 Detect and create a close parenthesis token.
(defvar semantic-lex-close-paren nil (#$ . 52925))
(defalias 'semantic-lex-close-paren #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-close-paren ((looking-at #1="\\s)") (setq semantic-lex-current-depth (1- semantic-lex-current-depth)) (semantic-lex-push-token (semantic-lex-token 'close-paren (match-beginning 0) (match-end 0)))) #[nil "\306``dB\307 \310\311!\203; \nS\312\307\224\307\225BB
B\211@\211 \211 A@\247\2044 AA\2027 A)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# close-paren token] 6 "Detect and create a close parenthesis token."]] 2)
#@35 Detect and create a string token.
(defvar semantic-lex-string nil (#$ . 53702))
(defalias 'semantic-lex-string #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-string ((looking-at #1="\\s\"") (semantic-lex-push-token (semantic-lex-token 'string (point) (save-excursion (semantic-lex-unterminated-syntax-protection 'string (forward-sexp 1) (point)))))) #[nil "\306``dB\307 \310\311!\203i \312`\212\203' \203' \313\314!\210`\202G \31514 \313\314!\210`0\202G \210\312 @ A#b\210`\211))BB
B\211@\211 \211 A@\247\204b AA\202e A)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# string forward-sexp 1 (error) debug-on-error semantic-lex-debug-analyzers syntax semantic-lex-unterminated-syntax-end-function token] 7 "Detect and create a string token."]] 2)
#@36 Detect and create a comment token.
(defvar semantic-lex-comments nil (#$ . 54638))
(defalias 'semantic-lex-comments #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-comments ((looking-at semantic-lex-comment-regex) (save-excursion (forward-comment 1) (if (bolp) (backward-char 1)) (setq semantic-lex-end-point (point)) (if (eq (semantic-lex-token-class (car semantic-lex-token-stream)) 'comment) (setcdr (semantic-lex-token-bounds (car semantic-lex-token-stream)) semantic-lex-end-point) (semantic-lex-push-token (semantic-lex-token 'comment (match-beginning 0) semantic-lex-end-point))))) #[nil "\306``dB\307 \310
!\203o \212\311\312!\210n\203 \313u\210`
@\211 @)\314=\203I
@\211 A@\247\204? AA\202B A)\f\241\210\202n \314\307\224\fBB
B\211@\211 \211 A@\247\204g AA\202j A)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 forward-comment 1 -1 comment semantic-lex-comment-regex token] 6 "Detect and create a comment token."]] 2)
#@48 Detect comments and create a whitespace token.
(defvar semantic-lex-comments-as-whitespace nil (#$ . 55752))
(defalias 'semantic-lex-comments-as-whitespace #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-comments-as-whitespace ((looking-at semantic-lex-comment-regex) (save-excursion (forward-comment 1) (if (bolp) (backward-char 1)) (setq semantic-lex-end-point (point)) (if (eq (semantic-lex-token-class (car semantic-lex-token-stream)) 'whitespace) (setcdr (semantic-lex-token-bounds (car semantic-lex-token-stream)) semantic-lex-end-point) (semantic-lex-push-token (semantic-lex-token 'whitespace (match-beginning 0) semantic-lex-end-point))))) #[nil "\306``dB\307 \310
!\203o \212\311\312!\210n\203 \313u\210`
@\211 @)\314=\203I
@\211 A@\247\204? AA\202B A)\f\241\210\202n \314\307\224\fBB
B\211@\211 \211 A@\247\204g AA\202j A)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 forward-comment 1 -1 whitespace semantic-lex-comment-regex token] 6 "Detect comments and create a whitespace token."]] 2)
#@36 Detect and create a comment token.
(defvar semantic-lex-ignore-comments nil (#$ . 56941))
(defalias 'semantic-lex-ignore-comments #[nil "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-ignore-comments ((looking-at semantic-lex-comment-regex) (let ((comment-start-point (point))) (forward-comment 1) (if (eq (point) comment-start-point) (skip-syntax-forward #1="-.'" (point-at-eol)) (if (bolp) (backward-char 1))) (if (eq (point) comment-start-point) (error #2="Strange comment syntax prevents lexical analysis")) (setq semantic-lex-end-point (point)))) #[nil "\306``dB\307 \310!\203? ` \311\312!\210`=\203* \313\314\315 \"\210\2021 n\2031 \316u\210`=\203< \317\320!\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 forward-comment 1 skip-syntax-forward #1# point-at-eol -1 error #2# semantic-lex-comment-regex comment-start-point] 5 "Detect and create a comment token."]] 2)
#@236 A simple lexical analyzer that handles comments.
This lexer will only return comment tokens. It is the default lexer
used by `semantic-find-doc-snarf-comment' to snarf up the comment at
point.
See `semantic-lex' for more information.
(defalias 'semantic-comment-lexer #[(start end &optional depth length) "\306\307\310 \n#\210`\306\211 $ %\311 &'\206 ( ) \nB *\306 +\ndV\2034 \312\313\nd#\210\314 p , -\315\216\316.!\210 b\210`\nW\203B/\203X \fG/X\203B\317\320!\203e \311\225%\202\340 \317\321!\203r \311\225%\202\340 \3170!\203\334 \212\322\323!\210n\203\205 \324u\210`%\f@\211 1@)\325=\203\261 \f@\211 1A@\247\204\246 1AA\202\251 1A)%\241\210\202\330 \325\311\224%BB\fB\211@\211 1\211 1A@\247\204\320 1AA\202\323 1A)A)%)\202\340 \312\326!\210%$=\203\360 \312\327$\f@#\210%$%b\2102\203\330 \204r\3313!q\210\2123b\210\332 *\203\3332\334\"\210\f@ 14\205=\306 5\335\2161\2033\3361!5\337\340\3411&#!*)\210\202E +
\203\204
\211A\242\211 6\211 7\203k\342\3437@7A@#\210
\211A\242\2117\204U6@ 898*@*A#b\210`\211%)\210* b\210\f\237. \207" [semantic-lex-block-streams start end starting-position semantic-lex-token-stream semantic-lex-block-stack nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-comment-lexer: end (%d) > point-max (%d)" syntax-table #[nil "rq\210\302 !)\207" [#1=#:buffer #2=#:table set-syntax-table] 2] set-syntax-table looking-at "\\s-+" "\\s-*\\(\n\\|\\s>\\)" forward-comment 1 -1 comment "Unmatched Text during Lexical Analysis" "semantic-comment-lexer: endless loop at %d, after %S" input-pending-p marker-buffer accept-process-output throw lex #[nil "\205 \301!\207" [o semantic-overlay-delete] 2] semantic-lex-highlight-token semantic-read-event format "%S :: Depth: %d :: SPC - continue" message "semantic-comment-lexer: `%s' block from %S is unterminated" tmp-start semantic-lex-end-point semantic-lex-current-depth depth semantic-lex-depth semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties #1# #2# semantic-lex-syntax-table length semantic-lex-comment-regex token semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug o last blk syntax semantic-lex-unterminated-syntax-end-function] 6 (#$ . 57987)])
#@198 A simple lexical analyzer that handles simple buffers.
This lexer ignores comments and whitespace, and will return
syntax as specified by the syntax table.
See `semantic-lex' for more information.
(defalias 'semantic-simple-lexer #[(start end &optional depth length) "\306\307\310 \n#\210`\306\211 < =\311 >?\206 @ A \nB B\306 C\ndV\2034 \312\313\nd#\210\314 p D E\315\216\316F!\210 b\210`\nW\2033G\203X \fGGX\2033\317\320!\203e \311\225=\202\321\317\321!\203r \311\225=\202\321\317H!\203\243 \322\311\224\311\225BB\fB\211@\211 I\211 IA@\247\204\230 IAA\202\233 IA)A)=\202\321\317\323!\203\374 \324\311!\211 J J\325K!\205\304 J;\205\304 \326JK\")\211J\205\316 JJ)\206\323 \327\311\224\311\225BB\fB\211@\211 I\211 IA@\247\204\361 IAA\202\364 IA)A)=\202\321\317\330!\203,\331\311\224\311\225BB\fB\211@\211 I\211 IA@\247\204!IAA\202$IA)A)=\202\321\317\332!\203\315A\203?>AW\203n>T>\333\311\224\311\225BB\fB\211@\211 I\211 IA@\247\204cIAA\202fIA)A)=\202\321\334\311\224\212L\203\204M\203\204\335\336!\210`\202\247\3371\221\335\336!\210`0\202\247\210\334 NONB@BA#b\210`\211=))BB\fB\211@\211 I\211 IA@\247\204\302IAA\202\305IA)A)=\202\321\317\340!\203>S>\341\311\224\311\225BB\fB\211@\211 I\211 IA@\247\204\367IAA\202\372IA)A)=\202\321\317\342!\203f\343`\212L\203 M\203 \344\336!\210`\202@\3451*\344\336!\210`0\202@\210\343 NONB@BA#b\210`\211=))BB\fB\211@\211 I\211 IA@\247\204[IAA\202^IA)A)=\202\321\317P!\203\235` Q\346\336!\210`Q=\203\204\347\350\351 \"\210\202\213n\203\213\352u\210`Q=\203\226\312\353!\210`=)\202\321\317\354!\203\315\355\311\224\311\225BB\fB\211@\211 I\211 IA@\247\204\302IAA\202\305IA)A)=\202\321\312\356!\210=<=\203\341\312\357<\f@#\210=<=b\210R\203 \360 \204r\361S!q\210\212Sb\210\362 *\203 \363R\364\"\210\f@ IT\205.\306 U\365\216I\203$\366I!U\367\370\371I>#!*)\210\202E +
\203u
\211A\242\211 V\211 W\203\\\372\373W@WA@#\210
\211A\242\211W\204FV@ NONB@BA#b\210`\211=)\210* b\210\f\237. \207" [semantic-lex-block-streams start end starting-position semantic-lex-token-stream semantic-lex-block-stack nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-simple-lexer: end (%d) > point-max (%d)" syntax-table #[nil "rq\210\302 !)\207" [#1=#:buffer #2=#:table set-syntax-table] 2] set-syntax-table looking-at "\\s-+" "\\s-*\\(\n\\|\\s>\\)" number "\\(\\sw\\|\\s_\\)+" match-string arrayp intern-soft symbol "\\s\\+" charquote "\\s(" open-paren semantic-list forward-list 1 (error) "\\s)" close-paren "\\s\"" string forward-sexp (error) forward-comment skip-syntax-forward "-.'" point-at-eol -1 "Strange comment syntax prevents lexical analysis" "\\(\\s.\\|\\s$\\|\\s'\\)" punctuation "Unmatched Text during Lexical Analysis" "semantic-simple-lexer: endless loop at %d, after %S" input-pending-p marker-buffer accept-process-output throw lex #[nil "\205 \301!\207" [o semantic-overlay-delete] 2] semantic-lex-highlight-token semantic-read-event format "%S :: Depth: %d :: SPC - continue" message "semantic-simple-lexer: `%s' block from %S is unterminated" tmp-start semantic-lex-end-point semantic-lex-current-depth depth semantic-lex-depth semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties #1# #2# semantic-lex-syntax-table length semantic-lex-number-expression token name semantic-flex-keywords-obarray debug-on-error semantic-lex-debug-analyzers syntax semantic-lex-unterminated-syntax-end-function semantic-lex-comment-regex comment-start-point semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug o last blk] 7 (#$ . 60271)])
#@120 Define a keyword type analyzer NAME with DOC string.
SYNTAX is the regexp that matches a keyword syntactic expression.
(defalias 'define-lex-keyword-type-analyzer '(macro . #[(name doc syntax) "\304\305!\306 \n\307\310 D\311\312BC\313\314\315\316BBDEEEF)\207" [key name doc syntax make-symbol "key" define-lex-analyzer and looking-at let ((semantic-lex-keyword-p (match-string 0))) when semantic-lex-push-token semantic-lex-token ((match-beginning 0) (match-end 0))] 13 (#$ . 63977)]))
#@177 Define a sexp type analyzer NAME with DOC string.
SYNTAX is the regexp that matches the beginning of the s-expression.
TOKEN is the lexical token returned when SYNTAX matches.
(defalias 'define-lex-sexp-type-analyzer '(macro . #[(name doc syntax token) "\304 \n\305\306 \307\310\311 \312BBDFD\257\207" [name doc syntax token define-lex-regex-analyzer semantic-lex-push-token semantic-lex-token (point) save-excursion semantic-lex-unterminated-syntax-protection ((forward-sexp 1) (point))] 12 (#$ . 64474)]))
#@255 Define a regexp type analyzer NAME with DOC string.
SYNTAX is the regexp that matches a syntactic expression.
MATCHES is an alist of lexical elements used to refine the syntactic
expression.
DEFAULT is the default lexical token returned when no MATCHES.
(defalias 'define-lex-regex-type-analyzer '(macro . #[(name doc syntax matches default) "\203^ \306\307!\306\310!\306\311!\306\312! \306\313! \314 \315\316!D\317 \320B\f\321B
\322B\nD \257\323\315\n\324 DE\325\326\327\nD E\330 \331\nDE\330\n\332\nDEFE\333\334\335 \"E\f
FDFEF-\207\336 !\"\257\207" [matches val lst elt pos end make-symbol "val" "lst" "elt" "pos" "end" define-lex-analyzer and looking-at let* ((match-string 0)) ((match-beginning 0)) ((match-end 0)) while not if string-match cdar setq caar cdr semantic-lex-push-token semantic-lex-token or define-lex-simple-regex-analyzer name doc syntax default] 16 (#$ . 64991)]))
#@255 Define a string type analyzer NAME with DOC string.
SYNTAX is the regexp that matches a syntactic expression.
MATCHES is an alist of lexical elements used to refine the syntactic
expression.
DEFAULT is the default lexical token returned when no MATCHES.
(defalias 'define-lex-string-type-analyzer '(macro . #[(name doc syntax matches default) "\203\203 \306\307!\306\310!\306\311!\306\312! \306\313! \306\314! %\315&'\316\317(D\320 \321B\f\322B
\323B%\324
\fED\nD \257\325\316\326%\327BB\330\331 \332 \nEEDE\331%\333%D \334 \335%F\257E\336 \331 \337 D
\340\f%E\257E\341\342\343 )E\f
FD\257EF.\207\344&'()\257\207" [matches val lst elt pos end make-symbol "val" "lst" "elt" "pos" "end" "len" define-lex-analyzer and looking-at let* ((match-string 0)) ((match-beginning 0)) ((match-end 0)) - while > (0) not setq rassoc 1- substring 0 when car + semantic-lex-push-token semantic-lex-token or define-lex-simple-regex-analyzer len name doc syntax default] 17 (#$ . 65903)]))
#@2319 Define a block type analyzer NAME with DOC string.
SYNTAX is the regexp that matches block delimiters, typically the
open (`\\s(') and close (`\\s)') parenthesis syntax classes.
MATCHES is a pair (OPEN-SPECS . CLOSE-SPECS) that defines blocks.
OPEN-SPECS is a list of (OPEN-DELIM OPEN-TOKEN BLOCK-TOKEN) elements
where:
OPEN-DELIM is a string: the block open delimiter character.
OPEN-TOKEN is the lexical token class associated to the OPEN-DELIM
delimiter.
BLOCK-TOKEN is the lexical token class associated to the block
that starts at the OPEN-DELIM delimiter.
CLOSE-SPECS is a list of (CLOSE-DELIM CLOSE-TOKEN) elements where:
CLOSE-DELIM is a string: the block end delimiter character.
CLOSE-TOKEN is the lexical token class associated to the
CLOSE-DELIM delimiter.
Each element in OPEN-SPECS must have a corresponding element in
CLOSE-SPECS.
The lexer will return a BLOCK-TOKEN token when the value of
`semantic-lex-current-depth' is greater than or equal to the maximum
depth of parenthesis tracking (see also the function `semantic-lex').
Otherwise it will return OPEN-TOKEN and CLOSE-TOKEN tokens.
TO DO: Put the following in the developer's guide and just put a
reference here.
In the grammar:
The value of a block token must be a string that contains a readable
sexp of the form:
"(OPEN-TOKEN CLOSE-TOKEN)"
OPEN-TOKEN and CLOSE-TOKEN represent the block delimiters, and must be
lexical tokens of respectively `open-paren' and `close-paren' types.
Their value is the corresponding delimiter character as a string.
Here is a small example to analyze a parenthesis block:
%token <block> PAREN_BLOCK "(LPAREN RPAREN)"
%token <open-paren> LPAREN "("
%token <close-paren> RPAREN ")"
When the lexer encounters the open-paren delimiter "(":
- If the maximum depth of parenthesis tracking is not reached (that
is, current depth < max depth), it returns a (LPAREN start . end)
token, then continue analysis inside the block. Later, when the
corresponding close-paren delimiter ")" will be encountered, it
will return a (RPAREN start . end) token.
- If the maximum depth of parenthesis tracking is reached (current
depth >= max depth), it returns the whole parenthesis block as
a (PAREN_BLOCK start . end) token.
(defalias 'define-lex-block-type-analyzer '(macro . #[(name doc syntax matches) "\306\307!\306\310!\306\311!\312 \f\313\314
D\315\316B $D\nE\317\320\n\321\322 DEE\323\324\325\326\327\330\331\332\nE\333BBDE\327\330\331\334\nE\335\336\337\331\334\nE\340BBDFDFD\320\n\321\341 DEE\342\327\330\331\332\nE\343BBDEEEEF+\207" [val lst elt name doc syntax make-symbol "val" "lst" "elt" define-lex-analyzer and looking-at let ((match-string 0)) cond setq assoc car 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 nth 1 ((match-beginning 0) (match-end 0)) 2 (match-beginning 0) save-excursion semantic-lex-unterminated-syntax-protection ((forward-list 1) (point)) cdr (setq semantic-lex-current-depth (1- semantic-lex-current-depth)) ((match-beginning 0) (match-end 0)) matches] 21 (#$ . 66907)]))
#@329 Using SYMBOL, execute FORMS catching lexical errors.
If FORMS results in a call to the parser that throws a lexical error,
the error will be caught here without the buffer's cache being thrown
out of date.
If there is an error, the syntax that failed is returned.
If there is no error, then the last value of FORMS is returned.
(defalias 'semantic-lex-catch-errors '(macro . #[(symbol &rest forms) "\306\307!\306\310!\306\311!\306\312!\313\314\315\n E\316\317\fD\nEED\320 \321\317\fD\322\323
\324\"BEDE\325 \326BB F,\207" [end start syntax ret symbol forms make-symbol "ret" "syntax" "start" "end" let* semantic-lex-unterminated-syntax-end-function lambda throw quote (semantic-flex-unterminated-syntax-end-function semantic-lex-unterminated-syntax-end-function) catch save-excursion append (nil) when ((semantic-parse-tree-unparseable))] 10 (#$ . 70192)]))
(byte-code "\300\301\302\303#\210\304\305\306\"\210\307\310\311\312#\210\307\313\314\312#\210\307\315\316\312#\210\307\317\320\312#\210\307\321\322\312#\210\307\323\324\312#\210\307\325\326\312#\210\307\327\330\312#\210\307\331\332\312#\210\307\333\334\312#\210\307\335\336\312#\207" [put semantic-lex-catch-errors lisp-indent-function 1 add-hook edebug-setup-hook #[nil "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\314\302\315#\207" [put define-lex edebug-form-spec (&define name stringp (&rest symbolp)) define-lex-analyzer (&define name stringp form def-body) define-lex-regex-analyzer (&define name stringp form def-body) define-lex-simple-regex-analyzer (&define name stringp form symbolp [&optional form] def-body) define-lex-block-analyzer (&define name stringp form (&rest form)) semantic-lex-catch-errors (symbolp def-body)] 4] semantic-alias-obsolete semantic-flex-start semantic-lex-token-start "23.2" semantic-flex-end semantic-lex-token-end semantic-flex-text semantic-lex-token-text semantic-flex-make-keyword-table semantic-lex-make-keyword-table semantic-flex-keyword-p semantic-lex-keyword-p semantic-flex-keyword-put semantic-lex-keyword-put semantic-flex-keyword-get semantic-lex-keyword-get semantic-flex-map-keywords semantic-lex-map-keywords semantic-flex-keywords semantic-lex-keywords semantic-flex-buffer semantic-lex-buffer semantic-flex-list semantic-lex-list] 4)
#@71 An alist of semantic token types.
See variable `semantic-lex-tokens'.
(defvar semantic-flex-tokens semantic-lex-tokens (#$ . 72518))
#@467 Function called when unterminated syntax is encountered.
This should be set to one function. That function should take three
parameters. The SYNTAX, or type of syntax which is unterminated.
SYNTAX-START where the broken syntax begins.
FLEX-END is where the lexical analysis was asked to end.
This function can be used for languages that can intelligently fix up
broken syntax, or the exit lexical analysis via `throw' or `signal'
when finding unterminated syntax.
(defvar semantic-flex-unterminated-syntax-end-function #[(syntax syntax-start flex-end) "\207" [flex-end] 1] (#$ . 72658))
#@375 Buffer local extensions to the lexical analyzer.
This should contain an alist with a key of a regex and a data element of
a function. The function should both move point, and return a lexical
token of the form:
( TYPE START . END)
nil is also a valid return value.
TYPE can be any type of symbol, as long as it doesn't occur as a
nonterminal in the language definition.
(defvar semantic-flex-extensions nil (#$ . 73255))
(make-variable-buffer-local 'semantic-flex-extensions)
#@322 Changes to the syntax table for this buffer.
These changes are active only while the buffer is being flexed.
This is a list where each element has the form:
(CHAR CLASS)
CHAR is the char passed to `modify-syntax-entry',
and CLASS is the string also passed to `modify-syntax-entry' to define
what syntax class CHAR has.
(defvar semantic-flex-syntax-modifications nil (#$ . 73742))
(make-variable-buffer-local 'semantic-flex-syntax-modifications)
#@133 Default comment handling.
The value t means to strip comments when flexing; nil means
to keep comments as part of the token stream.
(defvar semantic-ignore-comments t (#$ . 74196))
(make-variable-buffer-local 'semantic-ignore-comments)
#@172 When flexing, report newlines as syntactic elements.
Useful for languages where the newline is a special case terminator.
Only set this on a per mode basis, not globally.
(defvar semantic-flex-enable-newlines nil (#$ . 74439))
(make-variable-buffer-local 'semantic-flex-enable-newlines)
#@168 When flexing, report whitespace as syntactic elements.
Useful for languages where the syntax is whitespace dependent.
Only set this on a per mode basis, not globally.
(defvar semantic-flex-enable-whitespace nil (#$ . 74733))
(make-variable-buffer-local 'semantic-flex-enable-whitespace)
#@179 When flexing, report beginning of lines as syntactic elements.
Useful for languages like python which are indentation sensitive.
Only set this on a per mode basis, not globally.
(defvar semantic-flex-enable-bol nil (#$ . 75027))
(make-variable-buffer-local 'semantic-flex-enable-bol)
#@48 See variable `semantic-lex-number-expression'.
(defvar semantic-number-expression semantic-lex-number-expression (#$ . 75317))
(make-variable-buffer-local 'semantic-number-expression)
#@75 Default flexing depth.
This specifies how many lists to create tokens in.
(defvar semantic-flex-depth 0 (#$ . 75507))
(make-variable-buffer-local 'semantic-flex-depth)
#@735 Using the syntax table, do something roughly equivalent to flex.
Semantically check between START and END. Optional argument DEPTH
indicates at what level to scan over entire lists.
The return value is a token stream. Each element is a list, such of
the form (symbol start-expression . end-expression) where SYMBOL
denotes the token type.
See `semantic-flex-tokens' variable for details on token types.
END does not mark the end of the text scanned, only the end of the
beginning of text scanned. Thus, if a string extends past END, the
end of the return token will be larger than END. To truly restrict
scanning, use `narrow-to-region'.
The last argument, LENGTH specifies that `semantic-flex' should only
return LENGTH tokens.
(defalias 'semantic-flex #[(start end &optional depth length) "\306\307!\210\204\n \310\311`\311\312 \203 \313 \314Q\202 \315\316\317 !\n \206$ \f 9 : ; < = >
\203I \320
@@
@A@9#\210
A\211\2046 \317 p ? @\321\216\3229!\210Ab\210`BW\203\322C\203p >GCX\203\322D\203\203 n\203\203 \323``BB>B>E\203\316 E\311 F\211 G\203\270 \324G@@!\203\257 G@A >B>\325F\311G`<GA\211G\204\223 F\203\310 >@\204\310 >A>F*\204\303\324\326!\203\354 H\203\303\327\225<\330\327\224<BB>B>\202\303\324\331!\203I\203\303>@@\332=\203 >@A\312\225\241\210\202\303\332\312\224\312\225BB>B>\202\303J\2035\324J!\2035\333\312\224\312\225BB>B>\202\303\324\334!\203q\335\312!\211 K K\336!\205TK;\205T\337K\")\211K\205^KJ)\206c\340\312\224\312\225BB>B>\202\303\324\341!\203\206\342\312\224\312\225BB>B>\202\303\324\343!\203\324 \203\227; W\203\253;T;\344\312\224\312\225BB>B>\202\303\345\312\224\212\3461\272\347\327!0\202\304\210L\345AB#b\210`\211<)BB>B>\202\303\324\350!\203\356\351\312\224\312\225BB>B>;S;\202\303\324\352!\203 \353\312\224\212\3541\355\327!0\202
\210L\353AB#b\210`\211<)BB>B>\202\303\324:!\203\252M\203cI\204c` N\356\327!\210`N=\203E\357\360\361 \"\210\202QH\203Qn\203Q\362u\210`N=\203\\\363\364!\210`<)\202\303M\203l\332\202m\365 O\212\356\327!\210H\203\200n\203\200\362u\210`<)>@@O=\203\231>@A<\241\210\202\246O\312\224<BB>B>)\202\303\324\366!\203\277\367\312\224\312\225BB>B>\202\303\363\370!\210<\206\312\312\225b\210\311<\202[ +D\203\355`BU\203\355n\203\355\323``BB>B>=b\210>\237.\207" [semantic-flex-keywords-obarray comment-start-skip semantic-flex-syntax-modifications depth semantic-flex-depth mods message "`semantic-flex' is an obsolete function. Use `define-lex' to create lexers." [nil] nil 0 "\\(\\s<\\|" "\\)" "\\(\\s<\\)" copy-syntax-table syntax-table modify-syntax-entry #[nil "rq\210\302 !)\207" [#1=#:buffer #2=#:table set-syntax-table] 2] set-syntax-table bol looking-at t "\\s-*\\(\n\\|\\s>\\)" 1 newline "\\s-+" whitespace number "\\(\\sw\\|\\s_\\)+" match-string arrayp intern-soft symbol "\\s\\+" charquote "\\s(" open-paren semantic-list (error) forward-list "\\s)" close-paren "\\s\"" string (error) forward-sexp forward-comment skip-syntax-forward "-.'" point-at-eol -1 error "Strange comment syntax prevents lexical analysis" comment "\\(\\s.\\|\\s$\\|\\s'\\)" punctuation "What is that?" newsyntax cs curdepth ep pos ts #1# #2# start end length semantic-flex-enable-bol semantic-flex-extensions r fe semantic-flex-enable-newlines semantic-flex-enable-whitespace semantic-number-expression name semantic-flex-unterminated-syntax-end-function semantic-ignore-comments comment-start-point tk] 9 (#$ . 75682)])
(provide 'semantic/lex)
Kontol Shell Bypass