�
E�Wc@s�
dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlmZ
d
dl	m
Z

d
dl	mZmZ
d
dl
mZ
d
dlmZ
d
dlmZmZmZmZ
d
d	lmZmZmZ
d
d
lmZmZmZ
def
d��YZd
ef
d��YZdef
d��YZ def
d��YZ!def
d��YZ"dej#dd�f
d��YZ$edd��
def
d��YZ%dg
Z&d�Z'dd �
Z(dS(!sCode parsing for coverage.py.i����N(
tenv(
trange(t
bytes_to_intststring_class(
tCodeObjects(
tshort_stack(tcontracttnew_contractt	nice_pairt
join_regex(tCoverageExceptiontNoSourcet	NotPython(tcompile_unicodetgenerate_tokenstneuter_encoding_declarationtPythonParsercBs�eZ
dZed
d�
dddd��
Zed��
Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zdd�
ZRS(s�Parse code to find executable lines, excluded lines, etc.

    This information is all based on static analysis: no code execution is
    involved.

    ttextsunicode|NonecCs(
|
s|std
�
�
|p!d|_
|
|_|js�ddlm}
y||j
�
|_Wq�tk
r�
}
td|j
|f�
�
q�Xn||_|jjd�
|_	t
�|_t
�|_t
�|_
t
�|_t
�|_t
�|_t|_i|_d|_d|_d|_dS(s�
        Source can be provided as `text`, the text itself, or `filename`, from
        which the text will be read.  Excluded lines are those that match
        `exclude`, a regex.

        s*PythonParser needs either text or filenames<code>i����(
tget_python_sourcesNo source for code: '%s': %ss

N(tAssertionErrortfilenameRtcoverage.pythonRtIOErrorRtexcludetsplittlinestsett
statementstexcludedtraw_statementstraw_excludedt
raw_classdefstraw_docstringstFalsetshow_tokenst
_multilinetNonet_byte_parsert	_all_arcst_missing_arc_fragments(tselfRRRRterr((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt__init__s.

	
	





				
	
c

Cs.|js't
|jd
|j�

|_n|jS(sCreate a ByteParser on demand.R(R%t
ByteParserRR(
R(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytbyte_parser\s	

c
Gs�t|
�
}t
jr'|jd
�
}ntj|�
}t�}xBt|jdd�

D]+\}}|j	|�
rU|j
|�

qUqUW|S(s�Find the lines matching one of a list of regexes.

        Returns a set of line numbers, the lines that contain a match for one
        of the regexes in `regexes`.  The entire line needn't match, just a
        part of it.

        tutf8tstarti
(R	RtPY2tdecodetretcompileRt	enumerateRtsearchtadd(R(tregexestcombinedtregex_ctmatchest
itltext((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytlines_matchingcs
	

	
"


c
Cs#|jr!|j
|j�
|_nd
}
d
}t}t}tj}d}t}t}t|j	�
}	x�|	D]�\}
}\}}
\}}
}|j
r�dtjj
|
|
�t||f�
||fGHn|
tjkr�|
d7}
n�
|
tjkr�|
d8}
n�
|
tjkr0
|dkr�|jj|�

q�nP
|
tjkr�
|dkr�
||jkp]
|}|r�
|r�
|jj|�

|
}t}t}q�
q�|dkr�|r�||jkr�
t}n|r�
|jj|�

q�
q�n�|
tjkr|tjkr|jjt||d��

nd|
tjkr�|dk	rq||krqx+t||d�D]}||j|<qWWnd}t}n|j�r�|
tjkr�t}|dkr�|}|r�|
|k
r�t}n|r�|jj|�

nt}q�n|
}qjW|s|jj|jj��

