
NWc           @@  s  d  d l  m Z d  d l 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
 Z
 e
 j d e d e d e d	 e d
 e d e d e d e d e  	e j d  d k r e Z n e e f Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z m Z d d l m Z m Z d d l m Z d d l m  Z  y d  d l! m" Z" Wn! e# k
 rd  d l$ m" Z" n Xy d  d l! m% Z% Wn e# k
 re& Z% n Xd   Z' e j( e j) f d  Z* d   Z+ d    Z, d!   Z- d" e j. f d#     YZ/ d$   Z0 d%   Z1 d& e j2 f d'     YZ3 d( e j2 f d)     YZ4 d* e j5 e  f d+     YZ6 d, e j5 f d-     YZ7 d. e j2 f d/     YZ8 d0 e j9 e j2 f d1     YZ: d2 e j9 e j; f d3     YZ< e j= d4 d5  Z> e j= d6 d5  Z? e j= d7 d5  Z@ d8 e j5 e  f d9     YZA d: e jB e j9 f d;     YZC d< e jB f d=     YZD d S(>   i    (   t   absolute_importNi   (   t	   TypeSlots(   t   not_a_constantt   UtilityCodet   EncodedStringt   bytes_literalt   Nodest	   ExprNodest
   PyrexTypest   Builtint	   UtilNodest   _py_int_typesi   (   R   (   R   (   R   (   t   Visitor(   R	   (   R
   (   t   Options(   R   t   TempitaUtilityCode(   R   R   (   t   error(   t   SkipDeclarations(   t   reduce(   t
   basestringc         C@  s   t  j |  d  S(   Ns
   Optimize.c(   R   t   load_cached(   t   name(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   load_c_utility,   s    c         C@  s   t  |  |  r |  j S|  S(   N(   t
   isinstancet   arg(   t   nodet   coercion_nodes(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   unwrap_coerced_node0   s    c         C@  s&   x t  |  t j  r! |  j }  q W|  S(   N(   R   R
   t   ResultRefNodet
   expression(   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   unwrap_node6   s    c         C@  s   t  |   }  t  |  } t |  t j  rL t | t j  rL |  j | j k St |  t j  r t | t j  r |  j o t |  j | j  o |  j	 | j	 k St
 S(   N(   R   R   R   t   NameNodeR   t   AttributeNodet
   is_py_attrt   is_common_valuet   objt	   attributet   False(   t   at   b(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR!   <   s    $$/c         C@  s#   |  d  k	 r |  j d  k r d  S|  S(   N(   t   Nonet   constant_result(   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   filter_none_nodeF   s    t   _YieldNodeCollectorc           B@  sP   e  Z d  Z d   Z e j j Z d   Z d   Z	 d   Z
 d   Z d   Z RS(   s9   
    YieldExprNode finder for generator expressions.
    c         C@  s&   t  j j |   i  |  _ g  |  _ d  S(   N(   R   t   TreeVisitort   __init__t   yield_stat_nodest   yield_nodes(   t   self(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR,   P   s    	c         C@  s!   |  j  j |  |  j |  d  S(   N(   R.   t   appendt   visitchildren(   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_YieldExprNodeW   s    c         C@  s6   |  j  |  | j |  j k r2 | |  j | j <n  d  S(   N(   R1   t   exprR.   R-   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_ExprStatNode[   s    c         C@  s   d  S(   N(    (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_GeneratorExpressionNodeb   s    c         C@  s   d  S(   N(    (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_LambdaNodee   s    c         C@  s   d  S(   N(    (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_FuncDefNodeh   s    (   t   __name__t
   __module__t   __doc__R,   R   R+   R1   t
   visit_NodeR2   R4   R5   R6   R7   (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR*   L   s   					c         C@  s*   t  |   } t |  d k r" d S| d S(   Ni   i    (   NN(   t   _find_yield_statementst   lenR'   (   R   t   yield_statements(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _find_single_yield_expressionl   s    c         C@  sd   t    } | j |   y0 g  | j D] } | j | j | f ^ q# } Wn t k
 r_ g  } n X| S(   N(   R*   R1   R.   R   R-   t   KeyError(   R   t	   collectort
   yield_nodeR>   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR<   s   s    	-
t   IterationTransformc        
   B@  s  e  Z d  Z d   Z d   Z e d  Z d   Z e j	 e j
 e j d e j d  g  Z e j	 e j e j d e j d  g  Z e d  Z e j	 e j e j d e j d  e j d e j d  e j d	 e j d  g  Z e j	 e j e j d e j d  e j d
 e j d  e j d e j d  e j d e j d  g d d Z e d  Z e d  Z d   Z d   Z e d  Z  d   Z! d   Z" e j	 e j e j d e j d  e j d e j d  e j d e j d  e j d e j d  e j d e j d  g  Z# RS(   s   Transform some common for-in loop patterns into efficient C loops:

    - for-in-dict loop becomes a while loop calling PyDict_Next()
    - for-in-enumerate is replaced by an external counter variable
    - for-in-range loop becomes a plain C for loop
    c         C@  s  | j    r| j } t j |  } | j j rE | j j j j } n | j j j } t j	 |  } | j
 |  } t j | d d d | j d | } t j | d t j | d | d t j | d d	 t j |  g } t j | d
 t j | d | d | g d d  }	 t j | d | g d t j | d | d t j | j j d | j d |	 d t j | d | d t j | d d }
 |
 j |  j    }
 |  j |
  }
 t j | |
  } | j d k rt j | d | } n  | S|  j |  | Sd  S(   Nt   operatoru   ==t   operand1t   operand2t   statst   lhst   rhst   valuei   t
   if_clausest	   conditiont   bodyt   else_clauset   tempst   targett   iteratort   sequencei    t   not_int   operand(    t   is_ptr_containst   posR
   R   RF   t   is_subscriptt   baset   typet	   base_typet
   TempHandlet   refR   t   PrimaryCmpNodeRE   R   t   StatListNodet   SingleAssignmentNodet   BoolNodet   BreakStatNodet
   IfStatNodet   IfClauseNodeR'   t   TempsBlockNodet   ForInStatNodet   IteratorNodet   analyse_expressionst   current_envt   visitt   TempResultFromStatNodeRD   t   NotNodeR1   (   R/   R   RV   t
   result_refRZ   t   target_handleRP   t   cmp_nodet   if_bodyt   if_nodet   for_loopt   new_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_PrimaryCmpNode   sF    		'		0c         C@  s#   |  j  |  |  j | | j j  S(   N(   R1   t   _optimise_for_loopRQ   RR   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_ForInStatNode   s    c      
   C@  s  | j  t j k rA | r | S|  j | d | d d  d t d t S| j  j sY | j  j ro |  j	 | | d | S| j  t j
 k r |  j | | d | S| j  t j k r |  j | | d | St | t j  s | S| j d  k r| j r t | j j  pd } n1 t | j  } | r9| j d  k	 r9| d 8} n  | j } | j r| r| r| j ph| j } | j } |  j   j j d k } | r| d k rt | t j  r| j }	 |	 j r|	 j d
 k r|	 j r|	 j j  rt } qqn  t }
 } | d k s| r'| d k r't }
 nR | d k sE| rN| d k rNt } n+ | d k sl| ry| d	 k ryt }
 } n  |
 s| r|  j | | | |
 |  Sn  | j d  k r#| j r#| j r#| j j  r#| j d k r| r| S|  j! | |  S| j d k r#| r| S|  j" | |  Sn  t# j$ r| j% j  j& r| j d  k r| j r| j r| j j  r| j d k r|  j' | | d | Sn  | S(   Nt   dict_objt   methodt   keyst   valuest   reversedi    i   i   t   itemst   dictt   iterkeyst
   itervaluest	   iteritemst	   enumeratet   ranget   xrange(   Rx   Ry   s   items(   s   ranges   xrange((   RY   R	   t	   dict_typet   _transform_dict_iterationR'   t   TrueR$   t   is_ptrt   is_arrayt   _transform_carray_iterationt
   bytes_typet   _transform_bytes_iterationt   unicode_typet   _transform_unicode_iterationR   R   t   SimpleCallNodet   argst	   arg_tupleR=   R/   t   functiont   is_attributeR"   R#   t   global_scopet   contextt   language_levelt   CallNodet   is_nameR   t   entryt
   is_builtint   _transform_enumerate_iterationt   _transform_reversed_iterationR   t   convert_rangeRP   t   is_intt   _transform_range_iteration(   R/   R   RQ   Rz   t	   arg_countR   t   base_objRw   t   is_safe_itert   inner_functionRx   Ry   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRt      sp    $				
		c         C@  s   | j  j } t |  d k r2 t | j d  | St |  d k rX t | j d  | S| d } | j t j t j f k r | j	 d  | j
 _ t | j
 _ | S|  j | | d t S(   Ni    s(   reversed() requires an iterable argumenti   s#   reversed() takes exactly 1 arguments!   'NoneType' object is not iterableRz   (   R   R   R=   R   RV   RY   R	   t
   tuple_typet	   list_typet   as_none_safe_nodeRQ   RR   R   Rz   Rt   (   R/   R   t   reversed_functionR   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR     s    		
t   sc         C@  s   | j  j } | j r) | t j k	 r) | St j | j d   } t j	 | j
 d |  j d | g d d } t j	 | j
 d |  j d | g d d } t j | |  j | t j | j
 d | d d  d	 d  d
 | d | j d d d |  S(   Ns   'NoneType' is not iterablet   PyBytes_AS_STRINGR   t   is_tempi    t   PyBytes_GET_SIZERX   t   startt   stept   stopRY   i   Rz   (   RP   RY   R   R	   R   R
   t
   LetRefNodeR   R   t   PythonCapiCallNodeRV   t   PyBytes_AS_STRING_func_typet   PyBytes_GET_SIZE_func_typet   LetNodeR   t   SliceIndexNodeR'   (   R/   R   t
   slice_nodeRz   t   target_typet   unpack_temp_nodet   slice_base_nodet   len_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR   ,  s8    											t   kindt   datat   indext   lengtht   exception_values   -1c         C@  s  | j  r y t | j j d  d  } Wn t k
 r; q Xt j | j d t j | j d | d | d t	 j
 j t	 j |  j    d d  d t j | j d t t |   d t |  d t	 j d t j } |  j | | |  Sn  t j | j d	   } t j | j d d
 d d d t	 j } t j t	 j  } | j | j  }	 | rmd( \ }
 } |	 | } }	 n d) \ }
 } t j t	 j  } t j t	 j  } t j t	 j  } t j | j d |  j d | j | j  | j | j  | j | j j  g d t  } | j! | j j! k r<| j | j j! |  j    } n  t" j# d | j j d | j d |  } t" j$ | j d | | j% g } t" j& | j d | d |
 d | j | j j  d | d |	 d d  d | d | j' d t( 	} t" j) | j d  t j | j d! |  j* d | t j+ | j d" | j | j  d t	 j, t j+ | j d" | j | j  d t	 j- t j+ | j d" | j | j  d t	 j. g d t( d# t  d$ t/ j0 d% d&  } t j1 | t j2 | j d' | | | | g d t" j$ | j d | | g  S(*   Nt   latin1s	   iso8859-1RX   RJ   R(   RY   R   R   s   'NoneType' is not iterablet   0i    t   >s   >=s   <=t   <t   __Pyx_PyUnicode_READR   R   RV   RH   RI   RG   t   bound1t	   relation1RP   t	   relation2t   bound2R   RM   RN   t
   from_rangeR3   t   __Pyx_init_unicode_iterationRT   t   result_is_usedt   utility_codet   unicode_iters
   Optimize.cRO   (   R   s   >=(   s   <=R   (3   t
   is_literalR   RJ   t   encodet   UnicodeEncodeErrorR   R   RV   t	   BytesNodeR   t   c_const_char_ptr_typet	   coerce_tot   c_const_uchar_ptr_typeRh   R'   t   IntNodet   strR=   t   c_py_ssize_t_typeR	   R   R   R
   R   R   R[   R\   t
   c_int_typet   c_void_ptr_typeR   t   PyUnicode_READ_func_typeRP   R$   RY   R   R_   R^   RM   t   ForFromStatNodeRN   R   t   ExprStatNodet    init_unicode_iteration_func_typet   AmpersandNodet   c_py_ssize_t_ptr_typet   c_void_ptr_ptr_typet   c_int_ptr_typeR   R   R   Rd   (   R/   R   R   Rz   t   bytes_valuet   bytes_sliceR   t
   start_nodet   length_tempt   end_nodeR   R   t	   kind_tempt	   data_tempt   counter_tempt   target_valuet   target_assignRM   t	   loop_nodet
   setup_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR   b  s    		!													!	!	!c         C@  s  t  } t | t j  rq | j } t | j  } t | j  } d  } | sR| j	 j
 sj t | j d  n  | Sn| j rt | j t j  s t  | j } | j }	 t |	 j  } t |	 j  } t |	 j  } | rRt | j t  s(| j d k s(| j d k r| s(| j d k  rK| rK| j	 j
 sGt | j d  n  | S| j }
 | rd|
 }
 n  |
 d k  } t j | j d t j d t t |
   d t |
  } qRn | j	 j r/| j	 j d  k rt | j d  | S| } d  } t j | j d t | j	 j  d t j d | j	 j } d  } n# | j	 j
 sNt | j d  n  | S| rv| j t j |  j    } n  | r| j t j |  j    } n  | d  k r| rt j | j d d d t j d d } qt | j d  | Sn  | r3| s#t j | j d d	 d d d t j } n  | | } } n  | j	 } | j rT| j   } n  | j |  j    } | r| j d k rt j | j d
 | d d d | d | } n | } | r| j d k rt j | j d
 t j  |  d d d | d | j |  j    } n t j  |  } t! j" |  } | j# | j$ j  } | j	 j% r:| j$ j	 j
 r:| j	 t& j' k rt j( t j) | j$ j d | d | j* t j+  j | j$ j	 |  j    } qt j | j$ j d t j | j$ j d d	 d d d t j, d t j | j$ j d d d d d t j, d | d t& j- d d } n | j$ j	 j. rk| j$ j	 j/ | j*  rk| } nN t j0 | j$ j d t j | j$ j d d	 d d d t j, d | d | j* } | j	 | j$ j	 k r| j | j$ j	 |  j    } n  t1 j2 d | j$ j d | j$ d |  } t1 j3 | j d | | j4 g } |  j5 | |  \ } } t1 j6 | j d | d | d | d | d | d | d  | d! | j7 d" t8 	} t! j9 | j d# | g d  | S($   Ns*   C array iteration requires known end indexi    s8   C array iteration requires known step size and end indexRY   RJ   R(   s   -1iR   RE   RD   t   +RF   RT   R   R   t   1i   RX   R   R   RV   RH   RI   RG   R   R   RP   R   R   R   RM   RN   R   RO   (:   R$   R   R   R   RX   R)   R   R   R'   RY   t   is_pyobjectR   RV   RW   R   t	   SliceNodet   AssertionErrorR   R(   R   R   R   R   R   t   absR   t   sizeR   Rh   t   element_ptr_typet   coerce_to_simplet   AddNodet	   CloneNodeR
   R[   R\   RP   t	   is_stringR	   R   t   CastNodet   DereferenceNodeRZ   t   c_py_ucs4_typeR   R   R   t   assignable_fromt	   IndexNodeR   R_   R^   RM   t   _find_for_from_node_relationsR   RN   R   Rd   (   R/   R   R   Rz   t   neg_stept
   slice_baseR   R   R   R   t
   step_valuet   ptr_typet
   carray_ptrt   start_ptr_nodet   stop_ptr_nodet   counterR   R   R   RM   R   R   t   for_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR     s
   					
	$							(								c         C@  sl  | j  j } t |  d k r2 t | j d  | St |  d k rX t | j d  | S| j j sh | S| j j } t |  d k r | S| \ } } | j } | j r | j	 r | St |  d k r t
 | d  j | |  j    } n$ t j | j d d d | d	 d } t j |  }	 t j | j d
 |	 d t j | j d d d | d	 d d d d | d | j }
 t j d | j d | d |	  t j d | j d |	 d |
  g } t | j t j  r| | j j | j _ n. | j | j  t j | j j d | | _ | | _ | j j | j |  j    | _ | d | j _ t j |	 |  j | | j j   S(   Ni    s)   enumerate() requires an iterable argumenti   s%   enumerate() takes at most 2 argumentsi   RJ   R   RY   R(   RE   RF   R   RD   R   R   RV   RH   RI   RG   (   R   R   R=   R   RV   RP   t   is_sequence_constructorRY   R   R   R   R   Rh   R   R   R
   R   R   R   R_   R   RM   R^   RG   R0   t   itemRQ   RR   R   Rt   (   R/   R   t   enumerate_functionR   t   targetst   enumerate_targett   iterable_targett   counter_typeR   t   tempt   inc_expressiont	   loop_body(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR   b  sh    			%								!c         C@  s)   | r | r d Sd Sn | r! d Sd Sd  S(	   NR   s   <=R   s   >=(   R   s   <=(   R   s   >=(   s   >=R   (   s   <=R   (    (   R/   t   neg_step_valueRz   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR     s    c         C@  sZ  | j  j } t |  d k  rK | j } d } t j | d d d d } nc | d } | j } t | j t  st | S| j } | d k r | St j | d t	 |  d | } t |  d k r t j | j d d d d } | d j
 |  j    }	 n2 | d j
 |  j    } | d j
 |  j    }	 |  j | d k  |  \ }
 } d  } | rz|	 | } }	 t |  } | d k rzt | j t  rMt |	 j t  rM| d k  r|	 j } | j } | | | | d | d } n0 | j } |	 j } | | | | d | d } t j | j d t	 |  d | d	 t j | j |	 j  } qwt j |	  } |  j | | | |  } qzn  | d k  r| } n  t	 |  | _ | | _ | j
 |  j    } |	 j st } | pt j |	  }	 n t } t j | j d
 | j d | d |
 d | d |	 d | d | j d | j d t 	} | rVt j |	 |  } n  | S(   Ni   i   RJ   R   R(   i   i    R   RY   RP   R   R   R   R   R   RM   RN   R   (   R   R   R=   RV   R   R   R   R(   R   R   t   coerce_to_integerRh   R   R'   R   R   t   spanning_typeRY   R
   R   t   _build_range_step_calculationRJ   R   R   R$   R   R   RP   RM   RN   R   (   R/   R   t   range_functionRz   R   t   step_posR   R   R   R   R   R   t   bound2_ref_nodet   abs_stept   begin_valuet	   end_valuet   bound1_valuet   bound2_is_tempR  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR     sz    	
						!		
						c      !   C@  s  t  |  } t j | j | j  } | j j rT | d k  rT t j | t j  } n t j | | j  } | d k  r | } | }	 d }
 n | } | }	 d }
 t j | j d t j | j d | d |
 d t j	 | j d t j
 | j d t |  d	 | d
 | d d d t j | j d t j | j d t j | j d | d d d |	 d
 | d d d t j
 | j d d d	 d d
 | d d d t j
 | j d t |  d	 | d
 | d
 | d
 | d
 | d |
 d t j
 | j d d d	 d d
 | } | S(   Ni  i    t   -R   RE   RD   RF   RJ   R(   RY   t   *R   i   s   //(   R   R   R  RY   R   R   R   t
   binop_nodeRV   t   MulNodeR   R   t   DivNodet   SubNode(   R/   R   R  R   R   R  R  t   spanning_step_typeR  R  t   final_opt   step_calculation_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  	  st    																					c         @  s  g  } t  j t j  } | j |  | j | j  } t  j t j  } | j |  | j   j  }	 d  }
 } } | r | r   j	 j
 r t   j	 j  d k r   j	 j \ }
 } q   Sq   j	 } n | r   j	 }
 n	   j	 } t   j t j  r
  j } n$ t j d   j j d   j g  } t  j t j  } | j |  t j   j d | j | j  d t j | j  } t  j t j  } | j |  | j   j  } t j   j d | d t j | j  } t j | | j | j  |	 |
 | | |  } | j |  j    } | g | j d d +| rxt j | j d t d | } | j d	 d
 d d | g } n! t j | j  } | j d  }   f d   } t j   j d |	 d t j   j d d d d t j | j d | d t j  | j d |  j! d t" j# d d  d | | | j t$ j% k  | | | g d t t j&   j d d  d | d   j' g } t  j(   j d | d t j   j d | S(   Ni   RV   RG   RT   RY   i    t   is_identifierRJ   s'   'NoneType' object has no attribute '%s'R   t   PyExc_AttributeErrort   format_argss!   'NoneType' object is not iterablec         @  s4   |  r d p d }  t  j   j d t |   d |  S(   Ni   i    RJ   R(   (   R   R   RV   R   (   RJ   (   R   (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt	   flag_node  s    RH   RI   R   R(   t   __Pyx_dict_iteratorR   t	   dict_iters
   Optimize.cR   R   RL   RM   RN   RO   ()   R
   R[   R   t   py_object_typeR0   R\   RV   R   R'   RP   R  R=   R   R   RM   R   R^   R   R   t
   c_ptr_typeRY   R   t   DictIterationNextNodeRg   Rh   RG   t
   StringNodeR   R   t   NullNodeR_   R   R   t   PyDict_Iterator_func_typeR   R   R	   R   t   WhileStatNodeRN   Rd   (   R/   R   Rv   Rw   Rx   Ry   RO   R  t	   dict_tempt   pos_tempt
   key_targett   value_targett   tuple_targetRM   t   dict_len_tempt   dict_len_temp_addrt   is_dict_tempt   is_dict_temp_addrt   iter_next_nodet   method_nodeR(  t   result_code(    (   R   s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR   I  s    										R|   t   is_dictt   method_namet   p_orig_lengtht	   p_is_dictN($   R8   R9   R:   Rs   Ru   R$   Rt   R   R   t	   CFuncTypet   c_char_ptr_typet   CFuncTypeArgR	   R   R'   R   R   R   R   R   R   R   R   R+  R   R   R   R   R   R   R   R   R   R  R   R0  (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRC      sL   	1	Q	&	\	I	R	@	ct   SwitchTransformc           B@  sz   e  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 j j Z RS(   s   
    This transformation tries to turn long if statements into C switch statements.
    The requirement is that every clause be an (or of) var == value, where the var
    is common among all clauses and both var and value are ints.
    c   
      C@  s[  x t  r t | t j t j f  r0 | j } q t | t j  rQ | j j } q t | t j  ro | j	 } q t | t j
  r | j } q Pq Wt | t j  r| j d  k	 r |  j S| j   rNt | j t j t j f  rN| j d k } | r| r|  j St | j t j  r2| j j   r2|  j S| | j |  j | j  f S| j   sT| j d k rrt } n% | r| j d k rt  } n |  j St | j | j  r| j j r| | j | j g f St | j d d   r| j j j r| | j | j g f Sn  t | j | j  r| j j rB| | j | j g f St | j d d   r| j j j r| | j | j g f SqqTn t | t j  rT| j d k s| rT| j d k rT| j d k } |  j  | j |  \ } } } |  j  | j |  \ } } }	 | d  k	 rQ| | k rQt | |  rQ| s:| rN| | | |	 f SqQqTn  |  j S(   NRS   s   ==s   !=R   t   ort   and(!   R   R   R   t   CoerceToTempNodet   CoerceToBooleanNodeR   t   BoolBinopResultNodeR
   t   EvalWithTempExprNodet   subexpressiont   TypecastNodeRT   R]   t   cascadeR'   t   NO_MATCHt   is_c_string_containsRF   t   UnicodeNodeR   RD   t   contains_surrogatesRE   t   extract_in_string_conditionst   is_python_comparisonR$   R!   R   t   getattrR   t   is_constt   BoolBinopNodet   extract_conditions(
   R/   t   condt   allow_not_inRS   t   not_in_1t   t1t   c1t   not_in_2t   t2t   c2(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRX    sd    			$'c         C@  s   t  | t j  ro t t t t | j    } | j   g  | D]* } t j	 | j
 d t |  d | ^ qA S| j } t t g  t t |   D] } | | | d !^ q   } | j   g  | D]$ } t j | j
 d | d | ^ q Sd  S(   NRJ   R(   i   (   R   R   RQ  t   listt   mapt   ordt   setRJ   t   sortR   RV   R   R   R=   t   CharNode(   R/   t   string_literalt   charvalst   charvalt
   characterst   i(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRS    s    
2	<
c         C@  s   |  j  | |  \ } } } | d  k r. |  j S| d  k	 rQ t | |  rQ |  j S| j j pf | j j s t g  | D] } | j j p | j j ^ qt  r |  j S| | | f S(   N(   RX  R'   RO  R!   RY   R   t   is_enumt   sum(   R/   t
   common_varRL   RZ  RS   t   vart
   conditionsRY  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   extract_common_conditions  s    Kc         C@  s   t    } x | D]z } | j   rH | j | k r5 t S| j | j  q y | j j | k ra t SWn t k
 rv t SX| j | j j  q Wt S(   N(	   Rd  t   has_constant_resultR(   R   t   addR   t   cnamet   AttributeErrorR$   (   R/   t   condition_valuest   seenRJ   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   has_duplicate_values  s    	c      	   C@  sR  |  j  j d  s# |  j |  | Sd  } g  } xz | j D]o } |  j | | j t  \ } } } | d  k r} |  j |  | S| j t	 j
 d | j d | d | j   q9 Wg  | D] } | j D] } | ^ q q }	 t |	  d k  r |  j |  | S|  j |	  r|  j |  | St |  } t	 j d | j d | d | d | j  }
 |
 S(	   Ns   optimize.use_switchRV   Rp  RM   i   t   testt   casesRN   (   t   current_directivest   getR1   R'   RK   Rq  RL   R$   R0   R   t   SwitchCaseNodeRV   RM   Rp  R=   Rx  R   t   SwitchStatNodeRN   (   R/   R   Rn  Rz  t	   if_clauset   _Rp  t   caseRY  Rv  t   switch_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_IfStatNode*  s6    )c         C@  s   |  j  j d  s# |  j |  | S|  j d  | j t  \ } } } | d  k sq t |  d k  sq |  j |  r |  j |  | S|  j	 | | | | | j
 | j  S(   Ns   optimize.use_switchi   (   R{  R|  R1   Rq  R'   Ry  R   R=   Rx  t   build_simple_switch_statementt   true_valt	   false_val(   R/   R   RS   Rn  Rp  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_CondExprNodeK  s    c         C@  s   |  j  j d  s# |  j |  | S|  j d  | t  \ } } } | d  k sn t |  d k  sn |  j |  r |  j |  | j |  j	    | S|  j
 | | | | t j | j d t d t t j | j d t d t  S(   Ns   optimize.use_switchi   RJ   R(   (   R{  R|  R1   Rq  R'   R   R=   Rx  t   wrap_operandsRh   R  R   R`   RV   R$   (   R/   R   RS   Rn  Rp  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_BoolBinopNode[  s    c         C@  s   |  j  j d  s# |  j |  | S|  j d  | t  \ } } } | d  k sn t |  d k  sn |  j |  r |  j |  | S|  j | | | | t	 j
 | j d t d t t	 j
 | j d t d t  S(   Ns   optimize.use_switchi   RJ   R(   (   R{  R|  R1   Rq  R'   R   R=   Rx  R  R   R`   RV   R$   (   R/   R   RS   Rn  Rp  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRs   n  s    c      	   C@  s  t  j |  } t j | j d | d | j | j |  j    d t } t j | j d | d | j | j |  j    d t }	 | r |	 | } }	 n  t j	 d | j d | d |  g }
 t
 |  } t j d | j d | d |
 d	 |	  } t  j | |  } | S(
   NRH   RI   t   firstRV   Rp  RM   Ry  Rz  RN   (   R
   R   R   R_   RV   R   RY   Rh   R   R}  R   R~  Rj   (   R/   R   Rn  Rp  RS   R  R  Rl   t	   true_bodyt
   false_bodyRz  R  t   replacement(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s.    					c         C@  st   |  j  j d  s# |  j |  | S| j } | j } |  j |  | j | k	 rp t j | j |  sp | j Sn  | S(   Ns   optimize.use_switch(   R{  R|  R1   RL  t	   lazy_tempR   t   tree_contains(   R/   R   t	   orig_exprt   temp_ref(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_EvalWithTempExprNode  s    		
N(   NNN(   R8   R9   R:   R'   RO  RX  RS  Rq  Rx  R  R  R  Rs   R  R  R   t   VisitorTransformt   recurse_to_childrenR;   (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRE    s   	=		
		!					t   FlattenInListTransformc           B@  s#   e  Z d  Z d   Z e j j Z RS(   sj   
    This transformation flattens "x in [val1, ..., valn]" into a sequential list
    of comparisons.
    c         @  s  |  j     j d  k	 r   S j d k r> d   d } n"  j d k r\ d   d } n  St  j t j t j t j	 f  s  S j j
 } t |  d k r  St j  j  } g  } g  } x | D] } y | j   } Wn t k
 r t } n X| s$t j |  } | j |  n  t j d  j d	 | d
 | d | d d   }	 | j t j d  j d |	 d t j   q W   f d   }
 t |
 |  } t j | |  } x- | d  d  d  D] } t j | |  } qW| S(   Nt   inRF  s   ==RS   RG  s   !=i    RV   RE   RD   RF   RN  RT   RY   c      	   @  s%   t  j d  j d   d |  d |  S(   NRV   RD   RE   RF   (   R   RW  RV   (   t   leftt   right(   t   conjunctionR   (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   concat  s
    		i(   R1   RN  R'   RD   R   RF   R   t	   TupleNodet   ListNodet   SetNodeR   R=   R
   R   RE   t	   is_simplet	   ExceptionR$   R   R0   R]   RV   RM  R   t   c_bint_typeR   RK  (   R/   R   t	   eq_or_neqR   RH   t   condsRO   R   t   is_simple_argRY  R  RL   Rr   R  (    (   R  R   s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRs     sX    		
				(   R8   R9   R:   Rs   R   R  R  R;   (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s   	?t   DropRefcountingTransformc           B@  s5   e  Z d  Z e j j Z d   Z d   Z d   Z	 RS(   s&   Drop ref-counting in safe places.
    c         C@  s  g  g  } } g  g  } } g  } x~ | j  D]s } t | t j  r |  j | j | | |  sa | S|  j | j | | |  s | Sq* t | t j  r | S| Sq* W| s | r,g  | D] \ } }	 | ^ q }
 g  | D] \ } }	 | ^ q } t |
  t |  k r| St	 t |
   t	 |  k r,| Sn  | s8| rg  } x4 | D], } |  j
 |  } | sd| S| j |  qEWg  } x4 | D], } |  j
 |  } | s| S| j |  qWt |  t |  k r| St	 t |   t	 |  k r| S| Sg  | D] } | j ^ q} x | D] } t | _ qWx0 | | D]$ \ } } | | k r5t | _ q5q5Wx | | D] } t | _ qhW| S(   sF   
        Parallel swap assignments like 'a,b = b,a' are safe.
        (   RG   R   R   R_   t   _extract_operandRH   RI   t   CascadedAssignmentNodeRd  R=   t   _extract_index_idR0   R   R$   t   use_managed_ref(   R/   R   t
   left_namest   right_namest   left_indicest   right_indicesRO   t   statt   patht   nt   lnamest   rnamest   lindicest   lhs_nodet   index_idt   rindicest   rhs_nodet   tt	   temp_argsR  R  t	   name_nodet
   index_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_ParallelAssignmentNode  s`    c         C@  s+  t  |  } | j j s t St | t j  rG | j |  | j } n  g  } | } x3 | j	 r | j
 rl t S| j | j  | j } qV W| j r | j | j  | j d j | d  d  d   | f  nY | j r#| j j t j k r t S| j j j st S| j j st S| j |  n t St S(   Nt   .i(   R   RY   R   R$   R   R   RH  R0   R   R   R    t   memberR"   R   R   t   joinRW   RX   R	   R   R   R   R   (   R/   R   t   namest   indicesRO   t	   name_patht   obj_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  A  s4    		,	c         C@  sW   | j  } | j } t | t j  r0 | j } n t | t j  rF d  Sd  S| j | f S(   N(   RX   R   R   R   R   R   t	   ConstNodeR'   (   R/   R  RX   R   t	   index_val(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  ^  s    		(
   R8   R9   R:   R   R  R  R;   R  R  R  (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s
   	E	t   EarlyReplaceBuiltinCallsc           B@  s%  e  Z d  Z e j j Z d   Z d   Z d   Z	 d d  Z d d  Z d d  Z d   Z d   Z d	   Z d
   Z d   Z d   Z e j e j e j d e j d  g  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& RS(   s  Optimize some common calls to builtin types *before* the type
    analysis phase and *after* the declarations analysis phase.

    This transform cannot make use of any argument types, but it can
    restructure the tree in a way that the type analysis phase can
    respond to.

    Introducing C function calls here may not be a good idea.  Move
    them to the OptimizeBuiltinCalls transform instead, which runs
    after type analysis.
    c         C@  s?   |  j  |  | j } |  j |  s) | S|  j | | | j  S(   N(   R1   R   t   _function_is_builtin_namet   _dispatch_to_handlerR   (   R/   R   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_SimpleCallNodez  s
    	c         C@  sj   |  j  |  | j } |  j |  s) | S| j } t | t j  sH | S| j } |  j | | | | j	  S(   N(
   R1   R   R  t   positional_argsR   R   R  R   R  t   keyword_args(   R/   R   R   R   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_GeneralCallNode  s    			c         C@  sQ   | j  s t S|  j   } | j | j  } | | j   j | j  k	 rM t St S(   N(   R   R$   Rh   t   lookupR   t   builtin_scopet   lookup_hereR   (   R/   R   t   envR   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    	c         C@  sw   | d  k r d | j } n d | j } t |  | d   } | d  k	 rs | d  k r` | | |  S| | | |  Sn  | S(   Ns   _handle_simple_function_%ss   _handle_general_function_%s(   R'   R   RU  (   R/   R   R   R   t   kwargst   handler_namet   handle_call(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    c         C@  s1   t  j | j j | j j | | d | | _ d  S(   NR   (   R   t   PythonCapiFunctionNodeR   RV   R   (   R/   R   Rt  t	   func_typeR   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _inject_capi_function  s    c         C@  s   | s d } n? t  | t  s* | d k r3 d } n | d k rH d } n d } | d  k	 rg d | } n d } t | j d | | | t |  f  d  S(   Nt    i   s   ...t   xs   expected %s, s3   %s(%s) called with wrong number of args, %sfound %d(   R   R   R'   R   RV   R=   (   R/   t   function_nameR   R   t   expectedt   arg_strt   expected_str(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _error_wrong_arg_count  s    			c         C@  s   | s t  j | j d d St |  d k rG |  j d | | d  n  t | d d d   } | t j t	 j
 f k r} | d S| S(   NRJ   s   0.0i   t   floati    RY   (   R   t	   FloatNodeRV   R=   R  RU  R'   R   t   c_double_typeR	   t
   float_type(   R/   R   t   pos_argst   arg_type(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_float  s    c      	   C@  s   t  |  } d  } } | d k r. | \ } nP | d k rI | \ } } n5 | d k rg | \ } } } n |  j d | |  | St j | j d | p t j | j  d | d | p t j | j  S(   Ni   i   i   t   sliceR   R   R   (   R=   R'   R  R   R   RV   t   NoneNode(   R/   R   R  R   R   R   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_slice  s    
	c      	   C@  s  t  |  d k r | S| d } t | t j t j f  r t  | j  d k rt j | j d t j	 d t
 t | j   d t | j  Sn t | t j  r| j rt  | j  d k rt | j  d k rt j | j d t j d t
 t | j   d t | j  Sn  | S(   s   Unpack ord('X').
        i   i    RY   RJ   R(   i   (   R=   R   R   RQ  R   RJ   R   RV   R   t   c_long_typeR   Rc  R.  t   unicode_valueR   (   R/   R   R  R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_ord  s"    
c         C@  s   |  j  | | t  S(   s   Transform

        _result = all(p(x) for L in LL for x in L)

        into

        for L in LL:
            for x in L:
                if not p(x):
                    return False
        else:
            return True
        (   t   _transform_any_allR$   (   R/   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_all  s    c         C@  s   |  j  | | t  S(   s   Transform

        _result = any(p(x) for L in LL for x in L)

        into

        for L in LL:
            for x in L:
                if p(x):
                    return True
        else:
            return False
        (   R  R   (   R/   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_any   s    c         C@  sk  t  |  d k r | St | d t j  s0 | S| d } | j j } | j } t |  \ } } | d  k rq | S| r | }	 n t j	 | j
 d | }	 t j | j
 d d  d t j | j
 d |	 d t j | j
 d t j | j
 d | d	 | g }
 t j | j
 d t j | j
 d | d	 | | _ t j | | |
  t j | j
 d
 | d | rdd n d S(   Ni   i    RT   RN   RK   RL   RM   RJ   R(   t   gent	   orig_funct   anyt   all(   R=   R   R   t   GeneratorExpressionNodet   def_nodet   gbodyRM   R?   R'   Rk   RV   R   Rb   Rc   t   ReturnStatNodeR`   RN   R   t   recursively_replace_nodet   InlinedGeneratorExpressionNode(   R/   R   R  t   is_anyt   gen_expr_nodet   generator_bodyR   t   yield_expressiont   yield_stat_nodeRL   t	   test_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s6    
				*	&t   itc      	   C@  s'  t  |  d k r | S| d } t | t j  rZ | j t j k rZ | d } | j } n t | t j  r| } | j } t	 |  } | s | St j
 | j | d d d t j } x | D]@ \ } }	 t j | j d | d | j }
 t j | |	 |
  q WnG | j r| j   } } n+ t j | j d |  j d	 | d
 t } } t j d | j d t j d t  } t j | j d | d | d t } t j | j d | d t d  d t } t j | j d t j | j d | d	 g  } | j |  j    t j  | t j! | j d | | g  S(   s  Transform sorted(genexpr) and sorted([listcomp]) into
        [listcomp].sort().  CPython just reads the iterable into a
        list and calls .sort() on it.  Expanding the iterable in a
        listcomp is still faster and the result can be sorted in
        place.
        i   i    R  t   sortedt   comprehension_typeR3   RP   t   PySequence_ListR   R   RV   RY   t   may_hold_noneRH   RI   R  R"   R#   Re  t   needs_none_checkR   RG   ("   R=   R   R   t   ComprehensionNodeRY   R	   R   t   loopR  R<   R  RV   t   ComprehensionAppendNodeRP   R   R  R  t   as_listR   t   PySequence_List_func_typeR   R
   R   R$   R   R_   R   R   R   R   t   analyse_declarationsRh   Rj   R^   (   R/   R   R  R   t	   list_nodeR   R  R>   R  R  t   append_nodet   result_nodet   list_assign_nodet   sort_methodt	   sort_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_sorted8  sP    
$
					c         C@  s  t  |  d k r | St | d t j t j f  s9 | S| d } | j } t | t j  r t |  \ } } d } | d k r | SnF | j } | j	 } y | j
 s | j j r | SWn t k
 r | SXt  |  d k rt j | j d d d d } n
 | d } t j d | j d t j  } t j | j d	 | d
 t j | j d | |  }	 t j | | |	  t j | j d t j | j d	 t j d | j d |  d
 | d t | g }
 t j | j d |
 d | d | j d d d | j S(   sL   Transform sum(genexpr) into an equivalent inlined aggregation loop.
        i   i   i    RJ   R   R(   RV   RY   RH   RI   R   RG   R   R  R  R  t
   expr_scopeR  Rm  t   has_local_scope(   i   i   N(   R=   R   R   R  R  R  R?   R'   R0   R3   R   RY   R   Ru  R   RV   R
   R   R   R+  R   R_   R  R   R  R^   R   R  R  R  (   R/   R   R  R  R   R  R  R   Rl   t   add_nodet	   exec_code(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   __handle_simple_function_sumx  sP    
			!
			c         C@  s   |  j  | | d  S(   NR   (   t   _optimise_min_max(   R/   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_min  s    c         C@  s   |  j  | | d  S(   NR   (   R  (   R/   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_max  s    c   	      C@  s(  t  |  d k rZ t  |  d k rA | d j rA | d j } n  t  |  d k rZ | Sn  t t t j | d   } | d } xq | D]i } t j |  } t j | j	 d | d | d t j
 | j	 d | d | d | } t j | |  } q Wx- | d	 d	 d
  D] } t j | |  } qW| S(   sK   Replace min(a,b,...) and max(a,b,...) by explicit comparison code.
        i   i    R  R  Ry  RE   RD   RF   Ni(   R=   R  R   Ra  Rb  R
   R   R   t   CondExprNodeRV   R]   RK  (	   R/   R   R   RD   t   cascaded_nodest   last_resultt   arg_nodeRl   t   ref_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s,    
		c         C@  s`   | s" t  j | j d g  d d S|  j | | t j  } | | k	 r\ t  j | j d | S| S(   NR   R(   R   (    (   R   R  RV   t   _transform_list_set_genexprR	   R   t   AsTupleNode(   R/   R   R  t   result(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt&   _DISABLED_handle_simple_function_tuple  s    c         C@  sl   t  |  d k r | S| d j r; | d j r; | d =n- t | d t j  rh | d j   | d <n  | S(   sS   Replace frozenset([...]) by frozenset((...)) as tuples are more efficient.
        i   i    (   R=   R  R   R   R   R  t   as_tuple(   R/   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt!   _handle_simple_function_frozenset  s    
c         C@  s8   | s" t  j | j d g  d g  S|  j | | t j  S(   NR   R(   (   R   R  RV   R  R	   R   (   R/   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_list  s    c         C@  s;   | s% t  j | j d g  d t   S|  j | | t j  S(   NR   R(   (   R   R  RV   Rd  R  R	   t   set_type(   R/   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_set  s    c         C@  s   t  |  d k r | St | d t j  s0 | S| d } | j } t |  } | sY | St j | j | d | t j	 k r d n d d | } xH | D]@ \ } }	 t j
 | j d | d | j }
 t j | |	 |
  q W| S(	   sL   Replace set(genexpr) and list(genexpr) by an inlined comprehension.
        i   i    R  Rd  Ra  R  R3   RP   (   R=   R   R   R  R  R<   R  RV   R	   R$  R  RP   R   R  (   R/   R   R  R   R  R   R>   R  R  R  R
  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s(    
			c      	   C@  sT  t  |  d k r. t j | j d g  d i  St  |  d k rD | St | d t j  s^ | S| d } | j } t |  } | s | SxC | D]; \ } } t | t j  s | St  | j	  d k r | Sq Wt j
 | j | d d d t j } x\ | D]T \ } }	 t j | j d	 | j	 d d
 | j	 d d | j }
 t j | |	 |
  q W| S(   sD   Replace dict( (a,b) for ... ) by an inlined { a:b for ... }
        i    t   key_value_pairsR(   i   i   R  R|   R  t   key_exprt
   value_exprRP   (   R=   R   t   DictNodeRV   R   R  R  R<   R  R   R  R	   R   t   DictComprehensionAppendNodeRP   R   R  (   R/   R   R  R  R   R>   R  R  R  R  R
  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_dict  s6    
		c         C@  s0   t  |  d k r | St | t j  s, | S| S(   sl   Replace dict(a=b,c=d,...) by the underlying keyword dict
        construction which is done anyway.
        i    (   R=   R   R   R)  (   R/   R   R  R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_general_function_dictA  s
    N('   R8   R9   R:   R   R  R  R;   R  R  R  R'   R  R  R  R  R  R  R  R  R  R   RB  R	   R   RD  R+  R  R  t5   _EarlyReplaceBuiltinCalls__handle_simple_function_sumR  R  R  R   R"  R#  R%  R  R+  R,  (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  k  s:   			
	
					$	@	:			#						&t   InlineDefNodeCallsc           B@  s&   e  Z e j j Z d    Z d   Z RS(   c         C@  ss   | j  d  k r d  S| j  j r# d  S|  j   j | j  } | sa | j sa t | j  d k re d  S| j d j S(   Ni   i    (	   t   cf_stateR'   t
   cf_is_nullRh   R  R   t   cf_assignmentsR=   RI   (   R/   R  R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   get_constant_value_nodeO  s    c         C@  s   |  j  |  |  j j d  s# | S| j } | j s9 | S|  j |  } t | t j  s^ | St j	 | j
 d | d | d | j } | j   r |  j | |  S| S(   Ns   optimize.inline_defnode_callsR  R   R   (   R1   R{  R|  R   R   R2  R   R   t   PyCFunctionNodet   InlinedDefNodeCallNodeRV   R   t   can_be_inlinedt   replace(   R/   R   R  R   t   inlined(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  [  s    		(   R8   R9   R   R  R  R;   R2  R  (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR.  L  s   	t   OptimizeBuiltinCallsc           B@  s  e  Z d  Z d   Z d   Z d   Z d   Z e j e j	 e j
 d e j	 d  g  Z d   Z d   Z e j e j e j
 d e j d  e j
 d	 e j d  e j
 d
 e j d  g d d d e Z d   Z e d   e j e j e j f D  Z d   Z d d  Z d   Z d   Z e j e j  e j
 d e j  d  g  Z! d   Z" e j e j# e j
 d e j	 d  g  Z$ d   Z% e j e j& e j
 d e j# d  g  Z' e j e j& e j
 d e j	 d  g  Z( d   Z) e j e j* e j
 d e j	 d  g  Z+ d   Z, e j e j- e j
 d e j	 d  g  Z. d   Z/ e j e j e j
 d e j	 d  g d d d e Z0 d   Z1 e j e j	 e j
 d e j	 d  g  Z2 e j e j	 e j
 d e j d  g  Z3 d    Z4 d!   Z5 e j e j6 e j
 d e j7 d  g  Z8 e j e j6 e j
 d" e j9 d  g  Z: e j e j e j
 d e j	 d  g d d# Z; i d$ e j< 6d% e j 6d& e j# 6d' e j& 6d( e j* 6d( e j- 6d) e j  6j= Z> e? d* g  Z@ d+   ZA e j e jB e j
 d, e j	 d  g  ZC d-   ZD e j e jE e j
 d. e j	 d  g  ZF d/   ZG d0   ZH e j e j	 e j
 d1 e j	 d  e j
 d2 e j& d  g  ZI e j e j	 e j
 d1 e j	 d  e j
 d2 e j& d  e j
 d3 e j  d  g  ZJ d d4  ZK e j e jL e j
 d e j	 d  e j
 d5 e j	 d  g d d# ZM d6   ZN e j e jL e j
 d7 e j	 d  e j
 d e j d  g d d# ZO e j e jL e j
 d7 e j	 d  e j
 d e j	 d  g d d# ZP d8   ZQ e j e j	 e j
 d e j	 d  g  ZR e j e j	 e j
 d e j	 d  e j
 d9 e j	 d  e j
 d: e j d  e j
 d; e j d  g d< e ZS d=   ZT eU d>  ZV e j e jL e j
 d e j	 d  g d d# ZW d?   ZX e j e j	 e j
 d e j	 d  e j
 d@ e j	 d  e j
 dA e j	 d  g  ZY dB   ZZ e j e j	 e j
 d e j	 d  e j
 d@ e j	 d  e j
 dA e j	 d  e j
 dC e j d  g  Z[ dD   Z\ e j e j	 e j
 dE e j	 d  e j
 dF e j	 d  e j
 dG e j] d  e j
 dH e jE d  g  Z^ e j e j	 e j
 dE e j	 d  e j
 dF e j	 d  e j
 dI e j d  e j
 dH e jE d  g  Z_ dJ   Z` dK   Za dL   Zb dM   Zc dN   Zd dO   Ze dP   Zf dQ   Zg dR   Zh dS   Zi dT   Zj dU   Zk dV   Zl dW   Zm dX   Zn dY   Zo dZ   Zp d[   Zq d\   Zr d]   Zs d^   Zt e j e jE e j
 d_ e ju d  g  Zv d`   Zw ew Zx ew Zy ew Zz ew Z{ ew Z| ew Z} ew Z~ ew Z ew Z e j e ju e j
 d_ e ju d  g  Z da   Z e Z e Z e Z e j e j# e j
 db e j< d  e j
 dc e jE d  g  Z dd   Z e j e j# e j
 db e j< d  e j
 de e j	 d  e j
 df e j d  g  Z dg   Z e j e j< e j
 db e j< d  e j
 dh e j	 d  g  Z di   Z e j e jE e j
 db e j	 d  e j
 dj e j	 d  e j
 dk e j d  e j
 dl e j d  e j
 dm e j d  g d d# Z dn   Z do   Z dp   Z e j e j e j
 db e j< d  e j
 dj e j	 d  e j
 dk e j d  e j
 dl e j d  e j
 dm e j d  g d dq Z dr   Z ds   Z dt   Z e j e j e j
 db e j< d  e j
 dj e j	 d  e j
 dk e j d  e j
 dl e j d  g d d# Z du   Z e j e j< e j
 db e j< d  e j
 dj e j	 d  e j
 dv e j	 d  e j
 dw e j d  g  Z dx   Z e j e j e j
 d e j< d  e j
 dy e j7 d  e j
 dz e j7 d  g  Z e j e j e j
 d e j< d  g  Z d{ d| d} d~ d d g Z g  e D] Z e e j e  f ^ qqZ d   Z e j e j e j< e j
 d e j7 d  e j
 d e j d  e j
 dz e j7 d  g   Z e j e j< e j
 d e j7 d  e j
 dk e j d  e j
 d e j d  e j
 dy e j7 d  e j
 dz e j7 d  e j
 d e d  g  Z e j e j< e j
 d e j	 d  e j
 dk e j d  e j
 d e j d  e j
 dy e j7 d  e j
 dz e j7 d  e j
 d e d  g  Z d Z d   Z e Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z d d d e j j e d  Z d   Z d   Z RS(   s<  Optimize some common methods calls and instantiation patterns
    for builtin types *after* the type analysis phase.

    Running after type analysis, this transform can only perform
    function replacements that do not alter the function return type
    in a way that was not anticipated by the type analysis.
    c         C@  sE   | j  } |  j |  | | j  k s: | j  j | j k r> | S| j  S(   s:   Flatten redundant type checks after tree changes.
        (   R   R1   RY   (   R/   R   t   old_arg(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _visit_PyTypeTestNodex  s
    	$c         C@  s-   |  j  |  | j | j j k r) | j S| S(   s,   
        Drop redundant type casts.
        (   R1   RY   RT   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _visit_TypecastNode  s    c         C@  s8   |  j  |  t | j t j  r4 | j j | _ n  | S(   s)   
        Drop useless coercions.
        (   R1   R   R3   R   t   CoerceToPyTypeNodeR   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR4     s    c         C@  s~   |  j  |  | j } t | t j  r4 | j } n  t | t j  rz | j t j t	 j
 f k rz | j j |  j    Sn  | S(   s<   Drop redundant conversion nodes after tree changes.
        (   R1   R   R   R   t   PyTypeTestNodeR<  RY   R   R+  R	   t	   bool_typet   coerce_to_booleanRh   (   R/   R   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_CoerceToBooleanNode  s    	t   oc         C@  s   |  j  |  | j } t | t j  r4 | j } n  t | t j  r | j j d k r t | j	  d k r | j	 d } | j
 t j k r | j d  S| j
 j r t j | j d |  j d | g d d d | j d	 | j j | j
 |  j    Sq n  | S(
   s3   Drop redundant conversion nodes after tree changes.R  i   i    s=   float() argument must be a string or a number, not 'NoneType't   __Pyx_PyNumber_FloatR   t   py_nameR   R   (   R1   R   R   R   t   CoerceFromPyTypeNodeR   R   R   R=   R   RY   R	   R  R   R   RV   t   PyNumber_Float_func_typeR   R   R   Rh   (   R/   R   R   t   func_arg(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_CoerceToPyTypeNode  s$    	'		c         C@  s0  |  j  |  | j } | j j sV | j | j k rR | j | j |  j    } n  | St | t j  rt | j } n  | j	 r | j j
 r t | t j  s | j j r t | t j  s | j j
 r,t | t j  r,| j | j |  j    Sn9t | t j  r| j t j k rN| j j | j j  r| j j | j |  j    Sq,| j t j k r,| j j j r| j j r| j j | j |  j    Sq,n t | t j  r| j j
 s| j j r,|  j | |  SnR | j r,| j } t | t j  r
| j } n  | j j
 r,|  j | | |  Sn  | S(   s   Drop redundant conversion nodes after tree changes.

        Also, optimise away calls to Python's builtin int() and
        float() if the result is going to be coerced back into a C
        type anyway.
        (   R1   R   RY   R   R   Rh   R   R   R=  R   R   R   t   is_floatR  R`   R<  R   R+  R   R	   R   t   is_unicode_charR   t   _optimise_numeric_cast_callRW   R   t   _optimise_int_indexing(   R/   R   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_CoerceFromPyTypeNode  s<    		"		t   bytesR   t   check_boundsR   s
   ((char)-1)t   exception_checkc         C@  s  |  j    } | j d r d p" d } | j j t j k r| j t j t j f k rt	 j
 | j d t |  d | } t	 j | j d |  j d | j j d  | j t j |  | g d	 t d
 t j d d  } | j t j k	 r | j | j |  } n  | Sn  | S(   Nt   boundschecki   i    RJ   R(   t   __Pyx_PyBytes_GetItemIntR   s&   'NoneType' object is not subscriptableR   R   t   bytes_indexs   StringTools.c(   Rh   t
   directivesRX   RY   R	   R   R   t   c_char_typet   c_uchar_typeR   R   RV   R   R   t   PyBytes_GetItemInt_func_typeR   R   R   R   R   R   (   R/   t   coerce_nodeR   R  R  t   bound_check_boolt   bound_check_nodeR   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRK    s(    				c         c@  s9   |  ]/ } | t  j | t  j d  | d  g  f Vq d S(   R   N(   R   RB  RD  R'   (   t   .0R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pys	   <genexpr>	  s   c         C@  sr  | j  } d  } t | t j  r- | j } nE t | t j  rr | j j rr t | j	 t j
  rr | j	 j } qr n  | d  k s t |  d k r | S| d } t | t j  r | j } n | j j r | S| j d k r| j j s | j j rL| j | j k r	| S| j j | j  s*| j j rt j | j d | d | j Sqn| j j rn| j j rn| j j d k rd } n d | j j } t j | j | d	 |  j | j d
 | g d d d | j d | j j | j |  j    Sn | j d k rn| j j s| j j rn| j | j k r(| S| j j | j  sI| j j rkt j | j d | d | j Sqnn  | S(   Ni   i    t   intRT   RY   t   lt   __Pyx_trunclt   truncR  R   RC  R   R   R  (   R   R'   R   R   R   R   R   RY   t   is_builtin_typeR   R  R=   R<  R   R   R   R   R   RH  RM  RV   t
   is_numerict   math_h_modifiert   float_float_func_typesR   R   R   Rh   (   R/   R   R   R   R   RF  t   truncl(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRJ    sP    	!
!"			!c         C@  s   | s d } n? t  | t  s* | d k r3 d } n | d k rH d } n d } | d  k	 rg d | } n d } t | j d | | | t |  f  d  S(   NR  i   s   ...R  s   expected %s, s3   %s(%s) called with wrong number of args, %sfound %d(   R   R   R'   R   RV   R=   (   R/   R  R   R   R  R  R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  >  s    			c         C@  s   | S(   N(    (   R/   R   R  R   t   arg_listR  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_functionP  s    c         C@  sG  | r
 | S| s( | j  s( | j j r, | S|  j   j |  } | sK | St j | j j d t j	 | j d | d | d | j
 d | d t j |  j    }	 |	 d	 k r | S| j }
 |
 d	 k r | j r | j j }
 n  t j | j d |	 d |
 } | s| j | _ n  | j |  j    t | _ | j | j
 |  j    S(
   s  
        Try to inject C-API calls for unbound method calls to builtin types.
        While the method declarations in Builtin.py already handle this, we
        can additionally resolve bound and unbound methods here that were
        assigned to variables ahead of time.
        R"   R   R   RY   R#   t	   is_calledR   R   N(   R   R"   R   Rh   R  R   R   R   RV   R   RY   R   t   analyse_as_type_attributeR'   R   R   R   R/   t   analyse_c_function_callt   analysedR   (   R/   R   t	   type_namet	   attr_nameR   Rd  t   is_unbound_methodR  t
   type_entryRw   R   t	   call_node(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_methodS  s<    					R|   c         C@  sp   t  |  d k r | S| d } | j t j k rl | j d  } t j | j d |  j d | g d | j	 S| S(   s;   Replace dict(some_dict) by PyDict_Copy(some_dict).
        i   i    s   'NoneType' is not iterablet   PyDict_CopyR   R   (
   R=   RY   R	   R   R   R   R   RV   t   PyDict_Copy_func_typeR   (   R/   R   R   R  R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR+    s    
	
R  c         C@  sH   t  |  d k r | S| d } t j | j d |  j d | d | j S(   s0   Turn list(ob) into PySequence_List(ob).
        i   i    R   R   R   (   R=   R   R   RV   R  R   (   R/   R   R   R  R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR#    s    
Ra  c         C@  s   t  |  d k r | S| d } | j t j k rC | j   rC | S| j t j k r | j d  | d <t j | j	 d |  j
 d | d | j St j | j	 d |  j d | d | j Sd S(	   sD   Replace tuple([...]) by PyList_AsTuple or PySequence_Tuple.
        i   i    s!   'NoneType' object is not iterablet   PyList_AsTupleR   R   t   PySequence_TupleN(   R=   RY   R	   R   t   may_be_noneR   R   R   R   RV   t   PyList_AsTuple_func_typeR   t   PySequence_Tuple_func_type(   R/   R   R   R  R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_tuple  s    
c   	      C@  s  t  |  d k r | S| d j r g  } g  } xM | d j D]> } | j   sn t j |  } | j |  n  | j |  q= Wt j | j	 d d d | } |  j
 | |  x- | d  d  d  D] } t j | |  } q W| S|  j
 | t j | j	 d |  j d | d | j d d  Sd  S(	   Ni   i    R   R   it	   PySet_NewRC  Rd  (   R=   R  R   R  R
   R   R0   R   R  RV   R6  RK  R   t   PySet_New_func_typeR   (	   R/   R   R   R  R   RO   R   R  R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR%    s*    			c         C@  s   | s t  j | j  g } nE t |  d k r4 | S| d j t j k rc | d j   rc | d St  j | j d |  j	 d | d | j
 d t j d d  d	 d
 S(   Ni   i    t   __Pyx_PyFrozenSet_NewR   R   R   t   pyfrozenset_news
   Builtins.cRC  t	   frozenset(   R   R/  RV   R=   RY   R	   t   frozenset_typeRt  R   t   PyFrozenSet_New_func_typeR   R   R   (   R/   R   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR"    s    '			R"   s   ((double)-1)c         C@  s$  t  |  d k r@ t j | d d d d j t j |  j    St  |  d k rl |  j d | | d  | S| d } t | t j	  r | j
 } n  | j t j k r | S| j j | j  s | j j r t j | j d	 | d
 | j St j | j d |  j d | d | j d t d  d d S(   sY   Transform float() into either a C type cast or a faster C
        function call.
        i    RJ   s   0.0R(   g        i   R  s   0 or 1RT   RY   t   __Pyx_PyObject_AsDoubleR   R   R   t   pyobject_as_doubleRC  (   R=   R   R  R   R	   R  Rh   R  R   R<  R   RY   R   R  R   R`  RM  RV   R   t   PyObject_AsDouble_func_typeR   R   (   R/   R   R   R  RF  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s,    
!			RJ   c         C@  s	  t  |  d k r7 t j | j d d d d d t j St  |  d k rM | S| d } t | t j  r | j j	 j
 r t j | j d |  j d | j g d	 t d
 d d t j d d  S| Sn  | j	 j r| j	 j rt j | j d |  j d | d	 t d
 d S| S(   s7   Transform int() into a faster C function call.
        i    RJ   R   R(   RY   i   t   __Pyx_PyInt_FromDoubleR   R   RC  R[  R   t   PyIntFromDoubles   TypeConversion.ct   __Pyx_PyNumber_Int(   R=   R   R   RV   R   R+  R   R<  R   RY   RH  R   t   PyInt_FromDouble_func_typeR   R   R   R   t   PyNumber_Int_func_type(   R/   R   R   R  RF  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_int#	  s$    

c         C@  s   t  |  d k rC t j | j d t d t j t j |  j    St  |  d k ro |  j	 d | | d  | S| d j
 |  j    } t j | j d | } t j | j d | } | j |  j    Sd S(	   s=   Transform bool(x) into a type coercion to a boolean.
        i    RJ   R(   i   t   bools   0 or 1RT   N(   R=   R   R`   RV   R$   R   R	   R>  Rh   R  R?  Rk   t   coerce_to_pyobject(   R/   R   R   R  RT   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_bool:	  s    t   unicodes   -1t   __Pyx_PyUnicode_GET_LENGTHR   t   PyList_GET_SIZEt   PyTuple_GET_SIZEt   PySet_GET_SIZEt   PyDict_Sizes   cpython.array.arrayc         C@  s  t  |  d k r, |  j d | | d  | S| d } t | t j  rT | j } n  | j j r t j | j	 d |  j
 d | g d | j d t j d d	  } n| j j r t j | j	 d
 |  j d | g d | j } n | j j r|  j | j  } | d k rH| j } | j s#| j rA| j j |  j k rAd } qH| Sn  | j d  } t j | j	 | |  j d | g d | j } n5 | j j rt j | j	 d d d d d | j S| S| j t j t j f k r| j | j |  j     } n  | S(   s   Replace len(char*) by the equivalent call to strlen(),
        len(Py_UNICODE) by the equivalent Py_UNICODE_strlen() and
        len(known_builtin_type) by an equivalent C-API call.
        i   R=   i    t   strlenR   R   R   t   IncludeStringHs   StringTools.ct   __Pyx_Py_UNICODE_strlent   Py_SIZEs&   object of type 'NoneType' has no len()RJ   R   R(   RY   N(!   R=   R  R   R   R<  R   RY   R   R   RV   t   Pyx_strlen_func_typeR   R   R   t   is_pyunicode_ptrt   Pyx_Py_UNICODE_strlen_func_typeR   t   _map_to_capi_len_functionR'   t   is_extension_typeR_  R   t   qualified_namet   _ext_types_with_pysizeR   t   PyObject_Size_func_typeRI  R   R   t   c_size_t_typeR   R   Rh   (   R/   R   R   R  R   Rr   t
   cfunc_nameR  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_lenj	  sL    
							
t   objectc         C@  sP   t  |  d k r | St j | j d |  j d | d t } t j | t j  S(   s7   Replace type(o) by a macro call to Py_TYPE(o).
        i   t   Py_TYPER   R   (	   R=   R   R   RV   t   Pyx_Type_func_typeR$   R   R   R+  (   R/   R   R   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_function_type	  s    	R   c      
   @  s  t  |  d k r  S| \ } } g  } t | t j  r | j } t  |  d k ro | d j t j k	 ro  S| j s | j	   r t
 j |  } | j |  q n" | j t j k r | g } n  Sg  } g  } |  j     x| D]{}	 d }
 |	 j rH|	 j rH  j |	 j j  } | rE| j rE| j j rE| j }
 qEqHn  |
 t j k r| j d k s|| j ox| j j rd }
 qn  |
 d k	 r| j j d t  } | | k rq n  | j |  | g } na |	 j t j k rd } | |	 g } n: |	 j s#t
 j |	  }	 | j |	  n  d } | |	 g } | j t j |	 j | |  j d | d	 t  q Wt j    f d
  } t | |  j  j    } x- | d d d  D] } t
 j  | |  } qW| S(   sc   Replace isinstance() checks against builtin types by the
        corresponding C-API call.
        i   i   i    RY   t   exactt   __Pyx_TypeCheckt   PyObject_IsInstanceR   R   c         @  s5   |  j  d |  |  } t j | _ | j    | S(   NRF  (   RV   R   R  RY   R  (   R%   R&   t   make_binop_nodet   or_node(   R  R   (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   join_with_or	  s    Ni(!   R=   R   R   R  R   RY   R	   t	   type_typeR   R  R
   R   R0   Rh   R'   R   R   R  R   R_  t   scopet   is_builtin_scopet   type_check_functionR$   R   R   RV   t   Py_type_check_func_typeR   R  R   R   RK  (   R/   R   R   R  R   t   typesRO   t   testst
   test_nodest   test_type_nodet   builtin_typeR   R  t   type_check_argsR  R  R  (    (   R  R   s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt"   _handle_simple_function_isinstance	  sh    	(			c      	   C@  s  t  |  d k r | S| d } t | t j  r{ | j j j rt j | j d | j d t	 j
 j | j |  j    Snt | t j  r t  | j  d k rt j | j d t	 j d t t | j   d t | j  j | j |  j    Sn t | t j  r| j rt  | j  d k rt | j  d k rt j | j d t	 j d t t | j   d t | j  j | j |  j    Sn  | S(   s-   Unpack ord(Py_UNICODE) and ord('X').
        i   i    RT   RY   RJ   R(   i   (   R=   R   R   R<  R   RY   RI  RM  RV   R   R  R   Rh   RQ  RJ   R   R   R   Rc  R.  R  (   R/   R   R   R  R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  	  s0    
RY   R   R  c      
   C@  s  | j  } | s" t |  d k  r& | S| d } | j sD | j rH | S| j t j k sl | j t j k rp | S| j s | j r | j | j k r | Sn | j | j k r | St j	 | j
 d | d } | j |  j   d t } | j r>| j j }	 |	 j rM|	 j rM|	 j j   |  j   j   k rMt j d d  }
 t j |	 j |
  } | r;|  j j } t j | j d  j  } t j t j t j d | d  t j d t j d  t j d	 t j d  g  } t j | |  } | st j | j
 d t j } n  t j  | j
 | | d | | | g d
 t SqMn | j! d  } t" j# d d  } | rt j  | j
 d |  j$ d | | | g d | d
 | j% St j  | j
 d |  j& d | | g d | d
 | j% Sd S(   sO   Replace 'exttype.__new__(exttype, ...)' by a call to exttype->tp_new()
        i   i    R   t   skip_childrent   tp_newt   __new__t   PyTypeObjectRY   R  R   s4   object.__new__(X): X is not a type object (NoneType)s   ObjectHandling.ct   __Pyx_tp_new_kwargsR   t   __Pyx_tp_newN('   R"   R=   R   RY   R	   R  Rm  R   R   R  RV   t   analyse_typesRh   R   R  t   typeobj_cnameR  R   R   t   ConstructorSlott   get_slot_functionR   t   cython_scopeR   t   CPtrTypeR  RB  R+  RD  R'   R   R/  R   R   R   R   t   Pyx_tp_new_kwargs_func_typeR   t   Pyx_tp_new_func_type(   R/   R   R   R   Rl  R  R"   t   type_argt
   args_tuplet   ext_typet   tp_slott   slot_func_cnameR  t   PyTypeObjectPtrt   pyx_tp_new_kwargs_func_typeR   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_any_slot__new__
  sj    	
$	!		
R  c         C@  s_   t  |  d k s | j r | St j | j d |  j d | d t d | j d t d t d  S(	   s\   Optimistic optimisation as X.append() is almost always
        referring to a list.
        i   t   __Pyx_PyObject_AppendR   t   may_return_noneR   R   R   R0   (	   R=   R   R   R   RV   t   PyObject_Append_func_typeR$   R   R   (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_object_appendo
  s    	t	   bytearrayc   
      C@  sh  t  |  d k r | Sd } |  j } t | d  } | j j sS t | t j  r | j t	 j
 |  j    } t j d d  } n} | j r | j   s | S| j t	 j |  j    } t j d d  } n4 | j j r d } |  j } t j d d  } n | St j | j | | d | d	 | g d
 t d | j d | }	 | j rd|	 j | j |  j    }	 n  |	 S(   Ni   t   __Pyx_PyByteArray_Appendi   t   ByteArrayAppends   StringTools.ct   __Pyx_PyByteArray_AppendObjectt   ByteArrayAppendObjectR   i    R  R   R   (   R=   t   PyByteArray_Append_func_typeR   RY   R   R   R   R   R   R   R   Rh   R   R   t   is_string_literalt   can_coerce_to_char_literalRT  R   t"   PyByteArray_AppendObject_func_typeR   RV   R$   R   R   (
   R/   R   R   R   Rl  t	   func_nameR  RJ   R   Rr   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt&   _handle_simple_method_bytearray_append
  s6    						t   py_indext   c_indext	   is_signedt   has_varargsc         C@  s   |  j  | | | | d t S(   Nt   is_list(   t    _handle_simple_method_object_popR   (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_method_list_pop
  s    c         C@  s  | s
 | S| d } | rA d } | j  d d d d d g } n d } t |  d	 k r t j | j d
 | |  j d | g d t d | j d t d  St |  d k rt	 | d	  } t j
 | j  }	 | j }
 | j j st | t j  r(| j |  j    }	 | j t j |  j    } q| r| j j ra| j |  j    }	 t j |	  } n  | j t j |  j    } q| SnF t j | j t j  s| St | t j  r| j |  j    }	 n  |
 j s| j }
 n  |
 j |  j    s| S|
 j } t j t j t j d |
 d  g  } t j | j d | |  j d | |	 | t j | j d t |
 j  rpd	 psd  d |
 j  rd	 pd d t j! t j" | j t j# |
 j$    t j" | j | |  g d t d | j d t d  S| S(   s\   Optimistic optimisation as X.pop([n]) is almost always
        referring to a list.
        i    t   Lists'   'NoneType' object has no attribute '%s'R   R&  R'  t   popt   Objecti   s   __Pyx_Py%s_PopR   R  R   R   i   t   intvals   __Pyx_Py%s_PopIndexRJ   R(   RY   t	   pop_indexN(%   R   R=   R   R   RV   t   PyObject_Pop_func_typeR   R   R   R   R  RY   R   R   R   R  Rh   R   R   R   R   R   R   t   numeric_type_fitst   create_to_py_utility_codet   to_py_functionRB  R+  RD  R'   t   PyObject_PopIndex_func_typeR   t   signedR   t   RawCNameExprNodet   c_void_typet   empty_declaration_code(   R/   R   R   R   Rl  R  R"   Rj  R   R  t   orig_index_typet   convert_funct   conversion_type(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  
  sr    
						!		*		c         C@  sJ   t  |  d k r | S|  j | | d |  j d | |  j | j |  j  S(   s?   Call PyList_Sort() instead of the 0-argument l.sort().
        i   t   PyList_SortRe  (   R=   t   _substitute_method_callt   single_param_func_typeR   RY   Rh   (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_method_list_sort
  s
    t   keyt   defaultc         C@  s   t  |  d k r. | j t j | j   n, t  |  d k rZ |  j d | | d  | S|  j | | d |  j d | | d t d t	 d	  S(
   s:   Replace dict.get() by a call to PyDict_GetItem().
        i   i   s   dict.gets   2 or 3t   __Pyx_PyDict_GetItemDefaultR|  R  R   t   dict_getitem_default(
   R=   R0   R   R  RV   R  R  t   Pyx_PyDict_GetItem_func_typeR   R   (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _handle_simple_method_dict_get  s    	t   is_safe_typec         C@  s  t  |  d k r. | j t j | j   n, t  |  d k rZ |  j d | | d  | S| d j } | j r t | j	 d k  } n | t
 j k r d } n d } | j t j | j d	 t |  d
 |  |  j | | d |  j d | | d t d t d  S(   sU   Replace dict.setdefault() by calls to PyDict_GetItem() and PyDict_SetItem().
        i   i   s   dict.setdefaults   2 or 3i   s%   str bytes unicode float int long boolii    RJ   R(   t   __Pyx_PyDict_SetDefaultt
   setdefaultR  R   t   dict_setdefault(   R=   R0   R   R  RV   R  RY   R_  R[  R   R   R+  R   R   R  t   Pyx_PyDict_SetDefault_func_typeR   R   (   R/   R   R   R   Rl  t   key_typeR  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt%   _handle_simple_method_dict_setdefault2  s(    				t   op1t   op2R  t   inplacet   fvalc         C@  s   |  j  d | | | |  S(   Nt   Add(   t   _optimise_num_binop(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___add__\  s    c         C@  s   |  j  d | | | |  S(   Nt   Subtract(   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___sub___  s    c         C@  s   |  j  d | | | |  S(   Nt   Eq(   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_object___eq__b  s    c         C@  s   |  j  d | | | |  S(   Nt   Ne(   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___neq__e  s    c         C@  s   |  j  d | | | |  S(   Nt   And(   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___and__h  s    c         C@  s   |  j  d | | | |  S(   Nt   Or(   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_object___or__k  s    c         C@  s   |  j  d | | | |  S(   Nt   Xor(   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___xor__n  s    c         C@  s   t  |  d k s) t | d t j  r- | S| d j   sb d | d j k o\ d k n rf | S|  j d | | | |  S(   Ni   i   i?   t   Rshift(   R=   R   R   R   Rr  R(   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt'   _handle_simple_method_object___rshift__q  s
    )5c         C@  s   |  j  d | | | |  S(   Nt	   Remainder(   t   _optimise_num_div(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___mod__x  s    c         C@  s   |  j  d | | | |  S(   Nt   FloorDivide(   R  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt)   _handle_simple_method_object___floordiv__{  s    c         C@  s   |  j  d | | | |  S(   Nt
   TrueDivide(   R  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt(   _handle_simple_method_object___truediv__~  s    c         C@  s   |  j  d | | | |  S(   Nt   Divide(   R  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___div__  s    c         C@  s   t  |  d k s6 | d j   s6 | d j d k r: | St | d t j  rz d | d j k on d k n s | SnD t | d t j  r d
 | d j k o d k n s | Sn | S|  j | | | | |  S(   Ni   i   i    i   i5   i   @i   i   @I        I      I        (   R=   Rr  R(   R   R   R   R  R	  (   R/   RD   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    6##c         C@  s   |  j  d | | | |  S(   NR  (   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___add__  s    c         C@  s   |  j  d | | | |  S(   NR  (   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___sub__  s    c         C@  s   |  j  d | | | |  S(   NR  (   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt'   _handle_simple_method_float___truediv__  s    c         C@  s   |  j  d | | | |  S(   NR   (   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___div__  s    c         C@  s   |  j  d | | | |  S(   NR  (   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___mod__  s    c         C@  s   |  j  d | | | |  S(   NR  (   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt"   _handle_simple_method_float___eq__  s    c         C@  s   |  j  d | | | |  S(   NR  (   R	  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___neq__  s    c         C@  sa  t  |  d k r | S| j j s& | St j t j f } t | d |  rx | d j t j k	 re | S| d } d } nD t | d |  r | d j t j k	 r | S| d } d } n | S| j	   s | St | t j  }	 |	 r | d k r | Sn) | d
 k r| St
 | j  d  k r | St |  } | j |	 rAt j n t j | j d | j d | j d |	 rqt j n t j  t | t j  r| j n t }
 | j t j | j d |
 d |
  t j |	 rd n d d d t d | d |  } |  j | | d |	 rd n d | | f |	 r.|  j n |  j d | d  j   | | d t d t d | S(!   sY   
        Optimise math operators for (likely) float or small integer operations.
        i   i   i    t   ObjCt   CObjR  R  R  R  R   R  R  i   RJ   R(   RY   t   PyFloatBinopt
   PyIntBinops
   Optimize.cR   t   opt   orders   __Pyx_Py%s_%s%st   Floatt   Ints   __%s__i   R  t   with_none_checkR   (   s   Adds   Subtracts	   Remainders
   TrueDivides   Divides   Eqs   Nei   @(   R=   RY   R   R   R   R  R   R   R+  Rr  R   R(   Ra  R0   RV   RJ   R  R  t   NumBinopNodeR  R$   R`   R   R   R|   R  t   Pyx_PyFloat_BinopInt_func_typet   Pyx_PyInt_BinopInt_func_typet   lowerR   (   R/   RD   R   R   R   Rl  t	   num_nodest   numvalt	   arg_orderRH  R  R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR	    sT    
	
	!%"t   ucharc      
   C@  s   | s t  |  d k r | S| d } t | t j  sI | j j j rM | S| j } | j } | d k r t j	 d d  } d }	 n d  } d | j   }	 |  j | | |	 |  j | | | g d | }
 | j j r |
 j |  j  }
 n  |
 S(	   Ni   i    t   istitlet   py_unicode_istitles   StringTools.ct   __Pyx_Py_UNICODE_ISTITLEs   Py_UNICODE_%sR   (   R=   R   R   R<  R   RY   RI  R#   R   R   R'   t   upperR  t#   PyUnicode_uchar_predicate_func_typeR   R  Rh   (   R/   R   R   R   Rl  t   ustringR9  R?  R   R  t	   func_call(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _inject_unicode_predicate  s,    
					c   
      C@  s   | s t  |  d k r | S| d } t | t j  sI | j j j rM | S| j } | j } d | j   } |  j	 | | | |  j
 | | | g  }	 | j j r |	 j |  j  }	 n  |	 S(   Ni   i    s   Py_UNICODE_TO%s(   R=   R   R   R<  R   RY   RI  R#   R=  R  t$   PyUnicode_uchar_conversion_func_typeR   R  Rh   (
   R/   R   R   R   Rl  R?  R9  R?  R  R@  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _inject_unicode_character_conversion  s     
			R   t   keependsc         C@  sd   t  |  d k r, |  j d | | d  | S|  j | | d t  |  j | | d |  j d | |  S(   sf   Replace unicode.splitlines(...) by a direct call to the
        corresponding C-API function.
        i   i   s   unicode.splitliness   1 or 2t   PyUnicode_Splitlinest
   splitlines(   i   i   (   R=   R  t   _inject_bint_default_argumentR$   R  t   PyUnicode_Splitlines_func_type(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt(   _handle_simple_method_unicode_splitlines+  s    	t   sept   maxsplitc         C@  s   t  |  d	 k r, |  j d | | d  | St  |  d k  rZ | j t j | j   n  |  j | | d t j d  |  j	 | | d |  j
 d | |  S(
   sa   Replace unicode.split(...) by a direct call to the
        corresponding C-API function.
        i   i   i   s   unicode.splits   1-3s   -1t   PyUnicode_Splitt   split(   i   i   i   (   R=   R  R0   R   R/  RV   t   _inject_int_default_argumentR   R   R  t   PyUnicode_Split_func_type(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_unicode_splitA  s    	t   seqc         C@  s  t  |  d k r, |  j d | | d  | St | d t j  r | d } | j } t |  } | r t j | j | d d d t	 j
 } xH | D]@ \ }	 }
 t j |	 j d |	 d	 | j } t j | |
 |  q W| | d <q n  |  j | | d
 |  j d | |  S(   s^   
        unicode.join() builds a list first => see if we can do this more efficiently
        i   s   unicode.joint   2i   R  Ra  R  R3   RP   t   PyUnicode_JoinR  (   R=   R  R   R   R  R  R<   R  RV   R	   R   R  RP   R   R  R  t   PyUnicode_Join_func_type(   R/   R   R   R   Rl  R  R   R>   t   inlined_genexprR  R  R
  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt"   _handle_simple_method_unicode_joinX  s,    
			t	   substringR   t   endt	   directionc      	   C@  s#   |  j  | | | | d d t d 
 S(   NR  t   endswithi   (   t   _inject_tailmatcht   unicode_tailmatch_utility_code(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt&   _handle_simple_method_unicode_endswith  s    c      	   C@  s"   |  j  | | | | d d t d  S(   NR  t
   startswithi(   R[  R\  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt(   _handle_simple_method_unicode_startswith  s    c	   
   
   C@  s   t  |  d k r6 |  j d | | f | | d  | S|  j | | d t j d  |  j | | d t j d  | j t j | j d t	 |  d	 t j
  |  j | | d
 | j   |  j | | | d | }	 |	 j t j |  j    S(   s   Replace unicode.startswith(...) and unicode.endswith(...)
        by a direct call to the corresponding C-API function.
        i   i   i   s   %s.%ss   2-4R   t   PY_SSIZE_T_MAXRJ   RY   s   __Pyx_Py%s_TailmatchR   (   i   i   i   (   R=   R  RN  R   R   R0   R   R   RV   R   R   R  t
   capitalizet   PyString_Tailmatch_func_typeR   R	   R>  Rh   (
   R/   R   R   R   Rl  Rj  R?  R   RY  t   method_call(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR[    s      "	s   -2c         C@  s   |  j  | | | | d d 
 S(   Nt   findi   (   t   _inject_unicode_find(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt"   _handle_simple_method_unicode_find  s    c         C@  s   |  j  | | | | d d  S(   Nt   rfindi(   Re  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_unicode_rfind  s    c         C@  s   t  |  d k r0 |  j d | | | d  | S|  j | | d t j d  |  j | | d t j d  | j t j | j d t	 |  d	 t j
  |  j | | d
 |  j | | |  } | j |  j    S(   sw   Replace unicode.find(...) and unicode.rfind(...) by a
        direct call to the corresponding C-API function.
        i   i   i   s
   unicode.%ss   2-4R   R`  RJ   RY   t   PyUnicode_Find(   i   i   i   (   R=   R  RN  R   R   R0   R   R   RV   R   R   R  t   PyUnicode_Find_func_typeR  Rh   (   R/   R   R   R   Rl  R?  RY  Rc  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRe    s    "c         C@  s   t  |  d
 k r, |  j d | | d  | S|  j | | d t j d  |  j | | d t j d  |  j | | d |  j d	 | |  } | j |  j    S(   sa   Replace unicode.count(...) by a direct call to the
        corresponding C-API function.
        i   i   i   s   unicode.counts   2-4R   R`  t   PyUnicode_Countt   count(   i   i   i   (	   R=   R  RN  R   R   R  t   PyUnicode_Count_func_typeR  Rh   (   R/   R   R   R   Rl  Rc  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt#   _handle_simple_method_unicode_count  s    t   replstrt   maxcountc         C@  sj   t  |  d k r, |  j d | | d  | S|  j | | d t j d  |  j | | d |  j d | |  S(	   sc   Replace unicode.replace(...) by a direct call to the
        corresponding C-API function.
        i   i   s   unicode.replaces   3-4s   -1t   PyUnicode_ReplaceR6  (   i   i   (   R=   R  RN  R   R   R  t   PyUnicode_Replace_func_type(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt%   _handle_simple_method_unicode_replace  s    t   encodingt   errorst   UTF8t   UTF16t   Latin1t   ASCIIt   unicode_escapet   raw_unicode_escapec      
   C@  s  t  |  d k  s$ t  |  d k r> |  j d | | d  | S| d } t  |  d k r t j | j  } |  j | | d |  j d | | | | g  S|  j | j |  } | d k r | S| \ } }	 }
 } | r:t	 | t j
  r:y | j j | |
  } Wn q:Xt | |  } t j | j d | d	 t j Sn  | r|
 d
 k r|  j |  } | d k	 rd | } |  j | | | |  j d | | g  Sn  |  j | | d |  j d | | |	 | g  S(   s_   Replace unicode.encode(...) by a direct C-API call to the
        corresponding codec.
        i   i   s   unicode.encodes   1-3i    t   PyUnicode_AsEncodedStringR   RJ   RY   t   stricts   PyUnicode_As%sStringN(   R=   R  R   R/  RV   R  t#   PyUnicode_AsEncodedString_func_typet   _unpack_encoding_and_error_modeR'   R   RQ  RJ   R   R   R   R	   R   t   _find_special_codec_namet   PyUnicode_AsXyzString_func_type(   R/   R   R   R   Rl  t   string_nodet	   null_nodet
   parametersRt  t   encoding_nodet   error_handlingt   error_handling_nodeRJ   t
   codec_namet   encode_function(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_unicode_encode  sD    $
	"
		t   stringR   R   t   decode_funcc         C@  s  d t  |  k o d k n s< |  j d | | d  | S| d } d$ } } t | t j  r | } | j } | j | j } } | s | j	 d k r d$ } q n  t | t j
  r | j } n  | j }	 |	 t j t j f k r-| r| j d d d |	 j g } qE| j d	 d
 d d d g } n |	 j rE|	 j rE| S|  j | j |  }
 |
 d$ k rj| S|
 \ } } } } | st j | j d d d d } n* | j j s| j t j |  j    } n  | r| j j r| j t j |  j    } n  d$ } | d$ k	 r"|  j |  } n  | d$ k	 rht j | j d |  j d d | } t j | j  } n t j | j  } g  } |	 j r| s| j  st! j" |  } | j# |  n  t j$ | j d |  j% d | g d t& d t' j( d d  j t j |  j    } n  |  j) } d } n;|	 j r| sPt j | j d d d t j* } n  |  j+ d$ k rt j, t j- t j. d |	 d$  t j. d t j d$  t j. d t j d$  t j. d t j/ d$  t j. d t j/ d$  t j. d |  j d$  g  |  _+ n  |  j+ } d  } nQ | s1t j | j d d d t j* } n  |  j0 } |	 t j k rRd! } n d" } t j$ | j d# | | d | | | | | | g d | j1 d t' j( | d  } x- | d$ d$ d%  D] } t! j2 | |  } qW| S(&   s   Replace char*.decode() by a direct C-API call to the
        corresponding codec, possibly resolving a slice on the char*.
        i   i   s   bytes.decodes   1-3i    s@   descriptor '%s' requires a '%s' object but received a 'NoneType'R'  t   decodes'   'NoneType' object has no attribute '%s'R   R&  RJ   R   R(   RY   Rt  s   PyUnicode_Decode%sR  R   R   R   R  s   StringTools.ct   decode_c_stringR`  R  R   R   Rt  Ru  R  t   decode_cpp_stringt   decode_bytest   decode_bytearrays   __Pyx_%sNi(3   R=   R  R'   R   R   R   RX   R   R   R(   R<  R   RY   R	   R   t   bytearray_typeR   R   R   t   is_cpp_stringR  RV   R   R   R   R   R   Rh   R  R  t!   PyUnicode_DecodeXyz_func_ptr_typeR/  R   R
   R   R0   R   R  R$   R   R   t   _decode_c_string_func_typeR   t   _decode_cpp_string_func_typeRB  R   RD  R   t   _decode_bytes_func_typeR   RK  (   R/   R   R   R   Rl  R  R   R   R  t   string_typeR  Rt  R  R  R  R  t   decode_functionRO   t   helper_func_typet   utility_code_nameR  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt"   _handle_simple_method_bytes_decodeY  s    "

		!						$					c         C@  s   y t  j |  } Wn t k
 r' d  SXxg |  j D]\ \ } } | | k r2 d | k r d j g  | j d  D] } | j   ^ ql  } n  | Sq2 Wd  S(   NR  R  (   t   codecst
   getencodert   LookupErrorR'   t   _special_codecsR  RM  Ra  (   R/   Rt  t   requested_codecR   t   codecR   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    	+c         C@  s   t  j |  } t |  d k rM |  j | d  \ } } | d  k rY d  Sn d  } | } t |  d k r |  j | d  \ } } | d  k r d  S| d k r | } q n d } | } | | | | f S(   Ni   i   i   R}  (   R   R/  R=   t   _unpack_string_and_cstring_nodeR'   (   R/   RV   R   R  Rt  R  R  R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s     c         C@  s  t  | t j  r | j } n  t  | t j  rc | j } t j | j d | j   d t	 j
 } n t  | t j t j f  r | j j d  } t j | j d | j d t	 j
 } nU | j t j k r d  } | j t	 j
 |  j    } n | j j rd  } n
 d  } } | | f S(   NRJ   RY   s
   ISO-8859-1(   R   R   R<  R   RQ  RJ   R   RV   t   as_utf8_stringR   R   R.  R  RY   R	   R   R'   R   Rh   R   (   R/   R   Rt  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s"    	$!	
c      	   C@  s#   |  j  | | | | d d t d 
 S(   NR   RZ  i   (   R[  t   str_tailmatch_utility_code(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt"   _handle_simple_method_str_endswith  s    c      	   C@  s"   |  j  | | | | d d t d  S(   NR   R^  i(   R[  R  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_str_startswith  s    c      	   C@  s#   |  j  | | | | d d t d 
 S(   NRM  RZ  i   (   R[  t   bytes_tailmatch_utility_code(   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt$   _handle_simple_method_bytes_endswith  s    c      	   C@  s"   |  j  | | | | d d t d  S(   NRM  R^  i(   R[  R  (   R/   R   R   R   Rl  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt&   _handle_simple_method_bytes_startswith  s    c         C@  s   t  |  } | r | r | d j r | d } | rZ | j d d | | j j g } n | j d d d d | g } | | d <n  |	 d  k r | j }	 n  t j | j	 | | d | d |	 d	 | d
 |
 d | j
 S(   Ni    s@   descriptor '%s' requires a '%s' object but received a 'NoneType'R'  s'   'NoneType' object has no attribute '%s'R   R&  R   R   R   R  R   (   Ra  R   R   R"   R   R'   R   R   R   RV   R   (   R/   R   R   R   R  Rk  Rl  R   R   R   R  R1  t   self_arg(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  )  s*    
c      	   C@  s   t  |  | k s t  t  |  | k r^ | j t j | j d t |  d | d |  n  | | j | |  j    | | <d  S(   NRJ   RY   R(   (	   R=   R   R0   R   R   RV   R   R   Rh   (   R/   R   R   t	   arg_indexRY   t   default_value(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRN  F  s
    !c         C@  s   t  |  | k s t  t  |  | k r^ t |  } | j t j | j d | d |  n | | j |  j    | | <d  S(   NRJ   R(   (	   R=   R   R  R0   R   R`   RV   R?  Rh   (   R/   R   R   R  R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRG  N  s    N(    (   R8   R9   R:   R:  R;  R4   R@  R   RB  R+  RD  R'   RE  RG  RL  RT  R	   R   R   R   R   RV  RK  R|   t   c_float_typeR  t   c_longdouble_typeRb  RJ  R  Re  Ro  R   Rq  R+  R   R  R#  R   Ru  Rv  Rw  R$  Ry  R%  R}  R~  R"  R  R  R  R  R  R  R  R   R  t   c_const_py_unicode_ptr_typeR  R  R   R|  R  Rd  R  R  R  R  R  R  R  R  R  R  R  R  t   c_returncode_typeR  R  R  R  R  R  R  R  R$   R  R  R  R  R  R  R  R  R4  R3  R
  R  R  R  R  R  R  R  R  R  R  R!  R  R"  R#  R$  R%  R&  R'  R(  R	  R   R>  RA  t%   _handle_simple_method_unicode_isalnumt%   _handle_simple_method_unicode_isalphat'   _handle_simple_method_unicode_isdecimalt%   _handle_simple_method_unicode_isdigitt%   _handle_simple_method_unicode_islowert'   _handle_simple_method_unicode_isnumerict%   _handle_simple_method_unicode_isspacet%   _handle_simple_method_unicode_istitlet%   _handle_simple_method_unicode_isupperRB  RC  t#   _handle_simple_method_unicode_lowert#   _handle_simple_method_unicode_uppert#   _handle_simple_method_unicode_titleRH  RI  RO  RP  RT  RV  Rb  R]  R_  R[  Rj  Rf  Rh  Re  Rm  Rn  Rr  Rs  R~  R  t   _special_encodingsR   R  R  R  R  R  R  R  R  R  R  t&   _handle_simple_method_bytearray_decodeR  R  R  R  R  R  R  R   R   R  R  RN  RG  (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR8  m  s`  							(			/		+		
								





	.		D	K					!		D																										;					 											%	1!	t									t   unicode_tailmatchs   StringTools.ct   bytes_tailmatcht   str_tailmatcht   ConstantFoldingc           B@  sS  e  Z d  Z e d  Z d   Z e j e j e j	 e j
 g Z d   Z d   Z d   Z d   Z i d d 6d d 6d	 d
 6d
 d	 6j 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# d   Z$ d   Z% d   Z& e' j( j) Z* RS(    sF  Calculate the result of constant expressions to store it in
    ``expr_node.constant_result``, and replace trivial cases by their
    constant result.

    General rules:

    - We calculate float constants to make them available to the
      compiler, but we do not aggregate them into a single literal
      node to prevent any loss of precision.

    - We recursively calculate constants from non-literal nodes to
      make them available to the compiler, but we only aggregate
      literal nodes at each step.  Non-literal nodes are never merged
      into a single node.
    c         C@  s    t  t |   j   | |  _ d S(   s   
        The reevaluate argument specifies whether constant values that were
        previously computed should be recomputed.
        N(   t   superR  R,   t
   reevaluate(   R/   R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR,   n  s    c      
   C@  s)  |  j  r  | j t j k	 r  d  St j } | | _ |  j |  } xr | j   D]d } t |  t k r xI | D]" } t	 | d |  | k rm d  Sqm WqN t	 | d |  | k rN d  SqN Wy | j
   Wn^ t t t t t t f k
 r n< t k
 r$d d  l } d d  l } | j d | j  n Xd  S(   NR(   i    t   file(   R  R(   R   t   constant_value_not_setR   R1   Ry   RY   Ra  RU  t   calculate_constant_resultt
   ValueErrort	   TypeErrorR@   t
   IndexErrorRu  t   ArithmeticErrorR  t	   tracebackt   syst	   print_exct   stdout(   R/   R   R   t   childrent   child_resultt   childR  R  (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _calculate_constv  s(    
		c         G@  sF   y- |  j  t t |  j  j t t |    SWn t k
 rA d  SXd  S(   N(   t   NODE_TYPE_ORDERt   maxRb  R   RY   R  R'   (   R/   t   nodes(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _widest_node_class  s
    'c         C@  s(   t  |  } t j | j d | d | S(   NRJ   R(   (   R  R   R`   RV   (   R/   R   RJ   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt
   _bool_node  s    c         C@  s   |  j  |  | S(   N(   R  (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_ExprNode  s    c      	   C@  s   |  j  |  | j   s9 | j d k r5 |  j |  S| S| j j sI | S| j d k rk |  j | | j  St | j t	 j
  r t	 j | j d t t | j   d t j d t | j  S| j d k r |  j |  S| j d k r |  j |  S| S(   Nt   !RJ   RY   R(   R   R  (   R  Rr  RD   t   _handle_NotNodeRT   R   R  R(   R   R   R`   R   RV   R   R[  R   R   t   _handle_UnaryPlusNodet   _handle_UnaryMinusNode(   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_UnopNode  s$    $	RS   R  t   is_nott   isc         C@  sd   | j  } t | t j  r` |  j | j  } | r` t j |  } | | _ |  j |  } q` n  | S(   N(   RT   R   R   R]   t   _negate_operatorRD   t   copyRs   (   R/   R   RT   RD   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    		c      
   C@  s   d   } | j  j } t | j  t j  r[ t j | j d | | j  j  d | d | j S| j rm | j	 s t | j  t j
  r | j r t j
 | j d | | j  j  d | d | j  j d | j S| S(   Nc         S@  s*   |  j  d  r |  d }  n
 d |  }  |  S(   NR  i   (   R^  (   RJ   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   _negate  s    
RJ   RY   R(   t   longness(   RT   RY   R   R   R  RV   RJ   R(   R   R  R   R   R  (   R/   R   R  t	   node_type(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    	!
!
c         C@  s/   | j  j   r+ | j | j  j k r+ | j  S| S(   N(   RT   Rr  R(   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    c         C@  sm   |  j  |  | j j   s  | S| j j rL | j d k rB | j S| j Sn | j d k rb | j S| j Sd  S(   NRG  (   R  RE   Rr  R(   RD   RF   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    
c         C@  s  |  j  |  | j t j k r# | St | j t  r9 | S| j | j } } | j s` | j rd | Sy3 | j	 | j	 } } | d  k s | d  k r | SWn t k
 r | SX| j r | j r t j | |  } n	 t j } |  j | |  } | d  k r | S| t j k r(| j d k r(t j } n* | t j k rR| j d k rRt j } n  | t j k r@t | d d  ot | d d  } d t t t | d d   t t | d d     }	 t j d | j d | d |	 d t t | j   d	 t | j   }
 | j s|
 j	 j r%t j |
 _	 qt j | |
 j	  |
 _	 nQ | t j k r[| j } n t | j  } | d | j d
 | d | d	 | j  }
 |
 S(   Ns   +-//<<%**>>s   +-//<<%**>>&|^t   unsignedR  t   LLR  RV   RJ   R(   RY   (   R  R(   R   R   R   R  RE   RF   R   RY   R'   Ru  R`  R   t   widest_numeric_typeR+  R  R`   RD   R   Rf  RU  R  R=   RV   R   R[  R   (   R/   R   RE   RF   t   type1t   type2t   widest_typet   target_classR  R  Rr   t
   node_value(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_BinopNode  sV    	c         C@  s  |  j  |  | j t j k r# | S| j j r| j j r| j | j } } t | t j  rt | t j  rd  } | j
 d  k	 r | j
 d  k	 r | j
 j | j
 j k r t | j
 | j
 | j
 j  } q n  t | j  } t j | j d | d | j d | St | t j  rt | t j  r| j j | j j k r}t | j | j j  } t j | j d | d | j Sqn  |  j |  S(   NRJ   R(   R   (   R  R(   R   R   RE   R  RF   R   RQ  R'   R   Rt  R   R   RV   R   RJ   R  (   R/   R   t   str1t   str2R   t   string_value(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_AddNode2  s(    $$%c         C@  sy   |  j  |  | j j r2 |  j | | j | j  St | j t j  rl | j j rl |  j | | j | j  S|  j |  S(   N(	   R  RE   R  t   _calculate_constant_seqRF   R   R   R   R  (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_MulNodeK  s    c         C@  s   | j  d k r | j r t | j  t  rL | j  d k rL | j 2d  | _ q | j d  k	 r t | j  t  r t | j j  t  r | j j  | j  } t j | j j d t	 |  d | | _ q |  j
 |  Sq | | _ n  | S(   Ni   i    RJ   R(   (   R(   R   R   R   R'   t   mult_factorR   R   RV   R   R  (   R/   R   t   sequence_nodet   factorRJ   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  T  s    !c         C@  sy   |  j  |  t | j t j  r; | j j r; d  | _ n  | j d  k ru | j d  k ru t | j t j  ru | j S| S(   N(   R1   R   t   format_specR   RQ  RJ   R'   t   conversion_char(   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_FormattedValueNodeg  s    "3c         @  sG  |  j  |  t j   g  } x t j | j   f d    D] \ } } | r t |  } | d } t |  d k r t d j	 d   | D   | _
 n  | j
 r | j |  q q; | j |  q; W| s t j | j d t d  } nU t |  d k r| d } n6 t |  d k r:t j | j d	 |  } n	 | | _ | S(
   s   
        Clean up after the parser by discarding empty Unicode strings and merging
        substring sequences.  Empty or single-value join lists are not uncommon
        because f-string format specs are always parsed into JoinedStrNodes.
        c         @  s   t  |     S(   N(   R   (   t   v(   t   unicode_node(    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   <lambda>y  s    i    i   u    c         s@  s   |  ] } | j  Vq d  S(   N(   RJ   (   RZ  RJ   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pys	   <genexpr>~  s    RJ   R  i   R   (   R1   R   RQ  t	   itertoolst   groupbyRy   Ra  R=   R   R  RJ   R0   t   extendRV   R  (   R/   R   Ry   t   is_unode_groupt
   substringst   unode(    (   R  s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_JoinedStrNodeo  s(    	+
%	!	c         @  s   |  j  |  g   g       f d     x | j D] }   |  q8 W rf  j  d  n  t   d k r  d } | j s t | t j  r | Sn   | j (|  j |  | S(   s!   Unpack **args in place if we can.c         @  s   |  j  r9  r)  d j j |  j  q  j |   n^ t |  t j  rl xI |  j D] }   |  qU Wn+  r  j  d   2n   j |   d  S(   Ni    (   t   is_dict_literalR&  R  R0   R   R   t   MergedDictNodeR  (   R   t	   child_arg(   Rs  R   R{   (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRs    s    	i    i   (	   R1   R  R0   R=   R  R   R   R  R  (   R/   R   R   (    (   Rs  R   R{   s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_MergedDictNode  s    

c         @  s   |  j  |  | j t j k  g   g        f d     x | j D] }   |  qM W r{  j  d  n  t   d k r  d }  r | j s | j r | j | j k s t	 | t
 j  r | Sn   | j (|  j |  | S(   s    Unpack *args in place if we can.c         @  s    r |  j  s" |  j rR |  j rR  rB  d j j |  j  q  j |   n^ t |  t j  r xI |  j D] }   |  qn Wn+  r  j  d   2n   j |   d  S(   Ni    (	   t   is_set_literalR  R  R   R  R0   R   R   t   MergedSequenceNode(   R   R  (   Rs  R   t   is_setRy   (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRs    s    "i    i   (   R1   RY   R	   R$  R   R0   R=   R
  R  R   R   R  R  (   R/   R   R   (    (   Rs  R   R  Ry   s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_MergedSequenceNode  s$    

c         C@  s   |  j  |  g  } xf | j D][ } | j s< | j |  q | j j rk | j j rk | j | j j  q | j |  q W| | j (|  j |  | S(   s    Unpack *args in place if we can.(	   R1   R   t
   is_starredR0   RP   R  R  R  R  (   R/   R   R   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_SequenceNode  s    	
c   	      @  s   j  | d g  | j } | } x | d  k	 r  j  | d g  | j } t | _ | j   r | j   r y | j | j  Wq t t	 t
 t t t f k
 r q Xn  | } | j } q% W| j s | j   r  j | | j  S| S| j g g   g        f d     |  g  } x   D] } t |  d k  rLq.n  | d } t j | j d | d d | j d | j d t } | j |  | } x! | d D] } | | _ | } qWd  | _ q.W r| j  d  n | s j | t  S| d } t |  d k r<| j   r{ j | | j  Sn? x< | d D]0 } t j | j d | d d	 d | d t } qGW| S(
   NRE   RF   c         @  sv   |  j    rH |  j s2  j  j |  t   d  S  j |  j g  n   d j |   |  j rr  |  j  n  d  S(   Ni(   Rr  R(   R0   R  R$   RF   RN  (   Rn   (   t   cascadest   final_false_resultR/   t   split_cascades(    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s    		i   i   i    RD   R(   RG  (   R1   RE   R'   RF   R   R(   Rr  t"   calculate_cascaded_constant_resultR  R  R@   R  Ru  R  RN  R  R=   R   R]   RV   RD   R0   R   RW  (	   R/   R   t	   left_nodeRn   t
   right_nodet	   cmp_nodesRN  t	   pcmp_nodet   last_cmp_node(    (   R  R  R/   R  s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRs     sn    				

	
				

	c         C@  s>   |  j  |  | j j   s  | S| j j r3 | j S| j Sd  S(   N(   R  Ry  Rr  R(   R  R  (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  9  s    c         C@  s   |  j  |  g  } xO | j D]D } | j } | j   rT | j ra | j | _ Pqa q | j |  q W| rx | | _ | S| j r | j St j	 | j
 d g  Sd  S(   NRG   (   R1   RK   RL   Rr  R(   RM   RN   R0   R   R^   RV   (   R/   R   RK   R  RL   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  B  s    				c         C@  s  |  j  |  | j d  k s. | j j d  k r> d  } | _ n | j j } | j d  k sk | j j d  k r{ d  } | _ n | j j } | j t k	 r | j } | j r | j d  k r | j	 | | !| _	 | S| j
 r | j | |  } | d  k	 r | Sq n  | S(   N(   R  R   R'   R(   R   R   RX   R  R  R   R  t   as_sliced_node(   R/   R   R   R   RX   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_SliceIndexNodeY  s"    !!		
c         C@  s   |  j  |  t | j t j  r | j j r | j t j k r] t	 j
 | j d g  d g  S| j t j k r t	 j | j d g  d t   S| j t j k r t	 j | j d g  d i  Sn  | S(   NR   R(   R&  (   R1   R   R  R   R^   RG   RY   R	   R   R   R  RV   R$  R  Rd  R   R)  (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_ComprehensionNodep  s    "c         C@  s   |  j  |  | j j } t | t j  r | j s] | j rD | j St j	 | j
 d g  Sn  t | t j  r | j   | j _ q n  | S(   NRG   (   R1   RQ   RR   R   R   t   SequenceNodeR   RN   R   R^   RV   R  R!  (   R/   R   RR   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyRu     s    		c         C@  sT   |  j  |  | j rP | j j   rP | j j rF d  | _ d  | _ qP | j Sn  | S(   N(   R1   RL   Rr  R(   R'   RN   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_WhileStatNode  s    	
c         C@  s=   |  j  |  t | j t j  s& | S| j j   r9 d  S| S(   N(   R1   R   R3   R   t   ExprNodeRr  R'   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR4     s    (+   R8   R9   R:   R$   R,   R  R   R`   Rf  R   R  R  R  R  R  R  R|  R  R  R  R  R  R  R  R  R  R  R  R	  R  R  Rs   R  R  R  R  Ru   R  R4   R   R  R  R;   (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR  ]  sH   	 					
				:						!	"	&		R							
	t   FinalOptimizePhasec           B@  s2   e  Z d  Z d   Z d   Z d   Z d   Z RS(   s  
    This visitor handles several commuting optimizations, and is run
    just before the C code generation phase.

    The optimizations currently implemented in this class are:
        - eliminate None assignment and refcounting for first assignment.
        - isinstance -> typecheck for cdef types
        - eliminate checks for None and/or types that became redundant after tree changes
        - replace Python function calls that look like method calls by a faster PyMethodCallNode
    c         C@  s/   |  j  |  | j r+ | j } t | _ n  | S(   sa   Avoid redundant initialisation of local variables before their
        first assignment.
        (   R1   R  RH   R   t   lhs_of_first_assignment(   R/   R   RH   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_SingleAssignmentNode  s
    		c      
   @  s  |  j  |  | j } | j j r | j r | j d k rt | j  d k r| j d } | j j r | j j d k r |  j	 j
 } | j d  | _ | j j | _ t j | j d  j  } t j | j d |  | j d <q qn|  j j d  r| j r| j j rt | j t j  r| j j pH| j j oH| j j rt } | j t j k rmt } n | j r| j r| j j j rt } qnv | j r| j } | j s| j j rt } q| j  rt j! t j" t j# f   t$   f d   | j  D  } qn  | r| j% rd| j rdt | j& t j'  rd| j& j( | j% k rd| j& j( | _& n  |  j) | t j* j+ | d	 | d
 | j d | j  } qqn  | S(   s   
        Replace generic calls to isinstance(x, type) by a more efficient type check.
        Replace likely Python method calls by a specialised PyMethodCallNode.
        R   i   i   RY   t   PyObject_TypeCheckR  s   optimize.unpack_method_callsc         3@  s+   |  ]! } | j  o" t | j     Vq d  S(   N(   RI   R   (   RZ  t
   assignment(   t   non_method_nodes(    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pys	   <genexpr>  s   R   R   (,   R1   R   RY   t   is_cfunctionR   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   R1  R3  t	   ClassNodet   Py3ClassNodeR  R/   R"   R   R   R6  t   PyMethodCallNodet	   from_node(   R/   R   R   R  R  R  t   may_be_a_methodR   (    (   R$  s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    sJ    	$)%						*-c         C@  s8   |  j  |  | j s4 | j j   s4 t | _ q4 n  | S(   s   Remove tests for alternatively allowed None values from
        type tests when we know that the argument cannot be None
        anyway.
        (   R1   t   notnoneR   Rt  R   (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_PyTypeTestNode  s
    	c         C@  s'   |  j  |  | j j   s# | j S| S(   s_   Remove None checks from expressions that definitely do not
        carry a None value.
        (   R1   R   Rt  (   R/   R   (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_NoneCheckNode  s    (   R8   R9   R:   R!  R  R,  R-  (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR    s
   
	
	0	t   ConsolidateOverflowCheckc           B@  s&   e  Z d  Z d Z d   Z d   Z RS(   s5  
    This class facilitates the sharing of overflow checking among all nodes
    of a nested arithmetic expression.  For example, given the expression
    a*b + c, where a, b, and x are all possibly overflowing ints, the entire
    sequence will be evaluated and the overflow bit checked only at the end.
    c         C@  sK   |  j  d  k	 r: |  j  } d  |  _  |  j |  | |  _  n |  j |  | S(   N(   t   overflow_bit_nodeR'   R1   (   R/   R   t   saved(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR;   
  s    		c         C@  s{   | j  rj | j rj |  j d  k } | r3 | |  _ n |  j | _ t | _  |  j |  | rw d  |  _ qw n |  j |  | S(   N(   t   overflow_checkt   overflow_foldR/  R'   R$   R1   (   R/   R   t   top_level_overflow(    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   visit_NumBinopNode  s    	N(   R8   R9   R:   R'   R/  R;   R4  (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyR.    s   	
(E   t
   __future__R    R  R  R  R  R  R   R   R   t   cythont   declareR  t   version_infoR[  R   t   longR   R   R   R	   R
   R   t   CodeR   R   t   StringEncodingR   R   t   ErrorsR   t   ParseTreeTransformsR   t   __builtin__R   t   ImportErrort	   functoolsR   R   R   R<  RD  R   R   R!   R)   R+   R*   R?   R<   t   EnvTransformRC   RE  R  R  R  R  t   NodeRefCleanupMixinR.  t   MethodDispatcherTransformR8  R   R\  R  R  R  t   CythonTransformR  R.  (    (    (    s;   /bar/jli/Chip-seq/script/cython/Cython/Compiler/Optimize.pyt   <module>   s   	
			
	 		   8Ht !	        MY