
    kh9                    >   d dl Z d dlmZ d dlmZ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 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mZ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+m,Z,m-Z-m.Z.m/Z/m0Z0 d dl1m2Z2m3Z3 d dl4m5Z5  G d de      Z6y)    N)DFA)PredictionContextCachePredictionContextSingletonPredictionContext PredictionContextFromRuleContext)TokenStream)Parser)ParserRuleContext)RuleContext)Token)str_list)ATN)	ATNConfig)ATNConfigSet)ATNSimulator)StarLoopEntryStateDecisionStateRuleStopStateATNState)PredictionMode)SemanticContextAND
andContext	orContext)
TransitionRuleTransitionActionTransitionPrecedencePredicateTransitionPredicateTransitionAtomTransitionSetTransitionNotSetTransition)DFAStatePredPrediction)NoViableAltExceptionc                   j    e 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 Zd	ed
edefdZdeded	e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fdZdededed	ededefdZde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fd#Z!d$e"d%efd&Z#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fd-Z(dedefd.Z)d/e
ded0efd1Z*d2e+ded3e$d4eded5efd6Z,d2e+ded3e$d4eded7ed5efd8Z-d2e+ded3e$d4eded7ed5efd9Z.d: Z/d;efd<Z0 e1       Z2d= e2e"jf                  <   d> e2e"jh                  <   d? e2e"jj                  <   d@ e2e"jl                  <   dA e2e"jn                  <   dB e2e"jp                  <   dC e2e"jr                  <   dD e2e"jt                  <   d2e+de"d4edEeded5efdFZ;d2e+de<fdGZ=d2e+dHe>d4edEedef
dIZ?d2e+dHe@d4edEedef
dJZAd2e+deBfdKZCdefdLZDdefdMZEdefdNZFd	efdOZGdPeHfdQZId	edededefdRZJdefdSZKdedTededUefdVZLdedefdWZMdedXe$dededYef
dZZNded[edededYef
d\ZOdedededYed]ed'e$defd^ZP xZQS )_ParserATNSimulator)parserdecisionToDFApredictionMode_input_startIndex_outerContext_dfa
mergeCacheFr(   atnr)   sharedContextCachec                     t         |   ||       || _        || _        t        j
                  | _        d | _        d| _        d | _	        d | _
        d | _        y Nr   )super__init__r(   r)   r   LLr*   r+   r,   r-   r.   r/   )selfr(   r0   r)   r1   	__class__s        Y/var/www/teggl/fontify/venv/lib/python3.12/site-packages/antlr4/atn/ParserATNSimulator.pyr5   zParserATNSimulator.__init__  sW    01*,//!	     c                      y N )r7   s    r9   resetzParserATNSimulator.reset#  s    r:   inputdecisionouterContextc                    t         j                  st         j                  r|t        dt	        |      z   dz   | j                  |      z   dz   t	        |j                  d      j                        z   dz   t	        |j                  d      j                        z          || _	        |j                  | _        || _        | j                  |   }|| _        |j                         }|j                  }	 |j                   r*|j#                  | j$                  j'                               }n|j(                  }|W|t*        j,                  }t         j                  st         j                  r`t        dt	        |j.                        z   dz   | j                  |      z   dz   |j1                  | j$                  j2                  d       z          d}| j5                  |j6                  t*        j,                  |      }	|j                   ri|	|j(                  _        | j;                  |	      }	| j=                  |t?        |		            }|jA                  | j$                  j'                         |       n#| j=                  |t?        |		            }||_        | jC                  |||||      }
t         j                  r1t        d
|j1                  | j$                  j2                        z          |
d | _        d | _"        |jG                  |       |jI                  |       S # d | _        d | _"        |jG                  |       |jI                  |       w xY w)NzadaptivePredict decision  exec LA(1)== line    :zpredictATN decision z, outerContext=FconfigszDFA after predictATN: )%r'   debugdebug_list_atn_decisionsprintstrgetLookaheadNameLTlinecolumnr+   indexr,   r-   r)   r.   markprecedenceDfagetPrecedenceStartStater(   getPrecedences0r
   EMPTYr@   toStringliteralNamescomputeStartStateatnStartStaterH   applyPrecedenceFilteraddDFAStater#   setPrecedenceStartStateexecATNr/   seekrelease)r7   r?   r@   rA   dfamrQ   rV   fullCtx
