
    khyc                        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 _!        [y)    )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y)SimStateindexlinecolumndfaStatec                 $    | j                          y N)resetselfs    X/var/www/teggl/fontify/venv/lib/python3.12/site-packages/antlr4/atn/LexerATNSimulator.py__init__zSimState.__init__'   s    

    c                 <    d| _         d| _        d| _        d | _        y )Nr   r   r   s    r    r   zSimState.reset*   s    
	r"   N)__name__
__module____qualname__	__slots__r!   r    r"   r    r   r   $   s    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               | _        y )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   sn    01*

 	&&&	!..#22"*r"   	simulatorc                     |j                   | _         |j                  | _        |j                  | _        |j                  | _        y r   )r   r   r/   r.   )r   r<   s     r    	copyStatezLexerATNSimulator.copyStateX   s2    &&NN	NN	#..r"   inputr/   c                    || _         |j                         }	 |j                  | _        | j                  j                          | j                  |   }|j                  "| j                  |      |j                  |       S | j                  ||j                        |j                  |       S # |j                  |       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|		 #kkDOOO!!#$$T*Cvv~}}U+ MM$ ||E3662MM$EMM$s   AB. B. .Cc                     | j                   j                          d| _        d| _        d| _        | j
                  | _        y )Nr$   r7   r   )r2   r   r.   r   r   r0   r/   r   s    r    r   zLexerATNSimulator.resetl   s4    	%%	r"   c                 8   | j                   j                  | j                     }t        j                  r0t        dt        | j                        z   dz   t        |      z          | j                  }| j                  ||      }|j                  }d|_        | j                  |      }|s|| j                  | j                     _        | j                  ||      }t        j                  r2t        dt        | j                  |   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    XX..tyy9
