3
QF>]                 @   s   d Z ddlZddlZddlZddlZejdd dkrJddlmZ dd Z	dd	 Z
d
d ZG dd dZdddddddZG dd deZG dd deZdS )am  
Copyright (c) 2015-2017 Rocky Bernstein
Copyright (c) 1998-2002 John Aycock

  Permission is hereby granted, free of charge, to any person obtaining
  a copy of this software and associated documentation files (the
  "Software"), to deal in the Software without restriction, including
  without limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and to
  permit persons to whom the Software is furnished to do so, subject to
  the following conditions:

  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    N   z2.3)Setc             C   s   dd | D }|j   |S )Nc             S   s   g | ]}|qS  r   ).0xr   r   O/home/psgendb/BIRCHDEV/python/lib/python3.6/site-packages/spark_parser/spark.py
<listcomp>   s    zsorted.<locals>.<listcomp>)sort)iterabletempr   r   r   sorted   s    r   c             C   sr   g i | j g  }}}xX|D ]P}x|jD ]}|j| q&W x0t|jj D ]}||krH|j| d||< qHW qW |S )N   )	__class__	__bases__appendlist__dict__keys)instancenamelistZnamedictZ	classlistcbnamer   r   r   	_namelist#   s    

r   c             C   s   d| d dj | d f j S )Nz	%s ::= %sr    r   )joinrstrip)ruler   r   r   rule2str.   s    r   c               @   s   e Zd ZdZdd ZdS )_StatezQ
    Extracted from GenericParser and made global so that [un]picking works.
    c             C   s    g g |  | _ | _| _|| _d S )N)Tcompleteitemsstateno)selfr#   r"   r   r   r   __init__5   s    z_State.__init__N)__name__
__module____qualname____doc__r%   r   r   r   r   r   1   s   r   FT)rules
transitionreduce
errorstackcontextdupsc               @   s  e Zd ZdZedfddZdZdZdZdd	 Z	d
d Z
dd Zd\ddZdd ZeZdd Zdd Zdd Zdd Zdd Zdd Zdd  Zd!d" Zd#d$ Zd]d&d'Zd^d(d)Zd*d+ Zd_d-d.Zd/d0 Zd1d2 Zd3d4 Zd5d6 Zd`d7d8Z d9d: Z!d;d< Z"d=d> Z#d?d@ Z$dAdB Z%dCdD Z&dEdF Z'dGdH Z(e)j*fdIdJZ+e, e)j-fdKdLZ.dMdN Z/dbdPdQZ0dRdS Z1dTdU Z2dVdW Z3dXdY Z4dZd[ Z5dS )cGenericParsera  
    An Earley parser, as per J. Earley, "An Efficient Context-Free
    Parsing Algorithm", CACM 13(2), pp. 94-102.  Also J. C. Earley,
    "An Efficient Context-Free Parsing Algorithm", Ph.D. thesis,
    Carnegie-Mellon University, August 1968.  New formulation of
    the parser according to J. Aycock, "Practical Earley Parsing
    and the SPARK Toolkit", Ph.D. thesis, University of Victoria,
    2001, and J. Aycock and R. N. Horspool, "Practical Earley
    Parsing", unpublished paper, 2001.
    Nc             C   s   i | _ i | _i | _|| _|rLi | _t|trRtjj	|rRt
jt|d| _nd| _|| _t | _t | _| j  || j krtd| | j| d| _i | _dS )z_start_ : grammar start symbol;
           _debug_ : produce optional parsing debug information
           _profile_ : if not None should be a file path to open
           with where to store profile is stored
        rbNz+Start symbol "%s" is not in LHS of any ruleT)r*   	rule2func	rule2namecoverage_pathprofile_info