s0_closurealts              r9   adaptivePredictz"ParserATNSimulator.adaptivePredict&  s   ##'9'R'R-H=#23595J5J55QR#+,.1%((1+2B2B.CDFIJ $'uxx{'9'9#:; <  ;;)  *	JJL+	   001J1J1LM VVz'#4#:#:L%++/A/Z/Z03s||3DD'679=9N9Nu9UV'89;G;P;PQUQ\Q\QiQiko;pq r  !33C4E4EGXG^G^`gh
$$ &0CFFN!%!;!;J!GJ))#x
/KLB//0I0I0KRP))#x
/KLBCF,,sBulCC!''.dkk>V>V1WWXDI"DOJJuMM! DI"DOJJuMM!s   /G3L 2Mrb   rV   
startIndexc           	         t         j                  st         j                  rt        dt	        |j
                        z   dz   | j                  |      z   dz   t	        |j                  d      j                        z   dz   t	        |j                  d      j                        z          |}t         j                  rt        dt	        |      z          |j                  d      }	 | j                  ||      }|| j                  |||      }|| j                  u rb| j                  |||j                  |      }	|j!                  |       | j#                  |j                  |      }
|
t$        j&                  k7  r|
S |	|j(                  rz| j*                  t,        j.                  k7  r\|j                  j0                  }|j2                  t         j                  rt        d       |j4                  }||k7  r|j!                  |       | j7                  |j2                  |d      }t9        |      dk(  r&t         j                  rt        d	       t;        |      S ||k7  r|j!                  |       t         j<                  r&t        d
t	        |      z   dz   t	        |      z          d}| j?                  |j@                  ||      }| jC                  |||j                  ||j4                         | jE                  ||||||      }
|
S |jF                  r|j2                  |jH                  S |j4                  }|j!                  |       | j7                  |j2                  |d      }t9        |      dk(  r| j                  |||j                  |      t9        |      dk(  rt;        |      S | jK                  ||||d||j                         t;        |      S |}|tL        jN                  k7  r!|jQ                          |j                  d      }%)NzexecATN decision rC   rD   rE   rF   zs0 = Tz*DFA state has preds in DFA sim LL failoverzFull LL avoidedzctx sensitive state z in r   F))r'   rI   rJ   rK   rL   r@   rM   rN   rO   rP   LAgetExistingTargetStatecomputeTargetStateERRORnoViableAltrH   r`   7getSynValidOrSemInvalidAltThatFinishedDecisionEntryRuler   INVALID_ALT_NUMBERrequiresFullContextr*   r   SLLconflictingAlts
predicatesrQ   evalSemanticContextlenmin	dfa_debugrZ   r[   reportAttemptingFullContextexecATNWithFullContextisAcceptState
predictionreportAmbiguityr   EOFconsume)r7   rb   rV   r?   rh   rA   	previousDtDerf   rs   conflictIndexrd   re   	stopIndexaltss                    r9   r_   zParserATNSimulator.execATN  sz   ##'9'R'R%CLL(99#$&*&;&;E&BC"588A;#3#3457:;=@!ASAS=TU V 	##'CG#$HHQK++Iq9Ay++CA>DJJ $$UL):K:KZX

:&RRS\SdSdfrs...J$$)<)<@R@R)R"#))";";<<+)//JK$)KKM$
2

