
    bia                        d dl mZmZ d dl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mZm Z  dd	l!m"Z"m#Z#m$Z$ dd
l%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      Z0 edd      Z1 G d de2      Z3 G d d      Z4 G d d      Z5 G d d      Z6d  Z7d! Z8 G d" d#      Z9d$e2fd%Z: G d& d'      Z; G d( d)      Z<e
e3ge3f   Z= G d* d+e      Z>d4d,ee0e2f   fd-Z? G d. d/e>      Z@ G d0 d1e@      ZA G d2 d3e>      ZBy# e$ r Y w xY w# e,$ r dZ+Y w xY w)5    )abstractmethodABCN)TypeVarTypeDictIterator
CollectionCallableOptional	FrozenSetAnyClassVarTYPE_CHECKINGoverload)
ModuleType   )	LexerConf)ParserState)classifyget_regexp_width	Serializelogger	TextSliceTextOrSlice)UnexpectedCharactersLexErrorUnexpectedToken)TOKEN_DEFAULT_PRIORITY)suppress)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       E/home/cdr/jupyterlab/.venv/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$   r2   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)   NotImplementedErrorr2   s    r,   r1   zPattern.to_regexp8   s    !##r.   c                     t               r)   r<   r2   s    r,   	min_widthzPattern.min_width<        "##r.   c                     t               r)   r<   r2   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-   r3   r6   r:   r   r1   propertyintr?   rB   rG   rH   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%   rM   r&   r'   c                 ^    | j                  t        j                  | j                              S r)   )rG   reescaper#   r2   s    r,   r1   zPatternStr.to_regexpQ   s    ryy455r.   c                 ,    t        | j                        S r)   lenr#   r2   s    r,   r?   zPatternStr.min_widthT       4::r.   c                 ,    t        | j                        S r)   rW   r2   s    r,   rB   zPatternStr.max_widthX   rY   r.   N)rI   rJ   rK   __serialize_fields__r&   r   rM   rN   r1   rO   rP   r?   rB   rH   r.   r,   rR   rR   L   sX    2D(3-63 6 3   3  r.   rR   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%   _widthrT   r&   r'   c                 8    | j                  | j                        S r)   )rG   r#   r2   s    r,   r1   zPatternRE.to_regexpb   s    tzz**r.   Nc                 n    | j                   t        | j                               | _         | j                   S r)   )r^   r   r1   r2   s    r,   
_get_widthzPatternRE._get_widthf   s)    ;;*4>>+;<DK{{r.   c                 (    | j                         d   S Nr   ra   r2   s    r,   r?   zPatternRE.min_widthk        ##r.   c                 (    | j                         d   S )Nr   rd   r2   s    r,   rB   zPatternRE.max_widtho   re   r.   )rI   rJ   rK   r[   r&   r   rM   rN   r1   r^   ra   rO   rP   r?   rB   rH   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priorityri   rj   rk   r'   Nc                 \    t        |t              sJ |       || _        || _        || _        y r)   )
isinstancer"   ri   rj   rk   )r+   ri   rj   rk   s       r,   r-   zTerminalDef.__init__}   s,    '7+4W4+	 r.   c                 f    t        |       j                  d| j                  d| j                  dS )N(, rE   )r&   rI   ri   rj   r2   s    r,   r3   zTerminalDef.__repr__   s!    #Dz22DIIt||LLr.   c                     | j                   j                  d      r$| j                  j                  xs | j                   S | j                   S )N__)ri   
startswithrj   r%   r2   s    r,   	user_reprzTerminalDef.user_repr   s7    99%<<##0tyy099r.   )rI   rJ   rK   rL   r[   rR   r]   __serialize_namespace__rM   rN   r"   rP   r   r-   r3   rt   rH   r.   r,   rh   rh   t   s]     8()3
IMDZ !S !7 !c !_c !M3 r.   rh   _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 )rw   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&   rz   r#   r{   r|   r}   r~   r   r'   c	                      y r)   rH   )	clsr&   r#   rz   r{   r|   r}   r~   r   s	            r,   __new__zToken.__new__   s     	r.   type_c	                      y r)   rH   )	r   r   r#   rz   r{   r|   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)   )superrw   r   r&   rz   r#   r{   r|   r}   r~   r   )r   r&   r#   rz   r{   r|   r}   r~   r   inst	__class__s             r,   r   zToken._future_new   sS    UC(e4	"
	 $r.   c                      y r)   rH   r+   r&   r#   s      r,   updatezToken.update       r.   c                      y r)   rH   )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)   )rw   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)   )rz   r{   r|   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#   rz   r{   r|   r2   s    r,   
__reduce__zToken.__reduce__   s3    DJJ		SWS^S^ _``r.   c                 <    d| j                   d| j                  dS )NzToken(rp   rE   r   r2   s    r,   r3   zToken.__repr__  s    "&))TZZ88r.   c                     t        | j                  | j                  | j                  | j                  | j
                        S r)   )rw   r&   r#   rz   r{   r|   )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)rm   rw   r&   rM   r:   r8   s     r,   r:   zToken.__eq__	  s/    eU#		UZZ(?zz$&&r.   )NNNNNNNN)rI   rJ   rK   rL   	__slots____match_args__rM   rN   r   rP   r   r   r   classmethodr   r   r   r   rv   r   r   r3   r   r:   r6   __classcell__)r   s   @r,   rw   rw      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_posr{   r|   line_start_posnewline_charc                 J    || _         d| _        d| _        d| _        d| _        y )Nr   r   )r   r   r{   r|   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)   )rm   r   NotImplementedr   r   r8   s     r,   r:   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   r{   r   rindexr   rX   r|   )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)	rI   rJ   rK   rL   r   r-   r:   r   r   rH   r.   r,   r   r     s!    DNI [>+ >r.   r   c                        e Zd ZddZdefdZy)UnlessCallbackc                     || _         y r)   )scanner)r+   r   s     r,   r-   zUnlessCallback.__init__4  s	    r.   tc                 b    | j                   j                  |j                        }|||_        |S r)   )r   	fullmatchr#   r&   )r+   r   ress      r,   __call__zUnlessCallback.__call__7  s+    ll$$QWW-?AFr.   N)r   Scanner)rI   rJ   rK   r-   rw   r   rH   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.   N)rI   rJ   rK   r-   r   rH   r.   r,   r   r   >  s    
