
    Xh]                        d dl mZmZ d dlZd dlmZ d dlmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZ d dlmZ d dlZ	 d dlZerddlmZ ddlmZ dd	lmZmZmZm Z  dd
l!m"Z"m#Z#m$Z$ ddl%m&Z& d dl'm'Z' 	  e(e      Z) G d dee      Z+ G d de+      Z, G d de+      Z- G d de      Z. edd      Z/ G d de0      Z1 G d d      Z2 G d d      Z3 G d d      Z4d  Z5d! Z6 G d" d#      Z7d$e0fd%Z8 G d& d'      Z9 G d( d)      Z:ee1ge1f   Z; G d* d+e      Z<d4d,e	e.e0f   fd-Z= G d. d/e<      Z> G d0 d1e>      Z? G d2 d3e<      Z@y# e$ r Y w xY w# e*$ r dZ)Y w xY w)5    )abstractmethodABCN)suppress)TypeVarTypeDictIterator
CollectionCallableOptional	FrozenSetAnyClassVarTYPE_CHECKINGoverload)
ModuleType   )	LexerConf)ParserState)classifyget_regexp_width	Serializelogger)UnexpectedCharactersLexErrorUnexpectedToken)TOKEN_DEFAULT_PRIORITY)copyFc            	           e Zd ZU dZeed<   ee   ed<   ee   ed<   ee   ed<   ddedee   dee   ddfdZ	d	 Z
d
 Zd Zedefd       Zeedefd              Zeedefd              Zd Zy)Patternz(An abstraction over regular expressions.valueflagsrawtypeNreturnc                 @    || _         t        |      | _        || _        y N)r!   	frozensetr"   r#   )selfr!   r"   r#   s       >/var/www/html/myenv/lib/python3.12/site-packages/lark/lexer.py__init__zPattern.__init__)   s    
u%
    c                 4    t        | j                               S r'   )repr	to_regexpr)   s    r*   __repr__zPattern.__repr__.   s    DNN$%%r,   c                 X    t        t        |       | j                  | j                  f      S r'   )hashr$   r!   r"   r0   s    r*   __hash__zPattern.__hash__2   s     T$ZTZZ899r,   c                     t        |       t        |      k(  xr4 | j                  |j                  k(  xr | j                  |j                  k(  S r'   )r$   r!   r"   r)   others     r*   __eq__zPattern.__eq__5   s<    DzT%[(dTZZ5;;-Fd4::Y^YdYdKddr,   c                     t               r'   NotImplementedErrorr0   s    r*   r/   zPattern.to_regexp8   s    !##r,   c                     t               r'   r:   r0   s    r*   	min_widthzPattern.min_width<        "##r,   c                     t               r'   r:   r0   s    r*   	max_widthzPattern.max_widthA   r>   r,   c                 :    | j                   D ]  }d|d|d} |S )Nz(?:))r"   )r)   r!   fs      r*   
_get_flagszPattern._get_flagsF   s$     	.A#$e,E	.r,   ) N)__name__
__module____qualname____doc__str__annotations__r
   r   r   r+   r1   r4   r8   r   r/   propertyintr=   r@   rE   rF   r,   r*   r    r    !   s    .Jc?	#
3-c *S/ Xc] ^b 
&:e $3 $ $ $3 $  $ $3 $  $r,   r    c                   ^    e Zd ZU dZdZee   ed<   defdZe	de
fd       Ze	de
fd       Zy)	
PatternStr)r!   r"   r#   rK   r$   r%   c                 ^    | j                  t        j                  | j                              S r'   )rE   reescaper!   r0   s    r*   r/   zPatternStr.to_regexpQ   s    ryy455r,   c                 ,    t        | j                        S r'   lenr!   r0   s    r*   r=   zPatternStr.min_widthT       4::r,   c                 ,    t        | j                        S r'   rU   r0   s    r*   r@   zPatternStr.max_widthX   rW   r,   N)rG   rH   rI   __serialize_fields__r$   r   rK   rL   r/   rM   rN   r=   r@   rF   r,   r*   rP   rP   L   sX    2D(3-63 6 3   3  r,   rP   c                   h    e Zd ZU dZdZee   ed<   defdZdZ	d Z
edefd       Zedefd	       Zy)
	PatternRE)r!   r"   r#   _widthrR   r$   r%   c                 8    | j                  | j                        S r'   )rE   r!   r0   s    r*   r/   zPatternRE.to_regexpb   s    tzz**r,   Nc                 n    | j                   t        | j                               | _         | j                   S r'   )r\   r   r/   r0   s    r*   