:.&*&>&>q||\[_&`O?+Q.-33!"34"?33$
2 

=1%//03|3DDfLsSTvUV!33C4E4E|U\]
00oqyyR\^c^i^ij11#q*eZYef
<<'<<'!KK	

:&//lDQt9a<**5,		:VVY\t9$ ((aYtUVU^U^_t9$IEII~HHQKO r:   r   r   c                 b    |j                   }||dz   dk  s|dz   t        |      k\  ry ||dz      S )NrE   r   )edgesrv   )r7   r   r   r   s       r9   rk   z)ParserATNSimulator.getExistingTargetState  s:    =AEAIQ#e*)<Q<r:   c                 h   | j                  |j                  |d      }|*| j                  |||| j                         | j                  S t	        |      }| j                  |      }t        j                  rt        j                  |      }t        dt        |      z   dz   t        |      z   dz   t        |      z   dz   t        t        j                  |            z   dz   t        | j                  |            z          |t        j                  k7  r d|_        ||j                  _        ||_        nrt        j&                  | j(                  |      rR| j                  |      |j                  _        d|_        d|_        t/        |j                  j*                        |_        |j                   rl|j                  j0                  rV| j3                  || j4                  j7                  |j8                               |j:                  t        j                  |_        | j                  ||||      }|S )	NFrG   zSLL altSubSets=z
, configs=
, predict=z, allSubsetsConflict=z, conflictingAlts=T)computeReachSetrH   
addDFAEdgerm   r#   getUniqueAltr'   rI   r   getConflictingAltSubsetsrK   rL   allSubsetsConflictgetConflictingAltsr   rp   r{   	uniqueAltr|   #hasSLLConflictTerminatingPredictionr*   rs   rq   rw   hasSemanticContextpredicateDFAStater0   getDecisionStater@   rt   )r7   rb   r   r   reachr   predictedAlt
altSubSetss           r9   rl   z%ParserATNSimulator.computeTargetState  s   $$Y%6%65A=OOCAtzz::: U#((/##'@@GJ#c*o5Ds5zQ$%'*<'89;RSN==jIJKMab D33E:;< =
 ///"AO".AII'AL??@S@SUZ[(,(?(?(FAII%$(A!"AOqyy889AL??qyy;;""1dhh&?&?&MN||'"55 OOCAq1r:   dfaStatedecisionStatec                    t        |j                        }| j                  |j                        }| j	                  ||j                  |      }|-| j                  ||      |_        t        j                  |_	        y t        |      |_	        y r<   )rv   transitionsgetConflictingAltsOrUniqueAltrH   getPredsForAmbigAltsgetPredicatePredictionsrt   r   rp   r|   rw   )r7   r   r   naltsaltsToCollectPredsFrom	altToPreds         r9   r   z$ParserATNSimulator.predicateDFAState  s     M--. "&!C!CHDTDT!U--.DhFVFVX]^	 "&">">?UW`"aH"%"8"8H
 #&&<"=Hr:   r   c           	      L   t         j                  st         j                  rt        dt	        |             d}d}d }	|}
|j                  |       |j                  d      }d}	 | j                  |
||      }	|	N| j                  |||
|      }|j                  |       | j                  |
|      }|t        j                  k7  r|S |t        j                  |	      }t         j                  r[t        dt	        |      z   dz   t	        t        j                  |            z   dz   t	        t        j                  |            z          | j                  |	      |	_        |	j                   t        j                  k7  r|	j                   }n| j"                  t        j$                  ur)t        j                  |      }|t        j                  k7  rCnzt        j&                  |      r-t        j(                  |      rd}t        j*                  |      }n8|	}
|t,        j.                  k7  r!|j1                          |j                  d      }|	j                   t        j                  k7  r!| j3                  |||	||j4                         |S | j7                  ||||j4                  |d |	       |S )	Nrz   TFrE   zLL altSubSets=r   z, resolvesToJustOneViableAlt=)r'   rI   rJ   rK   rL   r`   rj   r   rn   ro   r   rp   r   r   r   resolvesToJustOneViableAltr   r*   LL_EXACT_AMBIG_DETECTIONr   allSubsetsEqualgetSingleViableAltr   r~   r   reportContextSensitivityrQ   r}   )r7   rb   r   rV   r?   rh   rA   rd   foundExactAmbigr   previousr   r   r   rf   r   s                   r9   rz   z)ParserATNSimulator.execATNWithFullContext0  s[   
 ##'9'R'R*CG4

:HHQK((1g>E} $$UL(JO

:&RRS[]ij...JG'@@GJ!''&Z8<G.55jABCEde.CCJOPQ R #//6EO 6 66$$$N,S,SS-HHT3#9#99 "44Z@^EcEcdnEo&*O#1#D#DZ#PL
 HEII~HHQKc l ??c444))#|UJPUP[P[\: 	S!ZotUZ[r:   closurerd   c           	      |   t         j                  rt        dt        |      z          | j                  t               | _        t        |      }d }|D ]  }t         j                  r,t        d| j                  |      z   dz   t        |      z          t        |j                  t              r3|s|t        j                  k(  r|
t               }|j                  |       |j                  j                  D ]>  }| j!                  ||      }||j#                  t%        ||      | j                         @  d }	|H|t        j                  k7  r5t'        |      dk(  r|}	n$| j)                  |      t*        j,                  k7  r|}	|	Et        |      }	t/               }
|t        j                  k(  }|D ]  }| j1                  ||	|
d||        |t        j                  k(  r| j3                  |	|	|u       }	|:|rt5        j6                  |	      s#|D ]  }|	j#                  || j                           t'        |	      dk(  ry |	S )Nz&in computeReachSet, starting closure: ztesting z at stateconfigrE   Fr   )r'   rI   rK   rL   r/   dictr   getTokenName
isinstancer   r   r   r~   listappendr   getReachableTargetaddr   rv   r   r   rp   setr   "removeAllConfigsNotInRuleStopStater   hasConfigInRuleStopState)r7   r   r   rd   intermediateskippedStopStatesctranstargetr   closureBusytreatEofAsEpsilons               r9   r   z"ParserATNSimulator.computeReachSet  s   ##:S\IJ??""fDO#G, !  	YA!''j4#4#4Q#77&@3q6IJ!''=1a599n(0,0F)%,,Q/,, Y00:% $$YVA%FXY	Y$  $EII< !#
 %""<0#2H2HH %
 = )E%K !UYY! WQ{E7DUVW 		>$ ;;E5LCXYE (G^ElElmrEs& .		!T__-.u:q=Lr:   rH   lookToEndOfRulec                 &   t        j                  |      r|S t        |j                        }|D ]  }t	        |j
                  t              r|j                  || j                         :|s=|j
                  j                  sT| j                  j                  |j
                        }t        j                  |v s| j                  j                  |j
                  j                     }|j                  t!        ||      | j                          |S Nr   )r   allConfigsInRuleStopStatesr   rd   r   r   r   r   r/   epsilonOnlyTransitionsr0   