isinstancestrospathexistspickleloadopendebugsetlist_like_ntoptional_ntcollectRules	TypeErroraugmentruleschangedcheck_reduce)r$   startr>   r4   r   r   r   r%   N   s&    


	zGenericParser.__init__z\e_ZSTARTz|-c             C   s   | j rR| j  i | _i | _| j  d| _ i i  | _| _d| j i| _| j	d| j
 d}xR|rd}xDt| jj D ]2\}}|d krp|\}}|| jkrp| j|| d}qpW qXW | jj }xt| jj D ]}|`qW |d= |d= |d= |S )NFr   Tr2   nullablecores)rE   computeNullnewrulesnew2oldmakeNewRulesedgesrI   
makeState0states	makeState_BOFr   r"   gotor   copyvalues)r$   changeskvstatesymrvsr   r   r   __getstate__   s2    

zGenericParser.__getstate__c             C   s\   i | _ i | _i | _| j  |d | j d d d }| j| | j|d< | j|d< || _d S )Nr*   r   r   r2   makeSet)r*   r2   r3   rB   _STARTrD   makeSet_fastr   )r$   DrG   r   r   r   __setstate__   s    


zGenericParser.__setstate__c             C   s   ||fS )Nr   )r$   r   funcr   r   r   
preprocess   s    zGenericParser.preprocessTc             C   s  |}t jjdd |j D }|j }g }x.tt|D ]}|| dkr8|j|d  q8W |jt| x&tt|d D ]}|||  }||| d ||d   }	|t|	f}
|r| j	|
|\}
}t|
d dkr|
d d |
d krt
dt|
 |
d d d }|dkr|
d d dd }|d
kr^|
d t|fg}| jj|
d  n,| jj|
d  |
d |
d gt|f g}t|}| j||| |d	kr||ff}n
|t f}t|}| j||| q||| jkr&|
| j| krd| jkr|| jd r|| j|
 q|| j| j|
 n|
g| j|< || j|
< |jdd | j|
< d| _| jdk	r|t|
d dkr|| j|
}|| jkr|d| j|< q|W dS )a9  Add a grammar rules to _self.rules_, _self.rule2func_,
            and _self.rule2name_

        Comments, lines starting with # and blank lines are stripped from
        doc. We also allow limited form of * and + when there it is of
        the RHS has a single item, e.g.
               stmts ::= stmt+
        c             S   s"   g | ]}|rt jd | r|qS )z^\s*#)rematch)r   r\   r   r   r   r      s    z)GenericParser.addRule.<locals>.<listcomp>z::=r      r   zComplete recursive rule %s*+?Nr/   Trk   )rh   ri   rj   rk   rk   )r8   linesepr   
splitlinessplitrangelenr   tuplerd   rC   r   r   rA   addr@   addRuler*   r>   duplicate_ruler2   r&   r3   rE   r5   reduce_string)r$   docrc   Z_preprocessfnr*   indexilhsrhsr   repeatntZnew_rule_pairZnew_ruleZsecond_rule_pairrule_strr   r   r   rs      sb    	








zGenericParser.addRulec       	      C   s2  t jjdd |j D }|j }g }x.tt|D ]}|| dkr4|j|d  q4W |jt| xtt|d D ]}|||  }||| d ||d   }|t|f}|| j	krdS || j	| krv| j	| j
| | j|= | j|= d| _| jdk	rvt|d dkrv| j|}|rv|| jkrv| j|= qvW dS )	zfRemove a grammar rules from  _self.rules_, _self.rule2func_,
            and _self.rule2name_
        c             S   s"   g | ]}|rt jd | r|qS )z^\s*#)re   rf   )r   r\   r   r   r   r     s    z.GenericParser.remove_rules.<locals>.<listcomp>z::=r   rg   NTr   )r8   rl   r   rm   rn   ro   rp   r   rq   r*   remover2   r3   rE   r5   ru   )	r$   rv   r*   rx   ry   rz   r{   r   r~   r   r   r   remove_rules  s0    

zGenericParser.remove_rulesc             C   sB   x<t | D ]0}|d d dkr
t| |}|j}| j|| q
W d S )Nrg   Zp_)r   getattrr)   rs   )r$   r   rc   rv   r   r   r   rB   3  s
    
zGenericParser.collectRulesc             C   s(   d| j | j|f }| j|dd d d S )Nz%s ::= %s %sc             S   s   | d S )Nr   r   )argsr   r   r   <lambda><  s    z'GenericParser.augment.<locals>.<lambda>F)r_   rR   rs   )r$   rG   r   r   r   r   rD   :  s    zGenericParser.augmentc             C   s   i | _ g }xt| jj D ]r}|s$q|d d }d| j |< xP|D ]H}|d }t|dkrdd| j |< q@x"|D ]}|| jkrjP qjW |j| q@W qW d}xR|rd}xD|D ]<\}}| j | rqx&|D ]}| j | sP qW d| j |< d}qW qW d S )Nr   r   )rH   r   r*   rU   rp   r   )r$   Ztbdrulelistrz   r   r{   rZ   rV   r   r   r   rJ   >  s6    








zGenericParser.computeNullc             C   s4   t dg }x$| j| j D ]}|jj|df qW |S )Nr   )r   rK   r_   r"   r   )r$   s0r   r   r   r   rO   i  s    
zGenericParser.makeState0c             C   sH   t | j| j dkr$t |dkr$dS | j| j d d d }| jd|S )Nrg   r   r   )rp   rK   r_   r*   rS   )r$   tokensrG   r   r   r   
finalStateo  s     zGenericParser.finalStatec             C   s8  g }x6t | jj D ]$}x|D ]}|j|dd|f qW qW x|D ]\}}}}|\}}t|}	x||	k r|| }
|
| jks|
| jko| j|
  rd}|d7 }q`t |}| j|
 ||< |t|f}|j||d ||f d}|d }q`W |r| j| }||f}|| jkr| j| j| n|g| j|< || j	|< qBW d S )Nr   r   )
r   r*   rU   r   rp   rH   	_NULLABLErq   rK   rL   )r$   worklistr   r   ry   	candidateZoldrulerz   r{   nrZ   ZnewrhsZnewruler   r   r   rM   x  s8    




zGenericParser.makeNewRulesc             C   s   d S )Nr   )r$   tokenr   r   r   
typestring  s    zGenericParser.typestringc             C   s   t dt|  d S )NzDuplicate rule:
	%s)printr   )r$   r   r   r   r   rt     s    zGenericParser.duplicate_rulec                sv   t d| | f  d| jkrn| jd rn|d dkr<|d nd} fddt||d D  t dd	j   td S )
Nz&Syntax error at or near token %d: `%s'r.   rg   r   c                s   g | ]}t  | qS r   )r7   )r   ry   )r   r   r   r     s    z'GenericParser.error.<locals>.<listcomp>r   zToken context:
	%sz
	)r   r>   ro   r   