"""S^3j@3z?RS99++E:>
!44(-
%
+/3Dtyy),,,ud+""(3t/A/A(/K/Y/Y/[+\\]r"   ds0c                    t         j                  r!t        dt        |j                        z          |j
                  r| j                  | j                  ||       |j                  d      }|}	 t         j                  rt        dt        |j                               | j                  ||      }|| j                  |||      }|| j                  k(  rnu|t        j                  k7  r| j                  |       |j
                  r1| j                  | j                  ||       |t        j                  k(  rn|j                  d      }|}| j                  | j                  ||j                  |      S )Nzstart state closure=r7   z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   s0   ""(3s{{+;;<  %=HHQK &&6AIIG( 00A6F~001= # EII~U###$$T__eVD		>AA[ ^   %AFFr"   re   rd   c                     |j                   || j                  k  s|| j                  kD  ry |j                   || j                  z
     }t        j                  r6|4t        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   sv    77?a$"3"33q4;L;L7LT.../""v'9-Q]]!3YFDVDV@WXr"   c                     t               }| j                  ||j                  ||       t        |      dk(  r5|j                  s| j                  ||| j                         | j                  S | j                  |||      S )Nr   )cfgs)r   getReachableConfigSetrZ   lenrO   
addDFAEdger`   )r   r?   re   rd   reachs        r    r_   z$LexerATNSimulator.computeTargetState   ss    #% 	""5!))UA>u:q=++ 1djj1 :: q!%00r"   r2   rq   c                    | j                   j                  j|j                  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"5"I"IKK2DOOZEUEUWaWfWfhrhyhyz&&111 %))|T__ <yy +DJJtPUVVr"   closurec           
      2   t         j                  }|D ]  }|j                  |k(  }|r|j                  r"t        j
                  r&t        d| j                  |      dt        |             |j                  j                  D ]  }| j                  ||      }	|	|j                  }
|
(|
j                  |j                  | j                  z
        }
|t         j"                  k(  }t%        |	|
|      }| j'                  ||||d|      s|j                  }  y )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-0WW-?(+0R0R &&i!2!21!5tc#hG.. *00:%*-*A*A'*6.A.V.VW\WbWbeietetWt.u+)*eii%+&NajmnF||E65:VX\^op #&''*	*r"   rs   r.   r   r   charPosc                     t         j                  rt        d|       |j                  |       || _        || _        |+| j                  |j                  | j                  ||       y y y )NACTION)r+   rK   rL   seekr   r   r-   execute)r   r?   rs   r.   r   r   r   s          r    rt   zLexerATNSimulator.accept  s`    ""(/0 	

5	*tzz/E''

E:F 0F*r"   r   c                 V    |j                  |d| j                        r|j                  S y )Nr   )matchesr1   rf   )r   r   rd   s      r    r   z$LexerATNSimulator.getReachableTarget)  s%    ==At223<<r"   pc           	         t         j                  }t               }t        dt	        |j
                              D ]B  }|j
                  |   j                  }t        ||dz   |      }| j                  |||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/  sy    *00%'qQ]]+, 	AA]]1%,,FV1nMALL7E5%@	A r"   r{   rZ   r   speculativer   c           	      t   t         j                  rt        dt        |      z   dz          t	        |j
                  t              rt         j                  rd| j                  Ct        d| j                  j                  |j
                  j                     dt        |             nt        dt        |             |j                  |j                  j                         ro|j                  |j                  j                         r|j                  |       y|j                  t        |j
                  |t        j                                d}|j                  |j                  j                         st#        dt%        |j                              D ]  }|j                  j'                  |      t        j(                  k7  s0|j                  j+                  |      }| j,                  j.                  |j                  j'                  |         }	t        |	||      }
| j1                  ||
||||      } |S |j
                  j2                  s|r|j4                  s|j                  |       |j
                  j6                  D ]1  }| j9                  ||||||      }
|
| j1                  ||
||||      }3 |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@  s6   ""*s6{*S01v||]4 &&::),

(@(@AWAW(X[fhklrhst0#f+>~~%)D)D)F>>)V^^-C-C-EKK'KKV\\&ZkZqZq rs370~~)&..2H2H2JqV^^!45 bA~~44Q7;L;_;__%+^^%=%=a%@
&*hhoofnn6S6STU6V&W*VU_`7;||E1g$@+O`8b4b 0/ ||22/v7\7\F#)) 	MA%%eVQN_`A}/3||E1gOkmx  {L  0M,	M
 ,+r"   c                 f   d }|j                   t        j                  k(  rNt        j                  |j
                  |j                  j                        }t        |j                  ||      }|S |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"                  |j$                  |      rt        |j                  |      }|S |j                   t        j*                  k(  r|j
                  |j
                  j-                         r[t/        j0                  |j2                  | j4                  j6                  |j8                           }	t        |j                  ||	      }|S t        |j                  |      }|S |j                   t        j:                  k(  rt        |j                  |      }|S |j                   t        j<                  t        j>                  t        j@                  fv rD|rB|jC                  tD        jF                  d| jH                        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}}OhOhi
"&*Ux u   *"7"7734hii  *"6"66& %**,AKK(883>Q[[AQQR-1*))%akk;W&QXXfEA@ =   *"3"33>>)V^^-H-H-J +>*D*DVE_E_$(HH$9$9!--$H+J'&QXXfZmnA  'QXXfEA    *"4"44QXXf=A    jooz7G7G$YY 99UYY4+>+>?&QXXfEAr"   r   r   c                    | j                   y|s| j                   j                  d ||      S | j                  }| j                  }|j                  }|j                         }	 | j                  |       | j                   j                  d ||      || _        || _        |j                  |       |j                  |       S # || _        || _        |j                  |       |j                  |       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    ::::%%dIyAAkkII		"LL::%%dIyA%DK!DIJJuMM&! &DK!DIJJuMM&!s   "-C   2C2settingsr   c                 x    |j                   |_         | j                  |_        | j                  |_        ||_        y r   r   )r   r   r?   r   s       r    r\   z!LexerATNSimulator.captureSimState  s+    		++$r"   from_tktorm   returnc                    |*|(|j                   }d|_         | j                  |      }|r|S || j                  k  s|| j                  kD  r|S t        j
                  r5t        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    :$*  22L&+D#!!$'B	 !!!R$*;*;%;I""'CJ&/#b'9HDc"gMN;; (d&7&7$:K:K&Ka&OPEK.0B***+	r"   c                    t        |      }t        d |D        d       }|Jd|_        |j                  |_        | j                  j
                  |j                  j                     |_        | j                  | j                     }|j                  j                  |d       }||S |}t        |j                        |_        |j                  d       ||_        ||j                  |<   |S )N)rZ   c              3   V   K   | ]!  }t        |j                  t              s| # y wr   )r   rz   r   ).0r   s     r    	<genexpr>z0LexerATNSimulator.addDFAState.<locals>.<genexpr>  s!     ,lSzRUR[R[]jGkS,ls   ))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,'+,lG,lnr's$'3%)H"+G+[+[H("&((":":;W;];];g;g"hH  +::>>(D1O"3::D!"'

8r"   c                      | j                   |   S r   )r,   )r   r/   s     r    getDFAzLexerATNSimulator.getDFA   s    !!$''r"   c                 T    |j                  | j                  |j                  dz
        S )Nr7   )getTextr.   r   )r   r?   s     r    r   zLexerATNSimulator.getText$  s    }}T__ekk!m<<r"   c                     |j                  d      }|t        d      k(  r| xj                  dz  c_        d| _        n| xj                  dz  c_        |j	                          y )Nr7   
r   )r]   ordr   r   rb   )r   r?   curChars      r    rb   zLexerATNSimulator.consume(  sF    ((1+CIIINIDKKK1Kr"   c                 0    |dk(  rydt        |      z   dz   S )Nr$   ra   ')r   )r   rd   s     r    r   zLexerATNSimulator.getTokenName1  s    b5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Jx 3 (1{ 1h 1# 1&	Wh 	W{ 	W, 	WZ] 	W*+ *| *S_ *cf *4
G; 
G<O 
G\_ 
Ggj 
Gqt 
G  B 
Gz S k X "),K ), ), ),sw ), ),48),XA[ A A: A_k A7;AOS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      sn   . k j *   / 0 E 7 > , ( X
v 
 	 A& A&H #:|~>  	r"   