nextTokensr   EPSILONruleToStopState	ruleIndexr   )r7   rH   r   resultr   r   endOfRuleStates          r9   r   z5ParserATNSimulator.removeAllConfigsNotInRuleStopState  s    44W=Ngoo. 	`F&,,6

64??36<<#F#F!XX00>
==J.%)XX%=%=fll>T>T%UNJJy~fMt_	` r:   pctxc           	      "   t        | j                  |      }t        |      }t        dt	        |j
                              D ]K  }|j
                  |   j                  }t        ||dz   |      }t               }	| j                  |||	d|d       M |S )Nr   rE   TF)
r   r0   r   rangerv   r   r   r   r   r   )
r7   r   r   rd   initialContextrH   ir   r   r   s
             r9   rZ   z$ParserATNSimulator.computeStartState'  s    9$((CHw'q#amm,- 	HA]]1%,,F&!A#~6A%KLLG[$G		H
 r:   c                    t               }t        |j                        }|D ]  }|j                  dk7  r|j                  j                  | j                  | j                        }|F|j                  ||j                  j                  <   ||j                  ur(|j                  t        ||      | j                         |j                  || j                          |D ]p  }|j                  dk(  r|j                  s6|j                  |j                  j                  d       }||j                  k(  rU|j                  || j                         r |S )NrE   )r   semantic)r   r   rd   rf   semanticContextevalPrecedencer(   r-   contextr   stateNumberr   r   r/   precedenceFilterSuppressedget)r7   rH   statesFromAlt1	configSetr   updatedContextr   s          r9   r\   z(ParserATNSimulator.applyPrecedenceFilterk  s#    1	 	7FzzQ#33BB4;;PTPbPbcN%7=~~N6<<334V%;%;;ivOQUQ`Q`afdoo6	7  	3FzzQ 44(,,V\\-E-EtLFNN*MM&$//2	3" r:   r   ttypec                 j    |j                  |d| j                  j                        r|j                  S y r3   )matchesr0   maxTokenTyper   )r7   r   r   s      r9   r   z%ParserATNSimulator.getReachableTarget  s)    ==488#8#89<<r:   	ambigAltsr   c                    d g|dz   z  }|D ]A  }|j                   |v st        ||j                      |j                        ||j                   <   C d}t        d|dz         D ]6  }||   t        j
                  ||<   ||   t        j
                  us2|dz  }8 |dk(  rd }t        j                  rt        dt        |      z          |S )NrE   r   zgetPredsForAmbigAlts result )
rf   r   r   r   r   NONEr'   rI   rK   r   )r7   r   rH   r   r   r   	nPredAltsr   s           r9   r   z'ParserATNSimulator.getPredsForAmbigAlts  s     Feai(	 	RAuu	!#,Yquu-=q?P?P#Q	!%% 	R 	q%'" 	A|#.33	!1_%9%99Q			 a<I##08I3FFGr:   r   c                     g }d}t        dt        |            D ]=  }||   }|||v r|j                  t        ||             |t        j
                  us<d}? |sy |S )NFrE   T)r   rv   r   r$   r   r   )r7   r   r   pairscontainsPredicater   preds          r9   r   z*ParserATNSimulator.getPredicatePredictions  sp    !q#i.) 	)AQ<D$i^D!45?///$(!	) !r:   c                     | j                  ||      \  }}| j                  |      }|t        j                  k7  r|S t	        |      dkD  r&| j                  |      }|t        j                  k7  r|S t        j                  S r3   ) splitAccordingToSemanticValidity#getAltThatFinishedDecisionEntryRuler   rp   rv   )r7   rH   rA   semValidConfigssemInvalidConfigsrf   s         r9   ro   zJParserATNSimulator.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule  s}    -1-R-RSZ\h-i**66G&&&J !!#::;LMCC***
%%%r:   c                 6   t               }|D ]b  }|j                  dkD  s6t        |j                  t              s-|j
                  j                         sH|j                  |j                         d t        |      dk(  rt        j                  S t        |      S r3   )r   reachesIntoOuterContextr   r   r   r   hasEmptyPathr   rf   rv   r   rp   rw   )r7   rH   r   r   s       r9   r   z6ParserATNSimulator.getAltThatFinishedDecisionEntryRule   sw    u 	 A((*z!''=/QVWV_V_VlVlVn	  t9a<)))t9r:   c                 ^   t        |j                        }t        |j                        }|D ]{  }|j                  t        j                  urL|j                  j                  | j                  |      }|r|j                  |       Y|j                  |       k|j                  |       } ||fS r<   )r   rd   r   r   r   evalr(   r   )r7   rH   rA   	succeededfailedr   predicateEvaluationResults          r9   r   z3ParserATNSimulator.splitAccordingToSemanticValidity  s     1	goo. 	!A  (<(<<,-,=,=,B,B4;;P\,]),MM!$JJqMa 	! &!!r:   predPredictionscompletec                 F   t               }|D ]  }|j                  t        j                  u r!|j	                  |j
                         |s |S A|j                  j                  | j                  |      }t        j                  st        j                  r&t        dt        |      z   dz   t        |      z          |st        j                  st        j                  r!t        dt        |j
                        z          |j	                  |j
                         |r |S  |S )Nz