SystemExit)r$   r   rx   rG   r   )r   r   error  s    zGenericParser.errorFc          
   C   s   t d dd | jj D }t }x|D ]}x~| j| jD ]n\}}|\}	}
|dkr:|r|jd|	dj|
d| dj|
|d f  q:|jd|	dj|
d| f  q:W q(W xt|D ]}t | qW dS )	av  Show the stacks of completed symbols.
        We get this by inspecting the current transitions
        possible and from that extracting the set of states
        we are in, and from there we look at the set of
        symbols before the "dot". If full is True, we
        show the entire rule with the dot placement.
        Otherwise just the rule up to the dot.
        z 
-- Stacks of completed symbols:c             S   s   g | ]}|r|qS r   r   )r   r\   r   r   r   r     s    z,GenericParser.errorstack.<locals>.<listcomp>r   z%s ::= %s . %sr   Nz	%s ::= %s)	r   rN   rU   r?   rP   r"   rr   r   r   )r$   r   ry   fullrP   Zstate_stackrY   r   dotrz   r{   stackr   r   r   r-     s*    	
zGenericParser.errorstackc             C   sp  || _ |r|| _dd	gg}i | _| jrr| j  i | _i | _| j  d| _i i  | _| _	d| j
 i| _| jd| j xVtt|D ]*}|jg  || g krP | j||| qW |jg  | jd|t| | j|df}||d
 krBt|dkr6| jjddr$| j||d t| jd dk | j||d  n| jdd | jdk	rV| j  | j| j||t|d S )zThis is the main entry point from outside.

        Passing in a debug dictionary changes the default debug
        setting.
        r   r   rg   FNr-   r   )r   r   )rg   r   )r   r>   linksrE   rJ   rK   rL   rM   rN   rI   rO   rP   rQ   rR   ro   rp   r   r^   r   getr-   r7   r   r5   dump_profile_info	buildTreer_   )r$   r   r>   setsry   Z	finalitemr   r   r   parse  s@    


 
