
V]c           @@  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 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 d e  
e j d  d k r e Z e e f Z n e e f Z 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! m" Z" d d l# m$ Z$ 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  Z0 d    Z1 d!   Z2 d"   Z3 d# e j4 f d$     YZ5 d%   Z6 d&   Z7 d' e j8 f d(     YZ9 d) e j8 f d*     YZ: d+ e j; e' f d,     YZ< d- e j; f d.     YZ= d/ e j8 f d0     YZ> d1 e j? e j8 f d2     YZ@ d3 e j? e jA f d4     YZB e jC d5 d6  ZD e jC d7 d6  ZE e jC d8 d6  ZF d9 e j; e' f d:     YZG d; e j8 e j? f d<     YZH d= e jI f d>     YZJ d S(?   i    (   t   absolute_importNi   (   t	   TypeSlots(   t   not_a_constantt   UtilityCodet   EncodedStringt   bytes_literalt   encoded_stringt   Nodest	   ExprNodest
   PyrexTypest   Builtint	   UtilNodest   _py_int_typesi   (   R   (   R   (   R	   (   t   Visitor(   R
   (   R   (   t   Options(   R   t   TempitaUtilityCode(   R   R   R   (   t   errort   warning(   t   SkipDeclarations(   t   reduce(   t
   basestringc         C@  s   t  j |  d  S(   Ns
   Optimize.c(   R   t   load_cached(   t   name(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   load_c_utility/   s    c         C@  s   t  |  |  r |  j S|  S(   N(   t
   isinstancet   arg(   t   nodet   coercion_nodes(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   unwrap_coerced_node3   s    c         C@  s&   x t  |  t j  r! |  j }  q W|  S(   N(   R   R   t   ResultRefNodet
   expression(   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   unwrap_node9   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(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR#   ?   s    $$/c         C@  s#   |  d  k	 r |  j d  k r d  S|  S(   N(   t   Nonet   constant_result(   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   filter_none_nodeI   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(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR.   S   s    	c         C@  s!   |  j  j |  |  j |  d  S(   N(   R0   t   appendt   visitchildren(   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_YieldExprNodeZ   s    c         C@  s6   |  j  |  | j |  j k r2 | |  j | j <n  d  S(   N(   R3   t   exprR0   R/   (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_ExprStatNode^   s    c         C@  s   d  S(   N(    (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_GeneratorExpressionNodee   s    c         C@  s   d  S(   N(    (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_LambdaNodeh   s    c         C@  s   d  S(   N(    (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_FuncDefNodek   s    (   t   __name__t
   __module__t   __doc__R.   R   R-   R3   t
   visit_NodeR4   R6   R7   R8   R9   (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR,   O   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(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _find_single_yield_expressiono   s    c         C@  sd   t    } | j |   y0 g  | j D] } | j | j | f ^ q# } Wn t k
 r_ g  } n X| S(   N(   R,   R3   R0   R   R/   t   KeyError(   R   t	   collectort
   yield_nodeR@   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR>   v   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# 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  Z$ d   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   RH   t   is_subscriptt   baset   typet	   base_typet
   TempHandlet   refR   t   PrimaryCmpNodeRG   R   t   StatListNodet   SingleAssignmentNodet   BoolNodet   BreakStatNodet
   IfStatNodet   IfClauseNodeR)   t   TempsBlockNodet   ForInStatNodet   IteratorNodet   analyse_expressionst   current_envt   visitt   TempResultFromStatNodeRF   t   NotNodeR3   (   R1   R   RX   t
   result_refR\   t   target_handleRR   t   cmp_nodet   if_bodyt   if_nodet   for_loopt   new_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_PrimaryCmpNode   sF    		'		0c         C@  s#   |  j  |  |  j | | j j  S(   N(   R3   t   _optimise_for_loopRS   RT   (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_ForInStatNode   s    c      
   C@  s~  d  } | j s | j r | j r | j j r | j j } | j rN | j } n  | j r | j r~ | j j d k r~ t j	 } n | j
 d k r t j	 } n  | j r | j j d k r t j } q | j
 d k r t j } q q n  t j	 | j | f k r(| r| S|  j | d | d d  d	 t d
 t St j | j | f k sXt j | j | f k rr| rb| S|  j | |  S| j j s| j j r|  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 r9| j r0t | j j  p3d } n1 t | j  } | rj| j d  k	 rj| d 8} n  | j  } | j r| r| r| j p| 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 sO|
 rX|	 d	 k rXt } nR |	 d k sv|
 r|	 d
 k rt } n+ |	 d k s|
 r|	 d k rt } } n  | s| r|  j | | |	 | |  Sn  | j d  k rT| j rT| j rT| j j' rT| j
 d k r(| r| S|  j( | |  S| j
 d k rT| rA| S|  j) | |  Sn  t* j+ rz| d k rz| j d  k rz| j rz| j
 d k rz| j rz| j j' rz| j, j j- s| j, j j. r|  j/ | | d | S| j, j j0 rzx | j d  k r| j j n | j D]M } t | t j1  rY| j2   rYd | j3 k oKd k  n rYqqYn  PqW|  j/ | | d | Sqzn  | S(    Ns   typing.Dictt   Dicts
   typing.Sets   typing.FrozenSett   Sett	   FrozenSett   dict_objt   methodt   keyst   valuest   reversedi    i   i   t   itemst   dictt   iterkeyst
   itervaluest	   iteritemst	   enumeratet   ranget   xrangei   i   (   s
   typing.Sets   typing.FrozenSet(   Ry   Rz   (   R}   R~   R   (   R   R   i   @i   i   @(4   R)   t   is_namet   is_attributet   entryt
   annotationRY   RZ   t   qualified_nameR
   t	   dict_typeR   t   set_typeR[   t   _transform_dict_iterationt   TrueR&   t   frozenset_typet   _transform_set_iterationt   is_ptrt   is_arrayt   _transform_carray_iterationt
   bytes_typet   _transform_bytes_iterationt   unicode_typet   _transform_unicode_iterationR   R   t   SimpleCallNodet   argst	   arg_tupleR?   R1   t   functionR$   R%   t   global_scopet   contextt   language_levelt   CallNodet
   is_builtint   _transform_enumerate_iterationt   _transform_reversed_iterationR   t   convert_rangeRR   t   is_intt   is_enumt   _transform_range_iterationt   is_pyobjectt   IntNodet   has_constant_resultR*   (   R1   R   t   iterableR   t   annotation_typeR   t	   arg_countR   t   base_objR|   t   is_safe_itert   inner_functionR}   R~   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRv      s    '		$				
		++	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 iterableR   (   R   R   R?   R   RX   R[   R
   t
   tuple_typet	   list_typet   as_none_safe_nodeRS   RT   R   R   Rv   (   R1   R   t   reversed_functionR   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR   2  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_SIZERZ   t   startt   stept   stopR[   i   R   (   RR   R[   R   R
   R   R   t
   LetRefNodeR   R   t   PythonCapiCallNodeRX   t   PyBytes_AS_STRING_func_typet   PyBytes_GET_SIZE_func_typet   LetNodeR   t   SliceIndexNodeR)   (   R1   R   t
   slice_nodeR   t   target_typet   unpack_temp_nodet   slice_base_nodet   len_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR   P  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-1RZ   RL   R*   R[   R   R   s   'NoneType' is not iterablet   0i    t   >s   >=s   <=t   <t   __Pyx_PyUnicode_READR   R   RX   RJ   RK   RI   t   bound1t	   relation1RR   t	   relation2t   bound2R   RO   RP   t
   from_rangeR5   t   __Pyx_init_unicode_iterationRV   t   result_is_usedt   utility_codet   unicode_iters
   Optimize.cRQ   (   R   s   >=(   s   <=R   (3   t
   is_literalR   RL   t   encodet   UnicodeEncodeErrorR   R   RX   t	   BytesNodeR	   t   c_const_char_ptr_typet	   coerce_tot   c_const_uchar_ptr_typeRj   R)   R   t   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_typeRR   R&   R[   R   Ra   R`   RO   t   ForFromStatNodeRP   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   Rf   (   R1   R   R   R   t   bytes_valuet   bytes_sliceR   t
   start_nodet   length_tempt   end_nodeR   R   t	   kind_tempt	   data_tempt   counter_tempt   target_valuet   target_assignRO   t	   loop_nodet
   setup_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR     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 indexR[   RL   R*   s   -1iR   RG   RF   t   +RH   RV   R   R   t   1i   RZ   R   R   RX   RJ   RK   RI   R   R   RR   R   R   R   RO   RP   R   RQ   (:   R&   R   R   R   RZ   R+   R   R   R)   R[   R   R   RX   RY   R   t	   SliceNodet   AssertionErrorR   R*   R   R   R	   R   R   t   absR   t   sizeR   Rj   t   element_ptr_typet   coerce_to_simplet   AddNodet	   CloneNodeR   R]   R^   RR   t	   is_stringR
   R   t   CastNodet   DereferenceNodeR\   t   c_py_ucs4_typeR   R   R   t   assignable_fromt	   IndexNodeR   Ra   R`   RO   t   _find_for_from_node_relationsR   RP   R   Rf   (   R1   R   R   R   t   neg_stept
   slice_baseR   R   R   R   t
   step_valuet   ptr_typet
   carray_ptrt   start_ptr_nodet   stop_ptr_nodet   counterR   R   R   RO   R   R   t   for_node(    (    s7   lib/python2.7/site-packages/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   RL   R   R[   R*   RG   RH   R   RF   R   R   RX   RJ   RK   RI   (   R   R   R?   R   RX   RR   t   is_sequence_constructorR[   R   R   R   R   Rj   R   R   R   R   R  R   Ra   R   RO   R`   RI   R2   t   itemRS   RT   R   Rv   (   R1   R   t   enumerate_functionR   t   targetst   enumerate_targett   iterable_targett   counter_typeR   t   tempt   inc_expressiont	   loop_body(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR     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   (    (   R1   t   neg_step_valueR   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR
    s    c         C@  sm  | 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 	} | j |  j    | rit j |	 |  } n  | S(   Ni   i   RL   R   R*   i   i    R   R[   RR   R   R   R   R   R   RO   RP   R   (    R   R   R?   RX   R   R   R   R*   R   R   t   coerce_to_integerRj   R
  R)   R   R	   t   spanning_typeR[   R   R   t   _build_range_step_calculationRL   R   R   R&   R   R   RR   RO   RP   t   set_up_loopR   (   R1   R   t   range_functionR   R   t   step_posR  R   R   R   R   R   t   bound2_ref_nodet   abs_stept   begin_valuet	   end_valuet   bound1_valuet   bound2_is_tempR  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR     s|    	
						!		
						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   RG   RF   RH   RL   R*   R[   t   *R   i   s   //(   R   R	   R   R[   R   R   R   t
   binop_nodeRX   t   MulNodeR   R   t   DivNodet   SubNode(   R1   R   R%  R   R  R&  R   t   spanning_step_typeR'  R(  t   final_opt   step_calculation_node(    (    s7   lib/python2.7/site-packages/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 +| rt j | j d t d | } | j d	 j t |  d
 k r{d n 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   RX   RI   RV   R[   i    t   is_identifierRL   s*   'NoneType' object has no attribute '%{0}s'i   s   .30t    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    RL   R*   (   R   R   RX   R   (   RL   (   R   (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt	   flag_node  s    RJ   RK   R   R*   t   __Pyx_dict_iteratorR   t	   dict_iters
   Optimize.cR   R   RN   RO   RP   RQ   (*   R   R]   R	   t   py_object_typeR2   R^   RX   R   R)   RR   R  R?   R   R   RO   R   R`   R   R   t
   c_ptr_typeR[   R   t   DictIterationNextNodeRi   Rj   RI   t
   StringNodeR   R   t   formatt   NullNodeRa   R   R   t   PyDict_Iterator_func_typeR   R   R
   R   t   WhileStatNodeRP   Rf   (   R1   R   R{   R|   R}   R~   RQ   R  t	   dict_tempt   pos_tempt
   key_targett   value_targett   tuple_targetRO   t   dict_len_tempt   dict_len_temp_addrt   is_dict_tempt   is_dict_temp_addrt   iter_next_nodet   method_nodeR8  t   result_code(    (   R   s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR   n  s    			'							R   t   is_dictt   method_namet   p_orig_lengtht	   p_is_dictt   sett   is_sett   p_is_setc         @  s  g  } t  j t j  } | j |  | j | j  } t  j t j  } | j |  | j   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  }   j } t
 j | | j | j  | | |
  } | j |  j    } | g | j d 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(   NRX   RI   RV   R[   i    c         @  s4   |  r d p d }  t  j   j d t |   d |  S(   Ni   i    RL   R*   (   R   R   RX   R   (   RL   (   R   (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR8    s    RJ   RK   RL   R   R*   t   __Pyx_set_iteratorR   t   set_iters
   Optimize.cR   R   RN   RO   RP   RQ   (#   R   R]   R	   R;  R2   R^   RX   R   R   RO   R   R`   R   R   R<  R[   R   RR   t   SetIterationNextNodeRi   Rj   RI   Ra   R   R   t   PySet_Iterator_func_typeR   R   R
   R   R   RB  R)   RP   Rf   (   R1   R   t   set_objRQ   R  t   set_tempRD  RO   t   set_len_tempt   set_len_temp_addrt   is_set_tempt   is_set_temp_addrRF  RL  R8  RN  (    (   R   s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR     sj    	!						N(&   R:   R;   R<   Ru   Rw   R&   Rv   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   RA  RY  R   (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRE      sZ   	1	r	&	\	I	S	@	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(   NRU   s   ==s   !=R   t   ort   and(!   R   R   R   t   CoerceToTempNodet   CoerceToBooleanNodeR   t   BoolBinopResultNodeR   t   EvalWithTempExprNodet   subexpressiont   TypecastNodeRV   R_   t   cascadeR)   t   NO_MATCHt   is_c_string_containsRH   t   UnicodeNodeR   RF   t   contains_surrogatesRG   t   extract_in_string_conditionst   is_python_comparisonR&   R#   R   t   getattrR   t   is_constt   BoolBinopNodet   extract_conditions(
   R1   t   condt   allow_not_inRU   t   not_in_1t   t1t   c1t   not_in_2t   t2t   c2(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRv  2  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(   NRL   R*   i   (   R   R   Ro  t   listt   mapt   ordRS  RL   t   sortR   RX   R   R   R?   t   CharNode(   R1   t   string_literalt   charvalst   charvalt
   characterst   i(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRq  o  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(   Rv  R)   Rm  R#   R[   R   R   t   sum(   R1   t
   common_varRN   Rx  RU   t   vart
   conditionsRw  (    (    s7   lib/python2.7/site-packages/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(	   RS  R   R*   R   t   addR   t   cnamet   AttributeErrorR&   (   R1   t   condition_valuest   seenRL   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   has_duplicate_values  s    	c      	   C@  s  |  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 |  | S|  j | d  x | D] } |  j | d  q/Wt |  } t	 j d | j d | d | d | j  }
 |
 S(	   Ns   optimize.use_switchRX   R  RO   i   RP   t   testt   cases(   t   current_directivest   getR3   R)   RM   R  RN   R&   R2   R   t   SwitchCaseNodeRX   RO   R  R?   R  R   t   SwitchStatNodeRP   (   R1   R   R  R  t	   if_clauset   _R  t   caseRw  R  t   switch_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_IfStatNode  s<    )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  R3   R  R)   R  R   R?   R  t   build_simple_switch_statementt   true_valt	   false_val(   R1   R   RU   R  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_CondExprNode  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   RL   R*   (   R  R  R3   R  R)   R   R?   R  t   wrap_operandsRj   R  R   Rb   RX   R&   (   R1   R   RU   R  R  (    (    s7   lib/python2.7/site-packages/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   RL   R*   (   R  R  R3   R  R)   R   R?   R  R  R   Rb   RX   R&   (   R1   R   RU   R  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRu     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(
   NRJ   RK   t   firstRX   R  RO   R  R  RP   (   R   R   R   Ra   RX   R   R[   Rj   R   R  R   R  Rl   (   R1   R   R  R  RU   R  R  Rn   t	   true_bodyt
   false_bodyR  R  t   replacement(    (    s7   lib/python2.7/site-packages/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  R3   Rj  t	   lazy_tempR   t   tree_contains(   R1   R   t	   orig_exprt   temp_ref(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_EvalWithTempExprNode  s    		
N(   NNN(   R:   R;   R<   R)   Rm  Rv  Rq  R  R  R  R  R  Ru   R  R  R   t   VisitorTransformt   recurse_to_childrenR=   (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRc  *  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   inRd  s   ==RU   Re  s   !=i    RX   RG   RF   RH   Rl  RV   R[   c      	   @  s%   t  j d  j d   d |  d |  S(   NRX   RF   RG   RH   (   R   Ru  RX   (   t   leftt   right(   t   conjunctionR   (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   concata  s
    		i(   R3   Rl  R)   RF   R   RH   R   t	   TupleNodet   ListNodet   SetNodeR   R?   R   R   RG   t	   is_simplet	   ExceptionR&   R   R2   R_   RX   Rk  R	   t   c_bint_typeR   Ri  (   R1   R   t	   eq_or_neqR   RJ   t   condsRQ   R   t   is_simple_argRw  R  RN   Rt   R  (    (   R  R   s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRu   /  sX    		
				(   R:   R;   R<   Ru   R   R  R  R=   (    (    (    s7   lib/python2.7/site-packages/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.
        (   RI   R   R   Ra   t   _extract_operandRJ   RK   t   CascadedAssignmentNodeRS  R?   t   _extract_index_idR2   R   R&   t   use_managed_ref(   R1   R   t
   left_namest   right_namest   left_indicest   right_indicesRQ   t   statt   patht   nt   lnamest   rnamest   lindicest   lhs_nodet   index_idt   rindicest   rhs_nodet   tt	   temp_argsR  R  t	   name_nodet
   index_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_ParallelAssignmentNodev  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   R[   R   R&   R   R   Rf  R2   R   R   R"   t   memberR$   R   R   t   joinRY   RZ   R
   R   R   R   R   (   R1   R   t   namest   indicesRQ   t	   name_patht   obj_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s4    		,	c         C@  sW   | j  } | j } t | t j  r0 | j } n t | t j  rF d  Sd  S| j | f S(   N(   RZ   R   R   R   R    R   t	   ConstNodeR)   (   R1   R  RZ   R   t	   index_val(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s    		(
   R:   R;   R<   R   R  R  R=   R  R  R  (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  q  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(   R3   R   t   _function_is_builtin_namet   _dispatch_to_handlerR   (   R1   R   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_SimpleCallNode  s
    	c         C@  sj   |  j  |  | j } |  j |  s) | S| j } t | t j  sH | S| j } |  j | | | | j	  S(   N(
   R3   R   R  t   positional_argsR   R   R  R   R  t   keyword_args(   R1   R   R   R   R   (    (    s7   lib/python2.7/site-packages/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&   Rj   t   lookupR   t   builtin_scopet   lookup_hereR   (   R1   R   t   envR   (    (    s7   lib/python2.7/site-packages/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   Rs  (   R1   R   R   R   t   kwargst   handler_namet   handle_call(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s    c         C@  s1   t  j | j j | j j | | d | | _ d  S(   NR   (   R   t   PythonCapiFunctionNodeR   RX   R   (   R1   R   R  t	   func_typeR   (    (    s7   lib/python2.7/site-packages/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(   NR5  i   s   ...t   xs   expected %s, s3   %s(%s) called with wrong number of args, %sfound %d(   R   R   R)   R   RX   R?   (   R1   t   function_nameR   R   t   expectedt   arg_strt   expected_str(    (    s7   lib/python2.7/site-packages/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(   NRL   s   0.0i   t   floati    R[   (   R   t	   FloatNodeRX   R?   R  Rs  R)   R	   t   c_double_typeR
   t
   float_type(   R1   R   t   pos_argst   arg_type(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_float5  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   RX   t   NoneNode(   R1   R   R  R   R   R   R   (    (    s7   lib/python2.7/site-packages/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    R[   RL   R*   i   (   R?   R   R   Ro  R   RL   R   RX   R	   t   c_long_typeR   R  R>  t   unicode_valueR   (   R1   R   R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_ordQ  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&   (   R1   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_allj  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   (   R1   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_anyz  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    RV   RP   RM   RN   RO   RL   R*   t   gent	   orig_funct   anyt   all(   R?   R   R   t   GeneratorExpressionNodet   def_nodet   gbodyRO   RA   R)   Rm   RX   R   Rd   Re   t   ReturnStatNodeRb   RP   R   t   recursively_replace_nodet   InlinedGeneratorExpressionNode(   R1   R   R  t   is_anyt   gen_expr_nodet   generator_bodyR   t   yield_expressiont   yield_stat_nodeRN   t	   test_node(    (    s7   lib/python2.7/site-packages/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_typeR5   RR   t   PySequence_ListR   R   RX   R[   t   may_hold_noneRJ   RK   R  R$   R%   R  t   needs_none_checkR   RI   ("   R?   R   R   t   ComprehensionNodeR[   R
   R   t   loopR  R>   R  RX   t   ComprehensionAppendNodeRR   R   R  R  t   as_listR   t   PySequence_List_func_typeR   R   R   R&   R   Ra   R!   R   R   R   t   analyse_declarationsRj   Rl   R`   (   R1   R   R  R   t	   list_nodeR   R  R@   R  R  t   append_nodet   result_nodet   list_assign_nodet   sort_methodt	   sort_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_sorted  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    RL   R   R*   RX   R[   RJ   RK   R   RI   R   R  R  R%  t
   expr_scopeR  R  t   has_local_scope(   i   i   N(   R?   R   R   R  R  R  RA   R)   R2   R5   R   R[   R   R  R   RX   R   R   R	   R;  R   Ra   R-  R   R  R`   R   R  R*  R+  (   R1   R   R  R  R   R  R  R   Rn   t   add_nodet	   exec_code(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   __handle_simple_function_sum  sP    
			!
			c         C@  s   |  j  | | d  S(   NR   (   t   _optimise_min_max(   R1   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_min,  s    c         C@  s   |  j  | | d  S(   NR   (   R/  (   R1   R   R  (    (    s7   lib/python2.7/site-packages/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  R  RG   RF   RH   Ni(   R?   R  R   R  R  R   R   R   t   CondExprNodeRX   R_   Ri  (	   R1   R   R   RF   t   cascaded_nodest   last_resultt   arg_nodeRn   t   ref_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR/  2  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  RX   t   _transform_list_set_genexprR
   R   t   AsTupleNode(   R1   R   R  t   result(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt&   _DISABLED_handle_simple_function_tupleU  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(   R1   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt!   _handle_simple_function_frozensetd  s    
c         C@  s8   | s" t  j | j d g  d g  S|  j | | t j  S(   NR   R*   (   R   R  RX   R7  R
   R   (   R1   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_listo  s    c         C@  s;   | s% t  j | j d g  d t   S|  j | | t j  S(   NR   R*   (   R   R  RX   RS  R7  R
   R   (   R1   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_sett  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  RS  R  R  R5   RR   (   R?   R   R   R  R  R>   R  RX   R
   R   R  RR   R   R  (   R1   R   R  R   R  R   R@   R%  R  R  R$  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR7  y  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_exprRR   (   R?   R   t   DictNodeRX   R   R  R  R>   R  R   R  R
   R   t   DictComprehensionAppendNodeRR   R   R  (   R1   R   R  R  R   R@   R  R  R%  R  R$  (    (    s7   lib/python2.7/site-packages/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   RB  (   R1   R   R  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_general_function_dict  s
    N('   R:   R;   R<   R   R  R  R=   R  R  R  R)   R  R  R  R  R   R  R  R  R  R	   R`  R
   R   Rb  R;  R!  R)  t5   _EarlyReplaceBuiltinCalls__handle_simple_function_sumR0  R1  R/  R:  R<  R=  R>  R7  RD  RE  (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    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_nullRj   R  R   t   cf_assignmentsR?   RK   (   R1   R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   get_constant_value_node  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   (   R3   R  R  R   R   RK  R   R   t   PyCFunctionNodet   InlinedDefNodeCallNodeRX   R   t   can_be_inlinedt   replace(   R1   R   R  R   t   inlined(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s    		(   R:   R;   R   R  R  R=   RK  R  (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRG    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 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  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  Z/ d   Z0 e j e j1 e j
 d e j	 d  g  Z2 d   Z3 e j e j e j
 d e j	 d  g d d  d e Z4 d!   Z5 e j e j	 e j
 d e j	 d  g  Z6 e j e j	 e j
 d" e j d  g  Z7 d#   Z8 d$   Z9 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 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 j1 6d- e j% 6jA ZB eC d. g  ZD d/   ZE e j e jF e j
 d0 e j	 d  g  ZG d1   ZH e j e jI e j
 d2 e j	 d  g  ZJ d3   ZK d4   ZL e j e j	 e j
 d5 e j	 d  e j
 d6 e j+ d  g  ZM e j e j	 e j
 d5 e j	 d  e j
 d6 e j+ d  e j
 d7 e j% d  g  ZN d d8  ZO e j e jP e j
 d e j	 d  e j
 d9 e j	 d  g d d& ZQ d:   ZR d;   ZS e j e jP e j
 d< e j	 d  e j
 d" e j d  g d d& ZT e j e jP e j
 d< e j	 d  e j
 d" e j	 d  g d d& ZU d=   ZV e j e j	 e j
 d e j	 d  g  ZW 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 dA e ZX dB   ZY eZ dC  Z[ e j e jP e j
 d e j	 d  g d d& Z\ dD   Z] e j e j	 e j
 d 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
 d e j	 d  e j
 dE e j	 d  e j
 dF e j	 d  e j
 dH e j d  g  Z` dI   Za e j e j	 e j
 d e j	 d  e j
 dE e j	 d  e j
 dF e j	 d  g  Zb dJ   Zc e dK   e jd e j f D  Ze dL   Zf dM   Zg dN   Zh dO   Zi dP   Zj dQ   Zk dR   Zl dS   Zm dT   Zn dU   Zo dV   Zp dW   Zq dX   Zr dY   Zs dZ   Zt d[   Zu d\   Zv d]   Zw d^   Zx d_   Zy d`   Zz da   Z{ e j e jI e j
 db e j| d  g  Z} dc   Z~ e~ Z e~ Z e~ Z e~ Z e~ Z e~ Z e~ Z e~ Z e~ Z e j e j| e j
 db e j| d  g  Z dd   Z e Z e Z e Z e j e j( e j
 de e j! d  e j
 df e jI d  g  Z dg   Z e j e j( e j
 de e j! d  e j
 dh e j	 d  e j
 di e j d  g  Z dj   Z e j e j! e j
 de e j! d  e j
 dk e j	 d  g  Z dl   Z e j e jI e j
 de e j	 d  e j
 dm e j	 d  e j
 dn e j d  e j
 do e j d  e j
 dp e j d  g d d& Z dq   Z dr   Z ds   Z e j e j e j
 de e j! d  e j
 dm e j	 d  e j
 dn e j d  e j
 do e j d  e j
 dp e j d  g d dt Z du   Z dv   Z dw   Z e j e j e j
 de e j! d  e j
 dm e j	 d  e j
 dn e j d  e j
 do e j d  g d d& Z dx   Z e j e j! e j
 de e j! d  e j
 dm e j	 d  e j
 dy e j	 d  e j
 dz e j d  g  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  Z e j e j e j
 d e j! d  g  Z d~ d d d d d d d g Z g  e D] Z e e j e  f ^ q[Z d   Z e j 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
 dn 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 d  g  Z e j e j! e j
 d e j	 d  e j
 dn 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 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 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@  s   |  j  |  | j   S(   s:   Flatten redundant type checks after tree changes.
        (   R3   t	   reanalyse(   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_PyTypeTestNode  s    c         C@  s-   |  j  |  | j | j j k r) | j S| S(   s,   
        Drop redundant type casts.
        (   R3   R[   RV   (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _visit_TypecastNode  s    c         C@  s   |  j  |  t | j t j  r4 | j j | _ n  | j } | d k s[ | j s[ | j r_ d S| j	 r | j
 r | j
 j s | j
 j r d S| S(   s7   
        Drop dead code and useless coercions.
        N(   R3   R   R5   R   t   CoerceToPyTypeNodeR   R)   t   is_noneR   R   R   t   is_localt   is_arg(   R1   R   R5   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR6     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.
        (   R3   R   R   R   t   PyTypeTestNodeRU  R[   R	   R;  R
   t	   bool_typet   coerce_to_booleanRj   (   R1   R   R   (    (    s7   lib/python2.7/site-packages/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   (   R3   R   R   R   t   CoerceFromPyTypeNodeR   R   R   R?   R   R[   R
   R  R   R   RX   t   PyNumber_Float_func_typeR   R   R   Rj   (   R1   R   R   t   func_arg(    (    s7   lib/python2.7/site-packages/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.
        (   R3   R   R[   R   R   Rj   R   R   RY  R   R   R   t   is_floatR  Rb   RU  R	   R;  R  R
   R   t   is_unicode_charR   t   _optimise_numeric_cast_callRY   R   t   _optimise_int_indexing(   R1   R   R   R  (    (    s7   lib/python2.7/site-packages/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    RL   R*   t   __Pyx_PyBytes_GetItemIntR   s&   'NoneType' object is not subscriptableR   R   t   bytes_indexs   StringTools.c(   Rj   t
   directivesRZ   R[   R
   R   R	   t   c_char_typet   c_uchar_typeR   R   RX   R   R   t   PyBytes_GetItemInt_func_typeR   R   R   R   R   R   (   R1   t   coerce_nodeR   R  R  t   bound_check_boolt   bound_check_nodeR   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRg  k  s(    				c         c@  s9   |  ]/ } | t  j | t  j d  | d  g  f Vq d S(   R   N(   R	   R`  Rb  R)   (   t   .0R  (    (    s7   lib/python2.7/site-packages/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   intRV   R[   t   lt   __Pyx_trunclt   truncR  R   R_  R   R   R  (   R   R)   R   R   R   R   R    R[   t   is_builtin_typeR   R  R?   RU  R   R   R   R   R  Rd  Rk  RX   t
   is_numerict   math_h_modifiert   float_float_func_typesR   R   R   Rj   (   R1   R   R   R   R   Rb  t   truncl(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRf    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(   NR5  i   s   ...R  s   expected %s, s3   %s(%s) called with wrong number of args, %sfound %d(   R   R   R)   R   RX   R?   (   R1   R  R   R   R  R  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s    			c         C@  s   | S(   N(    (   R1   R   R  R   t   arg_listR  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_function  s    c         C@  s\  | 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 |  j | | | | |  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   R[   R%   t	   is_calledR   R   N(   R   R$   R   Rj   R  R   R!   R   RX   R    R[   R   t   analyse_as_type_attributeR)   t%   _optimise_generic_builtin_method_callR   R   R   R1   t   analyse_c_function_callt   analysedR   (   R1   R   t	   type_namet	   attr_nameR   R  t   is_unbound_methodR  t
   type_entryR|   R   t	   call_node(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_method  s>    					c         C@  sz   t  |  } | s1 | d k s1 | j o- | j r5 | S| j j j sH | S| j j j d k ra | St j | | j | |  S(   s   
        Try to inject an unbound method call for a call to a method of a known builtin type.
        This enables caching the underlying C function of the method at runtime.
        i   R   R[   (   R   R[   (	   R?   R   R"   R$   R[   R{  R   R   t   CachedBuiltinMethodCallNode(   R1   R   R  R   R  R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s    %R$   c         C@  s   t  |  d k rG t  |  d k rC t j | j d t   d d S| S| d } | j t j k r | j   ss | Sd } t	 j
 d d  } n d	 } t	 j
 d
 d  } t j | j | |  j d | d | j d | d d S(   s5   Optimise single argument calls to unicode().
        i   i    RL   R*   u    t   __Pyx_PyUnicode_Unicodet   PyUnicode_Unicodes   StringTools.ct   __Pyx_PyObject_Unicodet   PyObject_UnicodeR   R   R   R_  t   unicode(   R?   R   Ro  RX   R   R[   R
   R   t   may_be_noneR   R   R   t   PyObject_Unicode_func_typeR   (   R1   R   R   R  R   R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_unicode	  s$    
	c         C@  so   |  j  |  | j j t j k rk | j rk | j rk | j sO | j d k rk |  j | d | j g  Sn  | S(   s   Simplify or avoid plain string formatting of a unicode value.
        This seems misplaced here, but plain unicode formatting is essentially
        a call to the unicode() builtin, which is optimised right above.
        R   N(
   R3   RL   R[   R
   R   t   c_format_spect   format_spect   conversion_charR  R)   (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_FormattedValueNode'	  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?   R[   R
   R   R   R   R   RX   t   PyDict_Copy_func_typeR   (   R1   R   R   R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRD  8	  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   RX   R!  R   (   R1   R   R   R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR=  K	  s    
R  c         C@  s   t  |  d k s | j r  | S| d } | j t j k rM | j   rM | S| j t j k r | j d  | d <t j	 | j
 d |  j d | d | j St j | j
 d | d t j Sd	 S(
   sD   Replace tuple([...]) by PyList_AsTuple or PySequence_Tuple.
        i   i    s!   'NoneType' object is not iterablet   PyList_AsTupleR   R   R   R[   N(   R?   R   R[   R
   R   R  R   R   R   R   RX   t   PyList_AsTuple_func_typeR8  (   R1   R   R   R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_tupleZ	  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_NewR_  RS  (   R?   R  R   R  R   R   R2   R   R  RX   RO  Ri  R   t   PySet_New_func_typeR   (	   R1   R   R   R  R   RQ   R   R9  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR>  q	  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.cR_  t	   frozenset(   R   R@  RX   R?   R[   R
   R   R  R   t   PyFrozenSet_New_func_typeR   R   R   (   R1   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR<  	  s    '			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    RL   s   0.0R*   g        i   R  s   0 or 1RV   R[   t   __Pyx_PyObject_AsDoubleR   R   R   t   pyobject_as_doubleR_  (   R?   R   R  R   R
   R  Rj   R  R   RU  R   R[   R	   R  R  R|  Rk  RX   R   t   PyObject_AsDouble_func_typeR   R   (   R1   R   R   R  Rb  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  	  s,    
!			RL   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    RL   R   R*   R[   i   t   __Pyx_PyInt_FromDoubleR   R   R_  Rw  R   t   PyIntFromDoubles   TypeConversion.ct   __Pyx_PyNumber_Int(   R?   R   R   RX   R	   R;  R   RU  R   R[   Rd  R   t   PyInt_FromDouble_func_typeR   R   R   R   t   PyNumber_Int_func_type(   R1   R   R   R  Rb  (    (    s7   lib/python2.7/site-packages/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    RL   R*   i   t   bools   0 or 1RV   N(   R?   R   Rb   RX   R&   R   R
   RZ  Rj   R  R[  Rm   t   coerce_to_pyobject(   R1   R   R   R  RV   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_bool	  s    R  s   -1t   __Pyx_PyUnicode_GET_LENGTHR   t   PyByteArray_GET_SIZEt   PyList_GET_SIZEt   PyTuple_GET_SIZEt   PySet_GET_SIZEt   PyDict_Sizes   cpython.array.arrayc   	      C@  sb  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 } nG| j j rGt j t j t j d | j d  g d t } t j | j	 d | d | g d | j } n | j j r|  j | j  } | d k r| j } | j s| j r| j j |  j k rd } q| 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   memoryviewslicet   nogilt   __Pyx_MemoryView_Lent   Py_SIZEs&   object of type 'NoneType' has no len()RL   R   R*   R[   N(%   R?   R  R   R   RU  R   R[   R  R   RX   t   Pyx_strlen_func_typeR   R   R   t   is_pyunicode_ptrt   Pyx_Py_UNICODE_strlen_func_typet   is_memoryviewsliceR	   R`  t   c_size_t_typeRb  R)   R   R   t   _map_to_capi_len_functiont   is_extension_typeR{  R   R   t   _ext_types_with_pysizeR   t   PyObject_Size_func_typeRe  R   R   R   Rj   (	   R1   R   R   R  R   Rt   R  t
   cfunc_nameR  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_len
  sZ    
							
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   RX   t   Pyx_Type_func_typeR&   R  R	   R;  (   R1   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_function_typeT
  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    R[   t   exactt   __Pyx_TypeCheckt   PyObject_IsInstanceR   R   c         @  s5   |  j  d |  |  } t j | _ | j    | S(   NRd  (   RX   R	   R  R[   R  (   R'   R(   t   make_binop_nodet   or_node(   R  R   (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   join_with_or
  s    Ni(!   R?   R   R   R  R   R[   R
   t	   type_typeR   R  R   R   R2   Rj   R)   R   R   R  R   R{  t   scopet   is_builtin_scopet   type_check_functionR&   R   R   RX   t   Py_type_check_func_typeR   R-  R   R   Ri  (   R1   R   R   R  R   t   typesRQ   t   testst
   test_nodest   test_type_nodet   builtin_typeR   R  t   type_check_argsR  R  R  (    (   R  R   s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt"   _handle_simple_function_isinstanced
  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    RV   R[   RL   R*   i   (   R?   R   R   RU  R   R[   Re  Rk  RX   R	   R  R   Rj   Ro  RL   R   R   R   R  R>  R  (   R1   R   R   R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  
  s0    
R[   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 rA| j j }	 |	 j rP|	 j rP|	 j j   |  j   j   k rPt j d d  }
 t j |	 j |
  } | r>|  j j } t j | j d  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! d t SqP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   PyTypeObjectR[   R  t   may_return_noneR   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   R[   R
   R  R  R   R   R  RX   t   analyse_typesRj   R   R  t   typeobj_cnameR  R   R   t   ConstructorSlott   get_slot_functionR   t   cython_scopeR	   t   CPtrTypeR  R`  Rb  R)   R;  R  R@  R   R&   R   R   R   t   Pyx_tp_new_kwargs_func_typeR   t   Pyx_tp_new_func_type(   R1   R   R   R   R  R  R$   t   type_argt
   args_tuplet   ext_typet   tp_slott   slot_func_cnameR  t   PyTypeObjectPtrt   pyx_tp_new_kwargs_func_typeR   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_any_slot__new__
  sl    	
$	!		
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   R  R   R   R   R2   (	   R?   R   R   R   RX   t   PyObject_Append_func_typeR&   R   R   (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_object_append'  s    	c         C@  s  t  |  d k r | S| \ } } | j s/ | St | j  } | j d k	 s_ t  |  d k r t r t | t j	  r | d j
   j |  j   d t } t j | | d |  n  | S|  j | | | d  }	 | s | j |	 _ |	 S|	 }
 } t  |  d k r#| j   r#t j |  }
 n  g  } | d } | j   s^t j |  } | j |  n  t j | j d |  j d |
 | g d	 t d
 t d  } x | d d d  D] } | j   st j |  } | j |  n  t j | j d t j | j d |  j d |
 | g d d d	 t d
 t d  | d t j } qW| j | _ |
 | k	 re| j |
  n  x, | D]$ } t j | |  } | j | _ qlW| S(   s   Replace list.extend([...]) for short sequence literals values by sequential appends
        to avoid creating an intermediate sequence argument.
        i   i   i   R  t   extendit   __Pyx_PyList_AppendR   R   R   t
   ListAppendiNt   |t   __Pyx_ListComp_AppendR_  t   ListCompAppendR[   (   R?   R  R  R   t   mult_factorR)   R&   R   R   R  R;  R  Rj   R   R   R  t   _wrap_self_argR   R  R   R   R2   R   RX   R  R   R-  R	   t   c_returncode_typeRi  (   R1   R   R   R   R  R$   RL   R   t
   tuple_nodet   wrapped_objt
   cloned_objRQ   R   Rt   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt!   _handle_simple_method_list_extend7  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   R[   R   R   R   R   R   R	   R   Rj   R   R   t   is_string_literalt   can_coerce_to_char_literalRp  R   t"   PyByteArray_AppendObject_func_typeR   RX   R&   R   R   (
   R1   R   R   R   R  t	   func_nameR  RL   R   Rt   (    (    s7   lib/python2.7/site-packages/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   (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/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 '%.30s'R   R6  R7  t   popt   Objecti   s   __Pyx_Py%s_PopR   R  R   R   i   t   intvals   __Pyx_Py%s_PopIndexRL   R*   R[   t	   pop_indexN(%   R   R?   R   R   RX   t   PyObject_Pop_func_typeR   R   R   R   R  R[   R   R   R   R  Rj   R   R	   R   R   R  R  t   numeric_type_fitst   create_to_py_utility_codet   to_py_functionR`  R;  Rb  R)   t   PyObject_PopIndex_func_typeR   t   signedR   t   RawCNameExprNodet   c_void_typet   empty_declaration_code(   R1   R   R   R   R  R  R$   R  R   R  t   orig_index_typet   convert_funct   conversion_type(    (    s7   lib/python2.7/site-packages/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_SortR  (   R?   t   _substitute_method_callt   single_param_func_typeR   R[   Rj   (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/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?   R2   R   R  RX   R  R*  t   Pyx_PyDict_GetItem_func_typeR   R   (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/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    RL   R*   t   __Pyx_PyDict_SetDefaultt
   setdefaultR  R   t   dict_setdefault(   R?   R2   R   R  RX   R  R[   R{  Rw  R   R	   R;  R   R   R*  t   Pyx_PyDict_SetDefault_func_typeR   R   (   R1   R   R   R   R  t   key_typeR3  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt%   _handle_simple_method_dict_setdefault)  s(    				c         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(
   s7   Replace dict.pop() by a call to _PyDict_Pop().
        i   i   s   dict.pops   2 or 3t   __Pyx_PyDict_PopR  R  R   t   py_dict_pop(
   R?   R2   R   R@  RX   R  R*  t   PyDict_Pop_func_typeR   R   (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _handle_simple_method_dict_popJ  s    	c         c@  s   |  ] } t  j t  j f D] } | | f t  j | t  j d  t  j d  t  j d t  j d  t  j d | d  t  j d t  j d  t  j d t  j d  g d | j r d n | j f Vq q d S(   t   op1t   op2t   cvalt   inplacet   zerodiv_checkR   N(   R	   R;  R  R`  Rb  R)   R   R   (   Rv  t   ctypet   ret_type(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pys	   <genexpr>[  s   c         C@  s   |  j  d | | | |  S(   Nt   Add(   t   _optimise_num_binop(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___add__g  s    c         C@  s   |  j  d | | | |  S(   Nt   Subtract(   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___sub__j  s    c         C@  s   |  j  d | | | |  S(   Nt   Eq(   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_object___eq__m  s    c         C@  s   |  j  d | | | |  S(   Nt   Ne(   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_object___ne__p  s    c         C@  s   |  j  d | | | |  S(   Nt   And(   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___and__s  s    c         C@  s   |  j  d | | | |  S(   Nt   Or(   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_object___or__v  s    c         C@  s   |  j  d | | | |  S(   Nt   Xor(   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___xor__y  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   R   R*   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt'   _handle_simple_method_object___rshift__|  s
    )5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   Lshift(   R?   R   R   R   R   R*   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt'   _handle_simple_method_object___lshift__  s
    )5c         C@  s   |  j  d | | | |  S(   Nt	   Remainder(   t   _optimise_num_div(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt$   _handle_simple_method_object___mod__  s    c         C@  s   |  j  d | | | |  S(   Nt   FloorDivide(   RY  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt)   _handle_simple_method_object___floordiv__  s    c         C@  s   |  j  d | | | |  S(   Nt
   TrueDivide(   RY  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt(   _handle_simple_method_object___truediv__  s    c         C@  s   |  j  d | | | |  S(   Nt   Divide(   RY  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/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?   R   R*   R   R   R   R  RF  (   R1   RF   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRY    s    6##c         C@  s   |  j  d | | | |  S(   NRE  (   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___add__  s    c         C@  s   |  j  d | | | |  S(   NRH  (   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___sub__  s    c         C@  s   |  j  d | | | |  S(   NR]  (   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt'   _handle_simple_method_float___truediv__  s    c         C@  s   |  j  d | | | |  S(   NR_  (   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___div__  s    c         C@  s   |  j  d | | | |  S(   NRX  (   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_float___mod__  s    c         C@  s   |  j  d | | | |  S(   NRJ  (   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt"   _handle_simple_method_float___eq__  s    c         C@  s   |  j  d | | | |  S(   NRL  (   RF  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt"   _handle_simple_method_float___ne__  s    c         C@  s  t  |  d k r | S| j j r. t j } n. | j t j k rX | d$ k rX t j } n | St j t j f } t	 | d |  r | d j t j k	 r | S| d } d }	 nD t	 | d |  r | d j t j k	 r | S| d } d }	 n | S| j
   s| St	 | t j  }
 |
 r#t j n t j } |
 rE| d% k rn| Sn) | d k rU| St | j  d& k rn| S| d' k r| d j d k r| Sn  t |  } | j |
 rt j n t j | j d | j d | j d |  t	 | t j  r| j n t } | j t j | j d | d |  |
 s8| d( k r|	 d k oct	 | t j  r`| j n t } | j t j | j d | d |  n  t j |
 rd n | d) k rd n d d d t d | d |	 d |  } |  j | | d |
 rd n d | j rd n d | |	 f |  j | | f d | d   j   | | d! t d" t d# | } | j j r| j rt j  | |  j!   | j  } n  | S(*   sY   
        Optimise math operators for (likely) float or small integer operations.
        i   RJ  RL  i   i    t   ObjCt   CObjRE  RH  RX  R]  R_  i   R[  RL   R*   R[   t   PyFloatBinopt   PyIntComparet
   PyIntBinops
   Optimize.cR   t   opt   orderRD  s   __Pyx_Py%s_%s%s%st   Floatt   IntR5  t   Bools   __%s__i   R  t   with_none_checkR   (   RJ  RL  (   RE  RH  RX  R]  R_  RJ  RL  i   @(   R]  R[  R_  RX  (   RJ  RL  (   RJ  RL  ("   R?   R[   R   R	   R;  R  R   R   R  R   R   R  R  R   R*   R  R2   RX   RL   t   NumBinopNodeRA  R&   Rb   R/  t	   cdivisionR   R   R   R*  t   Pyx_BinopInt_func_typest   lowerR   RU  Rj   (   R1   RF   R   R   R   R  RD  t	   num_nodest   numvalt	   arg_orderRd  t   num_typeRA  t   zerodivision_checkR   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRF    s|    
	
	
!%"(!	!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   RU  R   R[   Re  R%   R   R   R)   t   upperR*  t#   PyUnicode_uchar_predicate_func_typeR   R  Rj   (   R1   R   R   R   R  t   ustringR|  RP  R   R  t	   func_call(    (    s7   lib/python2.7/site-packages/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   RU  R   R[   Re  R%   R  R*  t$   PyUnicode_uchar_conversion_func_typeR   R  Rj   (
   R1   R   R   R   R  R  R|  RP  R  R  (    (    s7   lib/python2.7/site-packages/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(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt(   _handle_simple_method_unicode_splitlinesX  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  R2   R   R@  RX   t   _inject_int_default_argumentR	   R   R*  t   PyUnicode_Split_func_type(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt#   _handle_simple_method_unicode_splitn  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  R  R  R5   RR   t   PyUnicode_JoinR  (   R?   R  R   R   R  R  R>   R  RX   R
   R   R  RR   R   R  R*  t   PyUnicode_Join_func_type(   R1   R   R   R   R  R  R   R@   t   inlined_genexprR  R  R$  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt"   _handle_simple_method_unicode_join  s,    
			t	   substringR   t   endt	   directionc      	   C@  s#   |  j  | | | | d d t d 
 S(   NR  t   endswithi   (   t   _inject_tailmatcht   unicode_tailmatch_utility_code(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt&   _handle_simple_method_unicode_endswith  s    c      	   C@  s"   |  j  | | | | d d t d  S(   NR  t
   startswithi(   R  R  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/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_MAXRL   R[   s   __Pyx_Py%s_TailmatchR   (   i   i   i   (   R?   R  R  R	   R   R2   R   R   RX   R   R   R*  t
   capitalizet   PyString_Tailmatch_func_typeR   R
   RZ  Rj   (
   R1   R   R   R   R  R  RP  R   R  t   method_call(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s      "	s   -2c         C@  s   |  j  | | | | d d 
 S(   Nt   findi   (   t   _inject_unicode_find(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt"   _handle_simple_method_unicode_find  s    c         C@  s   |  j  | | | | d d  S(   Nt   rfindi(   R  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/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  RL   R[   t   PyUnicode_Find(   i   i   i   (   R?   R  R  R	   R   R2   R   R   RX   R   R   R*  t   PyUnicode_Find_func_typeR  Rj   (   R1   R   R   R   R  RP  R  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    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  R  R	   R   R*  t   PyUnicode_Count_func_typeR  Rj   (   R1   R   R   R   R  R  (    (    s7   lib/python2.7/site-packages/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_ReplaceRO  (   i   i   (   R?   R  R  R	   R   R*  t   PyUnicode_Replace_func_type(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt%   _handle_simple_method_unicode_replace  s    t   encodingt   errorst   UTF8t   UTF16s   UTF-16LEs   UTF-16BEt   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 | 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   RL   R[   t   strictR+  s   PyUnicode_As%sStringN(   R?   R  R   R@  RX   R*  t#   PyUnicode_AsEncodedString_func_typet   _unpack_encoding_and_error_modeR)   R   Ro  RL   R   R   R   R
   R   t   _find_special_codec_namet   PyUnicode_AsXyzString_func_type(   R1   R   R   R   R  t   string_nodet	   null_nodet
   parametersR  t   encoding_nodet   error_handlingt   error_handling_nodeRL   t
   codec_namet   encode_function(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt$   _handle_simple_method_unicode_encode8  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	 r| d, k rSd | j d d  } n
 d | } t j | j d |  j d | } t j  | j  } n t j  | j  } g  } |	 j rH| s6| 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 r2| s{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 j0 d*  t j/ d$ t j0 d*  t j/ d% |  j d*  g  |  _, n  |  j, } d& } nQ | s\t j | j d d d t j+ } n  |  j1 } |	 t j k r}d' } n d( } t j% | j d) | | d | | | | | | g d | j2 d t( j) | d  } x- | d* d* d+  D] } t" j3 | |  } 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'R7  t   decodes*   'NoneType' object has no attribute '%.30s'R   R6  RL   R   R*   R  s   UTF-16LEs   UTF-16BEs   __Pyx_PyUnicode_Decode%sR+  R5  s   PyUnicode_Decode%sR[   R  R  R   R   R   R  s   StringTools.ct   decode_c_stringR  R  R   R   R  R  R  t   decode_cpp_stringt   decode_bytest   decode_bytearrays   __Pyx_%sNi(   R  s   UTF-16LEs   UTF-16BE(4   R?   R  R)   R   R   R   RZ   R   R   R*   RU  R   R[   R
   R   t   bytearray_typeR   R   R  t   is_cpp_stringR  RX   R   R   R   R	   R   Rj   R  RO  R#  t!   PyUnicode_DecodeXyz_func_ptr_typeR@  R   R   R   R2   R   R  R&   R   R   t   _decode_c_string_func_typeR   t   _decode_cpp_string_func_typeR`  R   Rb  R   t   _decode_bytes_func_typeR   Ri  (   R1   R   R   R   R  R  R   R   R  t   string_typeR  R  R  R  R  R  t   codec_cnamet   decode_functionRQ   t   helper_func_typet   utility_code_nameR  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt"   _handle_simple_method_bytes_decode  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  R5  (   t   codecst
   getencodert   LookupErrorR)   t   _special_codecsR  R  R  (   R1   R  t   requested_codecR   t   codecR   (    (    s7   lib/python2.7/site-packages/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)   (   R1   RX   R   R  R  R  R  R  (    (    s7   lib/python2.7/site-packages/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(   NRL   R[   s
   ISO-8859-1(   R   R   RU  R   Ro  RL   R   RX   t   as_utf8_stringR	   R   R>  R  R[   R
   R   R)   R   Rj   R  (   R1   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  #  s"    	$!	
c      	   C@  s#   |  j  | | | | d d t d 
 S(   NR   R  i   (   R  t   str_tailmatch_utility_code(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt"   _handle_simple_method_str_endswith7  s    c      	   C@  s"   |  j  | | | | d d t d  S(   NR   R  i(   R  R  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt$   _handle_simple_method_str_startswith<  s    c      	   C@  s#   |  j  | | | | d d t d 
 S(   NRi  R  i   (   R  t   bytes_tailmatch_utility_code(   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt$   _handle_simple_method_bytes_endswithA  s    c      	   C@  s"   |  j  | | | | d d t d  S(   NRi  R  i(   R  R  (   R1   R   R   R   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt&   _handle_simple_method_bytes_startswithF  s    c         C@  s   t  |  } | r; | r; |  j | d | | |  | d <n  |	 d  k rS | j }	 n  t j | j | | d | d |	 d | d |
 d | j S(   Ni    R   R   R   R  R   (   R  R   R)   R   R   R   RX   R   (   R1   R   R   R   R  R  R  R   R   R   R  Rr  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR*  Y  s    #c         C@  sz   | j  r | S| r7 | j d d | | j j g } n? | j d j t |  d k r[ d n d  d d d | g } | S(	   Ns@   descriptor '%s' requires a '%s' object but received a 'NoneType'R7  s*   'NoneType' object has no attribute '%{0}s'i   s   .30R5  R   R6  (   R   R   R[   R   R?  R?   (   R1   t   self_argR   R  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR   l  s    	'c      	   C@  s   t  |  | k s t  t  |  | k r^ | j t j | j d t |  d | d |  n  | | j | |  j    | | <d  S(   NRL   R[   R*   (	   R?   R   R2   R   R   RX   R   R   Rj   (   R1   R   R   t	   arg_indexR[   t   default_value(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  z  s
    !c         C@  s   t  |  | k s t  t  |  | k r^ t |  } | j t j | j d | d |  n | | j |  j    | | <d  S(   NRL   R*   (	   R?   R   R  R2   R   Rb   RX   R[  Rj   (   R1   R   R   R  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s    N(    (   R:   R;   R<   RS  RT  R6   R\  R	   R`  R;  Rb  R)   Ra  Rc  Rh  Rp  R
   R   R   R   R   Rr  Rg  R   t   c_float_typeR  t   c_longdouble_typeR~  Rf  R  R  R  R  R   R  R  R  R   R  RD  R   R!  R=  R   R  R  R   R  R>  R   R  R<  R  R  R  R  R  R  R  R   R  t   c_const_py_unicode_ptr_typeR  R  R  R  R  RS  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  R2  R7  R9  R<  R=  R  Ru  RG  RI  RK  RM  RO  RQ  RS  RU  RW  RZ  R\  R^  R`  RY  Ra  Rb  Rc  Rd  Re  Rf  Rg  RF  R  R  R  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_isupperR  R  t#   _handle_simple_method_unicode_lowert#   _handle_simple_method_unicode_uppert#   _handle_simple_method_unicode_titleR  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  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*  R   R  R  (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRQ    sh  						(			/		,					
								






	5		D	L			?			!		D																												V					 											%	1!	w										t   unicode_tailmatchs   StringTools.ct   bytes_tailmatcht   str_tailmatcht   ConstantFoldingc           B@  st  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& 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(   R1   R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR.     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   R3   R~   R[   R  Rs  t   calculate_constant_resultt
   ValueErrort	   TypeErrorRB   t
   IndexErrorR  t   ArithmeticErrorR  t	   tracebackt   syst	   print_exct   stdout(   R1   R   R   t   childrent   child_resultt   childR  R  (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _calculate_const  s(    
		c         G@  sF   y- |  j  t t |  j  j t t |    SWn t k
 rA d  SXd  S(   N(   t   NODE_TYPE_ORDERt   maxR  R   R[   R  R)   (   R1   t   nodes(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _widest_node_class  s
    'c         C@  s(   t  |  } t j | j d | d | S(   NRL   R*   (   R  R   Rb   RX   (   R1   R   RL   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt
   _bool_node  s    c         C@  s   |  j  |  | S(   N(   R  (   R1   R   (    (    s7   lib/python2.7/site-packages/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   !RL   R[   R*   R   R+  (   R  R   RF   t   _handle_NotNodeRV   R   R  R*   R   R   Rb   R   RX   R   Rw  R	   R   t   _handle_UnaryPlusNodet   _handle_UnaryMinusNode(   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_UnopNode  s$    $	RU   R  t   is_nott   isc         C@  sd   | j  } t | t j  r` |  j | j  } | r` t j |  } | | _ |  j |  } q` n  | S(   N(   RV   R   R   R_   t   _negate_operatorRF   t   copyRu   (   R1   R   RV   RF   (    (    s7   lib/python2.7/site-packages/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  (   RL   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   _negate  s    
RL   R[   R*   t   longness(   RV   R[   R   R   R  RX   RL   R*   R   R"  R   R   R(  (   R1   R   R'  t	   node_type(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR!    s    	!
!
c         C@  s/   | j  j   r+ | j | j  j k r+ | j  S| S(   N(   RV   R   R*   (   R1   R   (    (    s7   lib/python2.7/site-packages/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(   NRe  (   R  RG   R   R*   RF   RH   (   R1   R   (    (    s7   lib/python2.7/site-packages/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   unsignedR5  t   LLR(  RX   RL   R*   R[   (   R  R*   R   R   R   R  RG   RH   R   R[   R)   R  R|  R	   t   widest_numeric_typeR;  R  Rb   RF   R   R  Rs  R  R?   RX   R   Rw  R   (   R1   R   RG   RH   t   type1t   type2t   widest_typet   target_classR*  R(  Rt   t
   node_value(    (    s7   lib/python2.7/site-packages/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(   NRL   R*   R   (   R  R*   R   R   RG   R  RH   R   Ro  R)   R   R  R   R   RX   R   RL   R2  (   R1   R   t   str1t   str2R   t   string_value(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_AddNodef  s(    $$%c         C@  s   |  j  |  | j j r2 |  j | | j | j  St | j t j  rl | j j rl |  j | | j | j  S| j j r |  j	 | | j | j  S| j j r |  j	 | | j | j  S|  j
 |  S(   N(   R  RG   R  t   _calculate_constant_seqRH   R   R   R   R  t   _multiply_stringR2  (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_MulNode  s    c         C@  sJ  | j  } t | t  s | S| j   o7 t | j  t  s> | St | j   d k rW | St } t | t j  rx t	 } n t | t j
  r | j d  k	 r t | j | | j j  | _ q nb t | t j  r| j d  k	 r t	 | j | | j j  | _ q n t s t d t |    | | j | | j j  | _  | _ | S(   Ni   s   unknown string node type: %s(   R*   R   R   R   t   _py_string_typesR?   R   R   R   R   R>  R  R)   R  Ro  R   R&   R   R[   RL   (   R1   R   R  t   multiplier_nodet
   multipliert   build_string(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR8    s2    		


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    RL   R*   (   R*   R   R   R   R)   R  R   R   RX   R   R2  (   R1   R   t   sequence_nodet   factorRL   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR7    s    !c         C@  s   |  j  |  t | j t j  r t | j t j  r | j j s |  j | j j	 | j j
 | j j  } | d  k	 r} | Sq n  |  j |  S(   N(   R3   R   RG   R   Ro  RH   R  R  t   _build_fstringRX   RL   R   R)   R2  (   R1   R   t   fstring(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_ModNode  s    *'
u&   (%(?:(?:[0-9]+|[ ])?(?:[.][0-9]+)?)?.)c         C@  sn  t  |  } g  } t } xt j |  j |  D]} | s@ q. n  | d k rz | j t j | d t d  d d  q. n  | d d k r | d d k r t	 | d | d d	 d
 t
 } n  | j t j | d t |  d |  q. n  | d } y t |  }	 Wn+ t k
 r3t	 | d d	 d
 t
 } Pn X|	 j rGt
 } Pn  | d k r| d
 }
 | d k r~d |
 k r~t
 } n | d k r|
 d  }
 n  | j t j |	 j d |	 d | d k r| n d  d |
 rt j | d t |
  d |
 n d   q. t
 } Pq. W| sd  Sy t |  Wn t k
 r4n Xt	 | d d	 d
 d  St j | d | } |  j |  S(   Nu   %%RL   u   %R*   i    is   Incomplete format: '...%s'it   leveli   s)   Too few arguments for format placeholdersu   asrfdoxXu   doxXu   .u   arsR  R  s*   Too many arguments for format placeholdersR~   (   t   iterR   t   reR  t   _parse_string_format_regexR2   R   Ro  R   R   R&   t   nextt   StopIterationt
   is_starredt   FormattedValueNodeRX   R)   t   JoinedStrNodet   visit_JoinedStrNode(   R1   RX   R  R7  R   t
   substringst   can_be_optimisedR   t   format_typeR   R  R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR@    s^    (	(
	
	4 c         C@  sI  |  j  |  | j p d } t | j t j  rJ | j j rJ d  | _ n  | j d  k r t | j t j  r t	 | j j  } | j
   r t j | j j d | d | Sn  | j d  k rE| d k rEd  } t | j t j  r | j j } n$ t | j t j  r| j j } n  | d  k	 rEt j | j j d | d | Sn  | S(   NR   RL   R*   (   R3   R  R   R  R   Ro  RL   R)   R   R   t   isdigitRX   R>  R  (   R1   R   R  RL   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  	  s"    "$""c         @  sn  |  j  |  t j   g  } x t j | j   f d    D] \ } } | r t |  } | d } t |  d k r t d j	 d   | D   } t j | j
 d | d | } n  | j r | j |  q q; | j |  q; W| st d  } t j | j
 d | d | } nU t |  d k r4| d } n6 t |  d	 k ra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(    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   <lambda>&  R5  i    i   u    c         s@  s   |  ] } | j  Vq d  S(   N(   RL   (   Rv  RL   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pys	   <genexpr>+  s    RL   R*   R5  i   R   (   R3   R   Ro  t	   itertoolst   groupbyR~   R  R?   R   R  RX   RL   R2   R  R-  (   R1   R   R~   t   is_unode_groupRM  t   unodeRL   (    (   RR  s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRL    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  R2   R   R   t   MergedDictNodeR  (   R   t	   child_arg(   R  R   R   (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  E  s    	i    i   (	   R3   R  R2   R?   RX  R   R   RY  R  (   R1   R   R   (    (   R  R   R   s7   lib/python2.7/site-packages/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  R2   R   R   t   MergedSequenceNode(   R   RZ  (   R  R   RT  R~   (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  i  s    "i    i   (   R3   R[   R
   R   R   R2   R?   R\  R  R   R   R]  R  (   R1   R   R   (    (   R  R   RT  R~   s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_MergedSequenceNodea  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.(	   R3   R   RI  R2   RR   R  R  R  R  (   R1   R   R   R   (    (    s7   lib/python2.7/site-packages/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(
   NRG   RH   c         @  sv   |  j    rH |  j s2  j  j |  t   d  S  j |  j g  n   d j |   |  j rr  |  j  n  d  S(   Ni(   R   R*   R2   R  R&   RH   Rl  (   Rp   (   t   cascadest   final_false_resultR1   t   split_cascades(    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRb    s    		i   i   i    RF   R*   Re  (   R3   RG   R)   RH   R   R*   R   t"   calculate_cascaded_constant_resultR  R  RB   R  R  R  Rl  R  R?   R   R_   RX   RF   R2   R   Ru  (	   R1   R   t	   left_nodeRp   t
   right_nodet	   cmp_nodesRl  t	   pcmp_nodet   last_cmp_node(    (   R`  Ra  R1   Rb  s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRu     sn    				

	
				

	c         C@  s>   |  j  |  | j j   s  | S| j j r3 | j S| j Sd  S(   N(   R  R  R   R*   R  R  (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    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(   NRI   (   R3   RM   RN   R   R*   RO   RP   R2   R   R`   RX   (   R1   R   RM   R  RN   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    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   RZ   R  R  R   R  t   as_sliced_node(   R1   R   R   R   RZ   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_SliceIndexNode  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?  (   R3   R   R  R   R`   RI   R[   R
   R   R   R  RX   R   R  RS  R   RB  (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_ComprehensionNode  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(   NRI   (   R3   RS   RT   R   R   t   SequenceNodeR   RP   R   R`   RX   R  R;  (   R1   R   RT   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRw   .  s    		c         C@  sT   |  j  |  | j rP | j j   rP | j j rF d  | _ d  | _ qP | j Sn  | S(   N(   R3   RN   R   R*   R)   RP   (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_WhileStatNode=  s    	
c         C@  s=   |  j  |  t | j t j  s& | S| j j   r9 d  S| S(   N(   R3   R   R5   R   t   ExprNodeR   R)   (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR6   G  s    (/   R:   R;   R<   R&   R.   R  R   Rb   R  R   R  R  R  R  R  R"  R  R%  R  R!  R   R  R2  R6  R9  R8  R7  RB  RF  R@  R  RL  R[  R^  R_  Ru   R  R  Rj  Rk  Rw   Rm  R6   R   R  R  R=   (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    sP   	 					
				:					
	<		#	"	&		R							
	t   FinalOptimizePhasec           B@  sJ   e  Z d  Z e Z d   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
        - eliminate useless string formatting steps
        - 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.
        (   R3   R  RJ   R   t   lhs_of_first_assignment(   R1   R   RJ   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_SingleAssignmentNodee  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 r| j j r|  j j |  j r(|  j   j r(d n d  rt | j t j  r| j j ps| j j ost | j j  d k rt } | j t j k r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( r| j! rt | j) t j*  r| j) j+ | j( k r| 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   R[   t   PyObject_TypeCheckR  s&   optimize.unpack_method_calls_in_pyinits   optimize.unpack_method_callsc         3@  s+   |  ]! } | j  o" t | j     Vq d  S(   N(   RK   R   (   Rv  t
   assignment(   t   non_method_nodes(    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pys	   <genexpr>  s   R   R   (/   R3   R   R[   t   is_cfunctionR   R   R?   R   R{  R   R  R  R   R	   R  R   R  R   R   R  R  t   in_loopRj   t   is_module_scopeR   R   R  R  R   R   R
   R  R&   R   R   RJ  RL  t	   ClassNodet   Py3ClassNodeR	  R1   R$   R  R   RO  t   PyMethodCallNodet	   from_node(   R1   R   R   R  R  R  t   may_be_a_methodR   (    (   Rt  s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR  o  sL    	$)	1						*-c         C@  s   |  j  |  | S(   N(   R3   (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_NumPyMethodCallNode  s    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.
        (   R3   t   notnoneR   R  R   (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRS    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.
        (   R3   R   R  (   R1   R   (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_NoneCheckNode  s    c         C@  s,   |  j  } t |  _  |  j |  | |  _  | S(   se   Remember when we enter a loop as some expensive optimisations might still be worth it there.
        (   Rv  R   R3   (   R1   R   t   old_val(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_LoopNode  s
    			(   R:   R;   R<   R&   Rv  Rq  R  R}  RS  R  R  (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyRo  W  s   	
	2				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)   R3   (   R1   R   t   saved(    (    s7   lib/python2.7/site-packages/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&   R3   (   R1   R   t   top_level_overflow(    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   visit_NumBinopNode  s    	N(   R:   R;   R<   R)   R  R=   R  (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyR    s   	
(K   t
   __future__R    RE  R  R&  R  RT  R5  R   R   R   t   cythont   declareR  t   version_infoRw  R   Ri  R   R:  t   longR  R   R	   R   R
   R   R   t   CodeR   R   t   StringEncodingR   R   R   t   ErrorsR   R   t   ParseTreeTransformsR   t   __builtin__R   t   ImportErrort	   functoolsR   R   RU  R`  R   R   R#   R+   R-   R,   RA   R>   t   EnvTransformRE   Rc  R  R  R  R  t   NodeRefCleanupMixinRG  t   MethodDispatcherTransformRQ  R   R  R  R  R  Ro  t   CythonTransformR  (    (    (    s7   lib/python2.7/site-packages/Cython/Compiler/Optimize.pyt   <module>   s   !
			
	 		   Ht !	         m