�`^c@s
dZd
dl
Z
d
dlZd
dlZd
dlmZ
d
dlmZmZm	Z	m
Z

dfd��YZd�Zdfd	��YZ
d
ZdZdZd
Zdef
d��YZd�Zdfd��YZd�Zd�Zdfd��YZdfd��YZe�jZdS(s/A flow graph representation for Python bytecodei�N(
tmisc(tCO_OPTIMIZEDtCO_NEWLOCALSt
CO_VARARGStCO_VARKEYWORDSt	FlowGraphcBs}eZ
d�Zd
�Zd
d�Zd�Zd�ZdZd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�ZRS(c

Cs[t�|_
|_td
�|_tj�|_|jj|j�
|jj|j�
dS(Ntexit(tBlocktcurrenttentryRRtSettblockstadd(
tself((s&/sys/lib/python2.7/compiler/pyassem.pyt__init__s





cCsr|jre|j
rWd
Gt|j
�GHdG|j
jGHdG|j
jGHdG|j
j�GHnt|
�GHn|
|_
dS(Ntends    nexts    prevs   (t_debugRtreprtnexttprevtget_children(R
tblock((s&/sys/lib/python2.7/compiler/pyassem.pyt
startBlocks
	
	





cCs<|
dkr|j
�}
n|jj|
�
|j|
�
dS(
N(tNonetnewBlockRtaddNextR(R
R((s&/sys/lib/python2.7/compiler/pyassem.pyt	nextBlocks

c
Cst�}
|j
j|
�
|
S(
N(RRR(R
t
b((s&/sys/lib/python2.7/compiler/pyassem.pyR5s
	

c

Cs|j|j
�
dS(
N(RR(
R
((s&/sys/lib/python2.7/compiler/pyassem.pytstartExitBlock:s
ic

Cs
d
|_dS(Ni
(
R(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyt
_enable_debug?s
c

Cs
d
|_dS(Ni(
R(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyt_disable_debugBs
c
Gse|jrd
G|
GHnt
|
�dkrQt|
dt�rQ|jj|
d�
n|jj|
�
dS(Ns
	ii
(Rtlent
isinstanceRRt
addOutEdgetemit(R
tinst((s&/sys/lib/python2.7/compiler/pyassem.pyR"Es

	

%

c
Cst|j
|j�}
|
S(
slReturn the blocks in reverse postorder

        i.e. each node appears before all of its successors
        (torder_blocksR	R(R
torder((s&/sys/lib/python2.7/compiler/pyassem.pytgetBlocksInOrderLs
c


Cs
|jj
�S(
N(Rtelements(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyt	getBlocksTs
c


Cs|jS(
s/Return nodes appropriate for use with dominator(
R	(
R
((s&/sys/lib/python2.7/compiler/pyassem.pytgetRootWsc
Cs4g}
x'|j�D]}|
j
|j��
qW|
S(
N(R(textendtgetContainedGraphs(R
t
lR((s&/sys/lib/python2.7/compiler/pyassem.pyR+[s



N(t__name__t
__module__RRRRRRRRRR"R&R(R)R+(((s&/sys/lib/python2.7/compiler/pyassem.pyRs
		
								cs�g}t��|g
}xh|r�|j
�}|�kr?qn�j|�
x0|j�D]"}|�krY|j|�
qYqYWqWi�x��D]�}tr�|jr�n�j|t��
xc|j�D]U}xL�j|t��j|�
|j	r
|j	d
|k	r
|j	d
}q�Pq�q�Wq�W��fd�}|}xu|j|�
�j
|�
|jrv
|jd
}q@
n)||
k	r�|j�r�|j|
�
n�s�Pn|�}q@
|S(s8Order blocks so that they are emitted in the right orderics>x7�D]/}x&�|D]}
|
�krPqqW|SqWdS(
N((Rt
c(t
dominatorst	remaining(s&/sys/lib/python2.7/compiler/pyassem.pyt	find_next�s




(tsettpopRRtappendt	__debug__Rt
setdefaultt
get_followersRtdiscardthas_unconditional_transfer(tstart_blockt
exit_blockR%ttodoRR/R2((R0R1s&/sys/lib/python2.7/compiler/pyassem.pyR$bsH	
	
	





















	








RcBszeZ
dZd
d�Zd�Zd�Zd�Zd�Zd�Zd�Z	dZ
d�Zd�Zd�Z
d�ZRS(itcCsPg|_t
�|_|
|_tj|_g|_g|_tjd
t_dS(Ni
(	tinstsR3toutEdgestlabelRt_counttbidRR(R
RA((s&/sys/lib/python2.7/compiler/pyassem.pyR�s
	

	

	
	
c

Cs,|jrd
|j|j
fSd|j
SdS(Ns<block %s id=%d>s
<block id=%d>(RARC(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyt__repr__�s
	
c
Cs2tt
|j�}
d
|j|jdj|
�fS(Ns<block %s %d:
%s>s

(tmaptstrR?RARCtjoin(R
R?((s&/sys/lib/python2.7/compiler/pyassem.pyt__str__�s


cCs|
d
}|jj
|
�
dS(Ni(R?R5(R
R#top((s&/sys/lib/python2.7/compiler/pyassem.pyR"�s


c


Cs|jS(
N(
R?(
R
((s&/sys/lib/python2.7/compiler/pyassem.pytgetInstructions�s
cCs|jj
|
�
dS(
N(R@R(R
R((s&/sys/lib/python2.7/compiler/pyassem.pyR!�s
cCs$|jj
|
�
|
jj
|�
dS(
N(RR5R(R
R((s&/sys/lib/python2.7/compiler/pyassem.pyR�s

tRETURN_VALUEt
RAISE_VARARGSt
JUMP_ABSOLUTEtJUMP_FORWARDt
CONTINUE_LOOPc
Cs?y|jd
\}
}Wnt
tfk
r1


dSX|
|jkS(s�Returns True if there is an unconditional transfer to an other block
        at the end of this block. This means there is no risk for the bytecode
        executer to go past this block's bytecode.i�N(R?t
IndexErrort
ValueErrort_uncond_transfer(R
RItarg((s&/sys/lib/python2.7/compiler/pyassem.pyR:�s




c

Cst|j
�|jS(
N(tlistR@R(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyR�s
c
CsNt|j
�}
x8|jD]-}|d
tjkr|
j|d�
qqW|
S(s:Get the whole list of followers, including the next block.ii
(R3RR?tPyFlowGraphthasjrelR(R
t	followersR#((s&/sys/lib/python2.7/compiler/pyassem.pyR8�s



c
Csbg}
xU|jD]J}t
|�d
kr.qn|d
}t|d�r|
j|j�
qqW|
S(s�Return all graphs contained within this block.

        For example, a MAKE_FUNCTION block will contain a reference to
        the graph for the function body.
        i
tgraph(R?RthasattrR5RX(R
t	containedR#RI((s&/sys/lib/python2.7/compiler/pyassem.pyR+�s







(RKRLRMRNRO(R-R.RBRRDRHR"RJR!RRRR:RR8R+(((s&/sys/lib/python2.7/compiler/pyassem.pyR�s
							
	
		
tRAWtFLATtCONVtDONERUcBsAeZ
ejZdddd
�Zd�Zd�Zd�Zd�Z	d�Z
d�Zdd�Zd	�Z
d
�Ze�Zx%ejD]Zejeje�
q�We�Zx%ejD]Zejeje�
q�Wd�Zd�Zd
�ZiZd�Zd�ZeZeZd�Zd�ZeZ eZ!eZ"eZ#eZ$eZ%eZ&eZ'eZ(eZ)d�Z*e*Z+e*Z,d�Z-e.ej/�Z0d�Z1xDe2�j3�D]3\Z4Z5e4d dkr�e4dZe5ee<q�q�W[4[5[d�Z6iZ7x.e8e9ej��D]Z:e:e7eje:<qW[:d�Z;d�Z<RS(icCs
|j�
|
|_
||_d|_||_t|�|_||_|r\t	t
B|_n	d
|_g|_g|_
g|_g|_g|_t|�p�g|_xOtt|j��D]8}|j|}t|t�r�|j�|j|<q�q�Wt|_dS(Ni(t
super_inittnametfilenameRt	docstringtargstgetArgCounttargcounttklassR
RtflagstconststnamestfreevarstcellvarstclosureRTtvarnamestrangeRR tTupleArgtgetNameR[tstage(R
R`RaRct	optimizedRft
itvar((s&/sys/lib/python2.7/compiler/pyassem.pyR

s*


	
	
	
	

	

	
	
		
		






cCs
|
|_dS(
N(
Rb(R
tdoc((s&/sys/lib/python2.7/compiler/pyassem.pytsetDocstring
s
cCs3|j|
B|_|
t
kr/|jd
|_ndS(Ni
(RgRRe(R
tflag((s&/sys/lib/python2.7/compiler/pyassem.pytsetFlag"
s


cCs|j|
@rd
SdS(Ni
(
Rg(R
Rw((s&/sys/lib/python2.7/compiler/pyassem.pyt	checkFlag'
s


cCst|
�|_
dS(
N(RTRj(R
Ri((s&/sys/lib/python2.7/compiler/pyassem.pytsetFreeVars+
s
cCs
|
|_dS(
N(
Rk(R
Ri((s&/sys/lib/python2.7/compiler/pyassem.pytsetCellVars.
s
c


Cs2|j�
|j
�
|j�
|j�
|j�S(
sGet a Python code object(tcomputeStackDepthtflattenGraphtconvertArgstmakeByteCodet
newCodeObject(
R
((s&/sys/lib/python2.7/compiler/pyassem.pytgetCode1
s





cCs�|
rtj
}|
t_
nd
}x~|jD]s}|d
}|dkrKHnt|�dkr{dGd|G|GH|d}q+dGd|G|G|dGH|d}q+W|
r�|t_
ndS(Nit
SET_LINENOi
s
	s%3di(tsyststdoutR?R(R
tiotsavetpct
ttopname((s&/sys/lib/python2.7/compiler/pyassem.pytdump=
s

	













c
spi�d}
x*�j
�D]}t|j���|<qWi�����fd
����jd��_dS(s�Compute the max stack depth.

        Approach is to compute the stack effect of each basic block.
        Then find the path through the code with the largest total
        effect.
        cs�|�kr|
Sd
�|<|
�|}
|j�}|r`t
g|D]}�||
�^qD�S|jdks��j|
�S|
SdS(Ni
R(RtmaxRAR(Rt
dtchildrenR/(tdeptht	max_depthtseenR
(s&/sys/lib/python2.7/compiler/pyassem.pyR�]
s







&
iN(RR(t	findDepthRJR	t	stacksize(R
RR((R�R�R�R
s&/sys/lib/python2.7/compiler/pyassem.pyR|O
s


c
Cs�g|_}
d
}i}i}x�|j
�D]z}|||<x]|j�D]O}|
j|�
t|�dkr{|d}qI|d
dkrI|d}qIqIW|||<q,Wd
}x�tt|
��D]�}|
|}t|�dkr�d}n|d
dkr
|d}n|d
}||jkrS
|d}	||	|}
||
f|
|<q�||jkr�|||df|
|<q�q�Wt|_	dS(s-Arrange the blocks in order and resolve jumpsii
R�iN(
R?R&RJR5RRnRVthasjabsR\Rq(R
R?R�tbeginRRR#RsR�topargtoffset((s&/sys/lib/python2.7/compiler/pyassem.pyR}m
s8


































c
Cs�|jj
d
|j�
|j�
x�tt|j��D]n}
|j|
}t|�dkr6|\}}|jj|d�}|r�||||�f|j|
<q�q6q6Wt
|_dS(s0Convert arguments from symbolic to concrete formiiN(RhtinsertRbt
sort_cellvarsRnRR?t_converterstgetRR]Rq(R
RsR�R�R�tconv((s&/sys/lib/python2.7/compiler/pyassem.pyR~�s









&
c
Cs�i}
x|jD]}d
|
|<qWg|j
D]}||
kr.|^q.|_x|jD]
}|
|=qYW|j|
j�|_|j|j|_dS(sHSort cellvars in the order of varnames and prune from freevars.
        i
N(RkRmtkeysRjRl(R
tcellsR`((s&/sys/lib/python2.7/compiler/pyassem.pyR��s







cCspt|
�}xDt
t|��D]0}|t||�kr|||
kr|SqWt|�}|j|
�
|S(
s�Return index of name in list, appending if necessary

        This routine uses a list instead of a dictionary, because a
        dictionary can't store two different keys if the keys have the
        same value but different types, e.g. 2 and 2L.  The compiler
        must treat these two separately, so it does an explicit type
        comparison before comparing the values.
        (ttypeRnRR5(R
R`RTR�RsR((s&/sys/lib/python2.7/compiler/pyassem.pyt_lookupName�s	

&




cCs1t|
d
�r|
j
�}
n|j|
|j�S(NR�(RYR�R�Rh(R
RS((s&/sys/lib/python2.7/compiler/pyassem.pyt_convert_LOAD_CONST�s


cCs&|j|
|j
�
|j|
|j�S(
N(R�RiRm(R
RS((s&/sys/lib/python2.7/compiler/pyassem.pyt_convert_LOAD_FAST�s

cCs8|jdkr%|j|
|j�
n|j|
|j�S(
N(RfRR�RmRi(R
RS((s&/sys/lib/python2.7/compiler/pyassem.pyt_convert_LOAD_NAME�s


cCs8|jdkr%|j|
|j�
n|j|
|j�S(
N(RfRR�RmRi(R
RS((s&/sys/lib/python2.7/compiler/pyassem.pyt
_convert_NAME�s


cCs9|j|
|j
�
|j|
|j�
|j|
|j�S(
N(R�RiRmRl(R
RS((s&/sys/lib/python2.7/compiler/pyassem.pyt_convert_DEREF�s


cCs&|j|
|j
�
|j|
|j�S(
N(R�RmRl(R
RS((s&/sys/lib/python2.7/compiler/pyassem.pyt_convert_LOAD_CLOSURE�s

cCs|jj
|
�S(
N(t_cmptindex(R
RS((s&/sys/lib/python2.7/compiler/pyassem.pyt_convert_COMPARE_OP�s
i	t	_convert_c
Cs�t�|_
}
x�|jD]�}|d
}t|�dkrS|
j|j|�
q|d}|dkr||
j|�
qnt|�\}}y|
j|j|||�
Wqtk
r�


|G|GH|j|G|G|GH�qXqWt	|_
dS(Nii
R�(t
LineAddrTabletlnotabR?RtaddCodetopnumtnextLinettwobyteRQR^Rq(R
R�R�R�R�thitlo((s&/sys/lib/python2.7/compiler/pyassem.pyR�s"















	


c
Cs�|jt
@d
krd
}
nt|j�}
|j}|jt@rN|d}ntj||
|j|j|j	j
�|j�t|j
�t|j�|j|j|j	j|j	j�t|j�t|j��S(Nii
(RgRRRmReRttypestCodeTypeR�R�R�t	getConststtupleRiRaR`t	firstlinetgetTableRjRk(R
tnlocalsRe((s&/sys/lib/python2.7/compiler/pyassem.pyR�s
	
	









c
CsOg}
x<|jD]1}t
|t�r4|j�}n|
j|�
qWt|
�S(
s�Return a tuple for the const slot of the code object

        Must convert references to code (MAKE_FUNCTION) to code
        objects recursively.
        (RhR RUR�R5R�(R
R,telt((s&/sys/lib/python2.7/compiler/pyassem.pyR�"s




(N(=R-R.RRR_RRvRxRyRzR{R�R�R|R}R3RVtdisRsRR�R�R~R�R�R�R�R�t_convert_STORE_FASTt_convert_DELETE_FASTR�R�t_convert_STORE_NAMEt_convert_DELETE_NAMEt_convert_IMPORT_NAMEt_convert_IMPORT_FROMt_convert_STORE_ATTRt_convert_LOAD_ATTRt_convert_DELETE_ATTRt_convert_LOAD_GLOBALt_convert_STORE_GLOBALt_convert_DELETE_GLOBALR�t_convert_LOAD_DEREFt_convert_STORE_DEREFR�RTtcmp_opR�R�tlocalstitemsR`tobjRR�RnRtnumR�R�(((s&/sys/lib/python2.7/compiler/pyassem.pyRU�sn
									!	


	

		
	
		
		








	
	
	




		


	c

Cs|d
 dkrdSdS(NitJUMPi
((
R�((s&/sys/lib/python2.7/compiler/pyassem.pytisJump/s

Roc
Bs)eZ
dZd
�Zd�Zd�ZRS(s:Helper for marking func defs with nested tuples in arglistcCs|
|_||_
dS(
N(tcountRi(R
R�Ri((s&/sys/lib/python2.7/compiler/pyassem.pyR5s
	
c

Csd
|j|j
fS(NsTupleArg(%s, %s)(R�Ri(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyRD8s
c

Csd
|jS(Ns.%d(
R�(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyRp:s
(R-R.t__doc__RRDRp(((s&/sys/lib/python2.7/compiler/pyassem.pyRo3s

		c
Cs^t|�}
|rZxE|D]:}t
|t�rttj|j��}|
|}
qqWn|
S(
N(RR RoRtflattenRi(RcReRStnumNames((s&/sys/lib/python2.7/compiler/pyassem.pyRd=s







c

Cs
t|d
�S(s/Convert an int argument into high and low bytesi
(
tdivmod(
tval((s&/sys/lib/python2.7/compiler/pyassem.pyR�FsR�c
Bs;eZ
dZd
�Zd�Zd�Zd�Zd�ZRS(s(lnotab

    This class builds the lnotab, which is documented in compile.c.
    Here's a brief recap:

    For each SET_LINENO instruction after the first one, two bytes are
    added to lnotab.  (In some cases, multiple two-byte entries are
    added.)  The first byte is the distance in bytes between the
    instruction for the last SET_LINENO and the current SET_LINENO.
    The second byte is offset in line numbers.  If either offset is
    greater than 255, multiple two-byte entries are added -- see
    compile.c for the delicate details.
    c

Cs:g|_d
|_
d
|_d
|_d
|_g|_dS(Ni(tcodet
codeOffsetR�tlastlinetlastoffR�(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyRZs
	
	
	
	
	
c
GsAx$|
D]}|jj
t|��
qW|jt|
�|_dS(
N(R�R5tchrR�R(R
RcRS((s&/sys/lib/python2.7/compiler/pyassem.pyR�bs



cCs
|jd
kr$|
|_|
|_
n�j|j}|
|j
}|d
kr
|jj}x.|dkr�|d�
|d
�
|d8}q\Wx4|dkr�||�
|d�
|d8}d
}q�W|d
ks�|d
kr�|�
||�
n|
|_
|j|_ndS(Nii�(R�R�R�R�R�R5(R
tlinenotaddrtlinetpush((s&/sys/lib/python2.7/compiler/pyassem.pyR�gs*

	





















	
c

Csd
j|j
�S(NR>(RGR�(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyR��s
c

Csd
jt
t|j��S(NR>(RGRER�R�(
R
((s&/sys/lib/python2.7/compiler/pyassem.pyR��s
(R-R.R�RR�R�R�R�(((s&/sys/lib/python2.7/compiler/pyassem.pyR�Ks
			 	tStackDepthTrackercBs�eZ
dd
�Zi&dd6dd6dd6dd6dd	6dd
6dd6dd6dd
6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd 6dd!6dd"6dd#6dd$6dd%6dd&6dd'6d(d)6d(d*6dd+6dd,6Zd;d<gZd/�Zd0�Zd1�Zd2�Zd3�Z	d4�Z
d5�Zd6�Zd7�Z
d8�Zd9�Zd:�ZRS(=icCs
d
}d
}x
|
D]�|d
}|r0|Gn|jj
|d�}|dk	r^||}n�xA|jD]6\}}	|t|� |krh|	}||}PqhqhW|dkr�||d�}
|
dk	r�|
|d�}q�||kr�}n|r|G|GHqqW|S(Nii
(teffectR�RtpatternsRtgetattr(R
R?tdebugR�tmaxDepthRsR�tdeltatpatt	pat_deltatmeth((s&/sys/lib/python2.7/compiler/pyassem.pyR��s.





















	


i�tPOP_TOPi
tDUP_TOPtLIST_APPENDtSET_ADDi�tMAP_ADDsSLICE+1sSLICE+2sSLICE+3s
STORE_SLICE+0s
STORE_SLICE+1s
STORE_SLICE+2i�s
STORE_SLICE+3sDELETE_SLICE+0sDELETE_SLICE+1sDELETE_SLICE+2sDELETE_SLICE+3tSTORE_SUBSCRt
DELETE_SUBSCRt
PRINT_ITEMRKtYIELD_VALUEt	EXEC_STMTtBUILD_CLASSt
STORE_NAMEt
STORE_ATTRtDELETE_ATTRtSTORE_GLOBALt	BUILD_MAPt
COMPARE_OPt
STORE_FASTtIMPORT_STARtIMPORT_NAMEtIMPORT_FROMt	LOAD_ATTRitSETUP_EXCEPTt
SETUP_FINALLYtFOR_ITERtWITH_CLEANUPtBINARY_tLOAD_cCs|
d
S(Ni
((R
R�((s&/sys/lib/python2.7/compiler/pyassem.pytUNPACK_SEQUENCE�s
cCs	|
d
S(Ni
((R
R�((s&/sys/lib/python2.7/compiler/pyassem.pytBUILD_TUPLE�s
cCs	|
d
S(Ni
((R
R�((s&/sys/lib/python2.7/compiler/pyassem.pyt
BUILD_LIST�s
cCs	|
d
S(Ni
((R
R�((s&/sys/lib/python2.7/compiler/pyassem.pyt	BUILD_SET�s
cCs"t|
d
�\}}||dS(Ni
i(
R�(R
targcR�R�((s&/sys/lib/python2.7/compiler/pyassem.pyt
CALL_FUNCTION�s

cCs|j|
�d
S(Ni
(
R

(R
R	
((s&/sys/lib/python2.7/compiler/pyassem.pytCALL_FUNCTION_VAR�s
cCs|j|
�d
S(Ni
(
R

(R
R	
((s&/sys/lib/python2.7/compiler/pyassem.pytCALL_FUNCTION_KW�s
cCs|j|
�d
S(Ni(
R

(R
R	
((s&/sys/lib/python2.7/compiler/pyassem.pytCALL_FUNCTION_VAR_KW�s
c
Cs|
S(
N((R
R	
((s&/sys/lib/python2.7/compiler/pyassem.pyt
MAKE_FUNCTION�s
c
Cs|
S(
N((R
R	
((s&/sys/lib/python2.7/compiler/pyassem.pytMAKE_CLOSURE�scCs$|
d
krdS|
dkr dSdS(Nii�ii�((R
R	
((s&/sys/lib/python2.7/compiler/pyassem.pytBUILD_SLICE�s



c
Cs|
S(
N((R
R	
((s&/sys/lib/python2.7/compiler/pyassem.pytDUP_TOPX�s
(R
i�(R
i
(R-R.R�R�R�R
R
R
R
R

R
R
R

R
R
R
R
(((s&/sys/lib/python2.7/compiler/pyassem.pyR��sl





































												(R�R�R�R�tcompilerRtcompiler.constsR
RRRRR$RR[R\R]R^RUR�RoRdR�R�R�R�(((s&/sys/lib/python2.7/compiler/pyassem.pyt<module>
s*


"W	CT


�
			Bn