zGenericParser.parsec             C   s   |j | jS )N)
startswithr   )r$   rZ   r   r   r   
isnullable  s    zGenericParser.isnullabler   c             C   s:   |\}}t |}x$||k r4| j|| s*P |d }qW |S )Nr   )rp   r   )r$   xxx_todo_changemeposrz   r{   r   r   r   r   skip  s    
zGenericParser.skipc             C   s*  |d k	st g }xP| j| jD ]@\}}|\}}|||d  |fkr|j|| j||d f qW tt|}|| jkr| j| S t| j }	| j|< t	|	|t	|	d g  }
}|
| j|	< i }| j
}| j}x|
|fD ]}|j}x|D ]}|\}}|\}}|t|kr|jj| q|| }|j|f}||krP||krd ||< |jj| qd ||< ||krd||< x0|| D ]$}| j|}||f}|jj| qrW qW ||
kri }qW |jg kr|	S tt|j }|| jkr| j| | j
|	d f< |	S |j } | j|< | j
|	d f< | j
j| || j|< |	S )Nr   )AssertionErrorrP   r"   r   r   rq   r   rI   rp   r   rN   rK   r!   r#   r    r   update)r$   rY   rZ   Zkitemsr   r   rz   r{   ZtcorerW   KZNKZ	predictedrN   r*   Xr   itemZnextSymkeyZpruleZpposnewnkr   r   r   rQ     s`    








zGenericParser.makeStatec             C   sB   ||f}|| j krd S | j | }|d kr>| j||}|| j |< |S )N)rN   rQ   )r$   rY   rZ   r   r[   r   r   r   rS   Z  s    


zGenericParser.gotoc             C   s$   | j d rtd|| | j||gS )Nr*   ZTerminal)r>   r   rS   )r$   rY   tr   r   r   gotoTk  s    
zGenericParser.gotoTc             C   sN   | j d rtd|| g }x.| j| jD ]}||kr(|j| j|| q(W |S )Nr+   ZGotoST)r>   r   rP   r    r   rS   )r$   rY   str[   r   r   r   r   gotoSTp  s    
zGenericParser.gotoSTc             C   sX   |d kr||krT|j | n8||f}||kr@g | j|< |j | | j| j ||f d S )N)r   r   )r$   r?   r   ry   predecessorcausalr   r   r   r   rr   y  s    

zGenericParser.addc          	   C   sT  || ||d   }}|d k	r2|| }| j |}nd }d }|d k	rP| j| }}	n| j| }}	x|D ]}
|
|f}|
\}}|||	}xT|D ]L}|d k	r| j|||f|d | | j|d }|d k	r| j|||d f qW ||krqdxd| j| jD ]R}|\}}| jd r| j|||| | j	d k	r4| j
| || jkr| j| dkr|sbt| drt| drt| j}| j|| j|
||}nd }| j||| j||}|r~|r| jd rtd|  qx~|| D ]r}|\}}| j||}|d k	r|
||f}||f}| j|||f||| | j|d }|d k	r| j|||f qW qW qdW d S )Nr   r,   ASTr   zReduce %s invalid by check)r   r   r   rr   rS   rP   r!   r>   debug_reducer5   profile_rulerF   hasattrr   
reduce_astZreduce_is_invalidr   )r$   r   r   ry   curnextr   ttyperw   argr   ptrrY   parentrr   rW   r   r   rz   r{   astinvalidpitempstatepparentwhypptrr   r   r   r^     sh    







zGenericParser.makeSetc             C   sJ  || ||d   }}|d k	r(| j |p*d }x|D ]}||f}|\}	}
|d k	r| jj|	|fd }|d k	r||
f}||d f}||krg | j|< |j| | j| j|d f | jj|d fd }|d k	r||d f}||kr|j| nh| j|	|}xZ|D ]R}|d k	r| j|||
f|d | | jj|d fd }|d k	r| j|||d f qW |
|kr^q4x| j|	 jD ]}|\}}x||
 D ]}|\}}| jj||fd }|d k	r|||f}||