:r.   r   c                 P    | j                  |||      }|r|j                  d      S y rc   )match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!        ||||            ||j"                  <    | D cg c]	  }||vs| }}||fS c c}w )Nc                 ,    t        | j                        S r)   )r&   rj   r   s    r,   <lambda>z _create_unless.<locals>.<lambda>O  s    4		? r.      )	use_bytes)r   rX   keyssetgetr]   rR   rk   rj   r#   r   r1   appendr$   addr   r   ri   )	terminalsg_regex_flagsr   r   tokens_by_typeembedded_strscallbackretokunlessstrtokr   r   new_terminalss                r,   _create_unlessr   N  sE   i)BCN~!#:^%8%8%::#EMH##Ir2 l$((R8 	.F%..0$$AJsEMM$;$;$=q-PPf%>>''5==+>+>>!%%f-	. #1'&-QT`i2j#kHUZZ l !*D1Qm-CQDMD("" Es   	EEc                   :    e Zd Zd Zd ZdefdZdedee   fdZ	y)r   c                     || _         || _        || _        || _        | j                   D ch c]  }|j                   c}| _        | j                  |t        |            | _        y c c}w r)   )	r   r   r   r   ri   allowed_types_build_mresrX   _mres)r+   r   r   r   r   r   s         r,   r-   zScanner.__init__e  sW    "*".2nn=aff=%%iY@
 >s   A'c                 F   g }|rxdj                  d |d | D              }| j                  r|j                  d      }	 | j                  j	                  || j
                        }|j                  |       ||d  }|rx|S # t        $ r | j                  ||dz        cY S w xY w)N|c              3   r   K   | ]/  }d |j                   d|j                  j                         d 1 yw)z(?P<>rE   N)ri   rj   r1   .0r   s     r,   	<genexpr>z&Scanner._build_mres.<locals>.<genexpr>u  s'     nTU9L9L9N Ons   57zlatin-1r   )	joinr   encoder   compiler   AssertionErrorr   r   )r+   r   max_sizemresrj   mres         r,   r   zScanner._build_mreso  s     iinYbcldlYmnnG~~!..3Bhh&&w0B0BC KK!(),I   " B''	8q=AABs   &A? ?B B textc                     | j                   D ]J  }|j                  |j                  ||j                        }|s-|j	                  d      |j
                  fc S  y rc   )r   r   r   endr   	lastgroup)r+   r   posr   r   s        r,   r   zScanner.match  sI    :: 	/C		$))S$((3Awwqz1;;..	/r.   r'   c                 h    | j                   D ]#  }|j                  |      }|s|j                  c S  y r)   )r   r   r   )r+   r   r   r   s       r,   r   zScanner.fullmatch  s5    :: 	#Cd#A{{"	# r.   N)
rI   rJ   rK   r-   r   r   r   rM   r   r   rH   r.   r,   r   r   d  s0    A$/) /c hsm 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.rH   )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                    t        |t              r|ft        t        |j                  t              rdnd      }|j
                  dkD  r0|j                  t        |j                  d|j
                               |j
                  |j                  cxk  r|j                  k  st        d       t        d      || _        || _
        || _        y )N   
