Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/cedet/semantic/lex.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.

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


(require 'semantic/fw)
#@206 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.

(fn FUN TABLE &optional PROPERTY)
(defalias 'semantic-lex-map-symbols #[770 "\300!\205\301\302\303\304\305\306\"\307\"\310\311%\"\207" [obarrayp mapatoms make-byte-code 257 "\301\203\n\211\301N\205
\300
!\207" vconcat vector [] 3 "\n\n(fn SYMBOL)"] 11 (#$ . 432)])
#@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 (#$ . 885))
(make-variable-buffer-local 'semantic-flex-keywords-obarray)
#@57 Signal that NAME is an invalid keyword name.

(fn NAME)
(defalias 'semantic-lex-keyword-invalid '(macro . #[257 "\300\301\302\303DDE\207" [signal 'wrong-type-argument quote semantic-lex-keyword-p] 6 (#$ . 1137)]))
#@65 Return keyword symbol with NAME or nil if not found.

(fn NAME)
(defalias 'semantic-lex-keyword-symbol #[257 "\301!\205\211;\205\302
\"\207" [semantic-flex-keywords-obarray obarrayp intern-soft] 4 (#$ . 1358)])
(put 'semantic-lex-keyword-symbol 'byte-optimizer 'byte-compile-inline-expand)
#@101 Return non-nil if a keyword with NAME exists in the keyword table.
Return nil otherwise.

(fn NAME)
(defalias 'semantic-lex-keyword-p #[257 "\211\301!\205\211;\205\302
\"\262
\211\262\205\211J\207" [semantic-flex-keywords-obarray obarrayp intern-soft] 5 (#$ . 1661)])
(put 'semantic-lex-keyword-p 'byte-optimizer 'byte-compile-inline-expand)
#@76 Set value of keyword with NAME to VALUE and return VALUE.

(fn NAME VALUE)
(defalias 'semantic-lex-keyword-set #[514 "\301\"
L\207" [semantic-flex-keywords-obarray intern] 5 (#$ . 2018)])
(put 'semantic-lex-keyword-set 'byte-optimizer 'byte-compile-inline-expand)
#@102 Return value of keyword with NAME.
Signal an error if a keyword with NAME does not exist.

(fn NAME)
(defalias 'semantic-lex-keyword-value #[257 "\211\301!\205\211;\205\302
\"\262
\211\203\211J\202\303\304\305\"\207" [semantic-flex-keywords-obarray obarrayp intern-soft signal wrong-type-argument (semantic-lex-keyword-p name)] 5 (#$ . 2291)])
(put 'semantic-lex-keyword-value 'byte-optimizer 'byte-compile-inline-expand)
#@77 For keyword with NAME, set its PROPERTY to VALUE.

(fn NAME PROPERTY VALUE)
(defalias 'semantic-lex-keyword-put #[771 "\301!\205\211;\205\302
\"\262
\211\203\303
#\202\"\304\305\306\"\207" [semantic-flex-keywords-obarray obarrayp intern-soft put signal wrong-type-argument (semantic-lex-keyword-p name)] 8 (#$ . 2729)])
(put 'semantic-lex-keyword-put 'byte-optimizer 'byte-compile-inline-expand)
#@71 For keyword with NAME, return its PROPERTY value.

(fn NAME PROPERTY)
(defalias 'semantic-lex-keyword-get #[514 "
\301!\205\211;\205\302
\"\262
\211\203\211N\202 \303\304\305\"\207" [semantic-flex-keywords-obarray obarrayp intern-soft signal wrong-type-argument (semantic-lex-keyword-p name)] 6 (#$ . 3143)])
(put 'semantic-lex-keyword-get 'byte-optimizer 'byte-compile-inline-expand)
#@401 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.

(fn SPECS &optional PROPSPECS)
(defalias 'semantic-lex-make-keyword-table #[513 "\301\302\303\"\304
\203\"@\262
A\262\211@
A\305\"
L\266\202\203]@\262
A\262\211@
A@\3068\307!\205F\211;\205F\310
\"\262
\211\203T\311
#\202X\312\313\314\"\266\202\")\207" [semantic-flex-keywords-obarray make-vector 13 0 nil intern 2 obarrayp intern-soft put signal wrong-type-argument (semantic-lex-keyword-p name)] 12 (#$ . 3545)])
#@210 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.

(fn FUN &optional PROPERTY)
(defalias 'semantic-lex-map-keywords #[513 "\301#\207" [semantic-flex-keywords-obarray semantic-lex-map-symbols] 6 (#$ . 4364)])
(put 'semantic-lex-map-keywords 'byte-optimizer 'byte-compile-inline-expand)
#@142 Return a list of lexical keywords.
If optional PROPERTY is non-nil, return only keywords which have a
PROPERTY set.

(fn &optional PROPERTY)
(defalias 'semantic-lex-keywords #[256 "\301C\302\303\304\305\306!\307\"\310\311%\312#\266\211\242\207" [semantic-flex-keywords-obarray nil make-byte-code 257 "\300
\300\242B\240\207" vconcat vector [] 4 "\n\n(fn SYMBOL)" semantic-lex-map-symbols] 8 (#$ . 4789)])
#@104 Fetch the start and end locations of the lexical token TOKEN.
Return a pair (START . END).

(fn TOKEN)
(defalias 'semantic-lex-token-bounds #[257 "\211A@\247\204\211AA\207\211A\207" [] 2 (#$ . 5207)])
(put 'semantic-lex-token-bounds 'byte-optimizer 'byte-compile-inline-expand)
#@110 Fetch the start position of the lexical token TOKEN.
See also the function `semantic-lex-token'.

(fn TOKEN)
(defalias 'semantic-lex-token-start #[257 "\211\211A@\247\204\211AA\262
\202\211A\262
@\207" [] 3 (#$ . 5494)])
(put 'semantic-lex-token-start 'byte-optimizer 'byte-compile-inline-expand)
#@108 Fetch the end position of the lexical token TOKEN.
See also the function `semantic-lex-token'.

(fn TOKEN)
(defalias 'semantic-lex-token-end #[257 "\211\211A@\247\204\211AA\262
\202\211A\262
A\207" [] 3 (#$ . 5802)])
(put 'semantic-lex-token-end 'byte-optimizer 'byte-compile-inline-expand)
#@267 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.

(fn SYNTAX)
(defalias 'semantic-lex-unterminated-syntax-detected #[257 "
	@	A#b\210`\211\207" [semantic-lex-unterminated-syntax-end-function semantic-lex-analysis-bounds semantic-lex-end-point] 5 (#$ . 6104)])
(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 (#$ . 6669))
(make-variable-buffer-local 'semantic-lex-types-obarray)
#@62 Signal that TYPE is an invalid lexical type name.

(fn TYPE)
(defalias 'semantic-lex-type-invalid #[257 "\300\301\302D\"\207" [signal wrong-type-argument semantic-lex-type-p] 5 (#$ . 6837)])
#@57 Return symbol with TYPE or nil if not found.

(fn TYPE)
(defalias 'semantic-lex-type-symbol #[257 "\301!\205\211;\205\302
\"\207" [semantic-lex-types-obarray obarrayp intern-soft] 4 (#$ . 7035)])
(put 'semantic-lex-type-symbol 'byte-optimizer 'byte-compile-inline-expand)
#@62 Return non-nil if a symbol with TYPE name exists.

(fn TYPE)
(defalias 'semantic-lex-type-p #[257 "\211\301!\205\211;\205\302
\"\262
\211\262\205\211J\207" [semantic-lex-types-obarray obarrayp intern-soft] 5 (#$ . 7319)])
(put 'semantic-lex-type-p 'byte-optimizer 'byte-compile-inline-expand)
#@80 Set value of symbol with TYPE name to VALUE and return VALUE.

(fn TYPE VALUE)
(defalias 'semantic-lex-type-set #[514 "\301\"
L\207" [semantic-lex-types-obarray intern] 5 (#$ . 7627)])
(put 'semantic-lex-type-set 'byte-optimizer 'byte-compile-inline-expand)
#@191 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.

(fn TYPE &optional NOERROR)
(defalias 'semantic-lex-type-value #[513 "
\301!\205\211;\205\302
\"\262
\211\203\211J\202#
?\205#\303!\207" [semantic-lex-types-obarray obarrayp intern-soft semantic-lex-type-invalid] 6 (#$ . 7894)])
(put 'semantic-lex-type-value 'byte-optimizer 'byte-compile-inline-expand)
#@225 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.

(fn TYPE PROPERTY VALUE &optional ADD)
(defalias 'semantic-lex-type-put #[1027 "\301!\205\211;\205\302
\"\262
\211\204<
\204\303!\210\304\305\"
L\266\301!\2058\211;\2058\302
\"\262
\262
\306
#\207" [semantic-lex-types-obarray obarrayp intern-soft semantic-lex-type-invalid nil intern put] 10 (#$ . 8378)])
(put 'semantic-lex-type-put 'byte-optimizer 'byte-compile-inline-expand)
#@215 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.

(fn TYPE PROPERTY &optional NOERROR)
(defalias 'semantic-lex-type-get #[770 "\301!\205\211;\205\302
\"\262
\211\203\211N\202$
?\205$\303!\207" [semantic-lex-types-obarray obarrayp intern-soft semantic-lex-type-invalid] 7 (#$ . 8971)])
(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 #[0 "\301\302\303\304\305!\205\211;\205\306
\"\262
\211\204@
\204\"\307!\210\310\311\"
L\266\305!\205<\211;\205<\306
\"\262
\262
\312
#\266\301\313\314\310\305!\205[\211;\205[\306
\"\262
\211\204\207
\204i\307!\210\310\311\"
L\266\305!\205\203\211;\205\203\306
\"\262
\262
\312
#\266\315\302\316\304\305!\205\242\211;\205\242\306
\"\262
\211\204\316
\204\260\307!\210\310\311\"
L\266\305!\205\312\211;\205\312\306
\"\262
\262
\312
#\266\315\313\317\310\305!\205\351\211;\205\351\306
\"\262
\211\204

\204\367\307!\210\310\311\"
L\266\305!\205
\211;\205
\306
\"\262
\262
\312
#\266\320\302\321\304\305!\2050
\211;\2050
\306
\"\262
\211\204\\

\204>
\307!\210\310\311\"
L\266\305!\205X
\211;\205X
\306
\"\262
\262
\312
#\266\320\313\317\310\305!\205w
\211;\205w
\306
\"\262
\211\204\243

\204\205
\307!\210\310\311\"
L\266\305!\205\237
\211;\205\237
\306
\"\262
\262
\312
#\266\322\302\323\304\305!\205\276
\211;\205\276
\306
\"\262
\211\204\352

\204\314
\307!\210\310\311\"
L\266\305!\205\346
\211;\205\346
\306
\"\262
\262
\312
#\266\322\313\324\310\305!\205\211;\205\306
\"\262
\211\2041
\204\307!\210\310\311\"
L\266\305!\205-\211;\205-\306
\"\262
\262
\312
#\266\325\302\321\304\305!\205L\211;\205L\306
\"\262
\211\204x
\204Z\307!\210\310\311\"
L\266\305!\205t\211;\205t\306
\"\262
\262
\312
#\266\325\313\326\310\305!\205\223\211;\205\223\306
\"\262
\211\204\277
\204\241\307!\210\310\311\"
L\266\305!\205\273\211;\205\273\306
\"\262
\262
\312
#\266\327\302\330\304\305!\205\332\211;\205\332\306
\"\262
\211\204
\204\350\307!\210\310\311\"
L\266\305!\205\211;\205\306
\"\262
\262
\312
#\266\327\313\331\310\305!\205!\211;\205!\306
\"\262
\211\204M
\204/\307!\210\310\311\"
L\266\305!\205I\211;\205I\306
\"\262
\262
\312
#\207" [semantic-lex-types-obarray "punctuation" matchdatatype string t obarrayp intern-soft semantic-lex-type-invalid 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)"] 10 (#$ . 9475)])
#@515 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 a 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).

(fn SPECS &optional PROPSPECS)
(defalias 'semantic-lex-make-type-table #[513 "\301\302\303\"\304\211\211\211\211\211\203g@\262A\262@\262A\262\304\262
\304\262\203W@\262A\262A\203AB\262\202(@\262\211\203Q\305\306$\210\262
\202(
\237B\307\"
L\266\202\310 \210\203\312@\262A\262@A@\3118\312\313!\205\224\211;\205\224\314
\"\262
\211\204\300
\204\242\315!\210\304\307\"
L\266\313!\205\274\211;\205\274\314
\"\262
\262
\316
#\266\202j)\207" [semantic-lex-types-obarray 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 obarrayp intern-soft semantic-lex-type-invalid put] 18 (#$ . 11869)])
#@208 Call function FUN on every lexical type.
If optional PROPERTY is non-nil, call FUN only on every type symbol
which has a PROPERTY value.  FUN receives a type symbol as argument.

(fn FUN &optional PROPERTY)
(defalias 'semantic-lex-map-types #[513 "\301#\207" [semantic-lex-types-obarray semantic-lex-map-symbols] 6 (#$ . 13109)])
(put 'semantic-lex-map-types 'byte-optimizer 'byte-compile-inline-expand)
#@148 Return a list of lexical type symbols.
If optional PROPERTY is non-nil, return only type symbols which have
PROPERTY set.

(fn &optional PROPERTY)
(defalias 'semantic-lex-types #[256 "\301C\302\303\304\305\306!\307\"\310\311%\312#\266\211\242\207" [semantic-lex-types-obarray nil make-byte-code 257 "\300
\300\242B\240\207" vconcat vector [] 4 "\n\n(fn SYMBOL)" semantic-lex-map-symbols] 8 (#$ . 13523)])
#@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 (#$ . 13941))
(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)) (#$ . 14212))
#@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 (#$ . 17490))
(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 (#$ . 17941))
(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 (#$ . 18141))
(make-variable-buffer-local 'semantic-lex-comment-regex)
#@554 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][[:xdigit:]]+
  ;
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][[:xdigit:]]+[lL]?\\>\\|\\<[0-9]+[lLfFdD]?\\>\\)" (#$ . 18457))
(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 (#$ . 19405))
(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 #[771 "\207" [] 4 "\n\n(fn SYNTAX SYNTAX-START LEX-END)"] (#$ . 19577))
#@112 Test the semantic lexer in the current buffer.
If universal argument ARG, then try the whole buffer.

(fn ARG)
(defalias 'semantic-lex-test #[257 "\300\301!\210\302 \303\203e\202`d\"\304\305\306\307\"\"\210\310\311!\210\300\312!\210\313 \210\314
!c\210eb\207" [require semantic current-time semantic-lex message "Elapsed Time: %.2f seconds." semantic-elapsed-time nil pop-to-buffer "*Lexer Output*" pp erase-buffer pp-to-string] 8 (#$ . 20175) "P"])
#@49 When non-nil, debug the local lexical analyzer.
(defvar semantic-lex-debug nil (#$ . 20637))
#@345 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.

(fn ARG)
(defalias 'semantic-lex-debug #[257 "\301\302!\210\303\304
!)\207" [semantic-lex-debug require semantic/debug t semantic-lex-test] 3 (#$ . 20737) "P"])
#@118 Highlight the lexical TOKEN.
TOKEN is a lexical token with a START And END position.
Return the overlay.

(fn TOKEN)
(defalias 'semantic-lex-highlight-token #[257 "\300
\211\211A@\247\204\211AA\262
\202\211A\262
@\262
\211\211A@\247\204*\211AA\262
\202.\211A\262
A\262
\"\301
\302\303#\210\211\207" [make-overlay overlay-put face highlight] 6 (#$ . 21241)])
#@175 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.

(fn ANALYZERS)
(defalias 'semantic-lex-one-token '(macro . #[257 "\300\301\302\"B\207" [cond mapcar symbol-value] 5 (#$ . 21613)]))
#@53 The end point as tracked through lexical functions.
(defvar semantic-lex-end-point nil (#$ . 21911))
#@57 The current depth as tracked through lexical functions.
(defvar semantic-lex-current-depth nil (#$ . 22018))
#@72 The maximum depth of parenthesis as tracked through lexical functions.
(defvar semantic-lex-maximum-depth nil (#$ . 22133))
#@45 The current token stream we are collecting.
(defvar semantic-lex-token-stream nil (#$ . 22263))
#@37 The bounds of the current analysis.
(defvar semantic-lex-analysis-bounds nil (#$ . 22365))
#@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 (#$ . 22463))
(byte-code "\300\301\302\303#\210\304\211\203(\211@\301
N\203!\302
N\204!\305\302\301N#\210
A\266\202\202\210\306\301\302\307#\207" [defvaralias semantic-lex-reset-hooks semantic-lex-reset-functions nil (saved-value saved-variable-comment) put make-obsolete-variable "24.3"] 7)
#@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 (#$ . 22995))
(defvar semantic-lex-block-stack nil)
#@53 Break during lexical analysis at TOKEN.

(fn TOKEN)
(defalias 'semantic-lex-debug-break #[257 "\205&\302C\303\304\305\306\307!\310\"\311$\216
\203\211\312!\240\210\313\314\315	#!)\262
\207" [semantic-lex-debug semantic-lex-current-depth nil make-byte-code 0 "\300\242\205	\301\300\242!\207" vconcat vector [delete-overlay] 2 semantic-lex-highlight-token read-event format "%S :: Depth: %d :: SPC - continue"] 8 (#$ . 23297)])
(put 'semantic-lex-debug-break 'byte-optimizer 'byte-compile-inline-expand)
#@677 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 a symbol.

(fn NAME DOC &rest ANALYZERS)
(defalias 'define-lex '(macro . #[642 "\300\301\302P\303\304\305\306\307\310\311\312\313\"\314BBE\315\316\317\320\321\322D\307\323\311\312\324\"\325BBE\326BBBBF\307\327\305\330\320\331\332\312\333\"\334BB\335BBB\336BBBE\337BBBBB\257\207" [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))] 24 (#$ . 23814)]))
#@331 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.)

(fn SYMBOL START END &optional STR)
(defalias 'semantic-lex-token '(macro . #[1027 "\211\203\300\300\300EEE\207\300\300EE\207" [cons] 11 (#$ . 26150)]))
#@100 Return non-nil if THING is a semantic lex token.
This is an exhaustively robust check.

(fn THING)
(defalias 'semantic-lex-token-p #[257 "\211:\205+\211@9\205+\211A@\247\203\211AA\247\206+\211A@;\205+\300
8\247\205+\301
\233\247\207" [2 3] 3 (#$ . 26615)])
#@100 Return non-nil if THING is a semantic lex token.
This is an exhaustively robust check.

(fn THING)
(defalias 'semantic-lex-token-with-text-p #[257 "\211:\205$\211@9\205$\211G\300U\205$\211A@;\205$\301
8\247\205$\302
8\247\207" [4 2 3] 3 (#$ . 26886)])
#@100 Return non-nil if THING is a semantic lex token.
This is an exhaustively robust check.

(fn THING)
(defalias 'semantic-lex-token-without-text-p #[257 "\211:\205\211@9\205\211G\300U\205\211A@\247\205\301
8\247\207" [3 2] 3 (#$ . 27150)])
#@573 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.

(fn SPECS)
(defalias 'semantic-lex-expand-block-specs #[257 "\300\301!\302\211\203I\211@\211@\203B\211A@\203)\303\304A@DE\305\304@DDDB\262\306
8\203B\303\304\3068DE\307\304@DDDB\262
A\266\202\202\210\211\205Y\310\311BC\312\237BEC\207" [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] 9 (#$ . 27402)])
#@584 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'.

(fn TOKEN &rest BLOCKSPECS)
(defalias 'semantic-lex-push-token '(macro . #[385 "\300\301\302BB\303\304!\305\"BB\207" [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))))] 7 (#$ . 28397)]))
#@101 Fetch the class of the lexical token TOKEN.
See also the function `semantic-lex-token'.

(fn TOKEN)
(defalias 'semantic-lex-token-class #[257 "\211@\207" [] 2 (#$ . 29265)])
(put 'semantic-lex-token-class 'byte-optimizer 'byte-compile-inline-expand)
#@113 Fetch the text associated with the lexical token TOKEN.
See also the function `semantic-lex-token'.

(fn TOKEN)
(defalias 'semantic-lex-token-text #[257 "\211A@;\203\211A@\207\300
\211\211A@\247\204\211AA\262
\202!\211A\262
@\262
\211\211A@\247\2045\211AA\262
\2029\211A\262
A\262
\"\207" [buffer-substring-no-properties] 6 (#$ . 29522)])
(put 'semantic-lex-token-text 'byte-optimizer 'byte-compile-inline-expand)
#@47 Initialize any lexical state for this buffer.
(defalias 'semantic-lex-init #[0 "\204	\203\304	\305Q\202\306\307\310 !\211\205-\211@\311
@A@\n#\210
A\266\202\202\207" [semantic-lex-comment-regex comment-start-skip semantic-lex-syntax-table semantic-lex-syntax-modifications "\\(\\s<\\|" "\\)" "\\(\\s<\\)" copy-syntax-table syntax-table modify-syntax-entry] 6 (#$ . 29950)])
#@736 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'.

(fn START END &optional DEPTH LENGTH)
(defalias 'semantic-lex #[1026 "\304\211\305\306\307!\305\204\"\211\262\204\"	\262\n\205 \310\n\"\262
\203M\211\204M\302N\203<\310\302N\"\211\262\204\"\211\311N\206F\211\312N\262
\262\202\"\266\203\211\262\205a\211\203_
N\205aJ\266\203\206\326\211\211\313N\262
\205\326\211\211\313N\262
\305\306\307!\305\204\225\211\262\204\225	\262\n\205\223\310\n\"\262
\203\300\211\204\300\302N\203\257\310\302N\"\211\262\204\225\211\311N\206\271\211\312N\262
\262\202\225\266\203\211\262\205\324\211\203\322
N\205\324J\266\203\262
\211\203\345\211$\202\353$\207" [mode-local-active-mode major-mode mode-local-symbol-table semantic-lex-analyzer semantic-lex nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete] 16 (#$ . 30345)])
(put 'semantic-lex 'mode-local-overload t)
#@104 Lex the current buffer.
Optional argument DEPTH is the depth to scan into lists.

(fn &optional DEPTH)
(defalias 'semantic-lex-buffer #[256 "\300ed#\207" [semantic-lex] 5 (#$ . 31977)])
(put 'semantic-lex-buffer 'byte-optimizer 'byte-compile-inline-expand)
#@55 Lex the body of SEMLIST to DEPTH.

(fn SEMLIST DEPTH)
(defalias 'semantic-lex-list #[514 "\300\211\211A@\247\204\211AA\262
\202\211A\262
@\262
\211\211A@\247\204*\211AA\262
\202.\211A\262
A\262
#\207" [semantic-lex] 7 (#$ . 32241)])
(put 'semantic-lex-list 'byte-optimizer 'byte-compile-inline-expand)
#@75 Mark the last read token as the beginning of a SYNTAX block.

(fn SYNTAX)
(defalias 'semantic-lex-start-block #[257 "\203\n	W\203	T\211\207\211\n@DB\211\207" [semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-token-stream semantic-lex-block-stack] 3 (#$ . 32558)])
#@415 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'.

(fn SYNTAX)
(defalias 'semantic-lex-end-block #[257 "\204		S\211\207\n\211A\242\211A\211@\211A\262\242\306@=\2045@
\f@\fA#b\210`\211\262
\202\300\203O\211A\262\242\211\262=\204O\211B\262\2025\211=\204\\\307\310	#\210\211\211A@\247\204n\211AA\262
\202r\211A\262
@\262
\240\210\237\241\210	B	@\211\211A@\247\204\231\211AA\262
\202\235\211A\262
A\262
BB\nB\211@\211\211A@\247\204\267\211AA\262
\202\273\211A\262
A\262
\211\207" [semantic-lex-block-stack semantic-lex-current-depth semantic-lex-token-stream semantic-lex-unterminated-syntax-end-function semantic-lex-analysis-bounds semantic-lex-end-point nil error "Token %S not found at beginning of block `%s'" semantic-lex-block-streams] 13 (#$ . 32855)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable semantic-lex-debug-analyzers funcall function #[0 "\300\207" [nil] 1] "Non-nil means to debug analyzers with syntax protection.\nOnly in effect if `debug-on-error' is also non-nil." :group semantic :type boolean] 8)
#@467 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.

(fn SYNTAX &rest FORMS)
(defalias 'semantic-lex-unterminated-syntax-protection '(macro . #[385 "\300\301\302B\303\304\302B\305\306	DDFF\207" [if (and debug-on-error semantic-lex-debug-analyzers) progn condition-case nil error semantic-lex-unterminated-syntax-detected] 11 (#$ . 34323)]))
(put 'semantic-lex-unterminated-syntax-protection 'lisp-indent-function 1)
#@1376 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'.

(fn NAME DOC CONDITION &rest FORMS)
(defalias 'define-lex-analyzer '(macro . #[899 "\300\301\302F\303\304BB\305\306BDE\307\306	D\310\302\n\311\312\313

BB\314BBBFE\257\207" [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)] 18 (#$ . 35140)]))
#@200 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.

(fn NAME DOC REGEXP &rest FORMS)
(defalias 'define-lex-regex-analyzer '(macro . #[899 "\300\301DBBBB\207" [define-lex-analyzer looking-at] 9 (#$ . 37000)]))
#@502 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.

(fn NAME DOC REGEXP TOKSYM &optional INDEX &rest FORMS)
(defalias 'define-lex-simple-regex-analyzer '(macro . #[1412 "\300\301D\302\303\304\n\305\206\306D\307\f\206\306DFDC\"BBBB\207" [define-lex-analyzer looking-at append semantic-lex-push-token semantic-lex-token match-beginning 0 match-end] 18 (#$ . 37334)]))
#@706 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.

(fn NAME DOC SPEC1 &rest SPECS)
(defalias 'define-lex-block-analyzer '(macro . #[899 "

B\300\211\211\211\203.@\262A\262A@\262@A@@EB\262\3018
B\262
\202\302		\303\304\305\306\307\310\311\312\313\314DEE\315B\310\311\312\313\314DEE\316BEEEF\207" [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))))))] 24 (#$ . 38115)]))
#@100 The default action when no other lexical actions match text.
This action will just throw an error.
(defvar semantic-lex-default-action nil (#$ . 39878))
(defalias 'semantic-lex-default-action #[0 "\300\207" [nil] 1])
(byte-code "\301\300\302M\207" [semantic-lex-default-action (t (error #1="Unmatched Text during Lexical Analysis")) #[0 "\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 (#$ . 40540))
(defalias 'semantic-lex-beginning-of-line #[0 "\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) #[0 "\306``dB\307n\2032\310``BB
B\211@\211\211A@\247\204*\211AA\262
\202.\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 bol] 6 "Detect and create a beginning of line token (BOL)."]] 2)
#@35 Detect and create newline tokens.
(defvar semantic-lex-newline nil (#$ . 41207))
(defalias 'semantic-lex-newline #[0 "\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)))) #[0 "\306``dB\307\310\311!\2036\312\313\224\313\225BB
B\211@\211\211A@\247\204.\211AA\262
\2022\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# newline 1] 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 (#$ . 41894))
(defalias 'semantic-lex-newline-as-whitespace #[0 "\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))))) #[0 "\306``dB\307\310\311!\203]
@\211@\262
\312=\2039
@\211A@\247\204.\211AA\262
\2022\211A\262
\307\225\241\210\202]\312\307\224\307\225BB
B\211@\211\211A@\247\204U\211AA\262
\202Y\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# whitespace] 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 (#$ . 43163))
(defalias 'semantic-lex-ignore-newline #[0 "\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))) #[0 "\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 (#$ . 43949))
(defalias 'semantic-lex-whitespace #[0 "\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))))) #[0 "\306``dB\307\310\311!\203_
@\211@\262
\312=\203;\307\225
@\211A@\247\2041\211AA\262
\2025\211A\262
\f\241\210\202_\312\307\224\307\225BB
B\211@\211\211A@\247\204W\211AA\262
\202[\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# whitespace] 6 "Detect and create whitespace tokens."]] 2)
#@41 Detect and skip over whitespace tokens.
(defvar semantic-lex-ignore-whitespace nil (#$ . 44957))
(defalias 'semantic-lex-ignore-whitespace #[0 "\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))) #[0 "\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 (#$ . 45540))
(defalias 'semantic-lex-number #[0 "\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)))) #[0 "\306``dB\307\310\n!\2037\311\307\224\307\225BB
B\211@\211\211A@\247\204/\211AA\262
\2023\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at number semantic-lex-number-expression] 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 (#$ . 46430))
(defalias 'semantic-lex-symbol-or-keyword #[0 "\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)))) #[0 "\306``dB\307\310\311!\203Z\312\307!\211\313!\205'\211;\205'\314
\"\262
\211\262\2051\211J\262
\2067\315\307\224\307\225BB
B\211@\211\211A@\247\204R\211AA\262
\202V\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# match-string obarrayp intern-soft symbol semantic-flex-keywords-obarray] 6 "Detect and create symbol and keyword tokens."]] 2)
#@37 Detect and create charquote tokens.
(defvar semantic-lex-charquote nil (#$ . 47356))
(defalias 'semantic-lex-charquote #[0 "\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)))) #[0 "\306``dB\307\310\311!\2036\312\307\224\307\225BB
B\211@\211\211A@\247\204.\211AA\262
\2022\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# charquote] 6 "Detect and create charquote tokens."]] 2)
#@39 Detect and create punctuation tokens.
(defvar semantic-lex-punctuation nil (#$ . 48040))
(defalias 'semantic-lex-punctuation #[0 "\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)))) #[0 "\306``dB\307\310\311!\2036\312\307\224\307\225BB
B\211@\211\211A@\247\204.\211AA\262
\2022\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# punctuation] 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 (#$ . 48757))
(defalias 'semantic-lex-punctuation-type #[0 "\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))))))) #[0 "\306``dB\307\310\311!\203\307\312\307!\307\224\307\225\211Z\313\314
\315!\2050\211;\2050\316
\"\262
\211\203;\211J\202C
?\205C\317!\266\203\211@
A\306
\203o\307V\203o\320\"\211\262\204oS\262\321\307#\262\202N\211\203\235\211@\211\\BB
B\211@\211\211A@\247\204\222\211AA\262
\202\226\211A\262
A\262
\202\305\203\305BB
B\211@\211\211A@\247\204\275\211AA\262
\202\301\211A\262
A\262
\266
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# match-string #2# t obarrayp intern-soft semantic-lex-type-invalid rassoc substring semantic-lex-types-obarray] 13 "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 (#$ . 50527))
(defalias 'semantic-lex-paren-or-list #[0 "\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))))))) #[0 "\306``dB\307\310\311!\203\232	\203\n	W\203F\nT\312\307\224\307\225BB
B\211@\211\211A@\247\204;\211AA\262
\202?\211A\262
A\262
\202\232\313\307\224\212\203\\\203\\\314\315!\210`\202z\3161i\314\315!\210`0\202z\210\313
@A#b\210`\211\262
)BB
B\211@\211\211A@\247\204\222\211AA\262
\202\226\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# open-paren semantic-list forward-list 1 (error) debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function] 8 "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 (#$ . 52100))
(defalias 'semantic-lex-open-paren #[0 "\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)))) #[0 "\306``dB\307\310\311!\2039\nT\312\307\224\307\225BB
B\211@\211\211A@\247\2041\211AA\262
\2025\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# open-paren] 6 "Detect and create an open parenthesis token."]] 2)
#@46 Detect and create a close parenthesis token.
(defvar semantic-lex-close-paren nil (#$ . 52875))
(defalias 'semantic-lex-close-paren #[0 "\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)))) #[0 "\306``dB\307\310\311!\2039\nS\312\307\224\307\225BB
B\211@\211\211A@\247\2041\211AA\262
\2025\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# close-paren] 6 "Detect and create a close parenthesis token."]] 2)
#@35 Detect and create a string token.
(defvar semantic-lex-string nil (#$ . 53655))
(defalias 'semantic-lex-string #[0 "\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)))))) #[0 "\306``dB\307\310\311!\203e\312`\212\203'\203'\313\314!\210`\202E\31514\313\314!\210`0\202E\210\312
@A#b\210`\211\262
)BB
B\211@\211\211A@\247\204]\211AA\262
\202a\211A\262
A\262

-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at #1# string forward-sexp 1 (error) debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function] 8 "Detect and create a string token."]] 2)
#@36 Detect and create a comment token.
(defvar semantic-lex-comments nil (#$ . 54588))
(defalias 'semantic-lex-comments #[0 "\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))))) #[0 "\306``dB\307\310
!\203k\212\311\312!\210n\203\313u\210`
@\211@\262
\314=\203G
@\211A@\247\204=\211AA\262
\202A\211A\262
\f\241\210\202j\314\307\224\fBB
B\211@\211\211A@\247\204b\211AA\262
\202f\211A\262
A\262
)
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at forward-comment 1 -1 comment semantic-lex-comment-regex] 6 "Detect and create a comment token."]] 2)
#@48 Detect comments and create a whitespace token.
(defvar semantic-lex-comments-as-whitespace nil (#$ . 55718))
(defalias 'semantic-lex-comments-as-whitespace #[0 "\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))))) #[0 "\306``dB\307\310
!\203k\212\311\312!\210n\203\313u\210`
@\211@\262
\314=\203G
@\211A@\247\204=\211AA\262
\202A\211A\262
\f\241\210\202j\314\307\224\fBB
B\211@\211\211A@\247\204b\211AA\262
\202f\211A\262
A\262
)
-\207" [semantic-lex-depth semantic-lex-maximum-depth semantic-lex-current-depth semantic-lex-analysis-bounds semantic-lex-end-point semantic-lex-token-stream nil 0 looking-at forward-comment 1 -1 whitespace semantic-lex-comment-regex] 6 "Detect comments and create a whitespace token."]] 2)
#@36 Detect and create a comment token.
(defvar semantic-lex-ignore-comments nil (#$ . 56923))
(defalias 'semantic-lex-ignore-comments #[0 "\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)))) #[0 "\306``dB\307\310!\203;`\311\312!\210`
=\203'\313\314\315 \"\210\202.n\203.\316u\210`
=\2038\317\320!\210`\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] 5 "Detect and create a comment token."]] 2)
#@275 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.

(fn START END &optional DEPTH LENGTH)
(defalias 'semantic-comment-lexer #[1026 "\306\307\310#\210`\306\211\211\311\206
*B+\306,dV\203.\312\313d#\210\314 p\315\311\316\317\320\"\321\"\322$\216\323-!\210b\210`W\203<
\203[	GX\203<
\324\325!\203g\311\225\202\331\324\326!\203s\311\225\202\331\324.!\203\325\212\327\330!\210n\203\206\331u\210`	@\211@\262
\332=\203\256	@\211A@\247\204\244\211AA\262
\202\250\211A\262
\241\210\202\321\332\311\224BB	B\211@\211\211A@\247\204\311\211AA\262
\202\315\211A\262
A\262
)\202\331\312\333!\210=\203\346\312\334	@#\210\262b\210/\203
\335 \204
r\3360!q\210\2120b\210\337 *\203
\340/\341\"\210	@1\2057
\306C\315\311\342\317\320!\343\"\322$\216
\203-
\211\344!\240\210\345\346\347\f#!)\262
\266\202I)\266\n\203s
\n\211A\242\211\211\203`
\350\351@A@#\210\n\211A\242\262
\202I

@2
+@+A#b\210`\211\266
b\210	\237.\207" [semantic-lex-block-streams semantic-lex-token-stream semantic-lex-block-stack semantic-lex-end-point semantic-lex-current-depth semantic-lex-depth nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-comment-lexer: end (%d) > point-max (%d)" syntax-table make-byte-code "r\301q\210\302\300!)\207" vconcat vector [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 "\300\242\205	\301\300\242!\207" [delete-overlay] semantic-lex-highlight-token read-event format "%S :: Depth: %d :: SPC - continue" message "semantic-comment-lexer: `%s' block from %S is unterminated" semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties semantic-lex-syntax-table semantic-lex-comment-regex semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug semantic-lex-unterminated-syntax-end-function] 17 (#$ . 57944)])
#@237 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.

(fn START END &optional DEPTH LENGTH)
(defalias 'semantic-simple-lexer #[1026 "\306\307\310#\210`\306\211\211\311\206
@BA\306BdV\203.\312\313d#\210\314 p\315\311\316\317\320\"\321\"\322$\216\323C!\210b\210`W\203\203[	GX\203\324\325!\203g\311\225\202\245\324\326!\203s\311\225\202\245\324D!\203\241\327\311\224\311\225BB	B\211@\211\211A@\247\204\226\211AA\262
\202\232\211A\262
A\262
\202\245\324\330!\203\362\331\311!\211\332E!\205\274\211;\205\274\333
E\"\262
\211\262\205\306\211J\262
\206\314\334\311\224\311\225BB	B\211@\211\211A@\247\204\347\211AA\262
\202\353\211A\262
A\262
\202\245\324\335!\203
\336\311\224\311\225BB	B\211@\211\211A@\247\204
\211AA\262
\202
\211A\262
A\262
\202\245\324\337!\203\264
@\2031
\f@W\203[
\fT\340\311\224\311\225BB	B\211@\211\211A@\247\204P
\211AA\262
\202T
\211A\262
A\262
\202\245\341\311\224\212F\203q
G\203q
\342\343!\210`\202\221
\3441~
\342\343!\210`0\202\221
\210\341H
A@AA#b\210`\211\262
)BB	B\211@\211\211A@\247\204\251
\211AA\262
\202\255
\211A\262
A\262
\202\245\324\345!\203\344
\fS\346\311\224\311\225BB	B\211@\211\211A@\247\204\331
\211AA\262
\202\335
\211A\262
A\262
\202\245\324\347!\203B\350`\212F\203\377
G\203\377
\351\343!\210`\202\3521\f\351\343!\210`0\202\210\350H
A@AA#b\210`\211\262
)BB	B\211@\211\211A@\247\2047\211AA\262
\202;\211A\262
A\262
\202\245\324I!\203t`\353\343!\210`
=\203]\354\355\356 \"\210\202dn\203d\357u\210`
=\203n\312\360!\210`\210\202\245\324\361!\203\241\362\311\224\311\225BB	B\211@\211\211A@\247\204\226\211AA\262
\202\232\211A\262
A\262
\202\245\312\363!\210=\203\262\312\364	@#\210\262b\210J\203\332\365 \204\324r\366K!q\210\212Kb\210\367 *\203\332\370J\371\"\210	@L\205\306C\315\311\372\317\320!\373\"\322$\216
\203\371\211\374!\240\210\375\376\377\f#!)\262
\266\202I)\266\n\203C\n\211A\242\211\211\2030\201M\201N@A@#\210\n\211A\242\262
\202
@H
A@AA#b\210`\211\266
b\210	\237.\207" [semantic-lex-block-streams semantic-lex-token-stream semantic-lex-block-stack semantic-lex-end-point semantic-lex-current-depth semantic-lex-depth nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-simple-lexer: end (%d) > point-max (%d)" syntax-table make-byte-code "r\301q\210\302\300!)\207" vconcat vector [set-syntax-table] 2 set-syntax-table looking-at "\\s-+" "\\s-*\\(\n\\|\\s>\\)" number "\\(\\sw\\|\\s_\\)+" match-string obarrayp 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 "\300\242\205	\301\300\242!\207" [delete-overlay] semantic-lex-highlight-token read-event format "%S :: Depth: %d :: SPC - continue" semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties semantic-lex-syntax-table semantic-lex-number-expression semantic-flex-keywords-obarray debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function semantic-lex-comment-regex semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug message "semantic-simple-lexer: `%s' block from %S is unterminated"] 17 (#$ . 60208)])
#@142 Define a keyword type analyzer NAME with DOC string.
SYNTAX is the regexp that matches a keyword syntactic expression.

(fn NAME DOC SYNTAX)
(defalias 'define-lex-keyword-type-analyzer '(macro . #[771 "\300\301!\302\303\304D\305\306BC\307\310\311\312BBDEEEF\207" [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))] 17 (#$ . 63950)]))
#@205 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.

(fn NAME DOC SYNTAX TOKEN)
(defalias 'define-lex-sexp-type-analyzer '(macro . #[1028 "\300\301\302\303\304\305\n\306BBDFD\257\207" [define-lex-regex-analyzer semantic-lex-push-token semantic-lex-token (point) save-excursion semantic-lex-unterminated-syntax-protection ((forward-sexp 1) (point))] 16 (#$ . 64436)]))
#@293 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.

(fn NAME DOC SYNTAX MATCHES DEFAULT)
(defalias 'define-lex-regex-type-analyzer '(macro . #[1285 "
\203i\300\301!\300\302!\300\303!\300\304!\300\305!\306\n\n\307\310\fD\311\n\312B\313B\314B\fD\f\257\315\307\f\316
DE\317\320\321DE\322\323DE\322\324DEFE\325\326\327
E\f\fFDFEF\207\330\257\207" [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] 26 (#$ . 64942)]))
#@293 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.

(fn NAME DOC SYNTAX MATCHES DEFAULT)
(defalias 'define-lex-string-type-analyzer '(macro . #[1285 "
\203\217\300\301!\300\302!\300\303!\300\304!\300\305!\300\306!\307\310\311
D\312\313B	\314B	\315B	\316\fEDD\257\317\310\320\n\321BB\322\323\324EEDE\323\n\325\fD\326\327F\257E\330\f\323\331D\332E\257E\333\334\335EFD\257EF\207\336\257\207" [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] 28 (#$ . 65817)]))
#@2348 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.

(fn NAME DOC SYNTAX MATCHES)
(defalias 'define-lex-block-type-analyzer '(macro . #[1028 "\300\301!\300\302!\300\303!\304\305\306	D\307\310BDE\311\312	\313
\314DEE\315\316\317\320\321\322\323\324E\325BBDE\321\322\323\326E\327\330\331\323\326E\332BBDFDFD\312\n\313\333DEE\334\321\322\323\324E\335BBDEEEEF\207" [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))] 28 (#$ . 66781)]))
#@354 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.

(fn SYMBOL &rest FORMS)
(defalias 'semantic-lex-catch-errors '(macro . #[385 "\300\301!\300\302!\300\303!\300\304!\305\306\307E\310\311DEED\312\313\311D\314\315\f\316\"BEDE\317\320BBF\207" [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))] 16 (#$ . 70043)]))
(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 #[0 "\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 (#$ . 72340))
#@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 #[771 "\207" [] 4 "\n\n(fn SYNTAX SYNTAX-START FLEX-END)"] (#$ . 72480))
#@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 (#$ . 73081))
(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 (#$ . 73568))
(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 (#$ . 74022))
(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 (#$ . 74265))
(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 (#$ . 74559))
(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 (#$ . 74853))
(make-variable-buffer-local 'semantic-flex-enable-bol)
#@48 See variable `semantic-lex-number-expression'.
(defvar semantic-number-expression semantic-lex-number-expression (#$ . 75143))
(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 (#$ . 75333))
(make-variable-buffer-local 'semantic-flex-depth)
#@774 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.

(fn START END &optional DEPTH LENGTH)
(defalias 'semantic-flex #[1026 "\204\306\307`\307\310	\203\311	\312Q\202\313\314\315 !\n\206!
\2037\316@@@A@#\210
A\262\202!\315 p\317\310\320\321\322\"\323\"\324$\216\325!\210
b\210`
W\203\256\n\203f	GX\203\256\f\203xn\203x\326``BB\nB\262\n
\203\267
\307
\203\243\327@@!\203\234
@A \fB\262\f\330\262
\307\262`\262\n
A\262\202~\211\203\262@\204\262A\262\f\262
\204\237\327\331!\203\325<\203\237\332\225\262\333\332\224	BB\nB\262\n\202\237\327\334!\203
=\203\237	@@\335=\203\364	@A\310\225\241\210\202\237\335\310\224\310\225BB\nB\262\n\202\237>\203
\327>!\203
\336\310\224\310\225BB\nB\262\n\202\237\327\337!\203U
\340\310!\211\341!\2057
\211;\2057
\342
\"\262
\211\262\205A
\211J\262
\206G
\343\310\224\310\225BB\nB\262\n\202\237\327\344!\203j
\345\310\224\310\225BB\nB\262\n\202\237\327\346!\203\270
\203{
W\203\217
T\262\347\310\224\310\225BB\nB\262\n\202\237\350\310\224\212\3511\236
\352\332!0\202\250
\210?\350#b\210`\211\262)BB\nB\262\n\202\237\327\353!\203\322
\354\310\224\310\225BB\nB\262\nS\262\202\237\327\355!\203
\356\310\224\212\3571\347
\360\332!0\202\361
\210?\356#b\210`\211\262)BB\nB\262\n\202\237\327!\203\206@\203C=\204C`\361\332!\210`
=\203&\362\363\364 \"\210\2022<\2032n\2032\365u\210`
=\203<\366\367!\210`\262	\210\202\237@\203L\335\202M\370\212\361\332!\210<\203^n\203^\365u\210`\262	)\n@@
=\203v\n@A	\241\210\202\202\211\310\224\nBBB\262\210\202\237\327\371!\203\233\372\310\224\310\225BB\nB\262\n\202\237\366\373!\210\206\246\310\225b\210\307\262\202Q)\266\f\203\312`U\203\312n\203\312\326``BBB\262b\210\237\207" [semantic-flex-keywords-obarray comment-start-skip semantic-flex-syntax-modifications semantic-flex-depth semantic-flex-enable-bol semantic-flex-extensions [nil] nil 0 "\\(\\s<\\|" "\\)" "\\(\\s<\\)" copy-syntax-table syntax-table modify-syntax-entry make-byte-code "r\301q\210\302\300!)\207" vconcat vector [set-syntax-table] 2 set-syntax-table bol looking-at t "\\s-*\\(\n\\|\\s>\\)" 1 newline "\\s-+" whitespace number "\\(\\sw\\|\\s_\\)+" match-string obarrayp 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?" semantic-flex-enable-newlines semantic-flex-enable-whitespace semantic-number-expression semantic-flex-unterminated-syntax-end-function semantic-ignore-comments] 21 (#$ . 75508)])
(byte-code "\300\301\302\303#\210\304\305!\207" [make-obsolete semantic-flex define-lex "23.2" provide semantic/lex] 4)