3
/*^&                @   s  d Z ddlmZ ddlZddlmZmZ ddlmZ ddl	m
Z
 ddlmZmZmZ ddlj
ZddlmZ dd	l	mZ dd
lmZmZ ddlmZ ddlmZmZ ddlmZmZmZm Z m!Z!m"Z"m#Z# ddl$m%Z& ddl'm(Z( ddl)m*Z* e*ddZ+e*ddZ,d@dAdBdCdFdJdNdQdRdUdYd^dcdhdidkdmd+Z-G d,d- d-ej.e/Z0d.d.d.d/Z1e d.d.d.i d0de0fd1d2Z2e dde1i d0e0fd3d4Z3dd5l4m5Z5 d6d7 Z6e dde1fd8d9Z7e d.d.d.d.fd:d;Z8d<d= Z9d>d? Z:dS )na  
Creates Python source code from an uncompyle6 parse tree,
and indexes fragments which can be accessed by instruction offset
address.

See https://github.com/rocky/python-uncompyle6/wiki/Table-driven-semantic-actions.
for a more complete explanation, nicely marked up and with examples.

We add some format specifiers here not used in pysource

1. %x
-----

   %x takes an argument (src, (dest...)) and copies all of the range attributes
from src to all nodes under dest.

For example in:
    'import': ( '%|import %c%x
', 2, (2,(0,1)), ),

node 2 range information, it in %c, is copied to nodes 0 and 1. If
1. is a nonterminal, all the nodes under it get node2 range information.

2. %r
-----

   %r associates recursively location information for the string that follows

For example in:
   'break':	( '%|%rbreak
', ),

The node will be associated with the text break, excluding the trailing newline.

Note we associate the accumulated text with the node normally, but we just don't
do it recursively which is where offsets are probably located.

2. %b
-----

   %b associates the text from the specified index to what we have now.
      it takes an integer argument.

For example in:
  'importmultiple':   ( '%|import%b %c%c
', 0, 2, 3 ),

The node position 0 will be associated with "import".

    )print_functionN)iscodesysinfo2float)pysource)parser)TokenCodeget_scanner)checker)IS_PYPY)maybe_show_asmmaybe_show_tree)
SyntaxTree)ParserErrorStringIO)INDENT_PER_LEVELNONE
PRECEDENCETABLE_DIRECTescapeMAPPASS)DEFAULT_DEBUG)#GenericASTTraversalPruningException)
namedtupleNodeInfoznode start finishExtractInfozGlineNo lineStartOffset markerLine selectedLine selectedText nonterminal
%|%rbreak
%|%rcontinue
	%|%rpass

%|%rraise
%|import %c%x
      , %c%xalias%|from %[2]{pattr}%x import %c
   
importlist%|import%b %c%c
 for %c%x in %c%c%|for%b %c%x in %c:
%+%c%-

store   *%|for%b %c%x in %c:
%+%c%-%|else:
%+%c%-

(%|for%b %c%x in %c:
%+%c%-%|else:
%+%c%-%|while%b %c:
%+%c%-

$%|while%b %c:
%+%c%-%|else:
%+%c%-

"%|while%b %c:
%+%c%-%|else:
%+%c%-)breakz
continue  passZraise_stmt0importZimport_contimport_fromZ
importfromZimportmultiplelist_forforZforelsestmtZforelselaststmtZforelselaststmtlZ	whilestmtZwhileelsestmtZwhileelselaststmtc                   s  e Zd Zf ZdZdedddfdd	Zed
d dd dd dZedd dd dd dZ	edd dd dd dZ
edd dd dd dZdddZd fdd	Zdd Ze Z Z Z ZZe Z Z Z ZZe Z Z ZZdd Zd d! Ze Z Z  Z!Z"d"d# Z#d$d% Z$d&d' Z%d(d) Z&d*d+ Z'd,d- Z( fd.d/Z) fd0d1Z* fd2d3Z+ fd4d5Z,d6d7 Z- fd8d9Z. fd:d;Z/ fd<d=Z0e0Z1 fd>d?Z2d@dA Z3dBdC Z4dDdE Z5dFdG Z6dHdI Z7ddKdLZ8ddMdNZ9dOdP Z:dQdR Z;dSdT Z<dUdV Z=dWdI Z7dXdY Z>dZd[ Z?d\d] Z@e@ZAdd^d_ZBdd`daZCdbdc ZDddde ZEddfdgZFdhdi ZGddjdkZHdldm ZIdndo ZJdpdq ZKdrds ZLdtdu ZMdvdw ZNdxdy ZOdzd{ ZPeP ZQ ZRZSd|d} ZTeUd~d ZV  ZWS )FragmentsWalkerfindent	is_lambda_globalsFexecTc             C   sJ   t jj| |t ||||||d	 d| _i | _d| _|| _tt	ft
fad S )N)versionoutscannershowastdebug_parsercompile_modeis_pypytolerate_errorsFr#   )r   SourceWalker__init__r   Zhide_internaloffsetslast_finishrE   dictr   TABLE_DIRECT_FRAGMENTMAP_DIRECT_FRAGMENT)selfr?   rA   rB   rC   rD   rE   rF    rP   [/home/psgendb/BIRCHDEV/python/lib/python3.6/site-packages/uncompyle6/semantics/fragments.pyrI      s     

zFragmentsWalker.__init__c             C   s
   | j d S )Nr:   )params)srP   rP   rQ   <lambda>   s    zFragmentsWalker.<lambda>c             C   s   | j jd|S )Nr:   )rR   __setitem__)rS   xrP   rP   rQ   rT      s    c             C   s   | j jdS )Nr:   )rR   __delitem__)rS   rP   rP   rQ   rT      s    Nc             C   s
   | j d S )Nr;   )rR   )rS   rP   rP   rQ   rT      s    c             C   s   | j jd|S )Nr;   )rR   rU   )rS   rV   rP   rP   rQ   rT      s    c             C   s   | j jdS )Nr;   )rR   rW   )rS   rP   rP   rQ   rT      s    c             C   s
   | j d S )Nr<   )rR   )rS   rP   rP   rQ   rT      s    c             C   s   | j jd|S )Nr<   )rR   rU   )rS   rV   rP   rP   rQ   rT      s    c             C   s   | j jdS )Nr<   )rR   rW   )rS   rP   rP   rQ   rT      s    c             C   s
   | j d S )Nr=   )rR   )rS   rP   rP   rQ   rT      s    c             C   s   | j jd|S )Nr=   )rR   rU   )rS   rV   rP   rP   rQ   rT      s    c             C   s   | j jdS )Nr=   )rR   rW   )rS   rP   rP   rQ   rT      s    c             C   sb   |d kr| j }t|dr4||_||_|| j||jf< t|drL|j|ksLt||_||_|| _d S )Noffsetparent)	namehasattrstartfinishrJ   rX   rY   AssertionErrorrK   )rO   noder\   r]   rZ   rP   rP   rQ   set_pos_info   s    

zFragmentsWalker.set_pos_infoc                s<   t | jj }ttj| j| | j||t | jj  d S )N)lenr:   getvaluesuperr   rH   preorderr`   )rO   r_   r\   )	__class__rP   rQ   rd      s    zFragmentsWalker.preorderc             C   s   t | jj }y| j| W n^ tk
rz   t|d dsD||d _t | jj }| j||| | j|d || tY nX dS )ziGeneral pattern where the last node should should
        get the text span attributes of the entire treer#   rY   NrG   rG   rG   )ra   r:   rb   defaultr   r[   rY   r`   )rO   r_   r\   finalrP   rP   rQ   table_r_node   s    
zFragmentsWalker.table_r_nodec             C   s<   t | jj t | j }| j|||t d  | j| d S )Nr4   )ra   r:   rb   r;   r`   rf   )rO   r_   r\   rP   rP   rQ   n_pass  s    zFragmentsWalker.n_passc             C   s@   t | jj t | j }| j|d ||t d  | j| d S )Nr   ztry:)ra   r:   rb   r;   r`   rf   )rO   r_   r\   rP   rP   rQ   n_try_except  s    zFragmentsWalker.n_try_exceptc             C   st   |d dkst t| jj t| j }y| j| W n8 tk
rn   | j|d |t| jj  | j  Y nX d S )Nr   ZRAISE_VARARGS_0)	r^   ra   r:   rb   r;   rf   r   r`   prune)rO   r_   r\   rP   rP   rQ   n_raise_stmt0  s    zFragmentsWalker.n_raise_stmt0c             C   st   |d dkst t| jj t| j }y| j| W n8 tk
rn   | j|d |t| jj  | j  Y nX d S )Nr#   ZRAISE_VARARGS_1)	r^   ra   r:   rb   r;   rf   r   r`   rk   )rO   r_   r\   rP   rP   rQ   n_raise_stmt1#  s    zFragmentsWalker.n_raise_stmt1c             C   st   |d dkst t| jj t| j }y| j| W n8 tk
rn   | j|d |t| jj  | j  Y nX d S )Nr"   ZRAISE_VARARGS_2)	r^   ra   r:   rb   r;   rf   r   r`   rk   )rO   r_   r\   rP   rP   rQ   n_raise_stmt2,  s    zFragmentsWalker.n_raise_stmt2c             C   st   |d dkst t| jj t| j }y| j| W n8 tk
rn   | j|d |t| jj  | j  Y nX d S )Nr'   ZRAISE_VARARGS_3)	r^   ra   r:   rb   r;   rf   r   r`   rk   )rO   r_   r\   rP   rP   rQ   n_raise_stmt36  s    zFragmentsWalker.n_raise_stmt3c             C   sZ  t | jj t | j }| jd rd| j|d  t|d	 drZ| j|d
 |t | jj  | j  nt | jj t | j }| j	| jd | j
s|tdtdtgtdgkr| j	d t | jj | _| j|d  t|d dr.| j|d |t | jj  n(x&|D ]}| j||t | jj  qW | j||t | jj  | j  | j  d S )Nr<   r   r#   rX   returnret_exprRETURN_VALUE rG   rG   rG   rG   )ra   r:   rb   r;   rR   rd   r[   r`   rk   writereturn_noner   r   r   rK   set_pos_info_recurseprintln)rO   r_   r\   nrP   rP   rQ   n_return?  s,    




zFragmentsWalker.n_returnc             C   s   t | jj t | j }| jd r<||d _| j|d  nt | jj t | j }| j| jd | js|t	dt	dt
gtdgkr| jd | j|d  t|d	 dr| j|d
 |t | jj  | j  | j||t | jj  | j  d S )Nr<   r   rp   rq   RETURN_END_IFrs   r#   rX   rG   rG   )ra   r:   rb   r;   rR   rY   rd   rt   ru   r   r   r   r[   r`   rw   rk   )rO   r_   r\   rP   rP   rQ   n_return_if_stmt\  s    



z FragmentsWalker.n_return_if_stmtc                s   t | jj }ytt| j| W n tk
r6   Y nX |tdtt	dgkrX||d _
| j|d |t | jj  | j||t | jj  | j  d S )NyieldYIELD_VALUEr   r#   rG   )ra   r:   rb   rc   r9   n_yieldr   r   r   r   rY   r`   rk   )rO   r_   r\   )re   rP   rQ   r~   p  s    
zFragmentsWalker.n_yieldc                sj   t | jj }ytt| j| W n tk
r6   Y nX | j|d  | j||t | jj  | j	  d S )Nr   )
ra   r:   rb   rc   r9   r~   r   rd   r`   rk   )rO   r_   r\   )re   rP   rQ   n_yield_from}  s    zFragmentsWalker.n_yield_fromc                s\   t | jj }ytt| j| W n tk
r6   Y nX | j||t | jj  | j  d S )N)	ra   r:   rb   rc   r9   n_buildslice3r   r`   rk   )rO   r_   r\   )re   rP   rQ   r     s    zFragmentsWalker.n_buildslice3c                s\   t | jj }ytt| j| W n tk
r6   Y nX | j||t | jj  | j  d S )N)	ra   r:   rb   rc   r9   n_buildslice2r   r`   rk   )rO   r_   r\   )re   rP   rQ   r     s    zFragmentsWalker.n_buildslice2c             C   s  t | jj }| j}|d jjdr6|d d d }n|d }tj|jd| _|dkrt|j	d dkr||_
| j||t | jj  d| _|| jk r| jd ||d _
t | jj | _| j|d  t | jj }t|d d	r| j|d |t | jj  | jd
 |d | _nR||d _
t | jj }| j|d  t|d d	rl| j|d |t | jj  || _| j||t | jj  | j  d S )Nr   Zbin_opr#   r"   
LOAD_CONST-   (rX   )rG   )ra   r:   rb   preckind
startswithr   getreprpattrrY   r`   rt   rK   rd   r[   rk   )rO   r_   r\   prx   r]   rP   rP   rQ   n_expr  s8    



zFragmentsWalker.n_exprc                s:   t | jj }tt| j| | j||t | jj  d S )N)ra   r:   rb   rc   r9   
n_ret_exprr`   )rO   r_   r\   )re   rP   rQ   r     s    zFragmentsWalker.n_ret_exprc                s   t | jj }x|D ]
}||_qW t | jj | _ytt| j| W n tk
rZ   Y nX | j	||t | jj  | j
  dS )z7bin_op (formerly "binary_expr") is the Python AST BinOpN)ra   r:   rb   rY   rK   rc   r9   n_bin_opr   r`   rk   )rO   r_   r\   rx   )re   rP   rQ   r     s    

zFragmentsWalker.n_bin_opc                s\   t | jj }ytt| j| W n tk
r6   Y nX | j||t | jj  | j  d S )N)	ra   r:   rb   rc   r9   n_LOAD_CONSTr   r`   rk   )rO   r_   r\   )re   rP   rQ   r     s    zFragmentsWalker.n_LOAD_CONSTc                s   t | jj t | j }ytt| j| W n tk
r@   Y nX | j||t | jj  | j|d |t | jj  | j	  dS )zm
        exec_stmt ::= expr exprlist DUP_TOP EXEC_STMT
        exec_stmt ::= expr exprlist EXEC_STMT
        r#   NrG   )
ra   r:   rb   r;   rc   r9   n_exec_stmtr   r`   rk   )rO   r_   r\   )re   rP   rQ   r     s    zFragmentsWalker.n_exec_stmtc             C   s~  |d dkr|d }d|_ n|d }t|dkr:| j| |d d d dkoh|d d d d d dk r|d d d dko|d d d d d dk r| j| d S t| jj t| j }| j| jd	 | j|d  | jd
 | j	  ||d _
| j|d  | j  d}t|d d dkrz||d d _
|d d d d dkrz|d d d d d d dkrzd}d}d}x|d D ]~}|d dkr|d d d dkr|rd|d _ d}n.d}| r| r| j| jd | j	  d}||_
| j| qW | s|r2| j| jd | j	  ||d d _
| j|d d  | j||t| jj  | j  | j  d S )Nr"   Z	COME_FROMr'   Zifelsestmtr2r   ifstmtr#   return_if_stmtszif :FTelifstmtzelse:rG   rG   rG   rG   )r   ra   rf   r:   rb   r;   rt   rd   rw   indent_morerY   indent_lessr`   rk   )rO   r_   Zreturn_stmts_noder\   Zif_ret_at_endZ	past_elseZprev_stmt_is_if_retrx   rP   rP   rQ   n_ifelsestmtr  s`    



"$
zFragmentsWalker.n_ifelsestmtrc             C   s\  t |d dkr| j| xB|d d D ]2}|d dkoJ|d d d dks(| j| d S q(W t | jj | j }| j| jd ||d _| j|d  | jd | j	  ||d _| j|d  | j
  x.|d d D ]}d|d _||_| j| qW | j| jd	 | j	  ||d d _| j|d d  | j
  | j||t | jj  | j  d S )
Nr"   r   r   r#   r   zelif r   r   zelse:)ra   rf   r:   rb   r;   rt   rY   rd   rw   r   r   r   r`   rk   )rO   r_   rx   r\   rP   rP   rQ   n_elifelsestmtr!  s4    
 




zFragmentsWalker.n_elifelsestmtrc       	      C   s   t | jj }|d j}|d d }|jjds4t|j}| j| t | jj }||ksh|j|d rx| j||| n^| jd t | jj }| j| t | jj }x|d D ]}| j||| qW | j	||| | j
  d S )	Nr   r#   ZSTORE_.z as rG   rG   rG   )ra   r:   rb   r   r   r   r^   rt   rv   r`   rk   )	rO   r_   r\   ZinameZstore_import_nodeZsnamer]   Zsname_startrx   rP   rP   rQ   n_alias@  s"    



zFragmentsWalker.n_aliasc             C   s   t | jj }| jdks$|d dkr.|d }n"|d dkrH|d d }n|d }|jj}| j| | j||t | jj  | j  t | jj }| j	|d|d | j||t | jj  t | j
d	kr| jd
 n
| jd | j  | j  d S )Ngffffff
@r"   kwargsr'   exprr   F)r<   	code_noder#   z

z


r   r   r   r   )ra   r:   rb   r?   attrco_namert   r`   r   Zmake_functionparam_stackr   rk   )rO   r_   r\   r   	func_namerP   rP   rQ   n_mkfuncV  s$    


zFragmentsWalker.n_mkfuncc             C   s   | j }d| _ |d }|dks txH|dkrh|d }|dkrD|d }q"|dkrV|d }q"|d	kr"|d }q"W |d
ksvt|d jjdrt| jj }| j|d ||d  | jd | j	|d  | j	|d  | jd || _ | j
  dS )zList comprehensions   r#   	list_iterr   r7   r'   list_ifr"   list_if_notlc_body
BUILD_LISTz[ z ]NrG   rG   )r   r^   r   r   ra   r:   rb   r`   rt   rd   rk   )rO   r_   r   rx   r\   rP   rP   rQ   n_list_compu  s,    




zFragmentsWalker.n_list_comp   c             C   s  | j }d| _ | jdkr(|dkr(|d }n| jdkrn|dkrn|d dkrP|d }n|d dkrd|d }|d }ntt|| dr|| }n\t|d dkrt|d d dr|d d }n,t|d d dr|d d }nd	std
t|jstt|j| j| j	}| j
|j|j}| j|j |d d d }|| }	|	dksDtxR|	dkr|	d }	|	dkrl|	d }	n&|	dkr|	d }	n|	dkrF|	d }	qFW |	dkst|| j|	d  | jd t| jj }
||d  }| j| | j||d  |
t| jj  | jd t| jj }
||d _| j|d  | j|d |
t| jj  t| jj }
| j||  | j|| |
t| jj  || _ d S )Nr   g      @Z	dict_compr#   Zgenerator_expr   load_genexprr   Fz!Can't find code for comprehension	comp_itercomp_forr'   comp_ifr"   
comp_ifnot	comp_bodyz for z in r   r   r   )r   r?   r[   ra   r^   r   r   r   rA   currentclass	build_ast_tokens
_customize	customizerd   rt   r:   rb   r`   rY   )rO   r_   
iter_index
code_indexr   Zcnr   codeastrx   r\   r,   rP   rP   rQ   comprehension_walk  s`    



"






 

z"FragmentsWalker.comprehension_walkc             C   s2  | j }d| _ || j}t|s*t|| |j}t|| j| j}| j|j	|j
}| j|j
 |d dkrp|d }|d d d }d}|dkr| j||i  xL|D ]}	|	dkr|	}
q|	dkr|	}qW n$|d d }|| }
|
d	kst|
d}d}d}|
dkr
|
}|d
 }d}xz|
dkr|
d }
|
d krL|
d dkrB|
d }|
d
 }
n8|
d!kr|
d"k}|
d }|
d dkr||
d }|
d }
qW |
jd#kst||std| j}|| _| j|
d  t| jj d }| jd t| jj }|r| j| n
| j| | j||t| jj  | jd t| jj }||d$ _| j|d%  t| jj }| j|d& ||| |dkr|d }|d	kst|dkr| j|d
  || _ dS |r| j| n*|r| jd |r| jd | j| || _ || _|d' jjdr.| j|d( |t| jj  dS ))z
        List comprehensions the way they are done in Python3.
        They're more other comprehensions, e.g. set comprehensions
        See if we can combine code.
        r   r   ZsstmtNset_comp_funcdict_comp_funcr   r,   r   r'   Fr7   r   r"   r   r   r   r   r#   r   r   set_comp_bodyz-Couldn't find store in list/set comprehensionz for z in Z	list_compz if znot CALL_FUNCTION)r   r   )r   r   )r7   r   )r   r   r   r   )r   r   )r   r   r   r   r   r   r   rG   rG   )r   r   r   r^   r   r   rA   r   r   r   r   r   
gen_sourcer   rZ   rd   ra   r:   rb   rt   r`   rY   r   )rO   r_   r   r   r   r   Z	code_namer   r,   krx   Zif_noder   Z
comp_storeZhave_notold_nameZ	gen_startr\   finr   rP   rP   rQ   comprehension_walk3  s    














z#FragmentsWalker.comprehension_walk3c       
      C   s  | j }d| _ t|d j| j| j}| j|j|j}| j|j |dkrX|d d d }n|d d d d d }|dkr|d }|d }|d }d}|dkst	x\|dk r|d }|d	kr|d
 }|d }q|dkr|d j
dkr|}n|d }|d
 }qW |dkst	|| j|d  | jd t| jj }	| j| | j||	t| jj  | jd t| jj }	||d _| j| | j||	t| jj  |rt| jj }	| j| | j||	t| jj  || _ dS )zList comprehensions the way they are done in Python 2 (and
        some Python 3?).
        They're more other comprehensions, e.g. set comprehensions
        See if we can combine code.
        r   r#   Zset_compr   r   r'   Nr   r7   r"   r   r   r   z for z in r   )r   r   r   )r   r   r   rA   r   r   r   r   r   r^   r   rd   rt   ra   r:   rb   r`   rY   )
rO   r_   r   r   r   rx   
collectionr   r,   r\   rP   rP   rQ   listcomprehension_walk2K  sR    






z'FragmentsWalker.listcomprehension_walk2c             C   sh   t | jj }| jd | jdkr&dnd	}| j|d|d | jd | j||t | jj  | j  d S )
Nr   g	@r   r   r'   )r   r   r   i)ra   r:   rb   rt   r?   r   r`   rk   )rO   r_   r\   r   rP   rP   rQ   n_generator_exp  s    

zFragmentsWalker.n_generator_expc             C   s   t | jj }| jd |d dkrXt | jj }| j|d |d | | j|dd n,|d jdkrv| j|dd n| j|dd	 | jd
 | j||t | jj  | j	  d S )N{r   LOAD_SETCOMPLOAD_DICTCOMPr#   load_closurer-   )collection_index)r   })r   r   )
ra   r:   rb   rt   r`   r   r   setcomprehension_walk3r   rk   )rO   r_   r\   rP   rP   rQ   
n_set_comp  s    

zFragmentsWalker.n_set_compc             C   s  t | jj }| j| jd |d }t | jj }| j| | j|d |t | jj  | jd t | jj }|d jjdst	| j|d |d | |d }|dkst	t | jj }| j| t | jj }| j||| |d }|jd	kst	| j||| | jd
 | j| | jd | j| t | jj }| j|d  | j|d |t | jj  | jd t | jj }| j||| |d dkr| j|d || | j
  d S )Nzlambda r#   r   z: {	BUILD_SETr'   r,   r"   FOR_ITERz for z in r-   r   rr   r   r   )ra   r:   rb   rt   r;   rd   r`   r   r   r^   rk   )rO   r_   Zsetcomp_startZ
param_noder\   r,   r   Zfor_iter_noderP   rP   rQ   n_set_comp_func  s@    







zFragmentsWalker.n_set_comp_funcc             C   sx   | j d |d jdkr$| j| n>|d dkrTt| jj }| j|d |d | | j|dd | j d | j  d S )N[r   r   ZLOAD_LISTCOMPr#   ])	rt   r   r   ra   r:   rb   r`   Zcomprehension_walk_newerrk   )rO   r_   r\   rP   rP   rQ   r     s    

c             C   sb   t |dkr^|d dkr^|d d dkr^|d jjdr^| j|d |d d j|d d j d S )Nr#   r   Zc_stmts_optr4   JUMP_FORWARD)ra   r   r   r`   r\   r]   )rO   r_   rP   rP   rQ   n__ifstmts_jump_exit  s
    z$FragmentsWalker.n__ifstmts_jump_exitc             C   s  | j }d| _ t|d j| j| j}| j|j|j}| j|j |d d d }|d }|| }|d }d}	|dksvt	xZ|dkr|d }|dkr|d	 }|d }qx|dkrx|d j
dkr|}	n|d }	|d	 }qxW |dkst	|| j|d  | jd t| jj }
| j| | j||
t| jj  | jd t| jj }
| j| | j||
t| jj  |	rt| jj }
| j|	 | j|	|
t| jj  || _ dS )zSet comprehensions the way they are done in Python3.
        They're more other comprehensions, e.g. set comprehensions
        See if we can combine code.
        r   r#   r   r'   r-   Nr   r7   r"   r   r   r   comp_if_notr   r   z for z in )r   r   r   r   )r   r   r   rA   r   r   r   r   r   r^   r   rd   rt   ra   r:   rb   r`   )rO   r_   r   r   r   r   r,   r   rx   r   r\   rP   rP   rQ   r     sJ    






z&FragmentsWalker.setcomprehension_walk3c             C   s  | j }| jdkr|dkr.|d d j}|}n|d d j}|d }|d dkr|t| jj }| j|d ||td d  d|d kst|d }|d d	krx(|D ] }t|d
rt	|j
r|j
}P qW |dkr|n|d }	n|d d dkrp|d }
t|
d d
r|
d j
}n t|
d d
r2|
d j
}ndt|d drP|d }	nt|d drj|d }	ndn|d d j
}|d }	n|dkr|n|d }|d d }t|d d d
r|d d j
}|d j}n6t|d d dr
|d d j
}|d d j}nd|dkr$| jd n
| jd t|| _ t| jj }| j| jd| j  | jdkrp| j|	 n
| j| | jd | j  | j| | j  || _ | j||t| jj  t| jdkr| jd n
| jd | j  d S )Ng      @Zclassdefdeco2r#   r"   r   LOAD_BUILD_CLASSclassmkfuncr   r   r   r'   z1Internal Error n_classdef: cannot find class body__len__z1Internal Error n_classdef: cannot superclass namer   z1Internal Error n_classdef: cannot find class name
z

zclass r   z


r   r   r   r   r   r   r   )r   r?   r   ra   r:   rb   r`   r^   r[   r   r   rt   strr;   print_super_classes3print_super_classesrw   r   Zbuild_classr   r   rk   )rO   r_   Zcclassr   Z
buildclassr\   r   rx   subclassZsubclass_infor   
build_listrP   rP   rQ   
n_classdef  sz    










zFragmentsWalker.n_classdefc             C   s^   | j }|| _ | j}|| _t|dkr4| j| jd n| j| | j||d| _|| _|| _ dS )z(convert parse tree to Python source coder   r4   )r<   N)ru   rZ   ra   rw   r;   r   traversetext)rO   r   rZ   r   r<   Z
returnNoneZrnr   rP   rP   rQ   r   i  s    
zFragmentsWalker.gen_sourcec       
       C   s  |rx.|D ]&}|j dkr d|_ q
|j dkr
d|_ q
W |jtd y<| jj}| jj| j_| jj| j_tj| j||}|| j_W n2 tj	t
fk
r }	 zt	|	|W Y d d }	~	X nX t| | |S t|dko| r4|d j dkr4|d j dkr&|s
|d jd kr|dd = n|jtd	 n|jtd	 t|d
krFtS y<| jj}| jj| j_| jj| j_tj| j||}|| j_W n6 tj	t
fk
r }	 zt	|	|i W Y d d }	~	X nX t| | t|d| j |S )Nrz   ZRETURN_END_IF_LAMBDArr   RETURN_VALUE_LAMBDAZLAMBDA_MARKERr"   r#   r   ZRETURN_LASTr   FrG   )rr   r   r   r   r   )r   appendr   r   ZinstsrA   Zoffset2inst_indexpython_parserparser   r^   r   ra   r   r   r   r
   
ast_errors)
rO   tokensr   r<   ZnoneInNamesZ
isTopLeveltZp_instsr   erP   rP   rQ   r   y  sJ    





zFragmentsWalker.build_astc             C   s   d| j  }}t|d }t|ds(||_xd|D ]\}|r`t|dr`|j|k rP|j}|j|kr`|j}t|dr~t|d r~||_q.| j|| q.W |r|| |_|_dS )z Make sure each node has a parentr   r\   rY   rX   N)rK   r[   rY   r\   r]   fixup_parents)rO   r_   rY   r\   r]   Zneeds_rangerx   rP   rP   rQ   r     s"    



zFragmentsWalker.fixup_parentsc             C   sv   t |dr&| j|7  _| j|7  _xJ|D ]B}t |drbt |drn| j|7  _| j|7  _q,| j|| q,W dS )zAdjust all offsets under noder\   rX   N)r[   r\   r]   fixup_offsets)rO   Z	new_startr_   rx   rP   rP   rQ   r     s    



zFragmentsWalker.fixup_offsetsc             C   sh   | j ||| |dkr|}xH|D ]@}||_t|drD| j ||| q ||_||_| j|||| q W dS )zSet positions under nodeNrX   )r`   rY   r[   r\   r]   rv   )rO   r_   r\   r]   rY   rx   rP   rP   rQ   rv     s    

z$FragmentsWalker.set_pos_info_recursec             C   sF   | j | t| jj | _| j| j| | j | t| jj | _d S )N)rt   ra   r:   rb   rK   r   )rO   Z
before_strZ	node_textr_   rP   rP   rQ   node_append  s
    

zFragmentsWalker.node_appendc             C   s   | j j| j |dkr| j}| j}d| _i t ||d| _| j| | jjd| j  | jj	 }t
|| _| j j | _|| _|S )zJBuilds up fragment which can be used inside a larger
        block of codeNr   )r=   r:   r;   r<   r   )r   r   rR   r;   Zpending_newlinesr   rd   r:   rt   rb   ra   rK   pop)rO   r_   r;   r<   r   r   rP   rP   rQ   r     s     



zFragmentsWalker.traversec             C   s&  |j |j }}| j}tjd||d  }|rD|d t|jd  }tjd||d  }|rr|t|jdd 7 }d}||krd}|}n||| }y|d | jdd }W n tk
r   d}Y nX || }	|j	d}
t|
dkrt|
d |	 }|
d d |
d  }nt|}|r2d	t|
d  d
 }nd	|	 d|  }d}t|
dkrh| rhd}|d7 }y"|||d d  j
d d }W n tk
r   t|}Y nX |d | j	d}
|||d  }|r|d7 }t|tr|j}n|}t|tr|d }n|j}tt|
|||||dS )Nz\n+$r   z\s*[^ \t\n]r#   FTr   z ...
rs   ^r   z ...r"   )ZlineNoZlineStartOffset
markerLineselectedLineselectedTextnonterminalrG   rG   )r\   r]   r   researchra   grouprindex
ValueErrorsplitindex
isinstancer   rY   r   r_   r   )rO   nodeInfor\   r]   r   matchZat_endr   	lineStartZadjustedStartlinesZadjustedEndr   ZelidedlineEndr   r   rP   rP   rQ   extract_node_info  sf    

"
z!FragmentsWalker.extract_node_infoc             C   s.   ||ft | jj krd S | j| j||f S )N)listrJ   keysr  )rO   rZ   rX   rP   rP   rQ   extract_line_infoz  s    z!FragmentsWalker.extract_line_infoc             C   s:   d }t |ds|S |j}x|D ]}||kr.|S |}qW |S )NrY   )r[   rY   )rO   r_   prevr   rx   rP   rP   rQ   	prev_node  s    

zFragmentsWalker.prev_nodec             C   st   t |dsdS |j}|}x@|rXt |drX|j|jkrX|j|jkrX||ksLt|}|j}qW |d krf|}| j||fS )NrY   )NN)r[   rY   r\   r]   r^   r  )rO   r_   r   Zorig_parentrP   rP   rQ   extract_parent_info  s    
"
z#FragmentsWalker.extract_parent_infoc             C   s   |dksd S t | jj }| jd d}d}x0|d d D ] }| j|}| j||| |}q:W | jd | j||t | jj  d S )Nr   r   z,  r#   r   rG   )ra   r:   rb   rt   r   r   r`   )rO   r_   r\   line_separatorsepelemvaluerP   rP   rQ   r     s    


z#FragmentsWalker.print_super_classesc       
      C   s  t | jj }t |d }|jdkr2|dkr>| jd| d S d }|| jjdsVt|| jjdr| jr| jd||d   d S ||d  j}t	|t
st|t |d  }d| || j }nH|d  }}x$t|ddD ]}|| jdkrP qW ||krd S |d7 }x,t|d ddD ]}|| jdkrP qW d}d}|d7 }| jd |rxB||k r| j| | j|| }	| jd|	  |}|d7 }q\W d}x|tk r| j| | j|| }	| jd|| |	f  |}|d7 }|d7 }qW n8xx|tk r.| j|| }	|d7 }| j||	 |}qW n@| jdkrP|d dkrPd S | j|d }	| jd | j|	 | jd | j||t | jj  d S )Nr#   r   kwarg(%[0]{attr}=%c)r   CALL_FUNCTION_KWr"   r   callLOAD_CLASSNAMEz, r  r   z%sz%s=%sg@r   r   )r  r#   )r  r#   rG   )r   r  r  rG   )r   r  )ra   r:   rb   r   template_enginer   r^   rE   r   r  tuplerangert   r   lr?   r`   )
rO   r_   r\   rx   r   ijr  r  r  rP   rP   rQ   r     sz    






z$FragmentsWalker.print_super_classes3c             C   s  | j }d| _ | jt d| j }tdd }t| jj }| jd | j|d ||d  | j	dkoj| j
 r|d jjdrL|d }t|}t|}|d jjd	r|d8 }d}	x|	|k rF| j| | j||	 d
d}
|||	 _|||	d  _| j|
d | j||	d  | jt|
d d  d}| j||
d| |}|	d7 }	qW q|d jjdr|d }t|}t|dkr|d jdkr|d d }t|}d}	x|	t|k r|||	 _|||	d  _t| jj t| }| j||	d  d
d}
|t|
 }|d }| j||	 | jt|
d d  d}| j||
d| | j||	d  || | j||	 ||t|  |}|	d7 }	qW n6|d jjdst|d }x|D ]
}|dkst|dkr| j|d d
d}
||d _| j|d | jt|
d d  d}n|dkrX| j|d d
d}
||d _| j|d | jt|
d d  d}nJ|dkr| j|d d
d}
||d _| j|d | jt|
d d  d}| j||
d| |}qW | jd t| jj }| j||| | jt || _ | j  dS )z]
        prettyprint a dict
        'dict' is something like k = {'a': 1, 'b': 42 }"
        d   z,
Nr#   r   r   g      @Zkvlist	BUILD_MAPr  )r;   z: r"   rs   kv3r'   kvkv2r   rG   rG   rG   rG   )r!  r"  r   r   r   r   r   )r   r   r   r;   ra   r:   rb   rt   r`   r?   rE   r   r   r  r   rY   rv   r^   r   rk   )rO   r_   r   Zline_seperatorr  r\   Zkv_noder  lengthr  rZ   r  Z	key_startZ
key_finishZ	val_startr!  r]   rP   rP   rQ   n_dict   s    




$
 

"

"

 


zFragmentsWalker.n_dictc             C   s  | j }d| _ |j }|j}t| jj }|jdrB| jd d}nV|jdr\| jd d}n<|jdrv| jd	 d
}n"|jdr| jd d}ntdg }xh|D ]`}|dkrxR|D ]}	x|	D ]}
|j	|
 qW qW q|dkrx"|D ]}	|j	|	 qW q|j	| qW | j
t t|dkr*d| j }nd}tdd }xF|D ]>}|dkrRq@|dks`t| j|}| j||| |}q@W t|dkr|jdr| jd | j| t| jj }|j|_| j||| | j||| | jt || _ | j  dS )z-
        prettyprint a list or tuple
        r  r   r   r   BUILD_TUPLEr   r   r   r   r   ROT_TWOz,Internal Error: n_list expects list or tupleZexpr1024Zexpr32r'   z,
z, Nr#   	ROT_THREEr   ,rG   )r   r   r   ra   r:   rb   r   rt   RuntimeErrorr   r   r   r;   r^   r   r   rY   r`   r   rk   )rO   r_   r   rx   Zlastnoder\   endcharZ
flat_elemsr  ZsubelemZ
subsubelemr  r  r  r]   rP   rP   rQ   n_listf  sf    



















zFragmentsWalker.n_listc             C   sN  t | jj }|}|d }d}d}d }d}	tj|}
x|
r|
j }| j|
jd |
jdpbd}|}y&|
jdr|t|
jd }||_	W n   t
|j  Y nX |dkrt | jj }| jd | j||t | jj  n|d	kr| j  n|d
kr| j  n|dkr(| j| j n|dkr:d}	n|dkr\|dkr| jd nv|dkrt | jj }| j|||  || |d7 }n<|dkr^t | jj }|| }t|tr||d  |d kstd|j|||d  j|d f |d }t|ts(td|j|t|f | j||  t | jj }| j||| |d7 }nt|dkr<| j}|| }t|tstt |dkr|\}}| _|| |kstd|j|||| jf n t |dkst|| \}| _||| _	t | jj }| j||  | j||t | jj  || _|d7 }n|dkr|| \}}}t |||  }}t | jj }x<||| D ],}| j| |d8 }|dkr| j| qW | j||t | jj  |d7 }n|dkr\|| \}}}t |||  }}xJ||| D ]:}|d8 }t |dkr| j| |dkr| j| qW |d7 }nv|dkr|| \}}x,|D ]$}| j|| || j|| j qxW |d7 }n&|dkr6| j}|| \}}}| _t |||  }}| j}x<||| D ],}| j| |d8 }|dkr| j| qW || _|d7 }n|dkr|j}|
jd}t|dr~|jr~t|dr~|j| j| j< y<t | jj }| jt||| | j||t | jj  W n   t
|  Y nX tj||}
q8W | j||d  t | jj }|	r| j||| n| j||| |jdkrJ|d! }| j||| j dS )"zThe format template interpetation engine.  See the comment at the
        beginning of this module for the how we interpret format
        specifications such as %c, %C, and so on.
        r   r#   Fprefixtyper   child%+r   |rTr(  bcz#at %s[%d], expected %s node; got %sz$at %s[%d], %s should be int or tupler   r'   z'at %s[%d], expected '%s' node; got '%s'r"   CDrV   Pr   	linestartcurrent_line_numberNr  rG   rG   ) ra   r:   rb   r   r   endrt   r   intrY   print__dict__r`   r   r   r;   r  r  r^   r   r-  rd   r   rv   r\   r]   rK   r[   r8  Zsource_linemapr9  eval)rO   entryZ	startnodeZstartnode_startr\   fmtargr  ZlastCZrecurse_nodemtypr_   r]   r   r   tupZnonterm_namelowhighr  	remainingsubnodesrcdestdr   r   Z	last_noderP   rP   rQ   r    s   












 
















zFragmentsWalker.template_enginec             C   sJ   t |dr>t|dkr>t|d tr>t |d d r>||d _tj|tS )Ndatar   r#   rY   rG   rG   rG   )r[   ra   r  r   rY   r   r   rN   )clsr_   rP   rP   rQ   _get_mapping`  s    

zFragmentsWalker._get_mapping)r:   r;   r<   r=   )N)Nr   )r   r   )r   )FF)FFF)N)NF)X__name__
__module____qualname__rN   Zstacked_paramsPARSER_DEFAULT_DEBUGrI   propertyr:   r;   r<   r=   r`   rd   rh   Zn_slice0Zn_slice1Zn_slice2Zn_slice3Zn_subscriptZn_aug_assign_1Zn_print_item	exec_stmtZprint_to_itemdel_stmtZn_classdefco1Zn_classdefco2Zexcept_cond1Zexcept_cond2ri   rj   Zn_tryelsestmtZn_tryelsestmtcZn_tryelsestmtlZn_tryfinallystmtrl   rm   rn   ro   ry   r{   r~   r   r   r   r   r   r   r   Z
n_LOAD_STRr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Zn_classdefdeco2r   r   r   r   rv   r   r   r  r
  r  r  r   r   r$  r+  Zn_setZn_tupleZn_build_setr  classmethodrN  __classcell__rP   rP   )re   rQ   r9      s   
		
	
		 	=
>
~=	#	5X

H

\TfB 7r9   F)asmtreegrammarr>   c
          
   C   s$   |||d}
t ||| |
||||	dS )N)rX  r   rZ  )r?   
debug_optscode_objectsrD   rE   walker)code_deparse)r?   cor@   showasmrB   showgrammarr\  rD   rE   r]  r[  rP   rP   rQ   deparse_coder  s    rb  c             C   s  t | st|dkrt }|dkr&t}t||d}|jdd}	|j| ||	d\}
}|j| \}
}t|	|
 tt	}|jdd}|r||d< d|d< |jd	d}|||||||d
}|j
|
||_|jdkstd~
|jdksttj|jt t | |\|_}|j|j| j| |j|jdt|j |j|jd x"t|jD ]}|jd|  qBW |jr|jd |jd x|jD ]}|j| q~W d|_|jr|jx0|jj D ]"\}}t||j|jd|j|< qW ||_|S )a  
    Convert the code object co into a python source fragment.

    :param version:         The python version this code is from as a float, for
                            example 2.6, 2.7, 3.2, 3.3, 3.4, 3.5 etc.
    :param co:              The code object to parse.
    :param out:             File like object to write the output to.
    :param debug_opts:      A dictionary with keys
       'asm':     value determines whether to show
                  mangled bytecode disassembly
       'ast':     value determines whether to show
       'grammar': boolean determining whether to show
                  grammar reduction rules.
       If value is a file-like object, output that object's write method will
       be used rather than sys.stdout

    :return: The deparsed source fragment.
    N)rE   rX  )r\  show_asmrZ  reduceTZ
errorstackr   )rB   rC   rD   rE   Zstmtsz Should have parsed grammar startr   z&# global %s ## Warning: Unused global
z## NOTE: have decompilation errors.
z%# Use -t option to show full context.)r_   r\   r]   ) r   r^   r   r   r	   r   Zingestr   rL   rR  r   r   r   Zfind_globals_and_nonlocalssetZ	mod_globsr   r   r`   ra   r   r   sortedrt   r   ERRORrJ   itemsr   r\   r]   rA   )r_  r@   r?   rE   r[  r\  rD   r]  rA   rc  r   r   rC   Zshow_grammarZshow_astdeparsed	nonlocalsgerrrD  r_   rP   rP   rQ   r^    s^    


r^  )bisect_rightc             C   s&   t | |}|t| kr| | S tdS )z"Find leftmost value greater than xN)rm  ra   r   )arV   r  rP   rP   rQ   find_gt  s    
ro  c                s   t |st|dkrt }|dkr&t}t|||||} |f|jj krL|S dd |jD }t fdd|D }	t|	|}
|j |
f |j |f< |S )z
    Like deparse_code(), but given  a function/module name and
    offset, finds the node closest to offset. If offset is not an instruction boundary,
    we raise an IndexError.
    Nc             S   s   g | ]}t |d  tr|qS )r#   )r  r;  ).0r   rP   rP   rQ   
<listcomp>  s    z.code_deparse_around_offset.<locals>.<listcomp>c                s    g | ]}|d   kr|d qS )r   r#   rP   )rp  r   )rZ   rP   rQ   rq    s    )	r   r^   r   r   r^  rJ   r	  rf  ro  )rZ   rX   r_  r@   r?   rE   r[  ri  Zvalid_offsetsZoffset_listZfound_offsetrP   )rZ   rQ   code_deparse_around_offset  s    
rr  c	       
      C   s    |||d}	t | ||||||	S )N)rX  r   rZ  )r^  )
rZ   rX   r?   r_  r@   r`  rB   ra  rE   r[  rP   rP   rQ   deparse_code_around_offset#  s    rs  c             C   s,   y| | }W n t k
r    dS X |j| S )a   Return the instruction name at code[loc] using
    opc to look up instruction names. Returns 'got IndexError'
    if code[loc] is invalid.

    `code` is instruction bytecode, `loc` is an offset (integer) and
    `opc` is an opcode module from `xdis`.
    zgot IndexError)
IndexErroropname)r   locopcoprP   rP   rQ   op_at_code_loc2  s
    ry  c       
      C   s   d}| \}}t |dsdS ||f|jj kr<|j||f }n\ddlm} ||j}|j}t|||jdkr|j	j
|| |}	||	f|jkr|j||	f }|S )zReturn a NodeInfo nametuple for a fragment-deparsed `deparsed` at `tup`.

    `tup` is a name and offset tuple, `deparsed` is a fragment object
    and `code` is instruction bytecode.
NrJ   r   )r	   DUP_TOP)r[   rJ   r	  uncompyle6.scannerr	   r?   co_codery  rw  rA   Znext_offset)
rD  ri  r   r  rZ   Zlast_ir	   rA   r_  rX   rP   rP   rQ   deparsed_findA  s    

r}  )r   )r   )r   )r    r   r#   r"   r~  )r!   r"   r  r"   r%   r   r#   r"   r  )r$   r  r  r   r#   r"   r  r'   r(   )r&   r  r  r   r#   r"   r  )r&   r  r'   )r)   r   r"   r'   r#   r"   r  )r*   r"   r  r   r'   r'   r,   r"   r'   r  )r+   r   r  r  r#   r-   r'   r,   r"   r'   r  r   )r.   r   r  r  r#   r-   r   r'   r,   r"   r'   r  r   )r/   r   r  r  r#   r-   r   r'   r,   r"   r'   r  r   )r.   r   r  r  r#   r-   r   )r0   r   r#   r"   r   )r1   r   r#   r"   r   r   )r2   r   r#   r"   r   );__doc__
__future__r   r   Zxdisr   r   Zuncompyle6.semanticsr   
uncompyle6r   r{  r   r   r	   Zuncompyle6.parserr   Zuncompyle6.semantics.check_astr
   r   Zuncompyle6.showr   r   Zuncompyle6.parsers.treenoder   Zuncompyle6.semantics.pysourcer   r   Zuncompyle6.semantics.constsr   r   r   r   r   r   r   Zspark_parserr   rR  Zspark_parser.astr   collectionsr   r   r   rM   rH   objectr9   ZDEFAULT_DEBUG_OPTSrb  r^  bisectrm  ro  rr  rs  ry  r}  rP   rP   rP   rQ   <module>>   s   
$

                               ea"