
    7                         S r SSKrSSKJr  SSKJr  SSKJr  SSKJ	r	J
r
  SSKJr  S	S
KJr  SSKJr  S	SKJr  S	SKJrJrJrJr  \R0                  (       a  SSKJrJr   " S S5      rg)a  This module implements an Earley parser.

The core Earley algorithm used here is based on Elizabeth Scott's implementation, here:
    https://www.sciencedirect.com/science/article/pii/S1571066108001497

That is probably the best reference for understanding the algorithm here.

The Earley parser outputs an SPPF-tree as per that document. The SPPF tree format
is explained here: https://lark-parser.readthedocs.io/en/latest/_static/sppf/sppf.html
    N)deque   )Token)Tree)UnexpectedEOFUnexpectedToken)logger   )GrammarAnalyzer)NonTerminal)Item)ForestSumVisitor
SymbolNode	TokenNodeForestToParseTree)	LexerConf
ParserConfc                   ^    \ rS rSr% S\S'   S\S'   \\S'   SS\4SS	 jjrS
 rSS jr	S r
Srg)Parser   r   
lexer_confr   parser_confdebugTFc                 F   [        U5      nXl        X l        X@l        XPl        X`l        UR                  U l        UR                  U l        UR                  U l        0 U l	        UR                   VV	s1 s H*  oR                    H  oR                  (       d  M  U	iM     M,     sn	nU l        UR                   VV	s1 s H*  oR                    H  oR                  (       a  M  U	iM     M,     sn	nU l        S U l        UR                   H  n
U
R                   U R                  ;  aL  UR#                  U
R                   5       Vs/ s H  oR$                  PM     snU R                  U
R                   '   U R                  b  Mx  U
R&                  R(                  c  M  [*        U l        M     U R                  R,                  S:w  aH  U R                  c;  U R                  R.                   H!  nUR(                  (       d  M  [*        U l          O   X0l        g s  sn	nf s  sn	nf s  snf )Nbasic)r   r   r   resolve_ambiguityr   
tree_classFIRSTNULLABLE	callbackspredictionsrules	expansionis_term	TERMINALSNON_TERMINALSforest_sum_visitororiginexpand_ruleruleoptionspriorityr   
lexer_type	terminalsterm_matcher)selfr   r   r/   r   r   r   analysisrsymr*   xterms                &lib/third_party/lark/parsers/earley.py__init__Parser.__init__!   s   ";/$&!2
$^^
 ))$.. )4(9(9a(91[[cT_T_3[3(9a,7,=,=i,=q#\g\gss,=i"&%%D{{$"2"22AIAUAUVZVaVaAb0cAbAAb0c  - &&.4<<3H3H3T*:' & ??%%0T5L5L5T11===.>D+ 2
 )/ bi
 1ds   3#H
H<#H#
HHc                 X
   0 n0 nX1   n[        U5      nU(       Ga
  UR                  5       n	U	R                  (       Ga`  U	R                  c|  U	R                  U	R
                  U4n
X;   a  XZ   OUR                  U
[        U
6 5      U	l        U	R                  R                  U	R                  U	R                  U	R
                  SS5        U	R                  R                  XIR
                     ;   Ga:  XIR
                     U	R                     nUR                  XKR                     ;   a  XKR                     UR                     nOUn[        UR                  UR                  UR
                  5      nUR                  UR
                  U4n
X;   a  XZ   OUR                  U
[        U
6 5      Ul        UR                  R                  XR                  5        UR                   U R"                  ;   a  UR%                  U5        GOX;  a"  UR%                  U5        UR'                  U5        GOU	R
                  U:H  nU(       a"  U	R                  XiR                  R                  '   X9R
                      Vs/ s H/  oR                   c  M  UR                   U	R                  :X  d  M-  UPM1     nnU H  nUR)                  5       nUR                  UR
                  U4n
X;   a  XZ   OUR                  U
[        U
6 5      Ul        UR                  R                  UR                  UR                  XR                  U	R                  5        UR                   U R"                  ;   a  UR%                  U5        M  X;  d  M  UR%                  U5        UR'                  U5        M     GO}U	R                   U R*                  ;   Gab  / nU R,                  U	R                       H!  n[        USU5      nUR'                  U5        M#     U	R                   U;   a  U	R)                  5       nUR                  U	R
                  U4n
X;   a  XZ   OUR                  U
[        U
6 5      Ul        UR                  R                  UR                  UR                  UR
                  U	R                  XiR                      5        UR'                  U5        U HY  nUR                   U R"                  ;   a  UR%                  U5        M0  X;  d  M7  UR%                  U5        UR'                  U5        M[     U(       a  GM	  ggs  snf )at  The core Earley Predictor and Completer.

At each stage of the input, we handling any completed items (things
that matched on the last cycle) and use those to predict what should
come next in the input stream. The completions and any predicted
non-terminals are recursively processed until we reach a set of,
which can be added to the scan list for the next scanner cycle.Nr   )r   popis_completenodesstart
setdefaultr   
add_familyr*   r(   previouscolumnr   ptradd_pathexpectr%   addappendadvancer&   r!   )r0   ito_scancolumnstransitives
node_cacheheld_completionsrB   itemsitemlabel
transitiveroot_transitivenew_itemis_empty_item
originatororiginators	new_itemsr*   s                      r6   predict_and_completeParser.predict_and_completeK   s[    
f99;D 99$!VVTZZ3E5:5H
 1jNcNcdikuw|k}N~DIII((DJJdS
 99##{::'>>!,ZZ!8!@J!**k:K:K.LL*56G6G*HI\I\*]*4#JOOZ^^ZEUEUVH,..0E0EqIE9>9LJ$5R\RgRghmoy  |A  pB  SCHMMM**?IIF$..8H-!/

8,X. %)JJ!OM$=AYY()9)9:@G

@S  #V@S*WhWh:  zD  zK  zK  OS  OU  OU  zU:@SK  #V&1
#-#5#5#7!)Z-=-=q A=B=P
(9V`VkVklqs}  @E  tF  WG 00X]]A`d`i`ij#??dnn<#KK1%3"JJx0!LL2 '2  2 22	 ,,T[[9D#D!Q/H$$X. :
 ;;"22#||~H%ZZQ7E9>9LJ$5R\RgRghmoy  |A  pB  SCHMMM,,XZZX\XaXacstt  dA  B$$X. )H$..8H-!/

8,X. !*O eT #Vs   0T'T' T'Nc                   ^ ^^^
^^ U U4S jnUU
U UU4S jnT R                   m
T R                  R                  m0 /mU Vs1 s H  owR                  iM     nnSnUR	                  U5       HS  n	T R                  WUTT5        U" XyU5      nUS-  nUR                  5         X Vs1 s H  owR                  iM     sn-  nMU     T R                  WUTT5        U[        T5      S-
  :X  d   eU$ s  snf s  snf )Nc                 >  > U R                   (       a  gU R                  5       nUR                   (       di  UR                  TR                  ;  a  gUR                  R
                  T:X  a  UR                  T:X  a  gUR                  5       nUR                   (       d  Mi  g)NTF)r;   rH   rE   r   r*   r(   )rP   quasir0   start_symbols     r6   is_quasi_complete(Parser._parse.<locals>.is_quasi_complete   st    LLNE''<<t}}4 ::$$49U  '''     c           	        > [        5       n[        5       nTR                  U5        TR                  0 5        0 n[        U5       GH/  nT" UR                  U5      (       d  M  UR                  5       nUR                  UR
                  U 4n[        U[        5      (       a  TR                  UR                  5      OSn	[        XSS9n
X;   a  XX   OUR                  U[        U6 5      Ul        UR                  R                  UR                  UR                  UR
                  UR                  U
5        UR                  TR                   ;   a  UR#                  U5        GM  UR#                  U5        GM2     U(       dP  U(       dI  U V s1 s H  o R                  R$                  iM     nn ['        X[        U5      [)        S U 5       5      S9eU$ s  sn f )a@  The core Earley Scanner.

This is a custom implementation of the scanner that uses the
Lark lexer to match tokens. The scan list is built by the
Earley predictor, based on the previously completed tokens.
This ensures that at each phase of the parse we have a custom
lexer context, allowing for more complex ambiguities.Nr   )r,   c              3   8   #    U  H  oR                   v   M     g 7fNr=   .0rI   s     r6   	<genexpr>.Parser._parse.<locals>.scan.<locals>.<genexpr>   s     cyqxlmdgdgqx   )considered_rulesstate)setrG   rE   rH   r=   r>   
isinstancer   gettyper   r?   r   r<   r@   r*   r%   rF   namer   	frozenset)rI   tokenrJ   next_to_scannext_setrM   rP   rT   rQ   r5   
token_noderE   rK   matchr0   r.   rL   s               r6   scanParser._parse.<locals>.scan   s{    5LuHNN8$r"JGe,,#||~H%ZZ;E 9C5%8P8P9==4VZD
 "+5!CJ9>9LJ$5R\RgRghmoy  |A  pB  SCHMMM,,XZZHNNTXT]T]_ij$..8$((2 !X.+ %. L189A((--9%ec'lZccyqxcyZyzz :s   Gr   r
   )r/   r   terminals_by_namerE   lexrY   clearlen)r0   lexerrK   rJ   r^   r_   rx   rI   expectsrs   rw   r.   rL   s   ` ` `     @@@r6   _parseParser._parse   s    	 )	  )	 Z !!OO55	 d &--W88W-YYw'E%%a';G1W-GFAMMO'2'Q'22G ( 	!!!Wg{C CLN""" . 3s   C,$C1c                 x   U(       d   U5       e[        U5      n[        5       /n[        5       nU R                  U    HQ  n[        USS5      nUR                  U R
                  ;   a  UR                  U5        M=  US   R                  U5        MS     U R                  XXS5      nUS    Vs/ s HT  oR                  (       d  M  UR                  c  M$  UR                  U:X  d  M6  UR                  S:X  d  MH  UR                  PMV     n	nU	(       d?  U V
s/ s H  oR                  R                  PM     nn
[        U[        S U 5       5      S9eU R                  (       a#  SSKJn   U" 5       nUR%                  U	S   S5        [-        U	5      S:  a   S	5       eU R.                  ba  [1        U R.                  U R2                  U R4                  =(       a    U R5                  5       U R6                  5      nUR9                  U	S   5      $ U	S   $ s  snf s  sn
f ! [&         a    [(        R*                  " S5         Nf = f)
Nr   c              3   8   #    U  H  oR                   v   M     g 7frd   re   rf   s     r6   rh   Parser.parse.<locals>.<genexpr>  s     CYQXACCQXrj   )rl   r
   )ForestToPyDotVisitorzsppf.pngzBCannot find dependency 'pydot', will not generate sppf debug imagez7Earley should not generate multiple start symbol items!)r   rm   r!   r   rE   r%   rF   r   r;   r<   r=   r>   rq   r   rr   r   earley_forestr   visitImportErrorr	   warningr}   r   r   r    r'   r   	transform)r0   r~   r>   r^   rK   rJ   r*   rP   n	solutionstexpected_terminalsr   debug_walkertransformers                  r6   parseParser.parse  s   eu"5)5'%
 $$\2Da#D{{dnn,D!
t$ 3 ++egD
 &-R[  C[MMVaffV]^]`]`dp]pVuvu|u|  AB  vBVQVV[	  C9@!AA((--!A 2)CYQXCY:YZZ::;=35 ""9Q<< y>ASSS5??&+DOOT^^TMdMd  NCim  jA  jA  jC  EI  E[  E[  \K((166 |1 C!A  ecdes6   ,HHH%H7HH'H  H98H9)r   r&   r   r%   r    r   r'   r   r   r!   r   r/   r   )r   r   r   r   rd   )__name__
__module____qualname____firstlineno____annotations__boolr   r7   rY   r   r   __static_attributes__ ra   r6   r   r      s9    Kkow|  JN ')T[/zYv.ra   r   )__doc__typingcollectionsr   r~   r   treer   
exceptionsr   r   utilsr	   grammar_analysisr   grammarr   earley_commonr   r   r   r   r   r   TYPE_CHECKINGcommonr   r   r   r   ra   r6   <module>r      sE   	     7  - !  U U	.U Ura   