_get_widthzPatternRE._get_widthf   s)    ;;*4>>+;<DK{{r,   c                 (    | j                         d   S Nr   r_   r0   s    r*   r=   zPatternRE.min_widthk        ##r,   c                 (    | j                         d   S )Nr   rb   r0   s    r*   r@   zPatternRE.max_widtho   rc   r,   )rG   rH   rI   rY   r$   r   rK   rL   r/   r\   r_   rM   rN   r=   r@   rF   r,   r*   r[   r[   ]   sd    <D(3-+3 + F
 $3 $ $ $3 $ $r,   r[   c            	       j    e Zd ZU dZdZeefZee	d<   e
e	d<   ee	d<   efdede
deddfdZd	 Zdefd
Zy)TerminalDefzA definition of a terminal)namepatternpriorityrg   rh   ri   r%   Nc                 \    t        |t              sJ |       || _        || _        || _        y r'   )
isinstancer    rg   rh   ri   )r)   rg   rh   ri   s       r*   r+   zTerminalDef.__init__}   s,    '7+4W4+	 r,   c                 f    t        |       j                  d| j                  d| j                  dS )N(, rC   )r$   rG   rg   rh   r0   s    r*   r1   zTerminalDef.__repr__   s!    #Dz22DIIt||LLr,   c                     | j                   j                  d      r$| j                  j                  xs | j                   S | j                   S )N__)rg   
startswithrh   r#   r0   s    r*   	user_reprzTerminalDef.user_repr   s7    99%<<##0tyy099r,   )rG   rH   rI   rJ   rY   rP   r[   __serialize_namespace__rK   rL   r    rN   r   r+   r1   rr   rF   r,   r*   rf   rf   t   s]     8()3
IMDZ !S !7 !c !_c !M3 r,   rf   _TToken)boundc                   ^    e Zd ZU dZdZdZeed<   ee	   ed<   e
ed<   ee	   ed<   ee	   ed<   ee	   ed	<   ee	   ed
<   ee	   ed<   e	 	 	 	 	 	 ddede
dee	   dee	   dee	   d	ee	   d
ee	   dee	   dd fd       Ze	 	 	 	 	 	 ddede
dee	   dee	   dee	   d	ee	   d
ee	   dee	   dd fd       Zd Zed fd	       Zeddee   dee
   dd fd       Zeddee   dee
   dd fd       Zd Zddee   dee
   dd fdZedee   dede
dd def
d       Zd Zd Zd Zd Zej0                  Z xZS )ru   a  A string with meta-information, that is produced by the lexer.

    When parsing text, the resulting chunks of the input that haven't been discarded,
    will end up in the tree as Token instances. The Token class inherits from Python's ``str``,
    so normal string comparisons and operations will work as expected.

    Attributes:
        type: Name of the token (as specified in grammar)
        value: Value of the token (redundant, as ``token.value == token`` will always be true)
        start_pos: The index of the token in the text
        line: The line of the token in the text (starting with 1)
        column: The column of the token in the text (starting with 1)
        end_line: The line where the token ends
        end_column: The next column after the end of the token. For example,
            if the token is a single character with a column value of 4,
            end_column will be 5.
        end_pos: the index where the token ends (basically ``start_pos + len(token)``)
    )r$   	start_posr!   linecolumnend_line