r  r   z%LineCounter.char_pos is out of bounds)rm   r   r   r   bytesstartr   r   r   
ValueErrorr	  r
  )r+   r   r	  r
  s       r,   r-   zLexerState.__init__  s    dI&&
499e0LuRVW::>MM)DIIq$**"EFJJ("3"3?txx? !HII @ !HII	 $r.   c                     t        |t              st        S | j                  |j                  k(  xr4 | j                  |j                  k(  xr | j
                  |j
                  k(  S r)   )rm   r  r   r   r	  r
  r8   s     r,   r:   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
  r2   s    r,   __copy__zLexerState.__copy__  s(    tDz$))T$--%8$//JJr.   r   )rI   rJ   rK   rL   r   r   rN   r   r   rw   r-   r:   r  rH   r.   r,   r  r    sU     1I
O%Y %(;2G %\dej\k %"sKr.   r  c                   r    e Zd ZdZdddee   fdZedddedd 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.   text_or_slicer'   c                 P    t        j                  |      } | |t        |            S r)   )r   	cast_fromr  )r   r  r  r   s       r,   	from_textzLexerThread.from_text  s$    ""=15*T*++r.   r   c                 &     | |t        |            S r)   )r  )r   r  r   s      r,   from_custom_inputzLexerThread.from_custom_input  s    5*T*++r.   c                 |    | j                   t        d      | j                  j                  | j                   |      S )Nz+Cannot lex: No text assigned to lexer state)r  r   r  lex)r+   parser_states     r,   r!  zLexerThread.lex  s1    ::IJJzz~~djj,77r.   c                 `     t        |       | j                  t        | j                              S r)   )r&   r  r    r  r2   s    r,   r  zLexerThread.__copy__  s"    tDz$**d4::&677r.   N)rI   rJ   rK   rL   r   r  r-   r   r   r  r   r  r!  r  rw   _TokenrH   r.   r,   r  r    s    !g !HZ4H ! ,g ,k ,m , , ,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e
f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.   r   c                 >    t        t        j                  |            S )
Deprecated)r  r   r  )r+   r   s     r,   make_lexer_statezLexer.make_lexer_state  s    )--d344r.   N)rI   rJ   rK   rL   r   r  r   r   rw   r!  rM   r)  rH   r.   r,   r  r    s@    
 z  %  5S 5r.   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)   )rk   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checkrk   markri   get_example_overlapformat_multiliner  r   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)   rH   )r+   confr8  s      r,   r-   zAbstractBasicLexer.__init__  r   r.   	lex_stater"  c                      y r)   rH   )r+   rF  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   EOFErrorrH  )r+   r  r"  s      r,   r!  zAbstractBasicLexer.lex  s6     h 	;ooe\:: 	; 	;s   5)25r)   rE  r   r'   N)rI   rJ   rK   r   rM   rh   rN   r   r-   r  r   rw   rH  r   r!  rH   r.   r,   rB  rB    sk    C,--  J c U  ; ;3 ;8E? ;r.   rB  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efd
