
    Ngyc                        d dl mZmZmZ d dlmZ d dlmZ d dlm	Z	 d dl
mZ d dlmZ d dlmZmZ d dlmZmZ d d	lmZ d d
lmZ d dlmZ d dlmZmZ  G d de          ZdZdZ  G d de          Z  ed e                      e _!        [dS )    )PredictionContextCacheSingletonPredictionContextPredictionContext)InputStream)Token)ATN)LexerATNConfig)ATNSimulator)ATNConfigSetOrderedATNConfigSet)RuleStopStateATNState)LexerActionExecutor)
Transition)DFAState)LexerNoViableAltExceptionUnsupportedOperationExceptionc                       e Zd ZdZd Zd ZdS )SimStateindexlinecolumndfaStatec                 .    |                                   d S N)resetselfs    X/var/www/html/ai-engine/env/lib/python3.11/site-packages/antlr4/atn/LexerATNSimulator.py__init__zSimState.__init__'   s    

    c                 >    d| _         d| _        d| _        d | _        d S )Nr   r   r   s    r    r   zSimState.reset*   s"    
	r"   N)__name__
__module____qualname__	__slots__r!   r    r"   r    r   r   $   s7        7I      r"   r   Nc                       e Zd ZdZdZdZdZdZdZde	de
ded	ef fd
ZdefdZdedefdZd ZdefdZdedefdZdedefdZdededefdZdedededefdZdedededefdZdedededed ed!efd"Zd#edefd$Z ded%e!fd&Z"ded'e#d(ed)e$d*e$d+e$fd,Z%ded'e#ded(ed*e$d+e$fd-Z&ded.ed/ed*e$fd0Z'd1eded2efd3Z(d?d4ed5ed6ed7ed8ef
d9Z)d(ed8efd:Z*defd;Z+defd<Z,defd=Z-defd>Z. xZ/S )@LexerATNSimulator)	decisionToDFArecog
startIndexr   r   modeDEFAULT_MODEMAX_CHAR_VALUE
prevAcceptFr      Nr-   atnr,   sharedContextCachec                    t                                          ||           || _        || _        d| _        d| _        d| _        ddlm} |j	        | _
        |j	        | _	        |j        | _        t                      | _        d S )Nr$      r   )Lexer)superr!   r,   r-   r.   r   r   antlr4.Lexerr8   r0   r/   r1   r   r2   )r   r-   r4   r,   r5   r8   	__class__s         r    r!   zLexerATNSimulator.__init__B   s    0111*

 	&&&&&&&	!.#2"**r"   	simulatorc                 f    |j         | _         |j        | _        |j        | _        |j        | _        d S r   )r   r   r/   r.   )r   r<   s     r    	copyStatezLexerATNSimulator.copyStateX   s,    &N	N	#.r"   inputr/   c                    || _         |                                }	 |j        | _        | j                                         | j        |         }|j        *|                     |          |	                    |           S | 
                    ||j                  |	                    |           S # |	                    |           w xY wr   )r/   markr   r.   r2   r   r,   s0matchATNreleaseexecATN)r   r?   r/   rA   dfas        r    matchzLexerATNSimulator.match^   s    	zz||		 #kDOO!!###$T*Cv~}}U++ MM$ ||E3622MM$EMM$s   AB0  B0 0Cc                 z    | j                                          d| _        d| _        d| _        | j        | _        d S )Nr$   r7   r   )r2   r   r.   r   r   r0   r/   r   s    r    r   zLexerATNSimulator.resetl   s9    	%			r"   c                 (   | j         j        | j                 }t          j        r7t          dt          | j                  z   dz   t          |          z              | j        }|                     ||          }|j        }d|_        | 	                    |          }|s|| j
        | j                 _        |                     ||          }t          j        r<t          dt          | j
        |                                                   z              |S )NzmatchATN mode z start: FzDFA after matchATN: )r4   modeToStartStater/   r+   debugprintstrcomputeStartStatehasSemanticContextaddDFAStater,   rB   rE   toLexerString)r   r?   