end_columnend_posr$   r!   r$   rx   r!   ry   rz   r{   r|   r}   r%   c	                      y r'   rF   )	clsr$   r!   rx   ry   rz   r{   r|   r}   s	            r*   __new__zToken.__new__   s     	r,   type_c	                      y r'   rF   )	r   r   r!   rx   ry   rz   r{   r|   r}   s	            r*   r   zToken.__new__   s     r,   c                     d|v r=t        j                  dt               d|v rt        d      |j	                  d      |d<    | j
                  |i |S Nr   z(`type_` is deprecated use `type` insteadr$   zAError: using both 'type' and the deprecated 'type_' as arguments.)warningswarnDeprecationWarning	TypeErrorpop_future_new)r   argskwargss      r*   r   zToken.__new__   sV    fMMDFXY cdd#ZZ0F6Ns///r,   c	                     t         t        |   | |      }	||	_        ||	_        ||	_        ||	_        ||	_        ||	_        ||	_	        ||	_
        |	S r'   )superru   r   r$   rx   r!   ry   rz   r{   r|   r}   )r   r$   r!   rx   ry   rz   r{   r|   r}   inst	__class__s             r*   r   zToken._future_new   sS    UC(e4	"
	 $r,   c                      y r'   rF   r)   r$   r!   s      r*   updatezToken.update       r,   c                      y r'   rF   )r)   r   r!   s      r*   r   zToken.update   r   r,   c                     d|v r=t        j                  dt               d|v rt        d      |j	                  d      |d<    | j
                  |i |S r   )r   r   r   r   r   _future_update)r)   r   r   s      r*   r   zToken.update   sX    fMMDFXY cdd#ZZ0F6N"t""D3F33r,   c                 r    t         j                  ||n| j                  |||       S | j                  |       S r'   )ru   new_borrow_posr$   r!   r   s      r*   r   zToken._future_update   sB    ##$D$))&E
 	
,0JJ
 	
r,   r   borrow_tc           
           | |||j                   |j                  |j                  |j                  |j                  |j
                        S r'   )rx   ry   rz   r{   r|   r}   )r   r   r!   r   s       r*   r   zToken.new_borrow_pos   sP    5%!3!3X]]HOOU]UfUfhph{h{  ~F  ~N  ~N  O  	Or,   c                     | j                   | j                  | j                  | j                  | j                  | j
                  ffS r'   )r   r$   r!   rx   ry   rz   r0   s    r*   
__reduce__zToken.__reduce__   s3    DJJ		SWS^S^ _``r,   c                 <    d| j                   d| j                  dS )NzToken(rn   rC   r~   r0   s    r*   r1   zToken.__repr__  s    "&))TZZ88r,   c                     t        | j                  | j                  | j                  | j                  | j
                        S r'   )ru   r$   r!   rx   ry   rz   )r)   memos     r*   __deepcopy__zToken.__deepcopy__  s)    TYY

DNNDIIt{{SSr,   c                     t        |t              r| j                  |j                  k7  ryt        j	                  | |      S )NF)rk   ru   r$   rK   r8   r6   s     r*   r8   zToken.__eq__	  s/    eU#		UZZ(?zz$&&r,   )NNNNNNNN)rG   rH   rI   rJ   	__slots____match_args__rK   rL   r   rN   r   r   r   classmethodr   r   r   r   rt   r   r   r1   r   r8   r4   __classcell__)r   s   @r*   ru   ru      s   $ fI&N
I}J
3-SMsmc] 
 (,"&$(&*(,%)   }	
 3- SM sm ! c] 
  
 (,"&$(&*(,%)

 
  }	

 3-
 SM
 sm
 !
 c]
 

 
0   8C=  QX   HSM # RY  4
8C= 
 