eval pred =zPREDICT )r   r   r   r   r   rf   r   r(   r'   rI   rx   rK   rL   )r7   r   rA   r   predictionspairr   s          r9   ru   z&ParserATNSimulator.evalSemanticContext'  s    e# 	DyyO000)  (,		t{{L(Q%!''+=+G+GlSY.4s;T7UUV(%++/A/K/K*s488}45)!	  r:   r   r   collectPredicatesr   c           	      6    d}| j                  |||||||       y r3   )closureCheckingStopState)r7   r   rH   r   r   rd   r   initialDepths           r9   r   zParserATNSimulator.closureC  s'    %%fg{DU!(,8I	Kr:   depthc           
         t         j                  rt        dt        |      z   dz          t	        |j
                  t              r|j                  j                         srt        dt        |j                              D ]N  }|j                  j                  |      }	|	t        j                  u r|rA|j                  t        |j
                  t        j                   |      | j"                         tt         j                  r1t        d| j%                  |j
                  j&                        z          | j)                  |||||||       | j*                  j,                  |	   }
|j                  j/                  |      }t        |
|j0                  ||j2                        }|j4                  |_        | j7                  ||||||dz
  |       Q y |r|j                  || j"                         y t         j                  r1t        d| j%                  |j
                  j&                        z          | j)                  |||||||       y )Nzclosure()r   r   r   r   zFALLING off rule )r   rf   r   r   rE   )r'   rI   rK   rL   r   r   r   r   isEmptyr   rv   getReturnStater   EMPTY_RETURN_STATEr   r   rW   r/   getRuleNamer   closure_r0   states	getParentrf   r   r   r   )r7   r   rH   r   r   rd   r  r   r   r   returnState
newContextr   s                r9   r   z+ParserATNSimulator.closureCheckingStopStateI  s   ##*s6{*S01fllM2 >>))+q#fnn"56 EA"NN99!<E 1 D DD"#KK	N_NeNent(uw{  xG  xG  H$  277 %&9D<L<LV\\McMc<d&d e MM&';HY%,e5FH "&((//%"8K!'!9!9!!<J!ZbhbxbxyA 170N0NA-11!WkK\^eglopgp  sD  E)E* FDOO4 &++-0@0@AWAW0XXYfg{4EwPUWhir:   c           
      n   |j                   }|j                  s|j                  || j                         d}	|j                  D ]o  }
|	rd}	| j                  |      r|xr t        |
t               }| j                  ||
||dk(  ||      }|K|}t        |j                   t              r| j                  J| j                  j                  r4|
j                  | j                  j                  j                  k(  rd|_        |xj                   dz  c_        ||v r|j                  |       d|_        |dz  }t$        j&                  rUt)        dt+        |      z          n=|
j,                  s||v r.|j                  |       t        |
t.              r
|dk\  r|dz  }| j1                  |||||||       r y )NTFr   rE   zdips into outer ctx: )r   r   r   r/   r   'canDropLoopEntryEdgeInLeftRecursiveRuler   r   getEpsilonTargetr   r.   rS   outermostPrecedenceReturnr[   r   r   r   dipsIntoOuterContextr'   rI   rK   rL   	isEpsilonr   r   )r7   r   rH   r   r   rd   r  r   r   firstr   continueCollectingr   newDepths                 r9   r	  zParserATNSimulator.closure_s  s   LL''KK0  '	AA??G!2!Z:aIY;Z7Z%%fa1CUaZQXZklA} v||]; yy,1H1H66$)):Q:Q:[:[[;?A8--2-K' OOA&37G0MH)//5A>?;;+$#*!!^4#q=$MH--a+GY[bdln  AO'	Ar:   c                    |j                   }|j                  t        j                  k7  s@|j                  r4|j
                  j                         s|j
                  j                         ryt        |j
                        }t        d|      D ]O  }| j                  j                  |j
                  j                  |         }|j                  |j                  k7  sO y |j                  d   j                  }|j                   j"                  }| j                  j                  |   }t        d|      D ]  }|j
                  j                  |      }	| j                  j                  |	   }t        |j                        dk7  s|j                  d   j$                  s y|j                  d   j                  }