startStateold_mode
s0_closuresuppressEdgenextpredicts           r    rC   zLexerATNSimulator.matchATNs   s    X.ty9
" 	T"S^^3j@3z??RSSS9++E:>>
!4(-
%
++ 	4/3Dty),,,ud++" 	^(3t/A(/K/Y/Y/[/[+\+\\]]]r"   ds0c                    t           j        r$t          dt          |j                  z              |j        r|                     | j        ||           |                    d          }|}	 t           j        r"t          dt          |j                             | 	                    ||          }|| 
                    |||          }|| j        k    rnq|t          j        k    r|                     |           |j        r-|                     | j        ||           |t          j        k    rn|                    d          }|}|                     | j        ||j        |          S )Nzstart state closure=r7   TzexecATN loop starting closure:)r+   rK   rL   rM   configsisAcceptStatecaptureSimStater2   LAgetExistingTargetStatecomputeTargetStateERRORr   EOFconsumefailOrAccept)r   r?   rX   tstargets         r    rE   zLexerATNSimulator.execATN   s`   " 	=(3s{+;+;;<<< 	>  %===HHQKK-	 & H6AIGGG( 00A66F~001== ## EI~~U#### $$T_eVDDD	>>AA[-	^   %AFFFr"   re   rd   c                     |j         || j        k     s|| j        k    rd S |j         || j        z
           }t          j        r8|6t          dt          |j                  dt          |j                             |S )Nzreuse statezedge to)edgesMIN_DFA_EDGEMAX_DFA_EDGEr+   rK   rL   rM   stateNumber)r   re   rd   rf   s       r    r^   z(LexerATNSimulator.getExistingTargetState   s{    7?a$"333q4;L7L7L4T../" 	Yv'9-Q]!3!3YFDV@W@WXXXr"   c                    t                      }|                     ||j        ||           t          |          dk    r*|j        s|                     ||| j                   | j        S |                     |||          S )Nr   )cfgs)r   getReachableConfigSetrZ   lenrO   
addDFAEdger`   )r   r?   re   rd   reachs        r    r_   z$LexerATNSimulator.computeTargetState   s    #%% 	""5!)UA>>>u::q==+ 2 1dj111 : q!%000r"   r2   rq   c                 6   | j         j        F|j        j        }|                     ||| j        |j        |j        |j                   |j        j        S |t          j
        k    r|j        | j        k    rt          j
        S t          | j        || j        |          r   )r2   r   lexerActionExecutoracceptr.   r   r   r   
predictionr   ra   r   r-   )r   r2   r?   rq   rd   rs   s         r    rc   zLexerATNSimulator.failOrAccept   s    ?#/","5"IKK2DOZEUWaWfhrhyzzz&11 %)||T_ < <y +DJtPUVVVr"   closurec           
         t           j        }|D ]}|j        |k    }|r|j        rt          j        r2t          d|                     |          dt          |                     |j	        j
        D ]}|                     ||          }	|	n|j        }
|
"|
                    |j        | j        z
            }
|t           j        k    }t%          |	|
|          }|                     ||||d|          r|j        }d S )Ntestingat)staters   configT)r   INVALID_ALT_NUMBERaltpassedThroughNonGreedyDecisionr+   rK   rL   getTokenNamerM   rz   transitionsgetReachableTargetrs   fixOffsetBeforeMatchr   r.   r   ra   r	   rv   )r   r?   rv   rq   rd   skipAltcfgcurrentAltReachedAcceptStatetransrf   rs   treatEofAsEpsilonr{   s                r    rn   z'LexerATNSimulator.getReachableConfigSet  s,    ( 	* 	*C-0W-?(+ 0R  & Hi!2!21!5!5tc#hhGGG. * *00::%*-*A'*6.A.V.VW\WbeietWt.u.u+)*ei%+&NajmnnnF||E65:VX\^opp * #&'*	* 	*r"   rs   r.   r   r   charPosc                     t           j        rt          d|           |                    |           || _        || _        |%| j         |                    | j        ||           d S d S d S )NACTION)r+   rK   rL   seekr   r   r-   execute)r   r?   rs   r.   r   r   r   s          r    rt   zLexerATNSimulator.accept  s{    " 	1(/000 	

5	*tz/E''
E:FFFFF +*/E/Er"   r   c                 L    |                     |d| j                  r|j        S d S )Nr   )matchesr1   rf   )r   r   rd   s      r    r   z$LexerATNSimulator.getReachableTarget)  s*    ==At233 	<4r"   pc           	         t           j        }t                      }t          dt	          |j                            D ]C}|j        |         j        }t          ||dz   |          }|                     |||ddd           D|S )Nr   r7   )rz   r}   contextF)	r   EMPTYr   rangero   r   rf   r	   rv   )r   r?   r   initialContextrZ   irf   cs           r    rN   z#LexerATNSimulator.computeStartState/  s    *0%''qQ]++,, 	A 	AA]1%,FV1nMMMALL7E5%@@@@r"   r{   rZ   r   speculativer   c           	      "   t           j        r"t          dt          |          z   dz              t	          |j        t                    rt           j        r^| j        :t          d| j        j        |j        j	                 dt          |                     nt          dt          |                     |j
        |j
                                        rm|j
        |j
                                        r|                    |           dS |                    t          |j        |t          j                             d}|j
        |j
                                        st#          dt%          |j
                            D ]}|j
                            |          t          j        k    rp|j
                            |          }| j        j        |j
                            |                   }	t          |	||          }