Y` 
 ODH OS O O OTV O Oa9T' ||Hr,   c                   .    e Zd ZdZdZd Zd ZddefdZy)	LineCounterz>A utility class for keeping track of line & column information)char_posry   rz   line_start_posnewline_charc                 J    || _         d| _        d| _        d| _        d| _        y )Nr   r   )r   r   ry   rz   r   )r)   r   s     r*   r+   zLineCounter.__init__  s'    (	r,   c                     t        |t              st        S | j                  |j                  k(  xr | j                  |j                  k(  S r'   )rk   r   NotImplementedr   r   r6   s     r*   r8   zLineCounter.__eq__  s;    %-!!}}.Z43D3DHZHZ3ZZr,   tokenc                 J   |rb|j                  | j                        }|rE| xj                  |z  c_        | j                  |j	                  | j                        z   dz   | _        | xj                  t        |      z  c_        | j                  | j
                  z
  dz   | _        y)zConsume a token and calculate the new line & column.

        As an optional optimization, set test_newline=False if token doesn't contain a newline.
        r   N)countr   ry   r   rindexr   rV   rz   )r)   r   test_newlinenewliness       r*   feedzLineCounter.feed$  s    
 {{4#4#45H		X%	&*mmell4CTCT6U&UXY&Y#U#mmd&9&99A=r,   N)T)	rG   rH   rI   rJ   r   r+   r8   ru   r   rF   r,   r*   r   r     s!    DNI [>% >r,   r   c                       e Zd Zd Zd Zy)UnlessCallbackc                     || _         y r'   )scanner)r)   r   s     r*   r+   zUnlessCallback.__init__4  s	    r,   c                 j    | j                   j                  |j                  d      }|r
|\  }|_        |S ra   )r   matchr!   r$   )r)   tres_values       r*   __call__zUnlessCallback.__call__7  s/    ll  !, NFAFr,   NrG   rH   rI   r+   r   rF   r,   r*   r   r   3  s    r,   r   c                       e Zd Zd Zd Zy)	CallChainc                 .    || _         || _        || _        y r'   )	callback1	callback2cond)r)   r   r   r   s       r*   r+   zCallChain.__init__?  s    ""	r,   c                 l    | j                  |      }| j                  |      r| j                  |      S |S r'   )r   r   r   )r)   r   t2s      r*   r   zCallChain.__call__D  s.    ^^A$(IIbMt~~a 9r9r,   Nr   rF   r,   r*   r   r   >  s    
:r,   r   c                 P    | j                  |||      }|r|j                  d      S y ra   )r   group)re_regexpsr"   ms        r*   
_get_matchr   I  s*    		&!U#Awwqz 	r,   c           
         t        | d       }t        |      dk  sJ |j                                t               }i }|j	                  t
        g       D ]  }g }|j	                  t        g       D ]  }	|	j                  |j                  k7  r|	j                  j                  }
|
t        ||j                  j                         |
|      k(  s]|j                  |	       |	j                  j                  |j                  j                  k  s|j                  |	        |st        t!        |||d|            ||j"                  <    | D cg c]	  }||vs| }}||fS c c}w )Nc                 ,    t        | j                        S r'   )r$   rh   r   s    r*   <lambda>z _create_unless.<locals>.<lambda>O  s    4		? r,      T)match_whole	use_bytes)r   rV   keyssetgetr[   rP   ri   rh   r!   r   r/   appendr"   addr   Scannerrg   )	terminalsg_regex_flagsr   r   tokens_by_typeembedded_strscallbackretokunlessstrtokr   r   new_terminalss                r*   _create_unlessr   N  sH   i)BCN~!#:^%8%8%::#EMH##Ir2 ~$((R8 	.F%..0$$AJsEMM$;$;$=q-PPf%>>''5==+>+>>!%%f-	. #1'&-QTbfr{2|#}HUZZ ~ !*D1Qm-CQDMD("" Es   	E E c                        e Zd ZddZd Zd Zy)r   c                     || _         || _        || _        || _        || _        | j                   D ch c]  }|j
                   c}| _        | j                  |t        |            | _	        y c c}w r'   )
r   r   r   r   r   rg   allowed_types_build_mresrV   _mres)r)   r   r   r   r   r   r   s          r*   r+   zScanner.__init__e  s_    "*"&.2nn=aff=%%iY@
 >s   A.c                 l   | j                   rdndg }|rzdj                  fd|d | D              }| j                  r|j                  d      }	 | j                  j                  || j                        }|j                  |       ||d  }|rz|S # t        $ r | j                  ||dz        cY S w xY w)N$ |c              3   z   K   | ]2  }d |j                   d|j                  j                         z   d 4 yw)z(?P<>rC   N)rg   rh   r/   ).0r   postfixs     r*   	<genexpr>z&Scanner._build_mres.<locals>.<genexpr>w  s.     x^_9L9L9NQX9X Yxs   8;zlatin-1r   )
r   joinr   encoder   compiler   AssertionErrorr   r   )r)   r   max_sizemresrh   mrer   s         @r*   r   zScanner._build_mresp  s     ))#riixclmvnvcwxxG~~!..3Bhh&&w0B0BC KK!(),I   " B''	8q=AABs   &B B32B3c                     | j                   D ]5  }|j                  ||      }|s|j                  d      |j                  fc S  y ra   )r   r   r   	lastgroup)r)   textposr   r   s        r*   r   zScanner.match  s?    :: 	/C		$$Awwqz1;;..	/r,   N)F)rG   rH   rI   r+   r   r   rF   r,   r*   r   r   d  s    	A&/r,   r   rc                 F    d| v xs d| v xs d| v xs d| v xs
 d| v xr d| v S )zExpressions that may indicate newlines in a regexp:
        - newlines (\n)
        - escaped newline (\\n)
        - anything but ([^...])
        - any-char (.) when the flag (?s) exists
        - spaces (\s)
    
z\nz\sz[^z(?s.rF   )r  s    r*   _regexp_has_newliner    s>     19Z
ZeqjZDAIZ%1*BYQTXYQYZr,   c                   h    e Zd ZU dZdZeed<   eed<   ee	   ed<   d
dedee   dee	   fdZ
d Zd	 Zy)
LexerStatezRepresents the current state of the lexer as it scans the text
    (Lexer objects are only instantiated per grammar, not per text)
    )r   line_ctr
last_tokenr   r	  r
  Nc                 l    || _         |xs t        t        |t              rdnd      | _        || _        y )N   
r  )r   r   rk   bytesr	  r
  )r)   r   r	  r
  s       r*   r+   zLexerState.__init__  s-    	 [KD%9PVZ$[$r,   c                     t        |t              st        S | j                  |j                  u xr4 | j                  |j                  k(  xr | j
                  |j
                  k(  S r'   )rk   r  r   r   r	  r
  r6   s     r*   r8   zLexerState.__eq__  sL    %,!!yyEJJ&r4==ENN+JrtbgbrbrOrrr,   c                 v     t        |       | j                  t        | j                        | j                        S r'   )r$   r   r   r	  r
  r0   s    r*   __copy__zLexerState.__copy__  s(    tDz$))T$--%8$//JJr,   r   )rG   rH   rI   rJ   r   rK   rL   r   r   ru   r+   r8   r  rF   r,   r*   r  r    sU     1I
I%S %H[,A %T\]bTc %
sKr,   r  c                   N    e Zd ZdZdddefdZedddedd fd       Zd	 Z	d
 Z
eZy)LexerThreadzTA thread that ties a lexer instance and a lexer state, to be used by the parser
    lexerLexerlexer_statec                      || _         || _        y r'   )r  state)r)   r  r  s      r*   r+   zLexerThread.__init__  s    
 
r,   r   r%   c                 &     | |t        |            S r'   r  )r   r  r   s      r*   	from_textzLexerThread.from_text  s    5*T*++r,   c                 N    | j                   j                  | j                  |      S r'   )r  lexr  )r)   parser_states     r*   r  zLexerThread.lex  s    zz~~djj,77r,   c                 `     t        |       | j                  t        | j                              S r'   )r$   r  r   r  r0   s    r*   r  zLexerThread.__copy__  s"    tDz$**d4::&677r,   N)rG   rH   rI   rJ   r  r+   r   rK   r  r  r  ru   _TokenrF   r,   r*   r  r    sT    !g !J ! ,g ,S ,] , ,88 Fr,   r  c                   :    e Zd ZdZedededee   fd       Z	d Z
y)r  zlLexer interface

    Method Signatures:
        lex(self, lexer_state, parser_state) -> Iterator[Token]
    r  r  r%   c                     t         S r'   )r   )r)   r  r  s      r*   r  z	Lexer.lex  s    r,   c                     t        |      S )