f}||f}||f}||krg | j|< |j| | j| j||f | jj|d fd }|d k	r||f}||kr|j| qW qlW q4W d S )Nr   )	r   rN   r   r   r   r   rr   rP   r!   )r$   r   r   ry   r   r   r   r   r   rY   r   rW   r   r   r   rr   r   rz   r{   r   r   r   r   r   r   r   r   r`     s^    










zGenericParser.makeSet_fastc             C   s0   x"| j | D ]\}}||kr|S qW ds,td S )Nr   )r   r   )r$   r   r   pr   r   r   r   r     s    zGenericParser.predecessorc             C   sd   | j | }t|dkr"|d d S g }i }x*|D ]"\}}|d }|j| |||< q0W || j| S )Nr   r   rg   )r   rp   r   	ambiguity)r$   r   r   choicesZ
rule2causer   r   r   r   r   r   r     s    

zGenericParser.causalc             C   s   t | j| dkr$| j| j| }n| j| d }|d }d gt | }x.tt |d ddD ]}| j|| ||< q^W | j| j|  |S )Nr   r   rk   rk   )rp   rK   r   ro   deriveEpsilonr2   rL   )r$   r}   r   r{   attrry   r   r   r   r      s    zGenericParser.deriveEpsilonc             C   s`  | j d rtd| |\}}g }x*| j| jD ]}|d |kr.|j| q.W |d }t|dkrj| j|}|d }	d gt|	 }
xtt|	d ddD ]}|	| }|| jkr|| j	kr||d  |
|< ||f}| j
|d \}}q| j|dt| j kr
| j||
|< q||f}| j|}| j||d ||d |
|< | j
||\}}qW | j| j|  |
S )Nr*   ZNTr   r   rk   rk   )r>   r   rP   r!   r   rp   r   ro   rK   rR   r   r   r   r   r   r2   rL   )r$   r}   r   r   rW   rY   r   r   r   r{   r   ry   rZ   r   r   r   r   r   r   .  s6    





zGenericParser.buildTreec       
      C   s   g }i }xNt t|D ]>}||  \}}}| j| j|  }|jt||f |||< qW |j  dd |D }	||| j|	  S )Nc             S   s   g | ]}|d  qS )r   r   )r   Za_br   r   r   r   _  s    z+GenericParser.ambiguity.<locals>.<listcomp>)ro   rp   r3   rL   r   r	   resolve)
r$   r*   ZsortlistZ
name2indexry   rz   r{   r   r   r   r   r   r   r   Q  s    zGenericParser.ambiguityc             C   s   |d S )z
        Resolve ambiguity in favor of the shortest RHS.
        Since we walk the tree from the top down, this
        should effectively resolve in favor of a "shift".
        r   r   )r$   r   r   r   r   r   b  s    zGenericParser.resolvec             C   s2   x,t | jj D ]}|jdt|d   qW dS )z%
        Print grammar rules
        z%s
r   N)r   r3   r"   writer   )r$   outr   r   r   r   dump_grammarj  s    zGenericParser.dump_grammarc       
      C   s*  d}| j  \}}}}}|| rL|d7 }|jd |jddjt|d   |rz|d7 }|jd |jdjt|d  |r|d7 }|jd x0t|D ]$}	|jd	|	d d
j|	d f  qW |r&|d7 }|jd xJt|j D ]:}|jdd
j|  |jddj||   |jd qW |S )a  
        Check grammar for:
        -  unused left-hand side nonterminals that are neither start symbols
           or listed in ok_start_symbols
        -  unused right-hand side nonterminals, i.e. not tokens
        -  right-recursive rules. These can slow down parsing.
        r   r   z!LHS symbols not used on the RHS:
z  z, 
z!RHS symbols not used on the LHS:
zRight recursive rules:
z  %s ::= %s
r   zNonterminals with the same RHS
z
  RHS: %s
z
  LHS: %s
z  ---
)
check_setsr   r   r   r   )
r$   Zok_start_symbolsr   warningsrz   r{   r   right_recursivedup_rhsr   r   r   r   check_grammarr  s2    	


 

zGenericParser.check_grammarc             C   sD  t  }t  }i }t  }t  }i }x| jD ]}| j| }|j| x|D ]}	|	d }
t|
dkr|
|kr|j|
g }|j| |||
< n|||
< x.|
D ]&}tjd|r|j| q|j| qW t|
dkrF||
d krF|j||
f qFW q(W |j| j	 |j| j
 || }|| }x |D ]}