Zedefd       Zd ZddededefdZy)
BasicLexerr   ignore_typesnewline_typesuser_callbacksr   rT   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)   )rm   rh   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. (rE   rT   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  rj   r1   ri   r   s     r,   r   z&BasicLexer.__init__.<locals>.<genexpr>D  s,     &o!DWXYXaXaXkXkXmDnqvv&os   (<<c                     | j                    | j                  j                   t        | j                  j                         | j
                  fS r)   )rk   rj   rB   rX   r#   ri   )xs    r,   r   z%BasicLexer.__init__.<locals>.<lambda>G  s9    qzzkAII4G4G3G#aiiooJ^I^`a`f`f%g r.   )key)listr   all	re_modulerT   skip_validationrj   r1   r   r   errorr   ri   r?   r&   r   ignorehas_interegularr@  strictr*   rO  rN  sort	callbacksrP  r   rC  _scanner)r+   rE  r8  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                        S )Nc                 "    | j                   k(  S r)   )r&   )r   r   s    r,   r   z+BasicLexer._build_scanner.<locals>.<lambda>W  s    TUTZTZ^cTc r.   )r   r   r   rT   r   r   rX  r2  rP  itemsr   r   )r+   r   rF   r   s      @r,   _build_scannerzBasicLexer._build_scannerP  s    #1$..$BTBTVZV]V]_c_m_m#n 	4=4=='')***++113 	)HE1%'0u1EqJc'de$'(e$	) y$"4"4dggt~~NNr.   c                 \    | j                   | j                         | _         | j                   S r)   )ra  re  r2   s    r,   r   zBasicLexer.scanner]  s&    ==  //1DM}}r.   c                 :    | j                   j                  ||      S r)   )r   r   )r+   r   r   s      r,   r   zBasicLexer.matchc  s    ||!!$,,r.   rF  r"  c           
      <   |j                   }|j                  |j                  j                  k  r| j	                  |j                  |j                        }|s| j
                  j                  | j                  z
  }|sdh}t        |j                  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                  |j                  j                  k  rt/        |       )Nz<END-OF-FILE>)allowedtoken_historyr  rC  z+Callbacks must return a token (returned %r))r	  r   r   r   r   r   r   rN  r   r{   r|   r
  rC  r   rw   r   rO  r}   r~   r   r&   rm   r   rJ  )
r+   rF  r"  r	  r   ri  r#   r   ignoredr   s
             r,   rH  zBasicLexer.next_tokenf  s   %%).."4"44**Y^^X->->?C,,44t7H7HH./G*9>>+>+>@Q@QS[S`S`bjbqbq3:)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 ).."4"44< tnr.   r)   rK  )rI   rJ   rK   r	   rh   rN   r   rM   r   	_Callbackr   r-   r   re  rO   r   r   r  r   rw   rH  rH   r.   r,   rM  rM    s    +&&C. S>!i((3	>""N(0TO O   
- J  c  U  r.   rM  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_lexerrM  rE  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)rW  r   rC  r    r]  rZ  r.  r/  r0  rj   r1   ro  rd  r*   KeyErrorr   r\  rM  rp  )r+   rE  rq  rr  r   rC  	trad_confr   r8  lexer_by_tokensr  acceptsrV  r  
lexer_confns                   r,   r-   zContextualLexer.__init__  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  rj  rC  )
ro  positionrH  rJ  r   r
  rp  r   ri  rC  )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)rH   )rI   rJ   rK   r   rP   rB  rN   rM  r   r	   rM   r-   r  r   rw   r!  rH   r.   r,   rn  rn    s    (())""+5J'(5A[ A$sJsO7K2L A]ghk]l Atx A<z  8TY? r.   rn  )   )Cabcr   r   rT   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   r   r   
exceptionsr   r   r   grammarr   
contextlibr   r    boolr]  	NameErrorr"   rR   r]   rh   rv   rM   rw   r   r   r   r   r   r   r  r  r  rl  r  r@  rB  rM  rn  rH   r.   r,   <module>r     s   $ 	     	 !6 X X G G +   ;'O(i (V "$ $.) 0 T!AC AH> >B : :
#,) )V[3 [#K #KL 8 eWe^$	5C 5[#5E0F @; ;"h# hV3e 3y  		"  Os#   E 3E EEEE