Deprecatedr  )r)   r   s     r*   make_lexer_statezLexer.make_lexer_state  s    $r,   N)rG   rH   rI   rJ   r   r  r   r	   ru   r  r$  rF   r,   r*   r  r    s9    
 z  %   r,   r  terminal_to_regexpc                    |st         j                  j                  |       }|rdnd}|j                         |k\  ry t	        | d       j                         D ]  }|j                  |d      D ]  \  }}|j                  |j                  k(  sJ |j                  ||       d|j                   d|j                   d}	 |j                  |||      j                         }	|rt        | d
|	       t        j                  d||	       |j                         |k\  st        j                  d         y   y # t        $ r d	}	Y fw xY w)Nr   g?c                     | j                   S r'   )ri   r   s    r*   r   z)_check_regex_collisions.<locals>.<lambda>  s
    

 r,   T)skip_markedzCollision between Terminals z and z. zONo example could be found fast enough. However, the collision does still existsr  z5%s The lexer will choose between them arbitrarily.
%sz2Found 8 regex collisions, will not check for more.)interegular
Comparatorfrom_regexescount_marked_pairsr   valuescheckri   markrg   get_example_overlapformat_multiline
ValueErrorr   r   warning)
r%  
comparatorstrict_modemax_collisions_to_showmax_timer   abmessageexamples
             r*   _check_regex_collisionsr<    sO    ++889KL
  qSH $$&*@@,.BCJJL $$U$= 	DAq::+++OOAq! 5QVVHE!&&LGl$88AxHYY[ '"WI677NNSU\^ef,,.2HHST#	  lkls   >!D88EEc                   p    e Zd ZU eeef   ed<   ed
dd       Zed
de	de
defd       Zde	de
dee   fd	Zy)AbstractBasicLexerterminals_by_nameNr%   c                      y r'   rF   )r)   confr4  s      r*   r+   zAbstractBasicLexer.__init__  r   r,   	lex_stater  c                      y r'   rF   )r)   rB  r  s      r*   
next_tokenzAbstractBasicLexer.next_token  r   r,   r  c              #   n   K   t        t              5  	 | j                  ||       # 1 sw Y   y xY wwr'   )r   EOFErrorrD  )r)   r  r  s      r*   r  zAbstractBasicLexer.lex   s6     h 	;ooe\:: 	; 	;s   5)25r'   rA  r   r%   N)rG   rH   rI   r   rK   rf   rL   r   r+   r  r   ru   rD  r	   r  rF   r,   r*   r>  r>    sk    C,--  J c U  ; ;3 ;8E? ;r,   r>  c                       e Zd ZU ee   ed<   ee   ed<   ee   ed<   eee	f   ed<   eee	f   ed<   e
ed<   ddd	Zd
 Zed        Zd ZddededefdZy)