ndS(swParse the source to find the interesting facts about its lines.

        A handful of attributes are updated.

        is%10s %5s %-20r %ri
tclasst
:t
@N(RR<RR!ttokentINDENTR$tTrueRRR"ttokenizettok_nametgetRtDEDENTtNAMERR5tOPtSTRINGR tupdateR
tNEWLINER#tstriptCOMMENTRR,t_find_statements(R(tindenttexclude_indentt	excludingtexcluding_decoratorstprev_toktypet
first_linetemptyt
first_on_linettokgenttoktypetttexttslinenot
_telinenoR;tshould_excludet
l((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt
_raw_parsevsp	




	



(
	



















	


 




	

	




cCs|jj
|
|
�S(
s?Return the first line number of the statement including `line`.(R#RE(R(tline((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyRT�scst�f
d
�|
D�
�
S(s�Map the line numbers in `lines` to the correct first line of the
        statement.

        Returns a set of the first lines.

        c
3s|]}
�j|
�
V
qdS(
N(
RT(t.0R^(
R((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pys	<genexpr>�s(
R(R(R((
R(sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytfirst_lines�scCs
|j|
�
S(
s)Implement `FileReporter.translate_lines`.(
Rb(R(R((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyttranslate_lines�scCs5g|
D]*\}}|j|�
|j|�
f^qS(
s(Implement `FileReporter.translate_arcs`.(
RT(R(tarcst
at
b((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyttranslate_arcs�sc
Cs�y|j�
Wnkt
jtfk
r{
}

t|
d
�rD|
j}n|
jdd}td|j|
jd|f�
�
n
X|j	|j
�
|_|j|jB}|j
|}|j	|�
||_dS(s�Parse source text to find executable lines, excluded lines, etc.

        Sets the .excluded and .statements attributes, normalized to the first
        line of multi-line statements.

        tlinenoi
iu5Couldn't parse '%s' as Python source: '%s' at line %dN(R_RCt
TokenErrortIndentationErrorthasattrRhtargsRRRbRRR RR(R(R)Rhtignoretstarts((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytparse_source�s






!


c

Cs#|jd
kr|j�
n|jS(s�Get information about the arcs available in the code.

        Returns a set of line number pairs.  Line numbers have been normalized
        to the first line of multi-line statements.

        N(R&R$t_analyze_ast(
R(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyRd
s


c
Cs�t|j
|j|j�}
|
j�
t�|_xZ|
jD]O\}}|j|�
}|j|�
}||kr;|jj	||f�

q;q;W|
j
|_d
S(skRun the AstArcAnalyzer and save its results.

        `_all_arcs` is the set of arcs in the code.

        N(tAstArcAnalyzerRRR#tanalyzeRR&RdRTR5tmissing_arc_fragmentsR'(R(taaatl1tl2tfl1tfl2((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyRp
s






c
Cs�tj
t�
}
xf|j�D]X\}}|d
kr:qn||jkrOqn||jkrdqn|
|cd7<qWx0|jD]%}||
kr�|
|cd8<q�q�W|
S(sYGet a count of exits from that each line.

        Excluded lines are excluded.

        ii
(tcollectionstdefaultdicttintRdRR(R(texit_countsRuRvR^((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR|
s





cCs
|jdkr|j�
n|
}|rx|d
krx||
krx||
f|krx||
f|jkrx||
}
}n|jj|
|fdg
�}g}x�|D]�}|\}}	|	dkr
|d
kr�||f|jkr�|j||�Sd}	q
d}	n|	jd|�
}	djd|d|	�}
|dk	ra
|
djd	|jd|�
�
7}
n|j|
�

q�Wd
j|�
S(
s5Provide an English sentence describing a missing arc.is didn't jump to the function exitsdidn't jump to line {lineno}Rhsline {start} {emsg}R.temsgs, because {smsg}tsmsgs or N(NN(R'R$RpREtmissing_arc_descriptiontformattappendtjoin(R(R.tendt
executed_arcstactual_starttfragment_pairstmsgst
fragment_pairR~R}tmsg((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR8
s0










		


%N(t__name__t
__module__t__doc__RR$R*tpropertyR,R<R_RTRbRcRgRoRdRpR|R(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyRs

=		[									R+cBsGeZ
dZed
d�
ddd��
Zd�Zd�Zd�ZRS(s3Parse bytecode to understand the structure of code.RtunicodecCs�|
|_|r||_
nNyt|
|d
�|_
Wn2tk
rh
}
td||j|jf�
�
n
Xx8dddgD]'}t|j
|�sytd�
�
qyqyWdS(Ntexecu5Couldn't parse '%s' as Python source: '%s' at line %dt	co_lnotabtco_firstlinenot	co_constsslThis implementation of Python doesn't support code analysis.
Run coverage.py under CPython for this command.(	RtcodeR
tSyntaxErrorRR�RhRkR
(R(RR�Rtsynerrtattr((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR*e
s	









c
s#t�j
�
}
�f
d
�|
D�
S(s~Iterate over all the code objects nested within this one.

        The iteration includes `self` as its first value.

        c
3s$|]}
t�j
d|
�

V
qd
S(R�N(R+R(Rat
c(
R((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pys	<genexpr>�
s(RR�(R(tchildren((
R(sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt
child_parsers}
s
c
cs�t|j
jd
dd��
}
t|j
jddd��
}d}|j
j}d
}xZt|
|�D]I\}}|r�||kr�||fV
|}n||7}n||7}qfW||kr�||fV
ndS(s&
Map byte offsets to line numbers in `code`.

        Uses co_lnotab described in Python/compile.c to map byte offsets to
        line numbers.  Produces a sequence: (b0, l0), (b1, l1), ...

        Only byte offsets that correspond to line numbers are included in the
        results.

        iNii
(RR�R�R$R�tzip(R(tbyte_incrementstline_incrementst
last_line_numtline_numtbyte_numt	byte_incrt	line_incr((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_bytes_lines�
s







	




c
cs=x6|j�D](}
x|
j
�D]\}}|V
q Wq
Wd
S(s�Find the statements in `self.code`.

        Produce a sequence of line numbers that start statements.  Recurses
        into all code objects reachable from `self.code`.

        N(R�R�(R(tbpR[R^((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyRN�
s
N(	R�R�R�RR$R*R�R�RN(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR+b
s

			t	LoopBlockc
BseZ
dZd
�ZRS(s@A block on the block stack representing a `for` or `while` loop.cCs|
|_t
�|_dS(
N(R.Rtbreak_exits(R(R.((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR*�
s
	
(R�R�R�R*(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR��
s

t
FunctionBlockc
BseZ
dZd
�ZRS(s>A block on the block stack representing a function definition.cCs|
|_||_
dS(
N(R.tname(R(R.R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR*�
s
	
(R�R�R�R*(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR��
s

tTryBlockcBseZ
dZddd
�ZRS(s6A block on the block stack representing a `try` block.cCsF|
|_||_
t�|_t�|_t�|_t�|_dS(
N(t
handler_starttfinal_startRt
break_fromt
continue_fromtreturn_fromt
raise_from(R(R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR*�
s
	
	



N(R�R�R�R$R*(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR��
s

tArcStarttArcs
lineno, causecBseZ
dZdd
�
ZRS(s�The information needed to start an arc.

    `lineno` is the line number the arc starts from.  `cause` is a fragment
    used as the startmsg for AstArcAnalyzer.missing_arc_fragments.

    cCstt
|�j||
|�S(
N(tsuperR�t__new__(tclsRhtcause((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR��
s
N(R�R�R�R$R�(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR��
s
t	ArcStartsc

Cstd
�|D�
�
S(Nc
ss|]}
t|
t
�V
qdS(
N(t
isinstanceR�(Rat
x((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pys	<genexpr>�
s(
tall(
tseq((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt<lambda>�
tRqc
BseZ
dZed
dde�d��
Zd�Zd9d9d�Zd�Z	ede
�
d	��
Zd
�Zd�Z
d�Zd
�Zeddddddddddddg�
Zedd�
d��
Zedd�
d9d9d��
Zd�Zedd�
d��
Zedd�
d ��
Zedd�
d!��
Zedd�
d"��
Zedd�
d#��
Zedd�
d$��
ZeZedd�
d%��
Zedd�
d&��
ZeZeZeZedd�
d'��
Z edd�
d(��
Z!edd�
d)��
Z"edd�
d*��
Z#d+�Z$edd�
d,��
Z%edd�
d-��
Z&edd�
d.��
Z'edd�
d/��
Z(e(Z)d0�Z*d1�Z+e+Z,d2�Z-d3�Z.e.d4�
Z/e.d5�
Z0e.d6�
Z1e.d7�
Z2e3j4re.d8�
Z5nRS(:s>Analyze source text with an AST to find executable code paths.RR�Rcs�tj
t|
�
�
|_t�f
d
�|D�
�
|_�|_ttj	j
dd��
r�dj|j�
GHdj|j�
GHt|j�

nt�|_
tjt�
|_g|_tttj	j
dd��
�
|_dS(Nc
3s!|]}
�j|
|
�V
qdS(
N(
RE(RaR^(
t	multiline(sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pys	<genexpr>�
stCOVERAGE_ASTDUMPisStatements: {}sMultiline map: {}tCOVERAGE_TRACK_ARCS(tasttparseRt	root_nodeRRR�R{tostenvironRER�tast_dumpRdRyRztlistRstblock_stacktbooltdebug(R(RRR�((
R�sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR*�
s
	


	c
Cs\xUtj
|j�
D]A}
|
jj}t|d
|d�}|dk	r||
�

qqWdS(s�Examine the AST tree from `root_node` to determine possible arcs.

        This sets the `arcs` attribute to be a set of (from, to) line number
        pairs.

        t_code_object__N(R�twalkR�t	__class__R�tgetattrR$(R(tnodet	node_nametcode_object_handler((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyRr�
s




cCs�|jr1d
j
|
|||�GHtdd�
GHn|jj|
|f�

|dk	s_|dk	r�|j|
|fj||f�

ndS(s@Add an arc, including message fragments to use if it is missing.s!
Adding arc: ({}, {}): {!r}, {!r}tlimitiN(R�R�RRdR5R$RsR�(R(R.R�R~R}((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytadd_arcs	



c

Cs
t|j
�
S(
s.Yield the blocks in nearest-to-farthest order.(treversedR�(
R(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytnearest_blocksstreturnscCsC|
jj
}t|d
|d�}|dk	r8||
�
S|
jSdS(s}What is the right line number to use for this node?

        This dispatches to _line__Node functions where needed.

        t_line__N(R�R�R�R$Rh(R(R�R�thandler((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt
line_for_nodes




cCs|j|
j
�
S(
N(R�tvalue(R(R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt
_line__Assigns
cCsUtj
dkrJ|
jrJ|
jddk	r9|
jdjS|
jdjSn|
jSdS(Niii(ii(Rt	PYVERSIONtkeysR$Rhtvalues(R(R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_line__Dict!s


cCs(|
jr|j
|
jd
�
S|
jSdS(Ni(teltsR�Rh(R(R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_line__List-s
	
cCs%|
jr|j
|
jd
�
SdSdS(Nii
(tbodyR�(R(R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt
_line__Module3s
	
tAssigntAssertt	AugAssigntDeletetExectExprtGlobaltImportt
ImportFromtNonlocaltPasstPrintR�cCsZ|
jj
}t|d
|d�}|dk	r8||
�
Stt|j|
�
dd�

g
�
S(shAdd the arcs for `node`.

        Return a set of ArcStarts, exits from this node to the next.

        t	_handle__R�N(R�R�R�R$RR�R�(R(R�R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytadd_arcs?s




cCs�|d
krt
|g
�
}nx�|
D]x}|j|�
}|jj||�}||jkrdq%nx'|D]}|j|j||j�
qkW|j	|�
}q%W|S(su
Add arcs for the body of a compound statement.

        `body` is the body node.  `from_start` is a single `ArcStart` that can
        be the previous line in flow before this body.  `prev_starts` is a set
        of ArcStarts that can be the previous line.  Only one of them should be
        given.

        Returns a set of ArcStarts, the exits from this body.

        N(
R$RR�R�RERR�RhR�R�(R(R�t
from_starttprev_startst	body_nodeRhRTt
prev_start((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt
add_body_arcsQs











cCsK|
jj
}|dkrtS|dkrGtjrG|
jdkrGtSntS(	s Is this a compile-time constant?tNameConstanttNumtNameRBR!R$(R�R�(RBR!R$(R�R�RBRtPY3tidR!(R(R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytis_constant_expris





texitscCspxi|j�D][}t
|t�r6|jj|
�

Pq
t
|t�r
|jd
k	r
|jj|
�

Pq
q
Wd
S(s0Add arcs due to jumps from `exits` being breaks.N(	R�R�R�R�RJR�R�R$R�(R(R�tblock((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytprocess_break_exitszs





cCs�x�|j�D]x}t
|t�rSx*|
D]"}|j|j|j|j�
q)WPq
t
|t�r
|jd
k	r
|j
j|
�

Pq
q
Wd
S(s3Add arcs due to jumps from `exits` being continues.N(R�R�R�R�RhR.R�R�R�R$R�RJ(R(R�R�txit((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytprocess_continue_exits�s



 



cCs�x�|j�D]�}t
|t�r�|jdk	rbx*|
D]"}|j|j|j|j�
q8WPq�|jdk	r�|j	j
|
�

Pq�q
t
|t�r
x:|
D]2}|j|j|j|jd
j
|j�
�
q�WPq
q
WdS(s0Add arcs due to jumps from `exits` being raises.s!didn't except from function '{0}'N(R�R�R�R�R$R�RhR�R�R�RJR�R.R�R�(R(R�R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytprocess_raise_exits�s




 









cCs�x�|j�D]�}t
|t�rE|jdk	rE|jj|
�

Pq
t
|t�r
x:|
D]2}|j|j	|j
|jd
j|j
�
�
q[WPq
q
WdS(s1Add arcs due to jumps from `exits` being returns.s!didn't return from function '{0}'N(R�R�R�R�R$R�RJR�R�RhR.R�R�R�(R(R�R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pytprocess_return_exits�s








cCs8|j|
�
}t
|d
d�

}|j|g
�

t�S(NR�s*the break on line {lineno} wasn't executed(R�R�R�R(R(R�theretbreak_start((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__Break�s


cCs�|j|
�
}|
j
r�xE|
j
D]:}|j|�
}||kr"|j||�
|}q"q"W|j|
jd
�
}|jj||�}xFt|d|�D].}||jkr�|j||�
|}q�q�Wntt	|dd�

g
�
S(sBAdd arcs for things that can be decorated (classes and functions).ii
R�N(R�tdecorator_listR�R�R�RER
RRR�R$(R(R�tlasttdec_nodet	dec_startt
body_startRh((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle_decorated�s
	










cCs8|j|
�
}t
|d
d�

}|j|g
�

t�S(NR�s-the continue on line {lineno} wasn't executed(R�R�R�R(R(R�R
tcontinue_start((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__Continue�s


cCs�|j|
j
�
}|jjtd
|�
�

t|dd�

}|j|
jd|�

}x'|D]}|j|j	||j
�
q\W|jj�}|j}t|dd�

}|
j
r�|j|
j
d|�

}||O}n
|j|�

|S(NR.R�s'the loop on line {lineno} never startedR�s)the loop on line {lineno} didn't complete(R�titerR�R�R�R�R�R�R�RhR�tpopR�torelseR5(R(R�R.R�R�R�tmy_blockt
else_exits((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__For�s






	

	




cCsn|j|
j
�
}t|d
d�

}|j|
jd|�

}t|d
d�

}||j|
jd|�

O}|S(NR�s-the condition on line {lineno} was never trueR�s.the condition on line {lineno} was never false(R�ttestR�R�R�R
(R(R�R.R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__If�s




cCs8|j|
�
}t
|d
d�

}|j|g
�

t�S(NR�s*the raise on line {lineno} wasn't executed(R�R�R
R(R(R�R
traise_start((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__Raise�s

cCs8|j|
�
}t
|d
d�

}|j|g
�

t�S(NR�s+the return on line {lineno} wasn't executed(R�R�R

R(R(R�R
treturn_start((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__Returns

cCs�|
jr"|j
|
jd
�
}nd}|
jrJ|j
|
jd
�
}nd}td|d|�}|jj|�

|j
|
�
}|j|
jdt	|dd�

�

}|
jr�d|_
|
jr�tg�
|_q�n
|jj
�
t�}|
jr|
d}x||
jD]n}	|j
|	�
}|dk	r;
|j||�
n|}d}
t	|d|
�

}||j|	jd|�

O}q
Wn|
jr�
|j|
jd|�

}n||O}|
jr�|jj
�
||jB|jB|jB|jB}|j|
jd|�

}|jr(|j|j|�}
|j|
�

n|jrV|j|j|�}|j|�

n|jr�|j|j|�}|j|�

n|jr�|j|j|�}|j|�

q�n|S(NiR�R�R�R�s3the exception caught by line {lineno} didn't happenR�(thandlersR�R$t	finalbodyR�R�R�R�R�R�R�RR�R
R�R
R�R�R�t_combine_finally_startsR�R�R
R

(R(R�R�R�t	try_blockR.R�t
handler_exitstlast_handler_startthandler_nodet
from_causeR�t
final_fromR�tcontinue_exitstraise_exitstreturn_exits((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__Trys^	
	


$	
	
	
		








#	

	




	


	


	


	

cszg}xBt|
�
D]4\}��dk	r|j�jd
|�
�

qqWdj|�
�t�f
d�|D�
�
}|S(s4Helper for building the cause of `finally` branches.Rhs or c
3s!|]}
t|
j
��V
qdS(
N(R�Rh(Ratex(
R�(sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pys	<genexpr>asN(tsortedR$R�R�R�R(R(RnR�tcausesRh((
R�sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR
Zs


 


cCsg|
_|j
|
�
S(
N(R
R%
(R(R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__TryExceptds	
cCs�g|
_g|
_
|
jd
}|jjdkr�|
j|jkr�t|
j�
dks^t�
|j|
_|j|
_|j
|
_
n|j|
�
S(Nit	TryExcepti
(	R
R
R�R�R�RhtlenRR%
(R(R�tfirst((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__TryFinallyls	
	

$



c
Cs6
|j|
j
�
}|j|
j
�
}}|rG|j|
jd
�
}n|jjtd|�
�

t|dd�

}|j|
jd|�

}x'|D]}|j	|j
||j�
q�Wt�}|jj
�}|j|j�

t|dd�

}|
jr
|j|
jd|�

}	||	O}n|s2
|j|�

n|S(NiR.R�s-the condition on line {lineno} was never trueR�s.the condition on line {lineno} was never false(R�R
R�R�R�R�R�R�R�R�RhR�RR
RJR�R
R5(
R(R�t
constant_testR.tto_topR�R�R�R
R
((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_handle__While}s&









	



	




cCs1|j|
�
}|j
|
jd
t|�
�

}|S(NR�(R�R�R�R�(R(R�R.R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt
_handle__With�s

cCs�|j|
�
}|
j
rh|j|
j
d
t|�
�

}xP|D]#}|j|j||jd�
q>Wn"|j||�
|j||�
dS(NR�sdidn't exit the module(R�R�R�R�R�RhR�(R(R�R.R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_code_object__Module�s

	



$
cCsn|j|
�
}|j
jtd
|d|
j��

|j|
jdt|�
�

}|j|�

|j
j	�
dS(NR.R�R�(
R�R�R�R�R�R�R�R�R

R
(R(R�R.R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_code_object__FunctionDef�s


"



cCs||j|
�
}|j
||�
|j|
jd
t|�
�

}x7|D]/}|j
|j||jdj|
j�
�
qEWdS(NR�s#didn't exit the body of class '{0}'(	R�R�R�R�R�RhR�R�R�(R(R�R.R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_code_object__ClassDef�s







c
s�f
d
�}
|
S(sFA function to make methods for online callable _code_object__ methods.csY|j|
�
}|j
||dd
j�|��
|j
||ddj�|��
dS(Nsdidn't run the {0} on line {1}s!didn't finish the {0} on line {1}(R�R�R$R�(R(R�R.(
tnoun(sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_code_object__oneline_callable�s


#



((R5
R6
((
R5
sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_make_oneline_code_method�stlambdasgenerator expressionsdictionary comprehensionsset comprehensionslist comprehensionN(6R�R�R�RRR*RrR$R�R�R{R�R�R�R�R�t
OK_TO_DEFAULTR�R�R�R�R�R
R

R
R

t_handle__ClassDefR
R
t_handle__AsyncFort_handle__FunctionDeft_handle__AsyncFunctionDefR
R
R
R%
R
R)
R-
R0
R1
t_handle__AsyncWithR2
R3
t_code_object__AsyncFunctionDefR4
R7
t_code_object__Lambdat_code_object__GeneratorExpt_code_object__DictCompt_code_object__SetCompRR�t_code_object__ListComp(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyRq�
sd
	

					


	
	K	
			
	



	
tctxc

Cs4|d
gdit
�gkp3t|tttf�S(s:Is `value` simple enough to be displayed on a single line?N((R$RR�RR{tfloat(
R�((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt_is_simple_value�s
ic
Cs�
d
|
}t|t
j�s:dj||jj|�GHdSt|dd�}|dk	rmdj|j�
}nd}dj||jj|�}gt
j	|�
D]$\}}|t
kr�||f^q�}|s�dj|�
GHn
t|�
d	kr,
t|d
d	�
r,
|d
\}	}dj||	|�GHn�|GH|d}
x�|D]�\}	}d
j|
|	�}t|�
r�
dj||�GHqB
t|t
�r�
dj|�
GHx|D]}t||
d�
q�
Wdj|
�
GHqB
|GHt||
d�
qB
Wdj|�
GHdS(s`Dump the AST for `node`.

    This recursively walks the AST, printing a readable version.

    t
 s{0}<{1} {2!r}>NRhs @ {0}R�s
{0}<{1}{2}s{0}>i
is{0} {1}: {2!r}>s    s{0}{1}:s	{0} {1!r}s{0} [is{0}](R�R�tASTR�R�R�R�R$Rhtiter_fieldstSKIP_DUMP_FIELDSR+
RG
R�R�(
R�tdepthRORhtlinemarktheadR�R�tnamed_fieldst
field_nametnext_indenttprefixt
n((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyR��s>










&













()R�R�RyR�R1R@RCtcoverageRtcoverage.backwardR
RRtcoverage.bytecodeRtcoverage.debugRt
coverage.miscRRRR	R
RRtcoverage.phystokensR
RRtobjectRR+R�R�R�t
namedtupleR�RqRK
RG
R�(((sB/opt/alt/python27/lib64/python2.7/site-packages/coverage/parser.pyt<module>s6









"

�LP"
��