|                     ||
||||          }|S |j        j        s|r|j        s|                    |           |j        j        D ]8}|                     ||||||          }
|
|                     ||
||||          }9|S )	Nzclosure()z
closure atz	rule stopzclosure at rule stopTrz   r{   r   r   )r+   rK   rL   rM   
isinstancerz   r   r-   symbolicNames	ruleIndexr   hasEmptyPathisEmptyaddr	   r   r   r   ro   getReturnStateEMPTY_RETURN_STATE	getParentr4   statesrv   epsilonOnlyTransitionsr~   r   getEpsilonTarget)r   r?   r{   rZ   r   r   r   r   
newContextreturnStater   rd   s               r    rv   zLexerATNSimulator.closure@  s   " 	2*s6{{*S0111v|]44 	0 & ?:),
(@AW(X[fhklrhshstttt0#f++>>>~%)D)D)F)F%>)V^-C-C-E-E)KK'''4KKV\&ZkZq r r rsss370~)&.2H2H2J2J)qV^!4!455 b bA~44Q77;L;___%+^%=%=a%@%@
&*hofn6S6STU6V6V&W*VU_```7;||E1g$@+O`8b 8b4 0/ |2 	$/ $v7\ $F###) 	M 	MA%%eVQN_``A}/3||E1gOkmx  {L  0M  0M,++r"   c                    d }|j         t          j        k    r=t          j        |j        |j        j                  }t          |j	        ||          }n|j         t          j
        k    rt          d          |j         t          j        k    rt          j        r<t          dt!          |j                  z   dz   t!          |j                  z              d|_        |                     ||j        |j        |          rt          |j	        |          }n'|j         t          j        k    r~|j        |j                                        rGt/          j        |j        | j        j        |j                           }	t          |j	        ||	          }nt          |j	        |          }n|j         t          j        k    rt          |j	        |          }nh|j         t          j        t          j        t          j         fv r>|r<|!                    tD          j#        d| j$                  rt          |j	        |          }|S )	Nr   z2Precedence predicates are not supported in lexers.z
EVAL rule :T)rz   r{   )rz   r{   rs   r   )%serializationTyper   RULEr   creater   followStaterk   r	   rf   
PRECEDENCEr   	PREDICATEr+   rK   rL   rM   r   	predIndexrO   evaluatePredicater   r   r   appendrs   r4   lexerActionsactionIndexEPSILONATOMRANGESETr   r   ra   r1   )
r   r?   r{   rd   rZ   r   r   r   r   rs   s
             r    r   z"LexerATNSimulator.getEpsilonTargetl  s   
//7>v~q}Ohii
"&*UUU *"77734hiii *"666& %* S,AK(8(883>Q[AQAQQRRR-1*))%ak;WW F&QXfEEEA *"333>)V^-H-H-J-J) +>*DVE_$(H$9!-$H+J +J'&QXfZmnnnAA 'QXfEEEAA *"444QXf===AA joz7G$YYY  F99UY4+>?? F&QXfEEEAr"   r   r   c                    | j         dS |s| j                             d ||          S | j        }| j        }|j        }|                                }	 |                     |           | j                             d ||          || _        || _        |                    |           |                    |           S # || _        || _        |                    |           |                    |           w xY w)NT)	r-   sempredr   r   r   rA   rb   r   rD   )	r   r?   r   r   r   savedcolumn	savedLiner   markers	            r    r   z#LexerATNSimulator.evaluatePredicate  s    :4 	B:%%dIyAAAkI		"LL:%%dIyAA%DK!DIJJuMM&!!!! &DK!DIJJuMM&!!!!s   0B; ;:C5settingsr   c                 \    |j         |_         | j        |_        | j        |_        ||_        d S r   r   )r   r   r?   r   s       r    r\   z!LexerATNSimulator.captureSimState  s+    	+$r"   from_tktorm   returnc                    |)|'|j         }d|_         |                     |          }|r|S || j        k     s|| j        k    r|S t          j        rEt          dt          |          z   dz   t          |          z   dz   t          |          z              |j	        d g| j        | j        z
  dz   z  |_	        ||j	        || j        z
  <   |S )NFzEDGE z -> z upon r7   )