BasicLexerr   ignore_typesnewline_typesuser_callbacksr   rR   Nr%   c                    t        |j                        }t        d |D              sJ |       |j                  | _        |j
                  sIi }|D ]  }|j                  j                         }	 | j                  j                  ||j                         |j                  j                  dk(  r&t        d|j                  d|j                  d      |j                  j                  dk(  s|||<    t        |j                         |D ch c]  }|j                   c}k  s<t        dt        |j                         |D ch c]  }|j                   c}z
  z        t"        rt%        |||j&                         n|j&                  rt        d	      t)        d
 |D              | _        t)        |j                         | _        |j/                  d        || _        |j0                  | _        |j                  | _	        |j4                  | _        |j6                  | _        d | _        y # | j                  j                  $ r& t        d|j                  d|j                        w xY wc c}w c c}w )Nc              3   <   K   | ]  }t        |t                y wr'   )rk   rf   r   r   s     r*   r   z&BasicLexer.__init__.<locals>.<genexpr>  s     A!:a-As   zCannot compile token z: r   z,Lexer does not allow zero-width terminals. (rC   rR   z$Ignore terminals are not defined: %szUinteregular must be installed for strict mode. Use `pip install 'lark[interegular]'`.c              3   |   K   | ]4  }t        |j                  j                               s'|j                   6 y wr'   )r  rh   r/   rg   rO  s     r*   r   z&BasicLexer.__init__.<locals>.<genexpr>,  s,     &o!DWXYXaXaXkXkXmDnqvv&os   (<<c                     | j                    | j                  j                   t        | j                  j                         | j
                  fS r'   )ri   rh   r@   rV   r!   rg   )xs    r*   r   z%BasicLexer.__init__.<locals>.<lambda>/  s9    qzzkAII4G4G3G#aiiooJ^I^`a`f`f%g r,   )key)listr   all	re_modulerR   skip_validationrh   r/   r   r   errorr   rg   r=   r$   r   ignorehas_interegularr<  strictr(   rK  rJ  sort	callbacksrL  r   r?  _scanner)r)   rA  r4  r   r%  r   r   s          r*   r+   zBasicLexer.__init__  s   (	AyAAL9LA..##!# 