||
 j||
  qW |||||fS )z
        Check grammar
        r   r   z^[A-Z]rk   )r?   r*   rr   rp   r   r   re   rf   r   r_   rR   )r$   Zlhs_setZrhs_setZrhs_rules_setZ	token_setr   r   rz   Zrules_for_lhsr   r{   ZlirZ   Zmissing_lhsZmissing_rhsr   r   r   r     s@    






zGenericParser.check_setsr   c             C   sB   |dkr$d|d dj |d |f S d|d dj |d f S d S )Nr   z%s ::= %s (%d)r   r   z	%s ::= %s)r   )r$   r   Zlast_token_posr   r   r   ru     s    zGenericParser.reduce_stringc             C   s   t | j|| d S )N)r   ru   )r$   r   r   r   ry   r   r   r   r     s    zGenericParser.debug_reducec             C   s6   | j |}|| jkr d| j|< n| j|  d7  < dS )z1Bump count of the number of times _rule_ was usedr   N)ru   r5   )r$   r   r~   r   r   r   r     s    

zGenericParser.profile_rulec             C   s   t | jj dd ddS )zAShow the accumulated results of how many times each rule was usedc             S   s   | d S )Nr   r   )Zkvr   r   r   r     s    z0GenericParser.get_profile_info.<locals>.<lambda>F)r   reverseN)r   r5   r"   )r$   r   r   r   get_profile_info  s    
zGenericParser.get_profile_infoc          
   C   sv   t | jtr4t| jd}tj| j| W d Q R X n>x(| j D ]\}}| jjd||f  q>W | jjdd d  d S )Nwbz	%s -- %d
-(   r   )	r6   r4   r7   r=   r;   dumpr5   r   r   )r$   fpr   countr   r   r   r     s    zGenericParser.dump_profile_infoc             C   s   |d }d gt | }xtt |d ddD ]}|| }	|	| jkrv|	| jkr||d  ||< ||f}
| j|
d \}}q,| j|	dt | j kr| j|	||< q,||f}
| j|
}| j|	|d ||d ||< | j|
|\}}q,W |S )Nr   r   rk   rk   )	rp   ro   rK   rR   r   r   r   r   r   )r$   r   r   r   rW   r   r{   r   ry   rZ   r   r   r   r   r   r     s$    


zGenericParser.reduce_ast)T)F)N)r   )NNNrk   )rk   )6r&   r'   r(   r)   DEFAULT_DEBUGr%   r   r_   rR   r]   rb   rd   rs   r   Zremove_rulerB   rD   rJ   rO   r   rM   r   rt   r   r-   r   r   r   rQ   rS   r   r   rr   r^   r`   r   r   r   r   r   r   sysstdoutr   r?   stderrr   r   ru   r   r   r   r   r   r   r   r   r   r0   B   s`   
0!
O&+	"	
$
2
	N	
?K#%,

r0   c               @   s8   e Zd ZefddZdd Zdd Zdd Zd	d
 ZdS )GenericASTBuilderc             C   s6   dt jkrt jd }nd }tj| |||d || _d S )NZSPARK_PARSER_COVERAGE)r>   r4   )r8   environr0   r%   r   )r$   r   rG   r>   r4   r   r   r   r%     s    

zGenericASTBuilder.__init__c             C   s    | fdd}|\}}|||fS )Nc             S   s   | |fddS )Nc             S   s   |j | |S )N)buildASTNode)r   rz   r$   r   r   r   r     s    z@GenericASTBuilder.preprocess.<locals>.<lambda>.<locals>.<lambda>r   )rz   r$   r   r   r   r     s    z.GenericASTBuilder.preprocess.<locals>.<lambda>r   )r$   r   rc   Zrebindrz   r{   r   r   r   rd     s    zGenericASTBuilder.preprocessc             C   sF   g }x4|D ],}t || jr&|j| q
|j| j| q
W | j||S )N)r6   r   r   terminalnonterminal)r$   r   rz   childrenr   r   r   r   r     s    
zGenericASTBuilder.buildASTNodec             C   s   |S )Nr   )r$   r   r   r   r   r   !  s    zGenericASTBuilder.terminalc             C   s   | j |}||d t|< |S )N)r   rp   )r$   typer   r[   r   r   r   r   $  s    
zGenericASTBuilder.nonterminalN)	r&   r'   r(   r   r%   rd   r   r   r   r   r   r   r   r     s
   		r   )r)   r8   r;   re   r   versionr   r   r?   r   r   r   r   r   objectr0   r   r   r   r   r   <module>   s$           L