rO   rP   ri   rj   r+   rK   rL   rM   chrrh   )r   r   r   r   rm   rU   s         r    rp   zLexerATNSimulator.addDFAEdge  s    :$*  2L&+D#!!$''B 	 !!!R$*;%;%;I" 	O'CJJ&/#b''9HDc"ggMNNN; (d&7$:K&Ka&OPEK.0B**+	r"   c                    t          |          }t          d |D             d           }|4d|_        |j        |_        | j        j        |j        j                 |_        | j	        | j
                 }|j                            |d           }||S |}t          |j                  |_        |                    d           ||_        ||j        |<   |S )N)rZ   c              3   N   K   | ] }t          |j        t                    |V  !d S r   )r   rz   r   ).0r   s     r    	<genexpr>z0LexerATNSimulator.addDFAState.<locals>.<genexpr>  s6      ,l,lSzRUR[]jGkGk,lS,l,l,l,l,l,lr"   T)r   rV   r[   rs   r4   ruleToTokenTyperz   r   ru   r,   r/   r   getro   rk   setReadonlyrZ   )r   rZ   proposedfirstConfigWithRuleStopStaterF   existingnewStates          r    rP   zLexerATNSimulator.addDFAState	  s    G,,,'+,l,lG,l,l,lnr's's$'3%)H"+G+[H("&(":;W;];g"hH +:>>(D11O"3:D!!!"'
8r"   c                     | j         |         S r   )r,   )r   r/   s     r    getDFAzLexerATNSimulator.getDFA   s    !$''r"   c                 H    |                     | j        |j        dz
            S )Nr7   )getTextr.   r   )r   r?   s     r    r   zLexerATNSimulator.getText$  s    }}T_ek!m<<<r"   c                     |                     d          }|t          d          k    r| xj        dz  c_        d| _        n| xj        dz  c_        |                                 d S )Nr7   
r   )r]   ordr   r   rb   )r   r?   curChars      r    rb   zLexerATNSimulator.consume(  s[    ((1++CIIIINIIDKKKK1KKr"   c                 <    |dk    rdS dt          |          z   dz   S )Nr$   ra   ')r   )r   rd   s     r    r   zLexerATNSimulator.getTokenName1  s%    b555Q<#%%r"   )NN)0r%   r&   r'   r(   rK   	dfa_debugri   rj   r`   r8   r   listr   r!   r+   r>   r   intrG   r   rC   r   rE   r^   r_   r   r   rc   rn   r   rt   r   r   r   rN   r	   boolrv   r   r   r\   rp   rP   r   r   rb   r   __classcell__)r;   s   @r    r+   r+   4   s       I
 EILLE%U % %4 %Tj % % % % % %,/"3 / / / / +  S        & & &[    ,:GK :GX :G :G :G :GJx 3    (1{ 1h 1# 1 1 1 1&	Wh 	W{ 	W, 	WZ] 	W 	W 	W 	W*+ *| *S_ *cf * * * *4
G; 
G<O 
G\_ 
Ggj 
Gqt 
G  B 
G 
G 
G 
Gz S    k X    "),K ), ), ),sw ), ),48), ), ), ),XA[ A A: A_k A7;AOSA A A An"k "S "C "]a " " " "*%x %{ %X % % % %$ $x $C $H $ $^f $ $ $ $V, 8    .(# ( ( ( (=K = = = =K    &S & & & & & & & &r"   r+   i)"antlr4.PredictionContextr   r   r   antlr4.InputStreamr   antlr4.Tokenr   antlr4.atn.ATNr   antlr4.atn.ATNConfigr	   antlr4.atn.ATNSimulatorr
   antlr4.atn.ATNConfigSetr   r   antlr4.atn.ATNStater   r   antlr4.atn.LexerActionExecutorr   antlr4.atn.Transitionr   antlr4.dfa.DFAStater   antlr4.error.Errorsr   r   objectr   r8   r+   r`   r)   r"   r    <module>r      s  . k j j j j j j j j j * * * * * *             / / / / / / 0 0 0 0 0 0 E E E E E E E E 7 7 7 7 7 7 7 7 > > > > > > , , , , , , ( ( ( ( ( ( X X X X X X X X
 
 
 
 
v 
 
 
 	 A& A& A& A& A& A& A& A&H #(:||~~>>  	EEr"   