
\K]c           @` s   d  d l  m Z m Z m Z d  d l Z d  d l Z d  d l Z d  d l m Z d  d l	 m
 Z
 d  d l m Z e d d d g  Z d	 e f d
     YZ d e j d d d d d f  f d     YZ d e f d     YZ d e f d     YZ d S(   i    (   t   print_functiont   divisiont   absolute_importN(   t   utils(   t   Loc(   t   UnsupportedErrort
   SETUP_LOOPt   FOR_ITERt
   SETUP_WITHt   CFBlockc           B` s#   e  Z d    Z d   Z d   Z RS(   c         C` s1   | |  _  g  |  _ i  |  _ i  |  _ t |  _ d  S(   N(   t   offsett   bodyt   outgoing_jumpst   incoming_jumpst   Falset   terminating(   t   selfR
   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   __init__   s
    				c         C` s,   |  j  t |  j  t |  j  f } d | S(   Ns,   block(offset:%d, outgoing: %s, incoming: %s)(   R
   t   sortedR   R   (   R   t   args(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   __repr__   s    $c         C` s   t  |  j  S(   N(   t   iterR   (   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   __iter__!   s    (   t   __name__t
   __module__R   R   R   (    (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR	      s   		t   Loopt   entriest   exitst   headerR   c           B` s&   e  Z d  Z d Z d   Z d   Z RS(   s?   
    A control flow loop, as detected by a CFGraph object.
    c         C` s   t  | t  o | j |  j k S(   N(   t
   isinstanceR   R   (   R   t   other(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   __eq__2   s    c         C` s   t  |  j  S(   N(   t   hashR   (   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   __hash__5   s    (    (   R   R   t   __doc__t	   __slots__R   R!   (    (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR   %   s   	t   CFGraphc           B` s  e  Z d  Z d   Z d   Z d+ d  Z d   Z d   Z d   Z	 d   Z
 d   Z d	   Z d
   Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z e d  Z d+ d  Z d d  Z d+ d  Z d   Z d+ d  Z d   Z  d   Z! d   Z" d    Z# d!   Z$ d"   Z% e d#  Z& d$   Z' d%   Z( d&   Z) d'   Z* d(   Z+ d)   Z, d*   Z- RS(,   sB   
    Generic (almost) implementation of a Control Flow Graph.
    c         C` sF   t    |  _ t j t   |  _ t j t   |  _ i  |  _ d  |  _ d  S(   N(	   t   sett   _nodest   collectionst   defaultdictt   _predst   _succst
   _edge_datat   Nonet   _entry_point(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR   >   s
    	c         C` s   |  j  j |  d S(   s   
        Add *node* to the graph.  This is necessary before adding any
        edges from/to the node.  *node* can be any hashable object.
        N(   R&   t   add(   R   t   node(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   add_nodeE   s    c         C` sA   | |  j  k s t  | |  j  k s* t  |  j | | |  d S(   s   
        Add an edge from node *src* to node *dest*, with optional
        per-edge *data*.
        If such an edge already exists, it is replaced (duplicate edges
        are not possible).
        N(   R&   t   AssertionErrort	   _add_edge(   R   t   srct   destt   data(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   add_edgeL   s    c         c` s4   x- |  j  | D] } | |  j | | f f Vq Wd S(   s   
        Yield (node, data) pairs representing the successors of node *src*.
        (*data* will be None if no data was specified when adding the edge)
        N(   R*   R+   (   R   R3   R4   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt
   successorsW   s    c         c` s4   x- |  j  | D] } | |  j | | f f Vq Wd S(   s   
        Yield (node, data) pairs representing the predecessors of node *dest*.
        (*data* will be None if no data was specified when adding the edge)
        N(   R)   R+   (   R   R4   R3   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   predecessors_   s    c         C` s"   | |  j  k s t  | |  _ d S(   s=   
        Set the entry point of the graph to *node*.
        N(   R&   R1   R-   (   R   R/   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   set_entry_pointg   s    c         C` s   |  j  d k r t d   n  |  j   |  j   |  j   |  j   |  j   |  j   |  j	   |  j
   |  j   |  j   |  j   d S(   s   
        Compute various properties of the control flow graph.  The graph
        must have been fully populated, and its entry point specified.
        s   no entry point defined!N(   R-   R,   t   RuntimeErrort   _eliminate_dead_blockst   _find_exit_pointst   _find_dominatorst   _find_back_edgest   _find_topo_ordert   _find_descendentst   _find_loopst   _find_post_dominatorst   _find_immediate_dominatorst   _find_dominance_frontiert   _find_dominator_tree(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   processn   s    









c         C` s   |  j  S(   s   
        Return a dictionary of {node -> set(nodes)} mapping each node to
        the nodes dominating it.

        A node D dominates a node N when any path leading to N must go through D.
        (   t   _doms(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt
   dominators   s    c         C` s   |  j  S(   s   
        Return a dictionary of {node -> set(nodes)} mapping each node to
        the nodes post-dominating it.

        A node P post-dominates a node N when any path starting from N must go
        through P.
        (   t
   _post_doms(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   post_dominators   s    c         C` s   |  j  S(   s   
        Return a dictionary of {node -> node} mapping each node to its
        immediate dominator (idom).

        The idom(B) is the closest strict dominator of V
        (   t   _idom(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   immediate_dominators   s    c         C` s   |  j  S(   s/  
        Return a dictionary of {node -> set(nodes)} mapping each node to
        the nodes in its dominance frontier.

        The dominance frontier _df(N) is the set of all nodes that are
        immediate successors to blocks dominanted by N but which aren't
        stricly dominanted by N
        (   t   _df(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   dominance_frontier   s    	c         C` s   |  j  S(   s   
        return a dictionary of {node -> set(nodes)} mapping each node to
        the set of nodes it immediately dominates

        The domtree(B) is the closest strict set of nodes that B dominates
        (   t   _domtree(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   dominator_tree   s    c         C` s   |  j  | S(   sx   
        Return the set of descendents of the given *node*, in topological
        order (ignoring back edges).
        (   t   _descs(   R   R/   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   descendents   s    c         C` s   |  j  d k	 s t  |  j  S(   s.   
        Return the entry point node.
        N(   R-   R,   R1   (   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   entry_point   s    c         C` s   |  j  S(   sG   
        Return the computed set of exit nodes (may be empty).
        (   t   _exit_points(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   exit_points   s    c         C` s   |  j  |  j S(   s   
        Return the set of nodes constituting the graph's backbone.
        (i.e. the nodes that every path starting from the entry point
         must go through).  By construction, it is non-empty: it contains
         at least the entry point.
        (   RI   R-   (   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   backbone   s    c         C` s   |  j  S(   s   
        Return a dictionary of {node -> loop} mapping each loop header
        to the loop (a Loop instance) starting with it.
        (   t   _loops(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   loops   s    c         C` s%   g  |  j  | D] } |  j | ^ q S(   sm   
        Return the list of Loop objects the *node* belongs to,
        from innermost to outermost.
        (   t	   _in_loopsRW   (   R   R/   t   x(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   in_loops   s    c         C` s   |  j  S(   sK   
        Return the set of dead nodes (eliminated from the graph).
        (   t   _dead_nodes(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt
   dead_nodes   s    c         C` s   |  j  S(   s/   
        Return the set of live nodes.
        (   R&   (   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   nodes   s    c         C` s   |  j  S(   sb   
        Return the sequence of nodes in topological order (ignoring back
        edges).
        (   t   _topo_order(   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt
   topo_order   s    c         c` sS   t  |  } |  j } | r* t |  } n  x" | D] } | | k r1 | Vq1 q1 Wd S(   s   
        Iterate over the *nodes* in topological order (ignoring back edges).
        The sort isn't guaranteed to be stable.
        N(   R%   R_   t   reversed(   R   R^   t   reverset   itt   n(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt	   topo_sort   s    	c         C` s  d d l  } | p t j } t d d | |  j |  t d d | | j  |  j d | t d d | | j  |  j d | t d t |  j  d | t d	 d | | j  |  j	 d | t d
 d | | j  |  j
 d | t d d | | j  |  j   d | d S(   s3   
        Dump extensive debug information.
        i    Ns   CFG adjacency lists:t   files   CFG dominators:t   streams   CFG post-dominators:s   CFG back edges:s
   CFG loops:s   CFG node-to-loops:s   CFG backbone:(   t   pprintt   syst   stdoutt   printt   _dump_adj_listsRG   RI   R   t   _back_edgesRW   RY   RV   (   R   Rf   Rh   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   dump   s    s   numba_cfg.dotc         C` s   y d d l  } Wn t k
 r/ t d   n X| j d |  } x$ |  j D] } | j t |   qL WxE |  j D]: } x1 |  j | D]" } | j t |  t |   q Wqs W| S(   s   Render the controlflow graph with GraphViz DOT via the
        ``graphviz`` python binding.

        Returns
        -------
        g : graphviz.Digraph
            Use `g.view()` to open the graph in the default PDF application.
        i    Nsc   The feature requires `graphviz` but it is not available. Please install with `pip install graphviz`t   filename(   t   graphvizt   ImportErrort   DigraphR&   R/   t   strR*   t   edge(   R   Ro   t   gvt   gRd   Rt   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt
   render_dot  s    
$c         C` s?   |  j  | j |  |  j | j |  | |  j | | f <d  S(   N(   R)   R.   R*   R+   (   R   t   from_t   toR5   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR2   .  s    c         C` s   xA |  j  j | d  D]* } |  j | j |  |  j | | f =q WxA |  j j | d  D]* } |  j  | j |  |  j | | f =qZ Wd  S(   N(    (    (   R*   t   popR)   t   removeR+   (   R   R/   t   succt   pred(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   _remove_node_edges5  s    c         c` s   | d  k r |  j f } n  t   } t |  } x\ | r | j   } | | k r3 | V| j |  x% |  j | D] } | j |  qq Wq3 q3 Wd  S(   N(   R,   R-   R%   t   listRz   R.   R*   t   append(   R   R   t   seent   stackR/   R|   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   _dfs=  s    		c         C` sk   t    } x! |  j   D] } | j |  q W|  j | |  _ | |  _ x |  j D] } |  j |  qP Wd S(   sx   
        Eliminate all blocks not reachable from the entry point, and
        stash them into self._dead_nodes.
        N(   R%   R   R.   R&   R\   R~   (   R   t   liveR/   t   dead(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR;   J  s    		c         C` sL   t    } x3 |  j D]( } |  j j |  s | j |  q q W| |  _ d S(   s2   
        Compute the graph's exit points.
        N(   R%   R&   R*   t   getR.   RT   (   R   RU   Rd   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR<   X  s
    	c         ` sM   |  j   |  j  g   t          f d       |  j   S(   Nc         ` sa   |   k r]  j  |   x1  |  D]% } |  | f  k r$   |  q$ q$ W j |   n  d  S(   N(   R.   R   (   R/   R4   (   t   _dfs_rect
   back_edgest
   post_orderR   t   succs(    s0   lib/python2.7/site-packages/numba/controlflow.pyR   h  s    (   R*   Rm   R%   R-   (   R   (    (   R   R   R   R   R   s0   lib/python2.7/site-packages/numba/controlflow.pyt   _find_postorderb  s    			c         ` s      f d   } |  j  } |  j } |  j   } d   t |  D  i | | 6  | j   | j   t } xv | r t } xc | D][ } t j	 |   f d   | | D  } |   k s   | | k r |   | <t } q q Wqp W  |  _
 d  S(   Nc         ` sa   xZ |  | k r\ x"  |   | k  r3   |  }  q Wx"  |   | k rX   | } q7 Wq W|  S(   N(    (   t   ut   v(   t   idomt   idx(    s0   lib/python2.7/site-packages/numba/controlflow.pyt	   intersect|  s    c         S` s   i  |  ] \ } } | |  q S(    (    (   t   .0t   it   e(    (    s0   lib/python2.7/site-packages/numba/controlflow.pys
   <dictcomp>  s   	 c         3` s!   |  ] } |   k r | Vq d  S(   N(    (   R   R   (   R   (    s0   lib/python2.7/site-packages/numba/controlflow.pys	   <genexpr>  s    (   R-   R)   R   t	   enumerateRz   Rb   t   TrueR   t	   functoolst   reduceRK   (   R   R   t   entryt   preds_tablet   ordert   changedR   t   new_idom(    (   R   R   s0   lib/python2.7/site-packages/numba/controlflow.pyRC   s  s"    			

	&
c         C` s~   |  j  } t j t  } xV | j   D]H \ } } | | k rM t   | | <n  | | k r% | | j |  q% q% W| |  _ d  S(   N(   RK   R'   R(   R%   t   itemsR.   RO   (   R   R   t   domtreeR   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyRE     s    	c         C` s   |  j  } |  j } d   | D } xq | D]i } t | |  d k  rK q) n  xD | | D]8 } x/ | | | k r | | j |  | | } q_ WqV Wq) W| |  _ d  S(   Nc         S` s   i  |  ] } t    |  q S(    (   R%   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pys
   <dictcomp>  s   	 i   (   RK   R)   t   lenR.   RM   (   R   R   R   t   dfR   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyRD     s    		c         C` s  | r* t  |  j  } |  j } |  j } n$ t  |  j g  } |  j } |  j } | sc t d   n  i  } x! | D] } t  | g  | | <qp Wg  } x@ |  j D]5 } | | k r t  |  j  | | <| j |  q q Wx | r| j   } | | k r q n  t  | g  }	 | | }
 |
 rO|	 t	 j
 t  j g  |
 D] } | | ^ q2 O}	 n  |	 | | k r t |	  t | |  k  st  |	 | | <| j | |  q q W| S(   Ns5   no entry points: dominator algorithm cannot be seeded(   R%   RT   R*   R)   R-   R:   R&   R   Rz   R   R   t   intersectionR   R1   t   extend(   R   t   postR   R   t   succs_tablet   domsR   t   todoRd   t   new_domst   predst   p(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   _find_dominators_internal  s>    				
$"
c         C` s   |  j  d t  |  _ d  S(   NR   (   R   R   RG   (   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR=     s    c         C` s   t    } |  j j |  xG |  j j   D]6 } | j s) x$ | j D] } |  j | |  qB Wq) q) W|  j d t	  |  _
 |  j
 | =x$ |  j
 j   D] } | j |  q W|  j |  |  j j |  d  S(   NR   (   t   objectRT   R.   RW   t   valuesR   R   R2   R   R   RI   t   discardR~   R{   (   R   t
   dummy_exitt   loopt   bR   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyRB     s    		
c         ` s|   t    } xc |  j j   D]R \   } |  j   | @} t |  d k sN t  | j   f d   | D  q W| |  _ d S(   su   
        Find back edges.  An edge (src, dest) is a back edge if and
        only if *dest* dominates *src*.
        i   c         3` s   |  ] }   | f Vq d  S(   N(    (   R   R4   (   R3   (    s0   lib/python2.7/site-packages/numba/controlflow.pys	   <genexpr>  s    N(   R%   R*   R   RG   R   R1   t   updateRm   (   R   R   R   t   back(    (   R3   s0   lib/python2.7/site-packages/numba/controlflow.pyR>     s    	!c         ` s`   |  j   |  j  g   t          f d       |  j   j    |  _ d  S(   Nc         ` sa   |   k r]  j  |   x1  |  D]% } |  | f  k r$   |  q$ q$ W j |   n  d  S(   N(   R.   R   (   R/   R4   (   R   R   R   R   R   (    s0   lib/python2.7/site-packages/numba/controlflow.pyR   
  s    (   R*   Rm   R%   R-   Rb   R_   (   R   (    (   R   R   R   R   R   s0   lib/python2.7/site-packages/numba/controlflow.pyR?     s    			
c         C` s   i  } xv t  |  j  D]e } t   | | <} xK |  j | D]< } | | f |  j k r; | j |  | j | |  q; q; Wq W| |  _ d  S(   N(   Ra   R_   R%   R*   Rm   R.   R   RQ   (   R   t   descsR/   t
   node_descsR|   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR@     s    c      
   C` s  i  } x |  j  D] \ } } | } t | g  } | g } xF | r | j   } | | k r= | j |  | j |  j |  q= q= W| | k r | | j |  q | | | <q Wi  } x | j   D] \ } } t   }	 t   }
 x> | D]6 } |	 j |  j | |  |
 j |  j | |  q Wt	 d | d | d |	 d |
  } | | | <q W| |  _
 t d   |  j D  } xK t | j   d d   D]. } x% | j D] } | | j | j  qWqW| |  _ d S(	   sC   
        Find the loops defined by the graph's back edges.
        R   R   R   R   c         s` s   |  ] } | g  f Vq d  S(   N(    (   R   Rd   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pys	   <genexpr>E  s    t   keyc         S` s   t  |  j  S(   N(   R   R   (   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   <lambda>H  t    N(   Rm   R%   Rz   R.   R   R)   R   R   R*   R   RW   t   dictR&   R   R   R   R   R   RY   (   R   t   bodiesR3   R4   R   R   t   queueRd   RX   R   R   R   R[   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyRA      s8    				!	"c         C` sB   t  d   |  j j   D  } d d  l } | j | d | d  S(   Nc         s` s-   |  ]# \ } } | t  t |   f Vq d  S(   N(   R   R   (   R   R3   t   dests(    (    s0   lib/python2.7/site-packages/numba/controlflow.pys	   <genexpr>N  s   i    Rg   (   R   R*   R   Rh   (   R   Rf   t	   adj_listsRh   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyRl   M  s    	N(.   R   R   R"   R   R0   R,   R6   R7   R8   R9   RF   RH   RJ   RL   RN   RP   RR   RS   RU   RV   RX   R[   R]   R^   R`   R   Re   Rn   Rw   R2   R~   R   R;   R<   R   RC   RE   RD   R   R=   RB   R>   R?   R@   RA   Rl   (    (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR$   9   sT   									
																		
		%		+					
	-t   ControlFlowAnalysisc           B` s   e  Z d  Z d   Z d   Z d   Z d   Z d d  Z d   Z	 d d  Z
 d	   Z d
   Z d   Z d   Z d   Z d   Z d   Z d   Z e Z e Z e Z e Z d   Z e Z e Z d   Z d   Z d   Z d   Z d   Z RS(   s   
    Attributes
    ----------
    - bytecode

    - blocks

    - blockseq

    - doms: dict of set
        Dominators

    - backbone: set of block offsets
        The set of block that is common to all possible code path.

    c         C` sg   | |  _  i  |  _ i  |  _ g  |  _ d  |  _ d  |  _ t |  _ d  |  _	 g  |  _
 g  |  _ g  |  _ d  S(   N(   t   bytecodet   blockst
   liveblockst   blockseqR,   R   RV   R   t   _force_new_blockt	   _curblockt   _blockstackRW   t   _withs(   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR   e  s    										c         c` s$   x |  j  D] } |  j | Vq
 Wd S(   s=   
        Return all blocks in sequence of occurrence
        N(   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt
   iterblockss  s    c         c` s6   x/ |  j  D]$ } | |  j k r
 |  j | Vq
 q
 Wd S(   sB   
        Return all live blocks in sequence of occurrence
        N(   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   iterliveblocksz  s    c         c` sH   xA | j  j   D]0 \ } } | |  j k r |  j | | f Vq q Wd S(   sQ   
        Yield (incoming block, number of stack pops) pairs for *block*.
        N(   R   R   R   R   (   R   t   blockR   t   pops(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   incoming_blocks  s    c         C` s   |  j  j d d   d  S(   NRf   (   t   graphRn   R,   (   R   Rf   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyRn     s    c         ` s  x   j    D] } d | j } t   | d   } | d  k	 rK | |  q | j r t   j j j | j	  } d | j } t
 | d |  q q WxX t   j   j d  D]= \ } }   j | } | j r | j r d | j | <q q Wt   }	 x   j D] }
 |	 j |
  qWxM   j j   D]< }
 x3 |
 j j   D]" \ } } |	 j |
 j | |  q@Wq*W|	 j t   j   |	 j   |	   _ xQ t j   j  D]= }
 x4 |
 j j   D]# \ } } |   j | j |
 j <qWqWt   f d     j j   D    _ x6 t    j  D] } |   j k rPqqWt! d     j j"   } t#   } x]   j j$   D]L }
 xC   j% D]8 \ } } | |
 k o| k  n r| j& |
  qqWqpW| |   _" d  S(   Ns   op_%ss$   Use of unsupported opcode (%s) foundt   loci   i    c         3` s"   |  ] } |   j  | f Vq d  S(   N(   R   (   R   R   (   R   (    s0   lib/python2.7/site-packages/numba/controlflow.pys	   <genexpr>  s   s   No live block that exits!?('   t
   _iter_instt   opnamet   getattrR,   t   is_jumpR   R   t   func_idRo   t   linenoR   t   zipR   R   R   R   R$   R0   R   R   R6   R
   R9   t   minRF   R   R   t
   itervaluesR   R   R^   R   Ra   R1   RV   R%   t   keysRW   R.   (   R   t   instt   fnamet   fnt   lt   msgt   curt   nxtt   blkR   R   t   outR   t   lastblkRV   t   inloopblockst   sR   (    (   R   s0   lib/python2.7/site-packages/numba/controlflow.pyt   run  sL    	&	
		i    c         C` s   | |  j  j | <d S(   s   
        Register a jump (conditional or not) to *target* offset.
        *pops* is the number of stack pops implied by the jump (default 0).
        N(   R   R   (   R   t   targetR   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   jump  s    c         c` sR   xK |  j  D]@ } |  j |  r/ |  j |  n  |  j j j | j  | Vq
 Wd  S(   N(   R   t   _use_new_blockt   _start_new_blockR   R   R   R
   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR     s
    c         C` sL   | j  |  j j k r t } n! | j t k r6 t } n	 |  j } t |  _ | S(   N(   R
   R   t   labelsR   R   t   NEW_BLOCKERSR   R   (   R   R   t   res(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR     s    				c         C` s<   t  | j  |  _ |  j |  j | j <|  j j | j  d  S(   N(   R	   R
   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR     s    c         C` sR   | j    } |  j j |  |  j j | j | f  |  j | j  t |  _ d  S(   N(	   t   get_jump_targetR   R   RW   R
   R   t   nextR   R   (   R   R   t   end(    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_SETUP_LOOP  s
    c         C` sR   | j    } |  j j |  |  j j | j | f  |  j | j  t |  _ d  S(   N(	   R   R   R   R   R
   R   R   R   R   (   R   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_SETUP_WITH  s
    c         C` s   |  j  j   d  S(   N(   R   Rz   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_POP_BLOCK  s    c         C` s0   |  j  | j    |  j  | j  t |  _ d  S(   N(   R   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_FOR_ITER  s    c         C` s0   |  j  | j    |  j  | j  t |  _ d  S(   N(   R   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   _op_ABSOLUTE_JUMP_IF  s    c         C` s6   |  j  | j    |  j  | j d d t |  _ d  S(   NR   i   (   R   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   _op_ABSOLUTE_JUMP_OR_POP  s    c         C` s    |  j  | j    t |  _ d  S(   N(   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_JUMP_ABSOLUTE  s    c         C` s    |  j  | j    t |  _ d  S(   N(   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_JUMP_FORWARD  s    c         C` s   t  |  j _ t  |  _ d  S(   N(   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_RETURN_VALUE  s    c         C` s   t  |  j _ t  |  _ d  S(   N(   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_RAISE_VARARGS  s    c         C` s!   |  j  |  j d  t |  _ d  S(   Ni(   R   R   R   R   (   R   R   (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   op_BREAK_LOOP#  s    N(   R   R   R"   R   R   R   R   R,   Rn   R   R   R   R   R   R   R   R   R   R   t   op_POP_JUMP_IF_FALSEt   op_POP_JUMP_IF_TRUEt   op_JUMP_IF_FALSEt   op_JUMP_IF_TRUER   t   op_JUMP_IF_FALSE_OR_POPt   op_JUMP_IF_TRUE_OR_POPR   R   R   R   R   (    (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyR   T  s8   					:				
	
								(   t
   __future__R    R   R   R'   R   Ri   t   numbaR   t   numba.irR   t   numba.errorsR   t	   frozensetR   R   R	   t
   namedtupleR   R$   R   (    (    (    s0   lib/python2.7/site-packages/numba/controlflow.pyt   <module>   s   "  