|j                  t        j&                  k(  r|
|u r||u r|
|u r|
j                  t        j&                  k(  rNt        |
j                        dk(  r6|
j                  d   j$                  r|
j                  d   j                  |u r y y)NFr   rE   T)r   	stateTyper   STAR_LOOP_ENTRYisPrecedenceDecisionr   r  r   rv   r   r0   r
  r  r   r   r   endStater   r  	BLOCK_END)r7   r   r   numCtxsr   r  decisionStartStateblockEndStateNumblockEndStatereturnStateNumberreturnStateTargets              r9   r  z:ParserATNSimulator.canDropLoopEntryEdgeInLeftRecursiveRule  s   LL ;;(222-->>))+>>..0 fnn%q'" 	A((//&..*G*G*JKK$$3	
 ]]1-44-66BB(89 q'"  	A & = =a @((//*;<K;**+q08O8OPQ8R8\8\ !, 7 7 : A A$$(:(::?PTU?U
 m+ !M1 !**h.@.@@)556!;%11!4>>%11!4;;q@ A 	D r:   rQ   c                 x    | j                   |dk\  r| j                   j                  |   S dt        |      z   dz   S )Nr   z<rule >)r(   	ruleNamesrL   )r7   rQ   s     r9   r  zParserATNSimulator.getRuleName@  s;    ;;"uax;;((//c%j(3..r:   c                 &    | j                  ||      S r<   )ruleTransitionsimr   r   r   	inContextrd   r   s          r9   <lambda>zParserATNSimulator.<lambda>G  s    61% r:   c                 ,    | j                  |||||      S r<   )precedenceTransitionr(  s          r9   r+  zParserATNSimulator.<lambda>I  s      ,=y'R r:   c                 ,    | j                  |||||      S r<   )predTransitionr(  s          r9   r+  zParserATNSimulator.<lambda>K  s    61&7GL r:   c                 &    | j                  ||      S r<   )actionTransitionr(  s          r9   r+  zParserATNSimulator.<lambda>M  s    VQ' r:   c                 0    t        |j                  |      S r   )r   r   r(  s          r9   r+  zParserATNSimulator.<lambda>O  s    0 r:   c                 z    |r8|j                  t        j                  dd      rt        |j                  |      S d S Nr   rE   r   r   r   r~   r   r   r(  s          r9   r+  zParserATNSimulator.<lambda>Q  7    4E!))TYT]T]_`bcJd	0 jn r:   c                 z    |r8|j                  t        j                  dd      rt        |j                  |      S d S r4  r5  r(  s          r9   r+  zParserATNSimulator.<lambda>S  r6  r:   c                 z    |r8|j                  t        j                  dd      rt        |j                  |      S d S r4  r5  r(  s          r9   r+  zParserATNSimulator.<lambda>U  r6  r:   r*  c           	      p    | j                   j                  |j                  d       }|y  || ||||||      S r<   )epsilonTargetMethodsr   serializationType)r7   r   r   r   r*  rd   r   rc   s           r9   r  z#ParserATNSimulator.getEpsilonTargetX  sA    %%))!*=*=tD9T61&7GM^__r:   c                     t         j                  r:t        dt        |j                        z   dz   t        |j
                        z          t        |j                  |      S )NzACTION edge rF   r   )r'   rI   rK   rL   r   actionIndexr   r   )r7   r   r   s      r9   r1  z#ParserATNSimulator.actionTransition_  sE    ##.3q{{#33c9C<NNOqxx77r:   ptc                 P   t         j                  rnt        dt        |      z   dz   t        |j                        z   dz          | j
                  /t        dt        | j
                  j                               z          d }|r|r|r| j                  j                  }| j                  j                  | j                         |j                         j                  | j
                  | j                        }| j                  j                  |       |rlt        |j                  |      }nTt!        |j"                  |j                               }	t        |j                  |	|      }nt        |j                  |      }t         j                  rt        dt        |      z          |S )NPRED (collectPredicates=) z>=_p, ctx dependent=truecontext surrounding pred is r   r   r   r   config from pred transition=)r'   rI   rK   rL   
precedencer(   getRuleInvocationStackr+   rQ   r`   r,   getPredicater   r-   r   r   r   r   
r7   r   r>  r   r*  rd   r   currentPositionpredSucceeds	newSemCtxs
             r9   r-  z'ParserATNSimulator.precedenceTransitiond  sD   ##,s3D/EEL&')CD E{{&4s4;;;];];_7``a
 #'++"3"3  !1!12!055dkk4CUCUV  1!		&AA&v'='=r?PQ	BII	&Q		&9A##03q69:r:   c                    t         j                  rt        dt        |      z   dz   t        |j                        z   dz   t        |j
                        z   dz   t        |j                        z          | j                  /t        dt        | j                  j                               z          d }|r|j                  r|j                  r|r|r| j                  j                  }| j                  j                  | j                         |j                         j                  | j                  | j                        }| j                  j                  |       |rlt!        |j"                  |      }nTt%        |j&                  |j                               }	t!        |j"                  |	|      }nt!        |j"                  |      }t         j                  rt        dt        |      z          |S )	Nr@  rA  rF   z, ctx dependent=rB  r   rC  rD  )r'   rI   rK   rL   r   	predIndexisCtxDependentr(   rF  r+   rQ   r`   r,   rG  r   r-   r   r   r   r   rH  s
             r9   r/  z!ParserATNSimulator.predTransition  s   ##,s3D/EELsSUS_S_O``bll+,.@ACFrGXGXCYZ [{{&4s4;;;];];_7``ab&7&7B<M<MR[
 #'++"3"3  !1!12!055dkk4CUCUV  1!		&AA&v'='=r?PQ	BII	&Q		&9A##03q69:r:   c                 R   t         j                  rJt        d| j                  |j                  j
                        z   dz   t        |j                        z          |j                  }t        j                  |j                  |j                        }t        |j                  ||      S )Nz