3,,.XGGOOFD,>,>? 99&&!+"\]\b\bdedmdm#noo99>>T),2&q)
3 $(CA(CCET[[IYmv\whi]^]c]c\wIwxyy'(:JTvww '&oy&oo%dkk2gh""nn!//!%!7!77 ww}} X"AFFAII#VWWX )D\ws   /&H-I/I4-?I,c                    t        | j                  | j                  | j                  | j                        \  }| _        t        | j
                  j                               sJ | j                  j                         D ]M  \  }| j
                  v r+t        | j
                     |fd      | j
                  <   ?|| j
                  <   O t        || j                  | j                  | j                        | _        y )Nc                 "    | j                   k(  S r'   )r$   )r   r   s    r*   r   z+BasicLexer._build_scanner.<locals>.<lambda>?  s    TUTZTZ^cTc r,   )r   r   r   rR   r   r   rU  r-  rL  itemsr   r   r^  )r)   r   rD   r   s      @r*   _build_scannerzBasicLexer._build_scanner8  s    #1$..$BTBTVZV]V]_c_m_m#n 	4=4=='')***++113 	)HE1%'0u1EqJc'de$'(e$	)  	4+=+=twwWr,   c                 R    | j                   | j                          | j                   S r'   )r^  rb  r0   s    r*   r   zBasicLexer.scannerE  s"    == !}}r,   c                 :    | j                   j                  ||      S r'   )r   r   )r)   r   r  s      r*   r   zBasicLexer.matchK  s    ||!!$,,r,   rB  r  c           
      $   |j                   }|j                  t        |j                        k  r| j	                  |j                  |j                        }|s| j
                  j                  | j                  z
  }|sdh}t        |j                  |j                  |j                  |j                  ||j                  xr |j                  g|| j                        |\  }}|| j                  v }d }	|r|| j                  v r-t        |||j                  |j                  |j                        }	|j                  ||| j                   v        |	|j                  |	_        |j                  |	_        |j                  |	_        |	j(                  | j                  v r | j                  |	j(                     |	      }	|s't+        |	t              st-        d|	z        |	|_        |	S |j                  t        |j                        k  rt/        |       )Nz<END-OF-FILE>)allowedtoken_historyr  r?  z+Callbacks must return a token (returned %r))r	  r   rV   r   r   r   r   rJ  r   ry   rz   r
  r?  r   ru   r   rK  r{   r|   r}   r$   rk   r   rF  )
r)   rB  r  r	  r   rf  r!   r   ignoredr   s
             r*   rD  zBasicLexer.next_tokenN  s   %%#inn"55**Y^^X->->?C,,44t7H7HH./G*9>>8;L;Lhmm]e]l]l3:)J^J^Jydmdxdxcy1=QUQgQgi i LE5t000GAet}}4%(9(98==(//ZMM%$*<*<!<=}%]]
'$--	66T]]*-aff-a0A%a/&'TWX'XYY+,I(H7 #inn"55< tnr,   r'   rG  )rG   rH   rI   r
   rf   rL   r   rK   r   	_Callbackr   r+   rb  rM   r   r   r  r   ru   rD  rF   r,   r*   rI  rI    s    +&&C. S>!i((3	>""N(TX  
- J  c  U  r,   rI  c            	           e Zd ZU eeef   ed<   eed<   eZee   ed<   ddddeee	e
   f   de	e
   dd	fd
Zdedddee   fdZy	)ContextualLexerlexers
root_lexerrI  rA  r   statesalways_acceptr%   Nc                 
   t        |j                        }|j                  }t        |      }||_        t        rS|j
                  sGt        j                  j                  |D ci c]  }||j                  j                          c}      }nd }i }	i | _        |j                         D ]%  \  }
}t        |      }	 |	|   }|| j                  |
<   ' |j                  |u sJ d|_        | j#                  ||      | _        y c c}w # t        $ ru t        |      t        |j                         z  t        |      z  }t        |      }|D cg c]  }||v s||    nc c}w c}|_        | j#                  ||      }||	|<   Y w xY w)NT)rT  r   r?  r   rZ  rW  r)  r*  r+  rh   r/   rl  ra  r(   KeyErrorr   rY  rI  rm  )r)   rA  rn  ro  r   r?  	trad_confr   r4  lexer_by_tokensr  acceptsrS  r  
lexer_confns                   r*   r+   zContextualLexer.__init__w  sp   (	 22J	'	4#7#7$//<<`i=j[\aATATAV>V=jkJJDF$lln 	'NE7G$C-', "'DKK	' ""i///$(	!//)Z@) >k  -g,T[[)99C<NN!)_
FM'hQRVgQg(9!(<'h'h
$
J?',$-s+   #"C?:DAF		EE%FFr  r  r   c              #   n  K   	 	 | j                   |j                     }|j                  ||       .# t        $ r Y y t        $ rl}	 |j
                  }| j                  j                  ||      }t        ||j                  ||g| j                  j                        # t        $ r |w xY wd }~ww xY ww)N)r  rg  r?  )
rl  positionrD  rF  r   r
  rm  r   rf  r?  )r)   r  r  r  er
  r   s          r*   r  zContextualLexer.lex  s     	L$9$9:&&{LAA   	# 	(33
22;M%eQYYl[eZfz~  {J  {J  {\  {\  ]  ]' 	s7   B5/3 	B2B5B2ABB**B--B22B5)rF   )rG   rH   rI   r   rN   r>  rL   rI  r   r
   rK   r+   r  r	   ru   r  rF   r,   r*   rk  rk  q  s    (())""+5J'(5A[ A$sJsO7K2L A]ghk]l Atx A<z  8TY? r,   rk  )   )Aabcr   r   rR   
contextlibr   typingr   r   r   r	   r
   r   r   r   r   r   r   r   typesr   r   r)  ImportErrorcommonr   parsers.lalr_parser_stater   utilsr   r   r   r   
exceptionsr   r   r   grammarr   r   boolrZ  	NameErrorr    rP   r[   rf   rt   rK   ru   r   r   r   r   r   r   r  r  r  ri  r  r<  r>  rI  rk  rF   r,   r*   <module>r     s   $ 	      	 !6 @ @ G G + ;'O(i (V "$ $.) 0 T!AC AH> >B : :
#,#/ #/L[3 [K K4 * eWe^$	 C  [#5E0F @; ;"h# hV3e 3G  		   Os#   E /E E
EEE