CALL rule z, ctx=r  )r'   rI   rK   r  r   r   rL   r   followStater   creater   r   )r7   r   r   r  r  s        r9   r'  z!ParserATNSimulator.ruleTransition  s|    ##,!1!1!((2D2D!EEPSVW]WeWeSffgmm/66v~~{G^G^_
qxxFLLr:   c                 V    t        j                  |      }t        j                  |      S r<   )r   r   getAlts)r7   rH   altsetss      r9   r   z%ParserATNSimulator.getConflictingAlts  s#     99'B%%g..r:   c                     d }|j                   t        j                  k7  r't               }|j	                  |j                          |S |j
                  }|S r<   )r   r   rp   r   r   rs   )r7   rH   rs   s      r9   r   z0ParserATNSimulator.getConflictingAltsOrUniqueAlt  sQ    s555!eO 1 12  &55Or:   c                    |t         j                  k(  ry| j                  c| j                  j                  M|t	        | j                  j                        k  r+| j                  j                  |   dz   t        |      z   dz   S t        |      S )Nr~   <r$  )r   r~   r(   rY   rv   rL   )r7   r   s     r9   r   zParserATNSimulator.getTokenName  sr    eii<;;"KK$$0DKK,,--003c9CFBSHHq6Mr:   c                 B    | j                  |j                  d            S NrE   )r   rj   )r7   r?   s     r9   rM   z#ParserATNSimulator.getLookaheadName  s      !--r:   nvaec                    t        d       |j                         D ]  }d}t        |j                  j                        dkD  r|j                  j                  d   }t        |t              rd| j                  |j                        z   }n?t        |t              r/t        |t              }|rdnddz   t        |j                        z   }t        |j                  | j                  d      d	z   |z   t        j                   
        y )Nzdead end configs: zno edgesr   zAtom ~ zSet TrF   )file)rK   getDeadEndConfigsrv   r   r   r   r    r   labelr!   r"   rL   r   rX   r(   sysstderr)r7   rZ  r   r   r   negs         r9   dumpDeadEndConfigsz%ParserATNSimulator.dumpDeadEndConfigs  s    "#'') 		PAE177&&')GG''*a0#T%6%6qww%??E=1$Q(89C$'SR7QUUCE!**T[[$/#5=CJJO		Pr:   c                 r    t        | j                  ||j                  |      |j                  d      ||      S rY  )r%   r(   r   rN   )r7   r?   rA   rH   rh   s        r9   rn   zParserATNSimulator.noViableAlt  s/    #DKK		*8MuxxXY{\ceqrrr:   c                     t         j                  }|D ]C  }|t         j                  k(  r|j                  }#|j                  |k7  s3t         j                  c S  |S r<   )r   rp   rf   )r7   rH   rf   r   s       r9   r   zParserATNSimulator.getUniqueAlt  sQ    $$ 	.Ac,,,ee---		.
 
r:   from_toc                 ,   t         j                  r;t        dt        |      z   dz   t        |      z   dz   | j	                  |      z          |y | j                  ||      }||dk  s|| j                  j                  kD  r|S |j                  "d g| j                  j                  dz   z  |_        ||j                  |dz   <   t         j                  rA| j                  d n| j                  j                  }t        d|j                  |      z          |S )NzEDGE z -> z upon r      rE   zDFA=
)r'   rI   rK   rL   r   r]   r0   r   r   r(   rY   rX   )r7   rb   rg  r   rh  namess         r9   r   zParserATNSimulator.addDFAEdge  s    ##'CJ&/#b'9HDtGXGXYZG[[\:c2&=AFa$((*?*?&?I;;&DHH$9$9A$=>EKAaC## KK/DT[[5M5ME(S\\%001	r:   c                    || j                   u r|S |j                  j                  |d       }||S t        |j                        |_        |j
                  j                  s6|j
                  j                  |        |j
                  j                  d       ||j                  |<   t        j                  rt        dt        |      z          |S )NTzadding new DFA state: )rm   r
  r   rv   r   rH   readonlyoptimizeConfigssetReadonlyr'   rI   rK   rL   )r7   rb   r   existings       r9   r]   zParserATNSimulator.addDFAState:  s    

?H ::>>!T*OCJJyy!!II%%d+II!!$'

1##*SV34r:   rs   r   c                    t         j                  st         j                  r^t        dt	        |j
                        z   dz   t	        |      z   dz   | j                  j                         j                  ||      z          | j                  9| j                  j                         j                  | j                  |||||       y y )Nz%reportAttemptingFullContext decision=rF   , input=)r'   rI   retry_debugrK   rL   r@   r(   getTokenStreamgetTextgetErrorListenerDispatchry   )r7   rb   rs   rH   rh   r   s         r9   ry   z.ParserATNSimulator.reportAttemptingFullContextL  s    ##'9'E'E9C<MMPSSVYZaVbb)*,0KK,F,F,H,P,PQ[]f,gh i;;"KK002NNt{{\_akmv  yH  JQ  R #r:   r|   c                    t         j                  st         j                  r^t        dt	        |j
                        z   dz   t	        |      z   dz   | j                  j                         j                  ||      z          | j                  9| j                  j                         j                  | j                  |||||       y y )Nz"reportContextSensitivity decision=rF   rr  )r'   rI   rs  rK   rL   r@   r(   rt  ru  rv  r   )r7   rb   r|   rH   rh   r   s         r9   r   z+ParserATNSimulator.reportContextSensitivityS  s    ##'9'E'E6S\\9JJSPSVW^S__)*,0KK,F,F,H,P,PQ[]f,gh i;;"KK002KKDKKY\^hjsu  BI  J #r:   exactc           	      x   t         j                  st         j                  rTt        dt	        |      z   dz   t	        |      z   dz   | j
                  j                         j                  ||      z          | j
                  :| j
                  j                         j                  | j
                  ||||||       y y )NzreportAmbiguity rF   rr  )
r'   rI   rs  rK   rL   r(   rt  ru  rv  r}   )r7   rb   r   rh   r   rx  r   rH   s           r9   r}   z"ParserATNSimulator.reportAmbiguity[  s    ##'9'E'E" $s9~5;c'lJ)*,0KK,F,F,H,P,PQ[]f,gh i;;"KK002BB4;;PSU_ajlqs|  F  G #r:   )R__name__
__module____qualname__	__slots__rI   rJ   rx   rs  r	   r   r   r   r5   r>   r   intr
   rg   r   r#   r_   rk   rl   r   r   r   rz   boolr   r   r   r   rZ   r\   r   r   r   r   r   ro   r   r   ru   r   r   r   r	  r  r  r   r:  RULE
PRECEDENCE	PREDICATEACTIONr   ATOMRANGESETr  r   r1  r   r-  r   r/  r   r'  r   r   r   rM   r%   rd  rn   r   r   r]   ry   r   r}   __classcell__)r8   s   @r9   r'   r'     s   I
 E$IKf # T Vl ,<K <# <L] <xT # T ( T + T # T \m T B x  3  &&S &H & &P> > >$e e e,8e/:e 58e 7H	eNkl kc k4 kB W[ 
( 
 
T 
H#L #Jz  S , c @ t |
&l 
&iz 
&, &"| "Rc "($ EV ae 8KY K K# Kae Kos K  HL K'ji 'j 'j[^ 'jrv 'j  AE 'j  MP 'j  dh 'jT0Ai 0A 0A3 0Abf 0Apt 0A| 0A  TX 0AX>B/ /  6-&)3S../2M--./(**+01++,-o).o))*,o(`i `: `QU `ae `os `  HL `8i 83C 8
) 8U jn z~   IM <I 2E Y] im w{ <MI M M/ /PL S .[ .P&: Ps s:K sUa snq s< :S  C H Hc X $Rc R3 RP\ Ril Rx{ RJ3 J3 J Jad Jps JG# G Gc GS G)-G9<GFRGr:   r'   )7ra  antlr4r   antlr4.PredictionContextr   r   r   r   antlr4.BufferedTokenStreamr   antlr4.Parserr	   antlr4.ParserRuleContextr
   antlr4.RuleContextr   antlr4.Tokenr   antlr4.Utilsr   antlr4.atn.ATNr   antlr4.atn.ATNConfigr   antlr4.atn.ATNConfigSetr   antlr4.atn.ATNSimulatorr   antlr4.atn.ATNStater   r   r   r   antlr4.atn.PredictionModer   antlr4.atn.SemanticContextr   r   r   r   antlr4.atn.Transitionr   r   r   r   r   r    r!   r"   antlr4.dfa.DFAStater#   r$   antlr4.error.Errorsr%   r'   r=   r:   r9   <module>r     sm   T  % % 2   6 *  !  * 0 0 Z Z 4 R RI I I 8 4pG pGr:   