
    ڏDjđ                    d   d dl Z  e j                  dIi dededededededed	ed
ededededededededede d dlZd dlZd dlZd dlZd dlmZm	Z	 d dl
mZ ddlmZ ddlmZm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% d$d%lm&Z& d& Z'ejP                  ejR                  ffd'Z*d( Z+d) Z,d* Z-d+e.fd,Z/ G d- d.ej`                        Z1d/ Z2d0 Z3 G d1 d2ejh                        Z5 G d3 d4ejh                        Z6 G d5 d6ejn                  e%      Z8 G d7 d8ejn                        Z9 G d9 d:ejh                        Z: G d; d<ejv                  ejh                        Z< G d= d>ejv                  ejz                        Z>d? Z? ej                  d@dA      ZA ej                  dBdA      ZB G dC dDejn                  e%      ZC G dE dFejh                  ejv                        ZD G dG dHej                        ZFy)J    NUtilityCodeEncodedStringbytes_literalencoded_stringNodes	ExprNodes
PyrexTypesBuiltin	UtilNodesOptionsUtilsrecopycodecs	itertools
attrgetterpartialreduce)r   r   )r      )	TypeSlots)UnicodeNodenot_a_constant)r   )r   )r	   )Visitor)r
   )r   )r   )r   TempitaUtilityCode)r   r   r   )errorwarning)SkipDeclarations   )r   c                 .    t        j                  | d      S )N
Optimize.c)r   load_cached)names    \C:\Crop_Prediction\Backend\crop-ai-system\venv\Lib\site-packages\Cython/Compiler/Optimize.pyload_c_utilityr$   %   s    ""466    c                 6    t        | |      r| j                  S | S N)
isinstancearg)nodecoercion_nodess     r#   unwrap_coerced_noder,   )   s    $'xxKr%   c                     t        | t        j                        r'| j                  } t        | t        j                        r'| S r'   )r(   r   ResultRefNode
expressionr*   s    r#   unwrap_noder1   /   s2    
T922
3 T922
3Kr%   c                    t        |       } t        |      }t        | t        j                        r3t        |t        j                        r| j                  |j                  k(  S t        | t        j
                        rdt        |t        j
                        rJ| j                   xr; t        | j                  |j                        xr | j                  |j                  k(  S yNF)
r1   r(   r   NameNoder"   AttributeNode
is_py_attris_common_valueobj	attribute)abs     r#   r7   r7   5   s    AAAA!Y''(Z9;M;M-Nvv!Y,,-*Q	@W@W2X<<`OAEE155$A`akkUVU`U`F``r%   c                 $    | | j                   y | S r'   )constant_resultr0   s    r#   filter_none_noder>   ?   s    D008Kr%   union_type_nodesc                 6   t         j                  fdg }d }| d d d   }|r|j                         }t        |      rt	         |            }t        |      dk(  r|j                         t        j                  u r|j                  j                  r|(|j                  }n|j                  |j                         |j                  j                  r|(|j                  }n|j                  |j                         |j                  |       |r||fS )Nc              3      K   t        |       r5 | j                        E d {     | j                        E d {    y | j                  s| j                   y y 7 ;7 #wr'   )r(   operand1operand2is_nonetype)	tree_nodeBitwiseOrNodecollect_tree_typess    r#   rH   z4_unpack_union_type_nodes.<locals>.collect_tree_typesI   sZ     i/))*<*<===))*<*<===""..  # >=s    "A%A!A%A# "A%#A%r   )r   rG   popr(   setlenr
   	type_typerC   rD   appendrB   )r?   typesallowed_none_node
type_stacktptype_setrG   rH   s         @@r#   _unpack_union_type_nodesrT   E   s    ++M! E!$B$'J
^^b-( -b12H8}!hlln8I8I&I;;&&(0,.KK)%%bkk2;;&&(0,.KK)%%bkk2R% ( ###r%   c                   `    e Zd ZdZd Zej                  j                  Zd Z	d Z
d Zd Zd Zy)	_YieldNodeCollectorz9
    YieldExprNode finder for generator expressions.
    c                 ^    t         j                  j                  |        i | _        g | _        y r'   )r   TreeVisitor__init__yield_stat_nodesyield_nodes)selfs    r#   rY   z_YieldNodeCollector.__init__o   s&    $$T* "r%   c                 \    | j                   j                  |       | j                  |       y r'   )r[   rN   visitchildrenr\   r*   s     r#   visit_YieldExprNodez'_YieldNodeCollector.visit_YieldExprNodev   s$    %4 r%   c                     | j                  |       |j                  | j                  v r|| j                  |j                  <   y y r'   )r^   exprr[   rZ   r_   s     r#   visit_ExprStatNodez&_YieldNodeCollector.visit_ExprStatNodez   s;    4 99(((/3D!!$)), )r%   c                      y r'    r_   s     r#   visit_GeneratorExpressionNodez1_YieldNodeCollector.visit_GeneratorExpressionNode       r%   c                      y r'   re   r_   s     r#   visit_LambdaNodez$_YieldNodeCollector.visit_LambdaNode   rg   r%   c                      y r'   re   r_   s     r#   visit_FuncDefNodez%_YieldNodeCollector.visit_FuncDefNode   rg   r%   N)__name__
__module____qualname____doc__rY   r   rX   r^   
visit_Noder`   rc   rf   ri   rk   re   r%   r#   rV   rV   k   s8    
 $$22J!4r%   rV   c                 @    t        |       }t        |      dk7  ry|d   S )Nr   )NNr   )_find_yield_statementsrL   )r*   yield_statementss     r#   _find_single_yield_expressionrt      s)    -d3
!Ar%   c                     t               }|j                  |        	 |j                  D cg c]  }|j                  |j                  |   f }}|S c c}w # t
        $ r g }Y |S w xY wr'   )rV   r^   r[   r)   rZ   KeyError)r*   	collector
yield_noders   s       r#   rr   rr      s    #%ID! (33
 ^^Y77
CD
 
 
  s"   A "AA A A%$A%c                      e Zd ZdZd Zd Zd!dZd Zd!dZ e	j                  e	j                   e	j                  dej                  d      gd	
      Z e	j                  e	j                    e	j                  dej                  d      gd
      Zd!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	j0                  d       e	j                  de	j2                  d       e	j                  de	j4                  d      gd
      Zd!dZd!dZd Zd Zd!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	j0                  d       e	j                  de	j4                  d      g      Z# e	j                  e	j.                   e	j                  de	j.                  d       e	j                  de	j(                  d       e	j                  de	j0                  d       e	j                  de	j4                  d      g      Z$d  Z%y)"IterationTransforma   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                    |j                         rN|j                  }t        j                  |      }|j                  j
                  r+|j                  j                  j                  j                  }n |j                  j                  j                  }t        j                  |      }|j                  |      }t        j                  |d|j                  |      }t        j                  |t        j                   ||t        j"                  |d            t        j$                  |      g      }t        j&                  |t        j(                  |||      gd       }	t        j*                  ||gt        j,                  ||t        j.                  |j                  j                  |j                  	      |	t        j                   ||t        j"                  |d
                        }
|
j1                  | j3                               }
| j5                  |
      }
t        j6                  ||
      }|j8                  dk(  rt        j:                  ||      }|S | j=                  |       |S )N==operatorrB   rC   Tvaluelhsrhsstats	conditionbody
if_clauseselse_clause)sequenceF)targetiteratorr   r   tempsr   not_inoperand)is_ptr_containsposr   r.   rC   is_subscriptbaserE   	base_type
TempHandlerefr   PrimaryCmpNoderB   r   StatListNodeSingleAssignmentNodeBoolNodeBreakStatNode
IfStatNodeIfClauseNodeTempsBlockNodeForInStatNodeIteratorNodeanalyse_expressionscurrent_envvisitTempResultFromStatNoder~   NotNoder^   )r\   r*   r   
result_refr   target_handler   cmp_nodeif_bodyif_nodefor_loopnew_nodes               r#   visit_PrimaryCmpNodez'IterationTransform.visit_PrimaryCmpNode   s   ! ((C"006J}})) MM..33==	 MM..88	%00;M"&&s+F //dT]]VMH((33CZYM_M_`ckoMpq,,S134G &&!..shWUV "G !//&**!&33DMM4E4EPTP]P]^  % : :1C1CCu1U!WX	YH  33D4D4D4FGHzz(+H 77
HMH}}($,,S(CO t$Kr%   c                 p    | j                  |       | j                  ||j                  j                        S r'   )r^   _optimise_for_loopr   r   r_   s     r#   visit_ForInStatNodez&IterationTransform.visit_ForInStatNode   s-    4 &&tT]]-C-CDDr%   c           	         |j                   }d }|j                  s|j                  rZ|j                  rN|j                  j                  r8|j                  j                  j
                  }|j                  r|j                  }t        j                  ||fv r|r|S | j                  ||d dd      S t        j                  ||fv st        j                  ||fv r|r|S | j                  ||      S | j                         }|j                  s|j                   r| j#                  |||      S |j$                  r|j&                  st)        j*                  |||      }|r|j,                  st/        d |j0                  D              st)        j2                  |j4                  |j0                        j7                  |      j9                  t;        j<                  |t?        |j0                              |      }| j#                  |||      S |j@                  r'|j&                  s|t        jB                  u r+t:        jD                  }tG        tH        |jJ                        }	nt:        jL                  }|jJ                  }	tO        t(        jP                  jR                  |j4                  |      }
t)        j2                  |j4                  |	D cg c]
  } |
|       c}      }|j7                  |      j9                  t;        j<                  |t?        |j0                              |      }| j#                  |||      S |t        jT                  u r5|j&                  r| jW                  ||d|	      S | jY                  |||      S |t        jB                  u r| j[                  |||      S |t        j\                  u r| jW                  ||d|	      S t_        |t(        j`                        r?|jb                  j                   jd                  r| jW                  ||jb                  d|	      S t_        |t(        jf                        s|S |j0                  2|jh                  xr t?        |jh                  j0                        xs d
}n(t?        |j0                        }|r|jj                  |dz  }|jl                  }|j                  r	|s|s|jj                  xs |jn                  }|jp                  }| js                         jt                  jv                  dk\  }|si|dv ret_        |t(        jx                        rK|jl                  }|j                  r3|jz                  dk(  r$|j                  r|j                  j|                  rd}dx}}|dk(  s|r|dk(  rd}n|dk(  s|r|dk(  rd}n|dk(  s|r	|dk(  rdx}}|s|r| j                  |||||      S |jj                  x|j                  rl|j                  r`|j                  j|                  rJ|jz                  dk(  r|r|S | j                  ||      S |jz                  dk(  r|r|S | j                  ||      S t        j                  r_d|cxk  rdk  rSn |S |jj                  B|j                  r5|jz                  dv r&|j                  r|j                  j|                  r|j                  j                   j                  s |j                  j                   j                  r| j                  |||      S |j                  j                   j,                  r|j0                  |jh                  j0                  n|j0                  D ]I  }t_        |t(        jP                        r+|j                         rd|j                  cxk  rdk  rn  |S H |S  | j                  |||      S |S c c}w )NTF)dict_objmethodkeysvaluesreversed)seq_typec              3   4   K   | ]  }|j                     y wr'   )
is_starred).0items     r#   	<genexpr>z8IterationTransform._optimise_for_loop.<locals>.<genexpr>   s     BmW[4??Bm   argsrE   )
is_mutabler   r   r      )r   r   itemsdictiterkeysr   
itervaluesr   	iteritemsr   	enumerater   )rangexrange      @)IrE   is_nameis_attributeentry
annotationrb   r   r   r
   	dict_type_transform_dict_iterationset_typefrozenset_type_transform_set_iterationr   is_ptris_array_transform_carray_iterationis_sequence_constructoris_generator_scoper   infer_sequence_item_typeis_pyobjectanyr   ListNoder   analyse_types	coerce_tor	   c_array_typerL   is_string_literalunicode_typec_py_ucs4_typemapordr   c_uchar_typer   IntNodefor_int
bytes_type_transform_indexable_iteration_transform_bytes_iteration_transform_unicode_iterationbytearray_typer(   CoerceToPyTypeNoder)   is_memoryviewsliceSimpleCallNode	arg_tupler\   functionr8   r9   global_scopecontextlanguage_levelCallNoder"   
is_builtin_transform_enumerate_iteration_transform_reversed_iterationr   convert_ranger   is_intis_enum_transform_range_iterationhas_constant_resultr=   )r\   r*   iterabler   	iter_typeannotation_typer   env	item_typer   as_int_nodech	arg_countr   base_objr   is_safe_iterinner_functionr   r   r)   s                        r#   r   z%IterationTransform._optimise_for_loop   s   MM	 5 58>>hnnNgNg!2277J&&'__
O <<11x4 2 O O O <<&&9o*FF00x@@  y1133D(X3VV++C4J4J "::X	3I!6!6sBm_g_l_lBm?m$--hllO]]^abll++Is8==7IJCQ77hQY7ZZ%%c.D.D G000&55	C0&33	 !)"3"3";";X\\PYZK ))(,,W\=]QSk"o=]^H--c2<<Z=T=TU^`cdldqdq`r=suxyH33D(X3VV***%%::4V[fn:oo66tXPX6YY,,,44T8h4WW ...66tXRVai6jjh	 < <=(,,BSBSBfBf66tX\\V[fn6oo (I$<$<=K==  **Ks83E3E3J3J/KPqIHMM*IX]]6Q	$$  )}}4H''F,,.66EEJLF.I$Ih	(:(:;%-%6%6N&..>3F3F&3P . 4 4 . 4 4 ? ?'+!!D6#69I<'LVx=O;&<Fg<M $$vv55(FD&: : == X%5%5~~(..";";}}+K::4JJ*,K99$II   Q)%8q%8   %  X]]6I%I8>>#<#<{{&&$++*:*:*B*B66tXPX6YY{{++7?}}7LH..33RZR_R_ ^C!#y'8'892243CVCV9^Y^9^  % ^  ::4T\:]]s >^s   	_
c                    |j                   j                  }t        |      dk(  rt        |j                  d       |S t        |      dkD  rt        |j                  d       |S |d   }|j
                  t        j                  t        j                  fv r3|j                  d      |j                  _        d|j                  _        |S | j                  ||d      S )Nr   z(reversed() requires an iterable argumentr   z#reversed() takes exactly 1 argument!'NoneType' object is not iterableTr   )r   r   rL   r   r   rE   r
   
tuple_type	list_typeas_none_safe_noder   r   r   r   )r\   r*   reversed_functionr   r)   s        r#   r   z0IterationTransform._transform_reversed_iterationh  s     **//t9>#''<>KY]#''79K1g 88**G,=,=>>%(%:%:;^%_DMM"%)DMM"K&&tS4&@@r%   c                 4
   g }t        j                  |j                  d      dd      }|j                  |       t	        j
                  |j                  t	        j                  |j                  dt        j                  j                  d            |g      }|r|}n6t        j                  |t        j                        }|j                  |       t        j                  t	        j                  |j                  d	            }	|j                  |	       |r2|}
t        j                  j                  |j                  d
      }d\  }}n/t        j                  j                  |j                  d      }
d\  }}t!        j                   |
      }t        j                  |
t        j                        }|j                  |       t	        j"                  |j                  |||      }|rF|rDt	        j$                  |j                  d|t	        j"                  |j                  |||            }t'        j(                  |j                  t'        j*                  |j                  |	t	        j                  |j                  d	            t'        j,                  |j                        g      }t	        j.                  |j                  ||      }t'        j*                  |j0                  j                  |j0                  |      }| j3                         }t5        j6                  |j8                  dd      }t'        j:                  |j                  ||      }t'        j<                  |j                  t'        j>                  |j                  ||      g|      }|r[|j@                  jB                  sJ |j@                         t'        jD                  |j                  |g|      }|jG                  |       t'        j(                  |j                  t'        j*                  |j                  |t	        jH                  |j                  |rdndd|t        j                  j                  |j                  d                  |g      }t'        jJ                  |j                  |	||jL                        }|}|ddd   D ]  }t        jN                  ||      } |jQ                  |      }|jR                  j                  |jT                         |S )zUIteration over iterables that Cython has a len() for and knows how to index.
        'NoneType' is not iterableFT)may_hold_noneis_temprL   )r"   r   r   r   r   r   r   >>=rI   <=<r}   andr   r   )r   indexr   r   r   )boundscheck
wraparound)
directivesr   r   r   )r   r   -+r   )r~   inplacerB   rC   r   r   r   N)+r   
LetRefNoder  rN   r   r   r   r4   r
   builtin_scopelookupr	   c_py_ssize_t_typer   r   for_sizer   r   BoolBinopNoder   r   r   ContinueStatNode	IndexNoder   r   r   copy_inherited_directivesr&  CompilerDirectivesNoder   r   rE   r   CriticalSectionStatNodeanalyse_declarations
binop_nodeWhileStatNoder   LetNoder   r   r   )r\   r*   
slice_noder   r   
temp_nodesunpack_temp_nodelength_call_nodeend_nodekeep_going_ref
start_node	relation1	relation2start_check_nodecounter_ref	test_nodefailed_test_bodytarget_valuetarget_assignr  new_directiveslength_check_and_target_assignr   	loop_noderetlet_ref_nodes                             r#   r   z1IterationTransform._transform_indexable_iteration|  sM   & 
$//(()EF

 	*+$33HH''u++2259 ##
 'H ++,<:C_C_`Hh'"--i.@.@QU.VW.)!J ((11$((A>H#, Iy"**33DHHbAJ#, Iy99Z0**:J<X<XY+&,,HH 	
	 (!//""11HH&-(		
I !--HH **HH&!**4885A
 &&txx0
 !**:>>@PXcd22++//++
   ::3>>W\ino44%
 */)9)9HH""HH'& )
*
& ??..?
? .3-J-J&'3.*
 +??D!!HH**HH#!,,(0c $!,!*!2!2!;!;DHHa!H
 /$ ''HH&**	
	 &tt, 	7L##L#6C	7 %%c*

$))$
r%   sNNULLexception_valuerI   c                    |j                   j                  }|j                  s|t        j                  ur|S t        j                  |j                  d            }t        j                  |j                  d| j                  |gd      }t        j                  |j                  d| j                  |gd      }t        j                  || j                  |t        j                  |j                  |d d ||j                  d      |            S )Nr  __Pyx_PyBytes_AsWritableStringr   r   r  __Pyx_PyBytes_GET_SIZE)r   startstepstoprE   r  r   )r   rE   r  r
   r   r   r+  r  r   PythonCapiCallNoder   PyBytes_AS_STRING_func_typePyBytes_GET_SIZE_func_typer9  r   SliceIndexNode)r\   r*   r:  r   target_typer<  slice_base_nodelen_nodes           r#   r   z-IterationTransform._transform_bytes_iteration*  s   kk&&!!k9K9K&K K$//(()EFH $66NN<,,$%	 //NN4++$%	   ,,((NN* #*// $ - %& 	&r%   kinddatar"  lengthc                 
   | j                         }|j                  r|j                  s	 t        |j                  j                  d      d      }t        j                  |j                  t        j                  |j                  ||t        j                        j                  t        j                  |      d t        j                  j                  |j                  t!        |            t"        j$                        }| j'                  |||      S t+        j,                  |j/                  d            }t        j                  j                  |j                  d      }t+        j0                  t        j2                        }	|	j5                  |j                        }
|r
d\  }}|
|}
}nd\  }}t+        j0                  t        j6                        }t+        j0                  t        j8                        }t+        j0                  t        j2                        }t        j:                  |j                  d	| j<                  |j5                  |j                        |j5                  |j                        |j5                  |j>                  j                        gd
      }|j@                  |j>                  j@                  k7  r&|j                  |j>                  j@                  |      }tC        jD                  |j>                  j                  |j>                  |      }tC        jF                  |j                  ||jH                  g      }tC        jJ                  |j                  |||j5                  |j>                  j                        ||
d ||jL                  d
      }tC        jN                  |j                  t        j:                  |j                  d| jP                  |t        jR                  |j                  |	j5                  |j                        t        jT                        t        jR                  |j                  |j5                  |j                        t        jV                        t        jR                  |j                  |j5                  |j                        t        jX                        gdd
t[        j\                  dd                  }t+        j^                  |t+        j`                  |j                  ||	||gtC        jF                  |j                  ||g                  S # t(        $ r Y 1w xY w)Nlatin1z	iso8859-1r   r=   rE   )r   rV  rX  rE   r  r   r  r  __Pyx_PyUnicode_READFrT  r#  r   T	bound1rA  r   rB  bound2rW  r   r   
from_range__Pyx_init_unicode_iterationr   rE   unicode_iterr    )r   r  result_is_usedutility_code)rb   r   )1r   
is_literalr   r   r   encoder   r\  r   	BytesNoder	   c_const_char_ptr_typer   c_const_uchar_ptr_typer   r/  rL   r
   r   r   UnicodeEncodeErrorr   r+  r  r   r.  r   
c_int_typec_void_ptr_typerY  PyUnicode_READ_func_typer   rE   r   r   r   r   ForFromStatNoder   ExprStatNode init_unicode_iteration_func_typeAmpersandNodec_py_ssize_t_ptr_typec_void_ptr_ptr_typec_int_ptr_typer   r!   r9  r   )r\   r*   r:  r   r  bytes_valuebytes_slicer<  r@  length_tempr>  rA  rB  	kind_temp	data_tempcounter_temprG  rH  r   rK  
setup_nodes                        r#   r   z/IterationTransform._transform_unicode_iterationa  s&      )?)?U+J,<,<,C,CH,M{[ (66NN",,"k(3'==? @Iy&==s@D"**33JNNCDTU --
 77k8TT$//(()EFH &&//!<
**:+G+GH??488,#, Iy#+ZJ#, Iy(()>)>?	(()C)CD	 ++J,H,HI 33NN2))MM*..1MM*..1 $$T[[__57   0 00'11$++2B2BCHL22++//++  !!HH"DII.0 ))HH##DKKOO4D((	 ''HH// >55(!//
XbXfXfHg5?5U5UW!//
	V`VdVdHe5?5S5SU!//
	V`VdVdHe5?5N5NP !&(44^\R
"   $${Iy Q''Y8OPRS 	SY & s   %T7 7	UUc                    d}t        |t        j                        ri|j                  }t	        |j
                        }t	        |j                        }d }|s5|j                  j                  st        |j                  d       |S |j                  rCt        |j                  t        j                        sJ |j                  }|j                  }	t	        |	j
                        }t	        |	j                        }t	        |	j                        }|rzt        |j                  t               r1|j                  dk(  s"|j                  dkD  r|r|j                  dk  r0|s.|j                  j                  st        |j                  d       |S |j                  }
|r|
 }
|
dk  }t        j"                  j%                  |j                  t'        |
            }n|j                  j(                  rs|j                  j*                  t        |j                  d       |S |}d x}}t        j"                  j%                  |j                  |j                  j*                        }n.|j                  j                  st        |j                  d       |S |r.|j-                  t.        j0                  | j3                               }|r.|j-                  t.        j0                  | j3                               }|E|r+t        j"                  j%                  |j                  d      }nt        |j                  d       |S |r0|s*t        j"                  j%                  |j                  d      }||}}|j                  }|j(                  r|j5                         }|j7                  | j3                               }|r4|j                  dk7  r%t        j8                  |j                  |d||      }n|}|rd|j                  dk7  rUt        j8                  |j                  t        j:                  |      d||      j7                  | j3                               }nt        j:                  |      }t=        j>                  |      }|jA                  |jB                  j                        }|j                  jD                  rk|jB                  j                  j                  rJ|j                  tF        jH                  u rt        jJ                  t        jL                  |jB                  j                  ||jN                        t.        jP                        j-                  |jB                  j                  | j3                               }n]t        j                  |jB                  j                  t        j"                  jS                  |jB                  j                  d      t        j"                  jS                  |jB                  j                  d	      |tF        jT                  d	
      }n|jB                  j                  jV                  r2|jB                  j                  jY                  |jN                        s|}nit        jZ                  |jB                  j                  t        j"                  jS                  |jB                  j                  d      ||jN                        }|j                  |jB                  j                  k7  r4|j-                  |jB                  j                  | j3                               }t]        j^                  |jB                  j                  |jB                  |      }t]        j`                  |j                  ||jb                  g      }| je                  ||      \  }}t]        jf                  |j                  ||||||||jh                  d
      }t=        jj                  |j                  |g|      S )NFz*C array iteration requires known end indexr   z8C array iteration requires known step size and end indexrI   r(  rB   r~   rC   rE   rl  r   )rV  rX  r   rE   r  )r"  r   rE   r#  r   Trg  r   )6r(   r   r\  r   r>   rV  rX  rE   r   r   r   r   r"  	SliceNoderW  r=   intr   r/  absr   sizer   r	   r.  r   element_ptr_typecoerce_to_simpleAddNode	CloneNoder   r   r   r   	is_stringr
   r   CastNodeDereferenceNoder   r   r   r   r   assignable_fromr2  r   r   r   r   _find_for_from_node_relationsry  r   r   )r\   r*   r:  r   neg_step
slice_baserV  rX  rW  r"  
step_valueptr_type
carray_ptrstart_ptr_nodestop_ptr_nodecounterr  rG  rH  r   rA  rB  for_nodes                          r#   r   z.IterationTransform._transform_carray_iteration  s   j)":":;#J$Z%5%56E#JOO4DD!22*..*VW$$j..	0C0CDD#J$$E$U[[1E#EJJ/D#EJJ/D!$"6"6<..!3..24..25%??66dhh(bcK "&!5!5J&0[
)A~H$,,55dhhJPD__%%##+jnn&RS#JED$$--jnnjoo>R>RSD ??..jnn&RSKOOJ$@$@$BRBRBTUE>>*">">@P@P@RSD< ((11*.."Ejnn&`a!))22:>>1E4E??002H001A1A1CD
U**a/&..		#N (ND((A-%--",,Z8 #"4#3#3#56  &//
;M&&x0{{4;;??3??$$)9)9)E)E'"6"66(11--%//1 --	 / 09y(($*:*:*<0>	   )77KKOO#++33DKKOOQG"**224;;??AF% ++  [[$$T[[-=-=-M-MhN`N`-a'L %..''//C!''	)L  0 00'11$++2B2B262B2B2DFL 22++//++ 
 !!HH"DII.0  $AA(HU	9((HH!YD(( ''HHWI 	r%   c           	         |j                   j                  }t        |      dk(  rt        |j                  d       |S t        |      dkD  rt        |j                  d       |S |j
                  j                  s|S |j
                  j                  }t        |      dk7  r|S |\  }}|j                  }|j                  s|j                  s|S t        |      dk(  r-t        |d         j                  || j                               }n,t        j                  j                  |j                  d|      }t!        j"                  |      }	t        j$                  |j                  |	t        j                  j                  |j                  d|      d||j                        }
t'        j(                  |j                  ||		      t'        j(                  |j                  |	|
	      g}t+        |j,                  t&        j.                        r)||j,                  j0                  z   |j,                  _        nK|j3                  |j,                         t'        j.                  |j,                  j                  |
      |_        ||_        |j4                  j                  |j                  | j                               |_        |d   |j6                  _        t!        j:                  |	| j=                  ||j6                  j8                              S )Nr   z)enumerate() requires an iterable argumentr   z%enumerate() takes at most 2 argumentsr   r   r(  )rB   rC   r~   rE   r  r#  r   )r   r   rL   r   r   r   r   rE   r   r  r,   r   r   r   r   r   r   r+  r  r   r   r(   r   r   r   rN   r   r   r   r9  r   )r\   r*   enumerate_functionr   targetsenumerate_targetiterable_targetcounter_typerV  tempinc_expression	loop_bodys               r#   r   z1IterationTransform._transform_enumerate_iterationP  sw   !++00t9>$((=?KY]$((9;K{{22K++""w<1K,3)/',,''0C0CKt9>'Q0::<IYIYI[\E%%--.@.D.Dal-[E##E*"**"" ((001<0P".. &&&**& &&&**$&		 dii!3!34'$))//9DIIOTYY'**		!#DI &II''(<(<d>N>N>PQ	!%a   t'>'>tT]]E[E['\]]r%   c                     |r|ryy|ryy)N)r   r  r  )r  r  r  re   )r\   neg_step_valuer   s      r#   r  z0IterationTransform._find_for_from_node_relations  s        r%   c                    |j                   j                  }t        |      dk  r/|j                  }d}t        j
                  j                  |d      }n`|d   }|j                  }t        |j                  t              s|S |j                  }|dk(  r|S t        j
                  j                  ||      }t        |      dk(  rMt        j
                  j                  |j                  d      }|d   j                  | j                               }	nD|d   j                  | j                               }|d   j                  | j                               }	| j                  |dk  |      \  }
}d }|r%|	|}	}t        |      }|dk7  rt        |j                  t              rt        |	j                  t              r|dk  r-|	j                  }|j                  }||||z
  dz
  |z  z  z
  dz
  }n,|j                  }|	j                  }||||z
  dz
  |z  z  z   dz   }t        j
                  j                  |j                  |t        j                   |j"                  |	j"                              }n)t%        j&                  |	      }| j)                  ||||      }|dk  r| }t+        |      |_        ||_        |j                  | j                               }|	j.                  sd}|xs t%        j&                  |	      }	nd}t1        j2                  |j                  |j4                  ||
||	||j6                  |j8                  d
      }|j;                  | j                                |rt%        j<                  |	|      }|S )	Nr   r   r   r   r   TF)	r   rh  rA  rB  ri  rW  r   r   rj  )r   r   rL   r   r   r   r/  r(   r=   r  coerce_to_indexr   r  r  r   r	   spanning_typerE   r   r+  _build_range_step_calculationstrr   rp  r   ry  r   r   r   set_up_loopr9  )r\   r*   range_functionr   r   step_posr  rW  rh  ri  rA  rB  bound2_ref_nodeabs_stepbegin_value	end_valuebound1_valuebound2_is_tempr  s                      r#   r  z-IterationTransform._transform_range_iteration  s6   '',,t9q=%))HJ$$--h:D7DxxHd22C8--JQ$$--h
CDt9>&&//0B0BAFF!W,,T-=-=-?@F!W,,T-=-=-?@F!W,,T-=-=-?@F#AA*q.RZ[	9#VFF:H1}v55s;"6#9#93?!A~&,&<&<$*$:$:	'2X+PYBY\]B]bjAj5k'kno'o&,&<&<$*$:$:	'08i@WZ[@[`h?h3i'ilm'm&..66

L'55fkk6;;O 7 QF
 '0&:&:6&BO!??zCF >$J_
)##D$4$4$67  !N$D	(<(<V(DF"N((HH;;YDII(( 	T--/0 ((:Hr%   c                 8   t        |      }t        j                  |j                  |j                        }|j                  j                  r*|dk  r%t        j                  |t        j
                        }n t        j                  ||j                        }|dk  r|}|}	d}
n|}|}	d}
t        j                  |j                  t        j                  |j                  ||
t        j                  |j                  t        j                  j                  |j                  ||      dt        j                  |j                  t        j                  |j                  t        j                  |j                  |d|	|      dt        j                  j                  |j                  d      |      d	t        j                  j                  |j                  ||      |      |      |      |
t        j                  j                  |j                  d      |      }|S )
Ni  r   r'  r(  r   *r  r   z//)r  r	   r  rE   r  rv  r   r7  r   MulNoder   r   DivNodeSubNode)r\   rh  r  rW  r  r  r  spanning_step_typer  r  final_opstep_calculation_nodes               r#   r  z0IterationTransform._build_range_step_calculation  s   z?"00o>R>RS996 1!+!9!9-I^I^!_!+!9!9-!S>)KIH K'IH ) 4 4JJ))

(!"**JJ&..66vzz8Rd6e &..

!*!2!2"JJ%.%6%6 &

)4),)2%2&4 &)%.%6%6%>%>vzz1%M!3
"5 "&!*!2!2!:!:6::xVh!:!i/1  ,)-* (3)4 &&..vzz1==! > %$r%   c                 	   g }t        j                  t        j                        }|j	                  |       |j                  |j                        }t        j                  t        j                        }|j	                  |       |j                  |j                        }	d x}
x}}|rc|ra|j                  j                  r>t        |j                  j                        dk(  r|j                  j                  \  }
}n*|S |j                  }n|r|j                  }
n|j                  }t        |j                  t        j                        r|j                  }n6t        j                  |j                  j                  |j                  g      }t        j                  t        j                        }|j	                  |       t!        j"                  |j                  |j                  |j                        t        j$                  |j&                              }t        j                  t        j(                        }|j	                  |       |j                  |j                        }t!        j"                  |j                  |t        j$                  |j&                              }t        j*                  ||j                  |j                        |	|
|||      }|j-                  | j/                               }|g|j0                  dd |rVt!        j2                  |j                  |      }|j5                  dj7                  t        |      dk  rdnd	      d
|g      }n0t!        j8                  |j                        }|j5                  d      }t         j:                  j=                  |j                  t?        |j&                  t@        jB                  u             }t        jD                  |j                  |	t         j:                  jG                  |j                  d            t        jD                  |j                  |t!        jH                  |j                  d| jJ                  tM        jN                  dd      |||||gd            t        jP                  |j                  d ||jR                        g}t        jT                  |j                  |t        j                  |j                  |            S )Nr   r   r   rl  r   r   )'NoneType' object has no attribute '%{}s'   .30 PyExc_AttributeErrorr   format_argsr  r   __Pyx_dict_iterator	dict_iterr    Tro  r   r  r*  r   r   )+r   r   r	   py_object_typerN   r   r   r.  r   r   rL   r   r(   r   r   r   r   r|  
c_ptr_typerE   rv  DictIterationNextNoder   r   r   IdentifierStringNoder  formatNullNoder   r   r  r
   r   r   r/  rY  PyDict_Iterator_func_typer   r!   r8  r   r   )r\   r*   r   r   r   r   r   r  	dict_temppos_temp
key_targetvalue_targettuple_targetr   dict_len_tempdict_len_temp_addris_dict_tempis_dict_temp_addriter_next_nodemethod_nodeis_dictresult_codes                         r#   r   z,IterationTransform._transform_dict_iteration#  s   ##J$=$=>THHX\\*	##J$@$@AT88DHH%377
7\LF{{22t{{''(A-/3{{/?/?,J  K#{{J;;Ldii!3!3499D%%DIIMM/3yyk;D ",,Z-I-IJ]#&44HHm//=&&}'9'9:< ##J$9$9:Txx)%33HHl&&tyy13 44}((6l (;;D<L<L<NO)*

1Q#88VTK11;BBCPVK[]L]5cef.%h 2 (H
 $,,X\\:K112UVH##++DHHc(--7K\K\:\6]^ &&''001=
 &&22LL)22#.#:#:;#U$g{<NPab 
  "..	#2 ''HHE### 	r%   r   r  method_namep_orig_length	p_is_dictrK   is_setp_is_setc                    g }t        j                  t        j                        }|j	                  |       |j                  |j                        }t        j                  t        j                        }|j	                  |       |j                  |j                        }t        |j                  t        j                        r|j                  }n6t        j                  |j                  j                  |j                  g      }t        j                  t        j                        }|j	                  |       t        j                  |j                  |j                  |j                        t        j                  |j                              }	t        j                  t        j                         }|j	                  |       |j                  |j                        }
t        j                  |j                  |
t        j                  |j                              }|j"                  }t        j$                  ||j                  |j                        |||
      }|j'                  | j)                               }|g|j*                  dd t        j,                  j/                  |j                  t1        |j                  t2        j4                  u             }t        j6                  |j                  |t        j,                  j9                  |j                  d            t        j6                  |j                  |t        j:                  |j                  d| j<                  t?        j@                  dd      |||	|gd	            t        jB                  |j                  d ||jD                  
      g}t        jF                  |j                  |t        j                  |j                  |            S )Nr  rl  r   r   __Pyx_set_iteratorset_iterr    Tr  r*  r   r   )$r   r   r	   r  rN   r   r   r.  r(   r   r   r   r   r|  r  rE   rv  r   SetIterationNextNoder   r   r   r   r   r  r
   r   r   r/  rY  PySet_Iterator_func_typer   r!   r8  r   r   )r\   r*   set_objr   r  set_tempr  r   set_len_tempset_len_temp_addris_set_tempis_set_temp_addrr  r  r  r  s                   r#   r   z+IterationTransform._transform_set_iteration  s   ##J$=$=>T88GKK(##J$@$@AT88DHH%dii!3!3499D%%DIIMM/3yyk;D !++J,H,HI\"%33HHl..w{{;&&|'8'89; ##J$9$9:Thhtxx($22HHk&&tyy13 {{33l&&w{{3X|[Z';;D<L<L<NO)*

1Q""**488SIYIY9Y5Z[ &&%%..txx;
 &&00KK(11!,!8!8\!R!6+<>NO 
  ,,	#2 ''HHE### 	r%   F)&rl   rm   rn   ro   r   r   r   r   r   r	   	CFuncTypec_char_ptr_typeCFuncTypeArgr
   r   rZ  r.  r[  r   r   rv  rw  rx  r  r}  r~  r  r{  r   r   r   r  r  r  r   r  r  r   re   r%   r#   rz   rz      s   0dEIVA(aF #7*"6"6""#J##C););TB%%#'
 "6!5!5$$#J##C););TB'
 	"%&N  4z33!!#J##FJ,A,A4H#J##FJ,F,FM#J##GZ-I-I4P$
  (<z';';#J##C)B)BDI#J##Hj.N.NPTU#J##FJ,J,JDQ#J##FJ,E,EtL	 
 ($VSpUnB^H
!Ob0%d\| !5
 4 4!!#J##FZ-F-FM#J##I
0E0EtL#J##MJ4M4MtT#J##Oj6V6VX\]#J##K*2K2KTR$!  4z33!!#J##EJ,E,EtL#J##Hz/D/DdK#J##Oj6V6VX\]#J##J1J1JDQ	$ Br%   rz   c                   |    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d Zej                   j"                  Zy)SwitchTransformz
    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.
    )NNNc                 z   	 t        |t        j                  t        j                  f      r|j                  }nt        |t        j
                        r|j                  j                  }nOt        |t        j                        r|j                  }n(t        |t        j                        r|j                  }nnt        |t        j                        r4|j                  | j                  S |j                         r{t        |j                  t        j                   t        j"                  f      rG|j$                  dk(  }|r|s| j                  S ||j&                  | j)                  |j                        fS |j+                         st|j$                  dk(  rd}n |r|j$                  dk(  rd}n| j                  S t-        |j&                  |j&                        r|j                  j.                  r||j&                  |j                  gfS t1        |j                  dd       r:|j                  j2                  j4                  r||j&                  |j                  gfS t-        |j                  |j                        r|j&                  j.                  r||j                  |j&                  gfS t1        |j&                  dd       r:|j&                  j2                  j4                  r||j                  |j&                  gfS | j                  S t        |t        j6                        r|j$                  dk(  s|r}|j$                  dk(  rn|j$                  dk(  }| j9                  |j&                  |      \  }}}| j9                  |j                  |      \  }}}	|||k(  rt-        ||      r|r|r||||	z   fS | j                  S )	NTr   r|   F!=r   orr!  )r(   r   CoerceToTempNodeCoerceToBooleanNoder)   BoolBinopResultNoder   EvalWithTempExprNodesubexpressionTypecastNoder   r   cascadeNO_MATCHis_c_string_containsrC   r   rr  r~   rB   extract_in_string_conditionsis_python_comparisonr7   rp  getattrr   is_constr0  extract_conditions)
r\   condallow_not_inr   not_in_1t1c1not_in_2t2c2s
             r#   r  z"SwitchTransform.extract_conditions  s   $!;!;!*!>!>!@ AxxD)"?"?@xx||D)"@"@A))D)"8"89||  dI445||'}}$**,dmmi.C.CYEXEX-YZ(2,==(t}}d.O.OPTP]P].^^^..0==D("F!dmmt&;!F==( #4==$--@}}//%t}}t}}oEE >!%!4!4!=!=%t}}t}}oEE"4==$--@}}//%t}}t}}oEE >!%!4!4!=!=%t}}t}}oEE }} i556}}$$--5:P $ 6#'#:#:4==,#W "b#'#:#:4==,#W "b>h(&:rSU?V$'RU22}}r%   c           
      :   t        |t        j                        rpt        t	        t        t        |j                                    }t        t        j                  j                  |j                        }|D cg c]
  } ||       c}S |j                  }|j                  }t        t        t        |            D ch c]
  }|||dz     c}      }|D cg c].  }t        j                  |j                  t!        ||      |      0 c}S c c}w c c}w c c}w )Nr   r   r=   )r(   r   r   sortedrK   r   r   r   r   r   r   r   encodingr   rL   CharNoder   )	r\   string_literalcharvalsnode_for_charcharval
charactersr  i	characters	            r#   r  z,SwitchTransform.extract_in_string_conditions  s    ni&;&;<c#c>+?+?"@ABH#I$5$5$=$=~?Q?QRM:BCwM'*CC (--J!**HU3z?=S U*Qqs"3 UVJ '13" ''(:(:-PY[cBd8AC 3 3 D
 !V3s   9D>D3Dc                    | j                  ||      \  }}}|| j                  S |t        ||      s| j                  S |j                  j                  s|j                  j
                  rFt        |D cg c]1  }|j                  j                  xs |j                  j
                   3 c}      r| j                  S |||fS c c}w r'   )r  r   r7   rE   r  r  r   )r\   
common_varr   r  r   var
conditionsr  s           r#   extract_common_conditionsz)SwitchTransform.extract_common_conditions$  s    "&"9"9)\"RZ;== #OC,L== ((//SXX%5%5#ISTdii&&;$))*;*;<T;V== sJ&& Us   46Cc                    t               }|D ]  }|j                         r,|j                  |v r y|j                  |j                         ?	 |j                  }|j
                  j                  s|j
                  j                  r|j                  |j                  }n|j                  }||v r y|j                  |        y# t        $ r Y  yw xY w)NTF)rK   r  r=   addr   rE   r  is_cpp_enumenum_int_valuecnameAttributeError)r\   condition_valuesseenr   value_entryvalue_for_seens         r#   has_duplicate_valuesz$SwitchTransform.has_duplicate_values/  s    u% 	)E((*((D0../ "'++K$))11[5E5E5Q5Q + : : F)4)C)C)4):): "T)('	)(  &   s   AC	CCc                    | j                   j                  d      s| j                  |       |S d }g }|j                  D ]u  }| j	                  ||j
                  d      \  }}}|| j                  |       |c S |j                  t        j                  |j                  ||j                               w |D cg c]  }|j                  D ]  }|  }	}}t        |	      dk  r| j                  |       |S | j                  |	      r| j                  |       |S | j                  |d       |D ]  }| j                  |d        t        |      }t        j                  |j                  |||j                         }
|
S c c}}w )Noptimize.use_switchFr   r  r   r   r   r   r   testcasesr   )current_directivesgetr^   r   r  r   rN   r   SwitchCaseNoder   r   r  rL   r*  r1   SwitchStatNoder   )r\   r*   r  r0  	if_clause_r  caser  r&  switch_nodes              r#   visit_IfStatNodez SwitchTransform.visit_IfStatNodeH  s   &&**+@At$K
 	DI(,(F(FI//)8%Az:!""4(LL--)--9C3<>>C D	D #@t@'+D@@ @ 1$t$K$$%56t$K 	4/ 	-DtV,	- !,
**txx0:167;7G7GI '@s   <Fc                 \   | j                   j                  d      s| j                  |       |S | j                  d |j                  d      \  }}}|t        |      dk  s| j                  |      r| j                  |       |S | j                  |||||j                  |j                        S )Nr,  Tr   )
r1  r2  r^   r  r/  rL   r*  build_simple_switch_statementtrue_val	false_valr\   r*   r   r  r  s        r#   visit_CondExprNodez"SwitchTransform.visit_CondExprNoden  s    &&**+@At$K)-)G)G$))T*#&
Jz?Q&,,Z8t$K11*j&MM4>>+ 	+r%   c                    | j                   j                  d      s| j                  |       |S | j                  d |d      \  }}}|t	        |      dk  s| j                  |      r2| j                  |       |j                  | j                                |S | j                  ||||t        j                  |j                  d      t        j                  |j                  d            S Nr,  Tr   r   F)r1  r2  r^   r  rL   r*  wrap_operandsr   r;  r   r   r   r>  s        r#   visit_BoolBinopNodez#SwitchTransform.visit_BoolBinopNode  s    &&**+@At$K)-)G)G$*&
Jz?Q&,,Z8t$t//12K11*j&txxt4txxu57 	7r%   c                    | j                   j                  d      s| j                  |       |S | j                  d |d      \  }}}|t	        |      dk  s| j                  |      r| j                  |       |S | j                  ||||t        j                  |j                  d      t        j                  |j                  d            S rA  )
r1  r2  r^   r  rL   r*  r;  r   r   r   r>  s        r#   r   z$SwitchTransform.visit_PrimaryCmpNode  s    &&**+@At$K)-)G)G$*&
Jz?Q&,,Z8t$K11*j&txxt4txxu57 	7r%   c           	      6   t        j                  |      }t        j                  |j                  ||j                  |j                  | j                               d      }t        j                  |j                  ||j                  |j                  | j                               d      }	|r|	|}	}t        j                  |j                  ||      g}
t        |      }t        j                  |j                  ||
|	      }t        j                  ||      }|S )NTr   r   firstr-  r.  )r   r.   r   r   r   r   rE   r   r3  r1   r4  r   )r\   r*   r  r  r   r<  r=  r   	true_body
false_bodyr0  r8  replacements                r#   r;  z-SwitchTransform.build_simple_switch_statement  s    ,,T2
..HH""499d.>.>.@A		
 //HH##DIIt/?/?/AB	
 $.	zI%%DHH3=-68 9 !,
**2<389CE  66z;Or%   c                 (   | j                   j                  d      s| j                  |       |S |j                  }|j                  }| j                  |       |j                  |ur,t        j                  |j                  |      s|j                  S |S )Nr,  )r1  r2  r^   r  	lazy_tempr   tree_contains)r\   r*   	orig_exprtemp_refs       r#   visit_EvalWithTempExprNodez*SwitchTransform.visit_EvalWithTempExprNode  s    &&**+@At$K &&	>>4 Y.((););XF)))r%   N)rl   rm   rn   ro   r   r  r  r  r*  r9  r?  rC  r   r;  rP  r   VisitorTransformrecurse_to_childrenrp   re   r%   r#   r  r    sU    
 "H5n3	'2$L+"7&7$: ))==Jr%   r  c                   B    e Zd ZdZd Zej                  j                  Zy)FlattenInListTransformzj
    This transformation flattens "x in [val1, ..., valn]" into a sequential list
    of comparisons.
    c                 f   | j                         j                  S j                  dk(  rdd}nj                  dk(  rdd}nS t        j                  t
        j                  t
        j                  t
        j                  f      sS j                  }j                  j                  }t        |      dk(  rB|j                         r0j                  dk(  }t        j                  j                  |      S S t        |D cg c]  }|j                    c}      rS t#        j$                  |      }g }g }|D ]  }|j                         s&t#        j&                  |      }|j)                  |       t        j*                  j                  |||d 	      }	|j)                  t        j,                  j                  |	t.        j0                  
              fd}
t3        |
|      }t#        j4                  ||      }|d d d   D ]  }t#        j4                  ||      } |S c c}w )Ninr  r|   r   r!  r  r   r   )r   rB   r~   rC   r  )r   r   rE   c                 J    t        j                  j                  | |      S )N)r   r~   rB   rC   )r   r0  r   )leftrightconjunctionr*   s     r#   concatz;FlattenInListTransform.visit_PrimaryCmpNode.<locals>.concat  s&    **&*hh+6+/+0	2 2r%   rI   )r^   r  r~   r(   rC   r   	TupleNoder   SetNoderB   r   rL   try_is_simpler   r   r   r   r   r.   r+  rN   r   r  r	   c_bint_typer   r  )r\   r*   	eq_or_neqr   r   r=   r)   condsr   r  r[  r   r   r  rZ  s    `            @r#   r   z+FlattenInListTransform.visit_PrimaryCmpNode  s   4 <<#K]]d"KI]]h&KIK$--)*=*=*3*<*<*3*;*;*= > Kmm}}!!t9>  ""&--8"; ))$((/JJK$/3/0K%%c* 	@C$$&**3/S!++&*hh+.+4+.*.0D LL//&*hh*.'1'='=? @	@ 	2 65)	11#yA$B$K 	FD 55dHEH	FG 0s   H.N)	rl   rm   rn   ro   r   r   rQ  rR  rp   re   r%   r#   rT  rT    s     
>@ ))==Jr%   rT  c                   N    e Zd ZdZej
                  j                  Zd Zd Z	d Z
y)DropRefcountingTransformz&Drop ref-counting in safe places.
    c                    g g }}g g }}g }|j                   D ]  }t        |t        j                        rE| j	                  |j
                  |||      s|c S | j	                  |j                  |||      r^|c S t        |t        j                        r|c S |c S  |s|rc|D 	cg c]  \  }}	|	 }
}}	|D 	cg c]  \  }}	|	 }}}	t        |
      t        |      k7  r|S t        t        |
            t        |      k7  r|S |s|rg }|D ]*  }| j                  |      }|s|c S |j                  |       , g }|D ]*  }| j                  |      }|s|c S |j                  |       , t        |      t        |      k7  r|S t        t        |            t        |      k7  r|S |S |D cg c]  }|j                   }}|D ]	  }d|_         ||z   D ]  \  }}||vsd|_         ||z   D ]	  }d|_         |S c c}	}w c c}	}w c c}w )zF
        Parallel swap assignments like 'a,b = b,a' are safe.
        F)r   r(   r   r   _extract_operandr   r   CascadedAssignmentNoderK   rL   _extract_index_idrN   r)   use_managed_ref)r\   r*   
left_namesright_namesleft_indicesright_indicesr   statpathnlnamesrnameslindiceslhs_nodeindex_idrindicesrhs_nodet	temp_argsr  r6  	name_node
index_nodes                          r#   visit_ParallelAssignmentNodez5DropRefcountingTransform.visit_ParallelAssignmentNode!  s<    #%bK
&("mJJ 	D$ : :;,,TXXz-95BK,,TXX{-:ECKD%">">?	 +57at7F7+68at8F86{c&k)3v;3{#33= H( *11(;K)	*
 H) *11(;K)	* 8}H-3x=!S%77 K$)*qQUU*	* 	)D#(D 	) '4 	2LAy	),1	)	2 '6 	/J).J&	/ W 88> +s   %G99G?*Hc                    t        |      }|j                  j                  syt        |t        j
                        r|j                  |       |j                  }g }|}|j                  rA|j                  ry|j                  |j                         |j                  }|j                  rA|j                  rD|j                  |j                         |j                  dj                  |d d d         |f       y|j                  rr|j                   j                  t"        j$                  k7  ry|j&                  j                  j(                  sy|j                   j                  sy|j                  |       yy)NF.rI   T)r1   rE   r   r(   r   r  rN   r)   r   r6   memberr8   r   r"   joinr   r   r
   r  r"  r  )r\   r*   namesindicesr   	name_pathobj_nodes          r#   re  z)DropRefcountingTransform._extract_operandf  s(   4 yy$$dI667LL88D	##""X__-||H	 ##
 X]]+LL388IddO4d;=  yy~~!2!22::??))99$$NN4   r%   c                     |j                   }|j                  }t        |t        j                        r|j
                  }nt        |t        j                        ry y |j
                  |fS r'   )r   r"  r(   r   r4   r"   	ConstNode)r\   rz  r   r"  	index_vals        r#   rg  z*DropRefcountingTransform._extract_index_id  sT      eY//0

Iy223		9%%r%   N)rl   rm   rn   ro   r   rQ  rR  rp   r{  re  rg  re   r%   r#   rc  rc    s)    ))==JCJ:
&r%   rc  c                   F   e Zd 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j0                  dej2                  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&y)EarlyReplaceBuiltinCallsa  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                     | j                  |       |j                  }| j                  |      s|S | j                  |||j                        S r'   )r^   r   _function_is_builtin_name_dispatch_to_handlerr   )r\   r*   r   s      r#   visit_SimpleCallNodez-EarlyReplaceBuiltinCalls.visit_SimpleCallNode  sE    4 ==--h7K((xCCr%   c                    | j                  |       |j                  }| j                  |      s|S |j                  }t	        |t
        j                        s|S |j                  }| j                  ||||j                        S r'   )
r^   r   r  positional_argsr(   r   r\  r   r  keyword_args)r\   r*   r   r   r   s        r#   visit_GeneralCallNodez.EarlyReplaceBuiltinCalls.visit_GeneralCallNode  sw    4 ==--h7K((	)Y%8%89K~~(((D$"3"35 	5r%   c                     |j                   sy| j                         }|j                  |j                        }||j	                         j                  |j                        uryy)NFT)r   r   r-  r"   r,  lookup_here)r\   r   r  r   s       r#   r  z2EarlyReplaceBuiltinCalls._function_is_builtin_name  sT     

8==)))+77FFr%   Nc                     |d|j                   z  }nd|j                   z  }t        | |d       }||	 |||      S  ||||      S |S )Nz_handle_simple_function_%sz_handle_general_function_%s)r"   r  )r\   r*   r   r   kwargshandler_namehandle_calls          r#   r  z-EarlyReplaceBuiltinCalls._dispatch_to_handler  s]    >7(--GL88==HLdL$7"~"4.."4v66r%   c                     t        j                  |j                  j                  |j                  j                  |||      |_        y )Nro  )r   PythonCapiFunctionNoder   r   r"   )r\   r*   r$  	func_typero  s        r#   _inject_capi_functionz.EarlyReplaceBuiltinCalls._inject_capi_function  s4    !88MMt}}115)')r%   c           
          |sd}n"t        |t              s|dkD  rd}n
|dk(  rd}nd}|d|z  }nd}t        |j                  d|||t	        |      fz         y Nr  r   z...xzexpected %s, z3%s(%s) called with wrong number of args, %sfound %dr(   r  r   r   rL   r\   function_namer*   r   expectedarg_strexpected_strs          r#   _error_wrong_arg_countz/EarlyReplaceBuiltinCalls._error_wrong_arg_count  n    G#&(Q,G]GG*X5LLdhhM7L#d)Q= = 	>r%   c                     |s!t        j                  |j                  d      S t        |      dkD  r| j	                  d||d       t        |d   dd       }|t        j                  t        j                  fv r|d   S |S )N0.0r   r   floatr   rE   )
r   	FloatNoder   rL   r  r  r	   c_double_typer
   
float_type)r\   r*   pos_argsarg_types       r#   _handle_simple_function_floatz6EarlyReplaceBuiltinCalls._handle_simple_function_float  sv    &&txxu==x=1''xC8A;5
00'2D2DEEA;r%   c                 V   t        |      }d x}}|dk(  r|\  }n,|dk(  r|\  }}n!|dk(  r|\  }}}n| j                  d||       |S t        j                  |j                  |xs t        j
                  |j                        ||xs t        j
                  |j                              S )Nr   r   r   slice)rV  rX  rW  )rL   r  r   r  r   NoneNode)r\   r*   r  r  rV  rW  rX  s          r#   _handle_simple_function_slicez6EarlyReplaceBuiltinCalls._handle_simple_function_slice  s    M	>ED!^"KE4!^ (E4''x@K""HH79--dhh75++DHH5	7 	7r%   c                 N   t        |      dk7  r|S |d   }t        |t        j                  t        j                  f      ret        |j
                        dk(  rMt        j                  j                  |j                  t        |j
                        t        j                        S |S )zUnpack ord('X').
        r   r   r   )rL   r(   r   r   rr  r   r   r   r   r   r	   c_long_type)r\   r*   r  r)   s       r#   _handle_simple_function_ordz4EarlyReplaceBuiltinCalls._handle_simple_function_ord  s~     x=AKqkcI1193F3FGH399~" ((00#cii.zOeOe0ffr%   c                 (    | j                  ||d      S )zTransform

        _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
        F_transform_any_allr\   r*   r  s      r#   _handle_simple_function_allz4EarlyReplaceBuiltinCalls._handle_simple_function_all	  s     &&tXu==r%   c                 (    | j                  ||d      S )zTransform

        _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
        Tr  r  s      r#   _handle_simple_function_anyz4EarlyReplaceBuiltinCalls._handle_simple_function_any  s     &&tXt<<r%   c                 0   t        |      dk7  r|S t        |d   t        j                        s|S |d   }|j                  j
                  }|j                  }t        |      \  }}||S |r|}	n!t        j                  |j                  |      }	t        j                  |j                  d t        j                  |j                  |	t        j                  |j                  t        j                  |j                  |                  g      }
t        j                  |j                  t        j                  |j                  |             |_        t!        j"                  |||
       t        j$                  |j                  ||rd	      S d	      S )
Nr   r   r   r   r   )r   r   r   all)gen	orig_func)rL   r(   r   GeneratorExpressionNodedef_nodegbodyr   rt   r   r   r   r   r   ReturnStatNoder   r   r   recursively_replace_nodeInlinedGeneratorExpressionNode)r\   r*   r  is_anygen_expr_nodegenerator_bodyrK  yield_expressionyield_stat_noder   rE  s              r#   r  z+EarlyReplaceBuiltinCalls._transform_any_all)  ss   x=AK(1+y'H'HIK &//55"''	,I),T)/#K(I!))*:*>*>HXYI$$  d""$(('--'001A1E1EVTV@	
	 !& 4 4HH$$%5%9%9VL!N	 	((S77=VEX 	XQVX 	Xr%   itc                 Z   t        |      dk7  r|S |d   }t        |t        j                        r |j                  t
        j                  u r|}n=t        |t        j                        r|}t        |j                        }|s|S t        j                  |j                  |dt
        j                        }|D ]H  \  }}t        j                  |j                  ||j                        }	t        j                  |||	       J n|j                   r|j#                         }nlt        j$                  |j                  |j'                         r.|j                  t(        j*                  t
        j                  fv rdnd| j,                  |d	      }t        j.                  |j                  |      S )
a  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.
        r   r   r  r  comprehension_typerb   r   __Pyx_PySequence_ListKeepNewPySequence_ListTrT  )rL   r(   r   ComprehensionNoderE   r
   r  r  rr   loopr  r   ComprehensionAppendNoder   r   r  r   as_listrY  result_in_tempr	   r  PySequence_List_func_typeSortedListNode)
r\   r*   r  r)   	list_noder  rs   r  r  append_nodes
             r#   _handle_simple_function_sortedz7EarlyReplaceBuiltinCalls._handle_simple_function_sortedQ  ss    x=AKqkc9667CHHHYHY<YIY>>?M5m6H6HI#!@@-8#*#4#46I 6F ^1 /'??$(()$++- 00Q\]^ (( I
 "44))+Z=V=VX_XiXi<j0j /*..t-I '')<<r%   c           
      ^   t        |      dvr|S t        |d   t        j                  t        j                  f      s|S |d   }|j
                  }t        |t        j                        rt        |      \  }}d}|@|S |j                  }|j                  }	 |j                  r|j                  j                  s|S 	 t        |      dk(  r+t        j                  j                  |j                  d      }n|d   }t!        j"                  |j                  t$        j&                        }t)        j*                  |j                  |t        j,                  |j                  d||            }	t/        j0                  |||	       t)        j2                  |j                  t)        j*                  |j                  t!        j"                  |j                  |      |d	
      |g      }
t        j4                  |j                  |
||j6                  d|j8                        S # t        $ r |cY S w xY w)zLTransform sum(genexpr) into an equivalent inlined aggregation loop.
        r   r   r   Nr   )r   rE   r(  r   )r   r/   TrF  r   sum)r  result_node
expr_scoper  has_local_scope)rL   r(   r   r  r  r  rt   rN   rb   rp  rE   r  r%  r   r/  r   r   r.   r	   r  r   r   r7  r   r  r   r  r  r  )r\   r*   r  r  rK  r  r  rV  r   add_node	exec_codes              r#   __handle_simple_function_sumz5EarlyReplaceBuiltinCalls.__handle_simple_function_sum  s    x=%K(1+	(I(I(1(C(C(E FK !&&	mY%F%FG0Mi0X-o#'+22O.33'22:J:O:O:V:VK ;W x=A%%..txx;EQKE,,
@Y@YZ
--  &&txxjBRS 	((R&&HH**II#11dhh:V 	"
 		 77iz&11u+;;= 	== " s   #H H,+H,c                 (    | j                  ||d      S )Nr   _optimise_min_maxr  s      r#   _handle_simple_function_minz4EarlyReplaceBuiltinCalls._handle_simple_function_min      %%dHc::r%   c                 (    | j                  ||d      S )Nr  r  r  s      r#   _handle_simple_function_maxz4EarlyReplaceBuiltinCalls._handle_simple_function_max  r  r%   c                 "   t        |      dk  r<t        |      dk(  r|d   j                  r|d   j                  }t        |      dk  r|S t        t	        t
        j                  |dd             }|d   }|D ]q  }t        j                  |      }t        j                  |j                  ||t        j                  |j                  |||            }t        j                  ||      }s |ddd   D ]  }t        j                  ||      } |S )zKReplace min(a,b,...) and max(a,b,...) by explicit comparison code.
        r   r   NrB   r~   rC   )r<  r=  r/  rI   )rL   r   r   listr   r   r.   r   CondExprNoder   r   r  )	r\   r*   r   r~   cascaded_nodeslast_resultarg_noder   ref_nodes	            r#   r  z*EarlyReplaceBuiltinCalls._optimise_min_max  s    t9>4yA~$q'"A"AAw||4yA~c)"9"948DE1g& 	RH"00=J#00#& //LL'')		
K $88[QK	R 'tt, 	PH#88;OK	P r%   c                     |s"t        j                  |j                  g d      S | j                  ||t        j
                        }||ur!t        j                  |j                  |      S |S )Nre   r   r=   )r)   )r   r\  r   _transform_list_set_genexprr
   r  AsTupleNode)r\   r*   r  results       r#   &_DISABLED_handle_simple_function_tuplez?EarlyReplaceBuiltinCalls._DISABLED_handle_simple_function_tuple  s^    &&txxb"MM 11$'BSBST((v>>r%   c                     t        |      dk7  r|S |d   j                  r|d   j                  s|d= |S t        |d   t        j
                        r|d   j                         |d<   |S )zSReplace frozenset([...]) by frozenset((...)) as tuples are more efficient.
        r   r   )rL   r   r   r(   r   r   as_tupler  s      r#   !_handle_simple_function_frozensetz:EarlyReplaceBuiltinCalls._handle_simple_function_frozenset  sm     x=AKA;..x{7G7G  Y%7%78"1+..0HQKr%   c                     |s"t        j                  |j                  g g       S | j                  ||t        j
                        S Nr  )r   r   r   r  r
   r  r  s      r#   _handle_simple_function_listz5EarlyReplaceBuiltinCalls._handle_simple_function_list  s9    %%dhhRLL//h@Q@QRRr%   c                     |s*t        j                  |j                  g t                     S | j	                  ||t
        j                        S r   )r   r]  r   rK   r  r
   r   r  s      r#   _handle_simple_function_setz4EarlyReplaceBuiltinCalls._handle_simple_function_set  s;    $$TXXBNN//h@P@PQQr%   c                    t        |      dkD  r|S t        |d   t        j                        s|S |d   }|j                  }t        |      }|s|S t        j                  |j                  ||t        j                  u rdnd|      }|D ]H  \  }}	t        j                  |j                  ||j                        }
t        j                  ||	|
       J |S )zLReplace set(genexpr) and list(genexpr) by an inlined comprehension.
        r   r   rK   r  r  r  )rL   r(   r   r  r  rr   r  r   r
   r   r  r   r   r  )r\   r*   r  r]  r  rK  rs   r  r  r  r  s              r#   r  z4EarlyReplaceBuiltinCalls._transform_list_set_genexpr	  s     x=1K(1+y'H'HIK !&&	1)<K>>HHm*g.>.>>eF*,
 2B 	Z-o#;; $$%"))+K ,,]O[Y	Z r%   c                    t        |      dk(  r"t        j                  |j                  g i       S t        |      dkD  r|S t	        |d   t        j
                        s|S |d   }|j                  }t        |      }|s|S |D ]?  \  }}t	        |t        j                        s|c S t        |j                        dk7  s=|c S  t        j                  |j                  |dt        j                        }|D ]c  \  }}	t        j                  |j                  |j                  d   |j                  d   |j                        }
t        j                   ||	|
       e |S )zDReplace dict( (a,b) for ... ) by an inlined { a:b for ... }
        r   key_value_pairsr=   r   r   r   r  )key_expr
value_exprr   )rL   r   DictNoder   r(   r  r  rr   r\  r   r  r
   r   DictComprehensionAppendNoder   r   r  )r\   r*   r  r  rK  rs   r  r6  r  r  r  s              r#   _handle_simple_function_dictz5EarlyReplaceBuiltinCalls._handle_simple_function_dict%  sY    x=A%%dhhTVWWx=1K(1+y'H'HIK !&&	1)<K#3 	a.	0C0CD#(()Q.		  >>HHmv&002 2B 	Z-o#?? $$)..q1+003"))	+K
 ,,]O[Y	Z r%   c                 ^    t        |      dkD  r|S t        |t        j                        s|S |S )zlReplace dict(a=b,c=d,...) by the underlying keyword dict
        construction which is done anyway.
        r   )rL   r(   r   r
  )r\   r*   r  r  s       r#   _handle_general_function_dictz6EarlyReplaceBuiltinCalls._handle_general_function_dictK  s/     x=1K&)"4"45Kr%   r'   )'rl   rm   rn   ro   r   rQ  rR  rp   r  r  r  r  r  r  r  r  r  r  r  r  r	   r  r
   r  r  r  r  r  5_EarlyReplaceBuiltinCalls__handle_simple_function_sumr  r  r  r  r  r  r  r  r  r  re   r%   r#   r  r    s    
 ))==JD
5)
>$7$	> = "XH !5
 4 4	 	 	 z'@'@$	GH!J/=b8=t;;F	S
R
8"Lr%   r  c                   D    e Zd Zej                  j
                  Zd Zd Zy)InlineDefNodeCallsc                    |j                   y |j                   j                  ry | j                         j                  |j                        }|r$|j
                  rt        |j
                        dk7  ry |j
                  d   j                  S Nr   r   )cf_state
cf_is_nullr   r-  r"   cf_assignmentsrL   r   )r\   ry  r   s      r#   get_constant_value_nodez*InlineDefNodeCalls.get_constant_value_nodeY  sx    %((  ")))..9U11 4 45:##A&***r%   c                    | j                  |       | j                  j                  d      s|S |j                  }|j                  s|S | j                  |      }t        |t        j                        s|S t        j                  |j                  |||j                  |j                        }|j                         r| j                  ||      S |S )Nzoptimize.inline_defnode_calls)r  r   r   generator_arg_tag)r^   r1  r2  r   r   r  r(   r   PyCFunctionNodeInlinedDefNodeCallNoder   r   r  can_be_inlinedreplace)r\   r*   r  r   inlineds        r#   r  z'InlineDefNodeCalls.visit_SimpleCallNodee  s    4 &&**+JKK$$K//>(I$=$=>K22HHMDII"446 !!#<<g..r%   N)	rl   rm   rn   r   rQ  rR  rp   r  r  re   r%   r#   r  r  V  s    ))==J
+r%   r  c                   '   e 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ej                  ej                   ej"                  fD  ci c]/  }|t        j                  |t        j                  d
|d      g      1 c}}} Zd Z ej                  ej(                   ej                  d
ej*                  d      gd      Z ej                  ej                    ej                  d
ej*                  d      gd      Zd ZddZd Zd Zd Z ej                  ej<                   ej                  dej                  d      g      Zd Z e Z!d Z" ej                  ejF                   ej                  dejF                  d      g      Z$d Z% ej                  ejL                   ej                  dej                  d      g      Z'd Z( ej                  ejR                   ej                  dejL                  d      g      Z*d Z+ ej                  ejX                   ej                  dej                  d      g      Z-d Z. ej                  ej^                   ej                  dej                  d      g      Z0d Z1 ej                  ej                    ej                  dej                  d      gdd !      Z2d" Z3 ej                  ejh                   ej                  dej                  d      g      Z5 ej                  ejh                   ej                  d#ej                   d      g      Z6d$ Z7d% Z8 ej                  ejr                   ej                  d#ej                  d      g      Z: ej                  ejr                   ej                  d#ejv                  d      g      Z<d& Z= ej                  ej|                   ej                  d'ej~                  d      gd      Z@ ej                  ej|                   ej                  d(ej                  d      gd      ZB ej                  ej|                   ej                  dej                  d      gd      ZCej<                  d)ej                  d*ej                  d+ejL                  d,ejR                  d-ejX                  d.ej^                  d.ejF                  d/ij                  ZGd0hZHd1 ZI ej                  ej                   ej                  d2ej                  d      g      ZKd3 ZL ej                  ej                   ej                  d
ej                  d      g      ZNd4 ZOd5 ZP ej                  ej                   ej                  d6ej                  d       ej                  d7ejR                  d      g      ZQ ej                  ej                   ej                  d6ej                  d       ej                  d7ejR                  d       ej                  d8ejF                  d      g      ZR	 dd9ZS	 dd:ZT ej                  ej                   ej                  dej                  d       ej                  d;ej                  d      gd      ZVd< ZWd= ZX ej                  ej                   ej                  d>ej                  d       ej                  d#ej(                  d      gd      ZY ej                  ej                   ej                  d>ej                  d       ej                  d#ej                  d      gd      ZZd? Z[ ej                  ej                   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                  dAej|                  d       ej                  dBej(                  d      gd C      Z]dD Z^ddEZ_ ej                  ej                   ej                  dej                  d      gd      Z`dF Za ej                  ej                   ej                  dej                  d       ej                  dGej                  d       ej                  dHej                  d      g      ZbdI Zc ej                  ej                   ej                  dej                  d       ej                  dGej                  d       ej                  dHej                  d       ej                  dJej(                  d      g      ZddK Ze ej                  ej                   ej                  dej                  d       ej                  dGej                  d       ej                  dHej                  d      g      Zf ej                  ej(                   ej                  dej                  d       ej                  dGej                  d       ej                  dHej                  d      gej(                  j                        ZhdL Ziej                  ej                   fD  ci c]  }t        j                  t        j                  fD ]  }||ft        j                  |t        j                  dMt        j                  d      t        j                  dNt        j                  d      t        j                  dO|d      t        j                  dPt        j                  d      t        j                  dQt        j                  d      g|j                  rdn|j                          c}}}} ZldR ZmdS ZndT ZodU ZpdV ZqdW ZrdX ZsdY ZtdZ Zud[ Zvd\ Zwd] Zxd^ Zyd_ ZzemZ{enZ|eoZ}epZ~eqZerZesZetZeuZevZewZexZeyZd` Zda Zdb Zdc Zdd Zde Zdf Zdg Zdh Z ej                  ej                   ej                  diej*                  d      gd      Zdj ZeZeZeZeZeZeZeZeZeZeZ ej                  ej*                   ej                  diej*                  d      g      Z	  ej                  ejL                   ej                  dkej<                  d       ej                  dlej                  d      g      Zdm Z ej                  ejL                   ej                  dkej<                  d       ej                  dnej                  d       ej                  doej|                  d      g      Zdp Z ej                  ej<                   ej                  dkej<                  d       ej                  dqej                  d      g      Zdr Z ej                  ej                   ej                  dkej                  d       ej                  dsej                  d       ej                  dtej|                  d       ej                  duej|                  d       ej                  dvej(                  d      gd      Zdw Zdx Zdy Z ej                  ej|                   ej                  dkej<                  d       ej                  dsej                  d       ej                  dtej|                  d       ej                  duej|                  d       ej                  dvej(                  d      gdz      Zd{ Zd| Zd} Z ej                  ej|                   ej                  dkej<                  d       ej                  dsej                  d       ej                  dtej|                  d       ej                  duej|                  d      gd      Zd~ Z ej                  ej<                   ej                  dkej<                  d       ej                  dsej                  d       ej                  dej                  d       ej                  dej|                  d      g      Zd Z ej                  ej                   ej                  dej<                  d       ej                  dej~                  d       ej                  dej~                  d      g      Z ej                  ej                   ej                  dej<                  d      g      Zg dZeD  cg c]  }|tg        jh                  |      f c}}} Zd Z ejn                   ej                  ej<                   ej                  dej~                  d       ej                  dej|                  d       ej                  dej~                  d      g            Z ej                  ej<                   ej                  dej~                  d       ej                  dtej|                  d       ej                  dej|                  d       ej                  dej~                  d       ej                  dej~                  d       ej                  ded      g      Z ej                  ej<                   ej                  dej                  d       ej                  dtej|                  d       ej                  dej|                  d       ej                  dej~                  d       ej                  dej~                  d       ej                  ded      g      ZdZd ZeZd Zd Zd Zd Zd Z	 dddeÐj                  j                  d fdZd Z ej                  ej                   ej                  dej                  d      g      Zd Zd Zd Zyc c}}} w c c}}}} w c c}}} w )OptimizeBuiltinCallsa<  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                 D    | j                  |       |j                         S )z:Flatten redundant type checks after tree changes.
        )r^   	reanalyser_   s     r#   visit_PyTypeTestNodez)OptimizeBuiltinCalls.visit_PyTypeTestNode  s     	4 ~~r%   c                     | j                  |       |j                  |j                  j                  k(  r|j                  S |S )z,
        Drop redundant type casts.
        )r^   rE   r   r_   s     r#   _visit_TypecastNodez(OptimizeBuiltinCalls._visit_TypecastNode  s7     	4 99)))<<r%   c                 ~   | j                  |       t        |j                  t        j                        r|j                  j
                  |_        |j                  }||j                  s|j                  ry|j                  r9|j                  r-|j                  j                  s|j                  j                  ry|S )z7
        Drop dead code and useless coercions.
        N)r^   r(   rb   r   r   r)   rD   rp  r   r   is_localis_arg)r\   r*   rb   s      r#   rc   z'OptimizeBuiltinCalls.visit_ExprStatNode  s     	4 dii!=!=>		DIyy<4<<4??<<DJJDJJ,?,?4::CTCTr%   c                 j   | j                  |       |j                  }t        |t        j                        r|j                  }t        |t        j
                        rU|j                  t        j                  t        j                  fv r)|j                  j                  | j                               S |S )z<Drop redundant conversion nodes after tree changes.
        )r^   r)   r(   r   PyTypeTestNoder   rE   r	   r  r
   	bool_typecoerce_to_booleanr   r\   r*   r)   s      r#   visit_CoerceToBooleanNodez.OptimizeBuiltinCalls.visit_CoerceToBooleanNode  s     	4 hhc9334''Cc9778xxJ55w7H7HIIww001A1A1CDDr%   oNc                     | j                  |       |j                  }t        |t        j                        r|j                  }t        |t        j
                        r|j                  j                  dk(  rt        |j                        dk(  r|j                  d   }|j                  t        j                  u r|j                  d      S |j                  j                  r|j                  j                  dk(  rt        j
                  |j                   d| j"                  |gd|j$                  t'        j(                  dd      |j*                  	      j-                  |j                  | j/                               S |S )
z3Drop redundant conversion nodes after tree changes.r  r   r   =float() argument must be a string or a number, not 'NoneType'__Pyx_PyObject_AsDouble__Pyx_PyNumber_Floatpynumber_floatzTypeConversion.c)r   py_namer  ro  rn  )r^   r)   r(   r   CoerceFromPyTypeNoderY  r   r"   rL   r   rE   r
   r  r  r   r$  r   PyNumber_Float_func_typer  r   r!   rn  r   r   )r\   r*   r)   func_args       r#   visit_CoerceToPyTypeNodez-OptimizeBuiltinCalls.visit_CoerceToPyTypeNode  s$   4 hhc999:''Cc9778||  G+CHH0B88A;==G$6$66#556uvv]]..3<<3E3EIb3b$77"8$:W:W&Z ' $'2'>'>?OQc'd'+':':  i		4+;+;+=>? r%   c                    | j                  |       |j                  }|j                  j                  sE|j                  |j                  k7  r*|j	                  |j                  | j                               }|S t        |t        j                        r|j                  }|j                  r|j                  j                  rt        |t        j                        s`|j                  j                  rt        |t        j                        s0|j                  j                  rDt        |t        j                        r*|j	                  |j                  | j                               S |S t        |t        j                        r|j                  t         j"                  u rc|j                  j%                  |j                  j                        r|j                  j	                  |j                  | j                               S |j                  t&        j(                  u rj|j                  j                  j*                  rJ|j                  j*                  r4|j                  j	                  |j                  | j                               S |S t        |t        j,                        r>|j                  j                  s|j                  j                  r| j/                  ||      S |S )zDrop 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.
        )r^   r)   rE   r   r   r   r(   r   r*  rp  r  r   is_floatr  r   r   r	   r  r  r
   r   is_unicode_charr   _optimise_numeric_cast_callr-  s      r#   visit_CoerceFromPyTypeNodez/OptimizeBuiltinCalls.visit_CoerceFromPyTypeNode  s    	4 hhxx##yyCHH$mmDIIt/?/?/ABJc9334''C>>		  ZY5F5F%GII&&:c9;N;N+OII$$C9K9K)L}}TYY0@0@0BCC  Y99:xx:44499,,SWW\\:77,,TYY8H8H8JKKW11177<<//DII4M4M77,,TYY8H8H8JKK  Y556yy499#5#577cBBr%   r)   c           	         |j                   }d }t        |t        j                        r|j                  }njt        |t        j
                        rP|j                  j                  r:t        |j                  t        j                        r|j                  j                  }|t        |      dk7  r|S |d   }t        |t        j                        r|j                  }n|j                  j                  r|S |j                  dk(  r|j                  j                  s|j                  j                  r|j                  |j                  k(  r|S |j                  t         j"                  t         j$                  fv r| j'                  ||j                  |      S |j                  j)                  |j                        s|j                  j*                  rt        j,                  |j.                  ||j                        S |j                  j*                  r|j                  j0                  r|j                  j2                  dk(  rd}nd|j                  j2                  z   }t        j                  |j.                  || j4                  |j                     |gd|j6                  |j8                        j;                  |j                  | j=                               S |S |j                  d	k(  r|j                  j*                  s|j                  j*                  r|j                  |j                  k(  r|S |j                  t         j"                  t         j$                  fv r| j'                  ||j                  |      S |j                  j)                  |j                        s|j                  j*                  r,t        j,                  |j.                  ||j                        S |S )
Nr   r   r  rl  l__Pyx_truncltrunc)r  r   r5  r  rn  r  )r   r(   r   rY  r   r4   rE   is_builtin_typer   r\  rL   r   r)   r   r"   r  r	   r   c_py_unicode_type_pyucs4_to_numberr  r;  r  r   
is_numericmath_h_modifierfloat_float_func_typesr  rn  r   r   )r\   r*   r)   r   r   r8  truncls          r#   r=  z0OptimizeBuiltinCalls._optimise_numeric_cast_call  s   <<c977888D)"4"45}},,CMM9K^K^1_}}))<3t9>K7h	 < <=||H]]&&K==E!}}##tyy'7'7==DII-#O]]z'@'@*B^B^&__11$xPPYY..x}}=AWAW$11$((HSWS\S\]]''DII,@,@==00C7+F$x}}'D'DDF 33HHf"99(--H"! LL#'#6#6 )DIIt'7'7'9:;$  ]]g%}}%%););==DII-#O]]z'@'@*B^B^&__11$xPPYY..x}}=AWAW$11(D Dr%   rI   rP  g      c                 P   |dv sJ t        j                  |j                  |dk(  rdnd|dk(  r| j                  n| j                  |g||j
                  |j                  t        j                  |dk(  rdndd            j                  |j                  | j                               S )	N)r  r  r  __Pyx_int_from_UCS4__Pyx_double_from_UCS4
int_pyucs4float_pyucs4
Builtins.c)r  r   r5  r  rn  ro  )r   rY  r   pyucs4_int_func_typepyucs4_double_func_typer  rn  r   r!   r   rE   r   )r\   r*   py_type_namer8  s       r#   rE  z&OptimizeBuiltinCalls._pyucs4_to_number7	  s    ///++HH|u/D+Jb3?53Hd//dNjNj LL..$00QVAV\jlxy
 )DIIt//1
2	3r%   c           
          |sd}n"t        |t              s|dkD  rd}n
|dk(  rd}nd}|d|z  }nd}t        |j                  d|||t	        |      fz         y r  r  r  s          r#   r  z+OptimizeBuiltinCalls._error_wrong_arg_countC	  r  r%   c                     |S r'   re   )r\   r*   r  r   arg_listr  s         r#   _handle_functionz%OptimizeBuiltinCalls._handle_functionU	  s    r%   c           	         |r|S |r"|j                   r|j                  j                  s|S | j                         j	                  |      }|s|S t        j                  |j                  j                  t        j                  |j                  |||j                        |d      j                  | j                               }	|	| j                  |||||      S |j                  }
|
"|j                  r|j                  j                  }
t        j                  |j                  |	|
      }|s|j                  |_        |j#                  | j                                d|_        |j'                  |j                  | j                               S )a  
        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   rE   T)r8   r9   	is_calledr  )r   r8   r   r   r-  r   r5   r   r   r4   rE   analyse_as_type_attribute%_optimise_generic_builtin_method_callr   r   r   r\   analyse_c_function_callanalysedr   )r\   r*   	type_name	attr_namer   rU  is_unbound_methodr  
type_entryr   r   	call_nodes               r#   _handle_methodz#OptimizeBuiltinCalls._handle_methodX	  sb    Kx44HLL<P<P K%%'..y9
K((MM"" __	&
   65d6F6F6HI 	 >==i85FH Hyy<DNN>>&&D,,HH	 !%\\IN))$*:*:*<=!	""499d.>.>.@AAr%   c                 2   t        |      }|s|dk\  s|j                  r|j                  s|S |j                  j                  j
                  s|S |j                  j                  t        j                  u r|S t        j                  ||j                  ||      S )z
        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.
        r   )
rL   r   r6   r8   rE   rC  r
   rM   r   CachedBuiltinMethodCallNode)r\   r*   r^  r   rU  r_  r  s          r#   rZ  z:OptimizeBuiltinCalls._optimise_generic_builtin_method_call	  s    
 M		Qx7L7LQYQdQdK||  00K<< 1 11K44(,,	85 	5r%   r8   c           	         t        |      dk7  r9t        |      dk(  r)t        j                  |j                  t	                     S |S |d   }|j
                  t        j                  u r+|j                         s|S d}t        j                  dd      }nd}t        j                  dd      }t        j                  |j                  || j                  ||j                  |d	
      S )z5Optimise single argument calls to unicode().
        r   r   r   __Pyx_PyUnicode_UnicodePyUnicode_UnicodeStringTools.c__Pyx_PyObject_UnicodePyObject_Unicodeunicoder   r  ro  r5  )rL   r   r   r   r   rE   r
   r   may_be_noner   r!   rY  PyObject_Unicode_func_typer  )r\   r*   r   r  r)   r$  ro  s          r#   _handle_simple_function_unicodez4OptimizeBuiltinCalls._handle_simple_function_unicode	  s     x=A8}! ,,TXX]_MMKqk88w+++??$
-E&223FXL,E&223EWL++HHeT<<LL% 	r%   c                    | j                  |       |j                  j                  t        j                  u rQ|j
                  sE|j                  s9|j                  r|j                  dk(  r| j                  |d|j                  g      S |S )zSimplify 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.
        rN  N)	r^   r   rE   r
   r   c_format_specformat_specconversion_charro  r_   s     r#   visit_FormattedValueNodez-OptimizeBuiltinCalls.visit_FormattedValueNode	  so    
 	4 ::??g2224;M;MVZVfVf''4+?+?3+F;;D$UUr%   r   c                     t        |      dk7  r|S |d   }|j                  t        j                  u rJ|j	                  d      }t        j                  |j                  d| j                  |g|j                        S |S )z;Replace dict(some_dict) by PyDict_Copy(some_dict).
        r   r   r  PyDict_CopyrT  )
rL   rE   r
   r   r  r   rY  r   PyDict_Copy_func_typer  r\   r*   r   r  r)   s        r#   r  z1OptimizeBuiltinCalls._handle_simple_function_dict	  sx     x=AKqk88w(((''(DEC//-)C)Cu,, 
 r%   r  c                 8   t        |      dk7  r|S |d   }t        j                  |j                  |j	                         r>|j	                         r.|j
                  t        j                  t        j                  fv rdnd| j                  ||j                        S )z0Turn list(ob) into PySequence_List(ob).
        r   r   r  r  rT  )rL   r   rY  r   r  rE   r	   r  r
   r  r  r  rx  s        r#   r  z1OptimizeBuiltinCalls._handle_simple_function_list	  s     x=AKqk++HH'')c.@.@.BHH!:!:G<M<M NN + '**LL	
 		
r%   r  c                    t        |      dk7  s|j                         s|S |d   }|j                  t        j                  u r|j                         s|S |j                  t        j                  u rB|j                  d      |d<   t        j                  |j                  d| j                  |d      S t        j                  |j                  |t        j                        S )zDReplace tuple([...]) by PyList_AsTuple or PySequence_Tuple.
        r   r   r  PyList_AsTupleTrT  )r)   rE   )rL   r  rE   r
   r  rm  r  r  r   rY  r   PyList_AsTuple_func_typer  rx  s        r#   _handle_simple_function_tuplez2OptimizeBuiltinCalls._handle_simple_function_tuple	  s     x=AT%8%8%:Kqk88w)))#//2CJ88w(((//35HQK //*D,I,It- - ((sASASTTr%   c                 B   t        |      dk7  r|S |d   j                  rg }g }|d   j                  D ]I  }|j                         s&t	        j
                  |      }|j                  |       |j                  |       K t        j                  |j                  d|      }| j                  ||       |d d d   D ]  }t	        j                  ||      } |S | j                  |t        j                  |j                  d| j                  ||j                  d            S )Nr   r   )r  r   rI   	PySet_NewrK   r   r  r5  )rL   r   r   	is_simpler   r+  rN   r   r]  r   r  r  rY  PySet_New_func_typer  )	r\   r*   r   r  r   r   r)   r  r  s	            r#   r  z0OptimizeBuiltinCalls._handle_simple_function_set
  s   x=AKA;.. DE{'' !}}#..s3CLL%C 	!
 &&txxFFLLv&dd F"77fEFM <<i&B&B+(('    r%   c                 r   |s!t        j                  |j                        g}nGt        |      dkD  r|S |d   j                  t
        j                  u r|d   j                         s|d   S t        j                  |j                  d| j                  ||j                  t        j                  dd      d      S )Nr   r   __Pyx_PyFrozenSet_Newpyfrozenset_newrO  	frozensetrl  )r   r  r   rL   rE   r
   r   rm  rY  PyFrozenSet_New_func_typer  r   r!   r\   r*   r   r  s       r#   r  z6OptimizeBuiltinCalls._handle_simple_function_frozenset&
  s    !**48845H]QKa[!7!77@W@W@YA;++HH-**LL$001BLQ! 	!r%   z((double)-1)T)rQ  exception_checkc           
         t        |      dk(  rDt        j                  |dd      j                  t        j
                  | j                               S t        |      dk7  r| j                  d||d       |S |d   }t        |t        j                        r|j                  }|j                  t        j                  u r|S |j                  t        j                  t        j                  fv r| j!                  ||j"                  |      S |j                  j%                  |j                        s|j                  j&                  r,t        j(                  |j*                  ||j                        S |d   j-                  d	      }|j                  t        j.                  u rd
}d}nl|j                  t        j0                  u rd}d}nK|j                  t        j2                  u rd}d}n*|j                  t        j4                  u rd}d}n	|d   }d}d}t        j6                  |j*                  || j8                  |g|j:                  |rt=        |      d      S dd      S )zYTransform float() into either a C type cast or a faster C
        function call.
        r   r  g        r  r   r  0 or 1rl  r1  __Pyx_PyBytes_AsDoublepybytes_as_double__Pyx_PyByteArray_AsDouble__Pyx_PyUnicode_AsDoublepyunicode_as_doublePyLong_AsDoubleNr2  pyobject_as_doublerl  )rL   r   r  r   r
   r  r   r  r(   r   r)   rE   r	   r  r   rD  rE  r"   r  rF  r  r   r  r   r   r   int_typerY  PyObject_AsDouble_func_typer  r$   )r\   r*   r   r  r8  r)   
cfunc_nameutility_code_names           r#   r  z2OptimizeBuiltinCalls._handle_simple_function_float=
  s    x=A&&E3)G..0@0@0BCD ]a''xJKA;h	 < <=||H==J444O]]z88*:V:VWW))$xHHYY&&x}}59Q9Q))(< < qk++KM ==G...1J 3]]g4445J 3]]g2223J 5]]g...*J $1+C2J 4++HHj,,5ll@Q>*;< 	
 X\ 	r%   r   c                 b   t        |      dk(  r:t        j                  j                  |j                  dt
        j                        S t        |      dk7  r|S |d   }t        |t        j                        r\|j                  j                  j                  r:t        j                  |j                  d| j                  |j                  gdd      S |S |j                  j                  rE|j                  j                  r/t        j                  |j                  d| j                  |dd      S |S )	z7Transform int() into a faster C function call.
        r   r   r   PyLong_FromDoubleTr  r  __Pyx_PyNumber_Int)rL   r   r   r   r   r
   r  r(   r   r)   rE   r;  rY  PyLong_FromDouble_func_typer   PyNumber_Int_func_type)r\   r*   r   r  r8  s        r#   _handle_simple_function_intz0OptimizeBuiltinCalls._handle_simple_function_int}
  s     x=A$$,,TXXqw?O?O,PP]aKA;h	 < <=||  )) 33HH143S3S",,u 
 ==$$)>)>//.0K0KtU< < r%   c                    t        |      dk(  r0t        j                  |j                  dt        j
                        S t        |      dk7  r| j                  d||d       |S |d   j                  | j                               }t        j                  |j                  |      }t        j                  |j                  |      }|j                  | j                               S )z=Transform bool(x) into a type coercion to a boolean.
        r   Fr   rE   r   boolr  r   )rL   r   r   r   r
   r+  r  r,  r   r   coerce_to_pyobject)r\   r*   r   r  r   s        r#   _handle_simple_function_boolz1OptimizeBuiltinCalls._handle_simple_function_bool
  s     x=A%%dhhe'BSBSTT]a''hIK qk33D4D4D4FGG''GDG''GDG--d.>.>.@AAr%   c                    t        |      dk7  r| j                  d||d       |S |d   j                  j                  r=t	        j
                  |j                  d| j                  |d   g|j                  d      S |d   j                  j                  r\|d   j                  t        j                  u r=t	        j
                  |j                  d| j                  |d   g|j                  d      S |S )Nr   
memoryview1r   PyMemoryView_FromObjectr  PyMemoryView_FromBuffer)rL   r  rE   r   r   rY  r   !PyMemoryView_FromObject_func_typer  r   r   r
   py_buffer_type!PyMemoryView_FromBuffer_func_typer  s       r#   "_handle_simple_function_memoryviewz7OptimizeBuiltinCalls._handle_simple_function_memoryview
  s    x=A''dHcJK{++ 33HH7::$QK="ll*, , !!!((Xa[-B-BgF\F\-\ !33HH7::$QK="ll*, , r%   bytesrk  __Pyx_PyUnicode_GET_LENGTHrU  __Pyx_PyByteArray_GET_SIZE__Pyx_PyList_GET_SIZE__Pyx_PyTuple_GET_SIZE__Pyx_PySet_GET_SIZEPyDict_Sizezcpython.array.arrayc                    t        |      dk7  r| j                  d||d       |S |d   }t        |t        j                        r|j
                  }|j                  j                  r;t        j                  |j                  d| j                  |g|j                        }n
|j                  j                  rPt        j                  |j                  d| j                  |g|j                  t        j                  dd      	      }n|j                  j                   rwt#        j$                  t"        j&                  t#        j(                  d
|j                  d      gd      }t        j                  |j                  d||g|j                        }n|j                  j*                  r| j-                  |j                        }|K|j                  }|j.                  s|j0                  r%|j2                  j4                  | j6                  v rd}n|S |j9                  d      }t        j                  |j                  || j:                  |g|j                        }nN|j                  j<                  r6t        j>                  jA                  |j                  d|j                        S |S |j                  t"        jB                  t"        j&                  fvr*|jE                  |j                  | jG                               }|S )zReplace 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.
        r   rL   r   __Pyx_ssize_strlenrT  __Pyx_Py_UNICODE_ssize_strlenssize_pyunicode_strlenrh  r   r  ro  memoryviewsliceNT)nogil__Pyx_MemoryView_LenPy_SIZEz&object of type 'NoneType' has no len()r   )$rL   r  r(   r   r   r)   rE   r  rY  r   Pyx_ssize_strlen_func_typer  is_pyunicode_ptrPyx_Py_UNICODE_strlen_func_typer   r!   r   r	   r  r.  r  r   _map_to_capi_len_functionis_extension_typerC  r   qualified_name_ext_types_with_pysizer  PyObject_Size_func_typer<  r   r   c_size_t_typer   r   )	r\   r*   r   r  r)   r   r  r  r  s	            r#   _handle_simple_function_lenz0OptimizeBuiltinCalls._handle_simple_function_len
  se   
 x=A''tXqAKqkc9778''C88 33.0O0Ou,,(H XX&& 3394;_;_u,,*667OQ`a	cH
 XX((",,,,++,=sxxN/I !330)UDLL2H XX!!77AJ!88//83K3K$NN99T=X=XX!*JK''8:C 33*d&B&BUDLL2H XX%%$$,,TXXqtyy,IIK99Z55z7S7STT))$))T5E5E5GHHr%   objectc                     t        |      dk7  r|S t        j                  |j                  d| j                  |d      }t        j
                  |t        j                        S )z7Replace type(o) by a macro call to Py_TYPE(o).
        r   Py_TYPEFrT  )rL   r   rY  r   Pyx_Type_func_typer  r	   r  r  s       r#   _handle_simple_function_typez1OptimizeBuiltinCalls._handle_simple_function_type  sW     x=AK++HHi!8!8 !!$
(A(ABBr%   c                    t        |      dk7  rS |\  }}g }t        |t        j                        r|j                  }n<|j
                  t        j                  u st        |t        j                        r|g}nS t        |      \  }}|rZ|st        |      dkD  rJ|j                  s>|j                  r|j                  r&t        j                  |      }|j                  |       g }	| j!                         |_|	j                  t        j"                  |j$                  |d|      j'                        j)                  t*        j,                               t/               }
|D ]  }dx}}|j                  ra|j0                  rUj3                  |j0                  j4                        }|r.|j
                  r"|j
                  j6                  r|j
                  }|t        j                  u r3|j4                  dk7  s"|j8                  r|j8                  j:                  sd}|,|j=                  d      }||
v r|
j?                  |       |g}n[|j
                  t        j                  u rd	}||g}n8|j                  s&t        j                  |      }|j                  |       d
}||g}|	j                  t        j@                  |j$                  || jB                  |||jD                  ndd              t        jF                  ffd	}tI        ||	      j)                  j
                        }|ddd   D ]  }t        jJ                  ||      } |S )zcReplace isinstance() checks against builtin types by the
        corresponding C-API call.
        r   r   Nisr  rE   F)exact__Pyx_TypeCheckPyObject_IsInstanceTr   ro  r  c                 ~     |j                   d| |      }t        j                  |_        |j	                         |S )Nr  )r   r	   r_  rE   rB  )r:   r;   make_binop_nodeor_noder  r*   s       r#   join_with_orzMOptimizeBuiltinCalls._handle_simple_function_isinstance.<locals>.join_with_or|  s7    %dhha;G%11GL!!#&Nr%   rI   )&rL   r(   r   r\  r   rE   r
   rM   rG   rT   rp  r   r  r   r.   rN   r   r   r   r   r   r	   r_  rK   r   r-  r"   rC  scopeis_builtin_scopetype_check_functionr!  rY  Py_type_check_func_typero  r7  r   r  )r\   r*   r   r  r)   
type_nodesr   rO   rP   
test_nodesbuiltin_teststest_type_nodebuiltin_typer   r  type_check_argsr  rE  r  r  s    `                 @r#   "_handle_simple_function_isinstancez7OptimizeBuiltinCalls._handle_simple_function_isinstance/  s    x=AK"Zj)"5"56#J__ 1 11Z
ILcLc5d$JK $<J#G   '3u:>
 NNs{{3;;--c2S!
 (((%)) !.	
 mC :+A+A3!GI #  	N#''L5%%.*>*>

>#7#7#<#<=UZZEJJ,F,F#(::Lw000::'(D(D#'L'&2&F&FU&F&S#&-7!!"56#&%$$(9(99&7##&"7%00%.%<%<^%LNLL0&;##&"7,,"&&(;T=Y=Y(7<7H!3!3d 	5 	D 09/C/C 	 <4>>tyy#N	$B$K 	HD!66tYGI	Hr%   c                    t        |      dk7  r|S |d   }t        |t        j                        r|j                  j
                  j                  rbt        j                  |j                  |j                  t        j                        j                  |j
                  | j                               S |S t        |t        j                  t        j                  f      r}t        |j                        dk(  ret        j                   j#                  |j                  t%        |j                              j                  |j
                  | j                               S |S )z-Unpack ord(Py_UNICODE) and ord('X').
        r   r   rl  )rL   r(   r   r   r)   rE   r<  r  r   r	   r  r   r   r   rr  r   r   r   r   rx  s        r#   r  z0OptimizeBuiltinCalls._handle_simple_function_ord  s     x=AKqkc9778ww||++ --GGSWW:3I3Ii		4+;+;+=>?  i33Y5H5HIJ399~" ((00#cii.ISSTXT]T]_c_o_o_qrrr%   rE   r   r  c           
         |j                   }|rt        |      dk  r|S |d   }|j                  r|j                  s|S |j                  t        j
                  k7  s|j                  t        j
                  k7  r|S |j                  r|j                  s|j                  |j                  k7  r|S |j                  |j                  k7  r|S t        j                  |j                  |dd       }|j                  | j                         d      }|j                  r|j                  j                  }	|	j                  r|	j                  r|	j                  j!                         | j                         j!                         k(  rqt#        j$                  dd      }
t#        j&                  |	j                  |
      }|r8| j(                  j*                  }t-        j.                  |j1                  d	      j                        }t-        j2                  |	t-        j4                  d
|d      t-        j4                  dt,        j6                  d      t-        j4                  dt,        j6                  d      g      }t        j8                  ||      }|s/t        j:                  |j                  t,        j6                        }t        j<                  |j                  |||||gdd      S |j?                  d      }tA        jB                  dd      }|r<t        j<                  |j                  d| jD                  |||g||jF                        S t        j<                  |j                  d| jH                  ||g||jF                        S )zOReplace 'exttype.__new__(exttype, ...)' by a call to exttype->tp_new()
        r   r   Nr   T)skip_childrentp_new__new__PyTypeObjectrE   r   r  r   F)r   may_return_noner  z4object.__new__(X): X is not a type object (NoneType)zObjectHandling.c__Pyx_tp_new_kwargsr  __Pyx_tp_new)%r8   rL   r   rE   r
   rM   r`  r"   r   r\  r   r   r   r  typeobj_cnamer  r   r   ConstructorSlotget_slot_functionr   cython_scoper	   CPtrTyper-  r  r  r  r  r  rY  r  r   r!   Pyx_tp_new_kwargs_func_typer  Pyx_tp_new_func_type)r\   r*   r   r   r_  r  r8   type_arg
args_tupleext_typetp_slotslot_func_cnamer  PyTypeObjectPtrpyx_tp_new_kwargs_func_typero  s                   r#   _handle_any_slot__new__z,OptimizeBuiltinCalls._handle_any_slot__new__  s    ll CIMK7{{("2"2K88w(((HMMW=N=N,NK""#..xx8==(   CNN2K((QRA
--d . 4
 **//H**x/E/ENN//1T5E5E5G5T5T5VV#33HiH"+"="=hnng"V"#'<<#<#<L&0&9&9$++N;@@'BO2<2F2F &33FotT&33Fj>W>WY]^&33Hj>W>WY]^#3/  )11(OLH!!*!3!3DHH:C\C\!]$77/3&
F;(- $& &  11FHH #..x9KL///1Q1Q
F3)	  //.$*C*C
+)	 r%   c                     |S r'   re   )r\   r*   r   r   r_  r  s         r#   _handle_any_slot__class__z.OptimizeBuiltinCalls._handle_any_slot__class__  s	    
 r%   r   c                     t        |      dk7  s"|j                  s|j                  j                  r|S t	        j
                  |j                  d| j                  |d|j                  dt        d            S )z\Optimistic optimisation as X.append() is almost always
        referring to a list.
        r   __Pyx_PyObject_AppendFrN   )r   r  r  rn  ro  )
rL   rn  r   r   r   rY  r   PyObject_Append_func_typer  r$   r\   r*   r   r   r_  s        r#   #_handle_simple_method_object_appendz8OptimizeBuiltinCalls._handle_simple_method_object_append  se     t9>T00DMM4G4GK++HH-t/M/M!LL '1
 	
r%   c                 b   t        |      dk7  r|S |\  }}|j                  s|S t        |j                        }|j                  t        |      dkD  r	 |S | j                  |||d      }	|s|j                  |	_        |	S |	x}
}t        |      dkD  r%|j                         st!        j"                  |      }
g }|d   }|j                         s&t!        j"                  |      }|j%                  |       t        j&                  |j(                  d| j*                  |
|gdt-        d	      
      }|ddd   D ]  }|j                         s&t!        j"                  |      }|j%                  |       t        j.                  |j(                  dt        j&                  |j(                  d| j*                  |
|gddt-        d            |t0        j2                        } |j                  |_        |
|ur|j%                  |
       |D ])  }t!        j4                  ||      }|j                  |_        + |S )zReplace list.extend([...]) for short sequence literals values by sequential appends
        to avoid creating an intermediate sequence argument.
        r   N   r   TextendrI   __Pyx_PyList_Append
ListAppendr  |__Pyx_ListComp_AppendListCompAppend)r   r5  r  ro  r   )rL   r   r  r   mult_factorr(   r   r   r  r   r   r   r  _wrap_self_argrn  r  r   r+  rN   rY  r   r  r$   r7  r	   c_returncode_typer  )r\   r*   r   r   r_  r8   r   r   
tuple_nodewrapped_obj
cloned_objr   r)   r   r  s                  r#   !_handle_simple_method_list_extendz6OptimizeBuiltinCalls._handle_simple_method_list_extend  s    t9>K
U,,KUZZ (CJN  K))#x9JHU)-)<)<K&&&
Su:>#--/"--c2J Bi}}&&s+CLL//HH+T-K-Kc"'5	7
 R= 	C==?**3/S! ++#,,HH5t7U7U$c*H !/0@!A	C
 11	H		 #'"5"5S LL$ 	:D 55dHEH&*&9&9H#	: r%   	bytearrayc           	      ^   t        |      dk7  r|S d}| j                  }t        |d         }|j                  j                  st        |t        j                        rE|j                  t        j                  | j                               }t        j                  dd      }n|j                  rW|j                         s|S |j                  t        j                   | j                               }t        j                  dd      }n=|j                  j"                  r%d}| j$                  }t        j                  dd      }n|S t        j&                  |j(                  |||d   |gd	|j*                  |
      }	|j,                  r*|	j                  |j                  | j                               }	|	S )Nr   __Pyx_PyByteArray_Appendr   ByteArrayAppendrh  __Pyx_PyByteArray_AppendObjectByteArrayAppendObjectr   Fr   r  r  ro  )rL   PyByteArray_Append_func_typer,   rE   r  r(   r   r   r   r	   rv  r   r   r!   r   can_coerce_to_char_literalc_char_typer   "PyByteArray_AppendObject_func_typerY  r   r  rn  )
r\   r*   r   r   r_  	func_namer  r   ro  r   s
             r#   &_handle_simple_method_bytearray_appendz;OptimizeBuiltinCalls._handle_simple_method_bytearray_append\  sb   t9>K.	55	#DG,::
5)2C2C DOOJ$9$94;K;K;MNE&223DoVL$$335OOJ$:$:D<L<L<NOE&223DoVLZZ##8I??I&223JO\LK//HHiq'5!!LL%
 ))$))T5E5E5GHHr%   py_indexc_index	is_signed)has_varargsc                 .    | j                  ||||d      S )NT)is_list) _handle_simple_method_object_popr  s        r#   _handle_simple_method_list_popz3OptimizeBuiltinCalls._handle_simple_method_list_pop  s(    44(D"3T 5 C 	Cr%   c                    |s|S |d   }|rd}|j                  dddg      }nd}t        |      dk(  rGt        j                  |j                  d	|z  | j
                  |gd
|j                  t        d            S t        |      dk(  rt        |d         }t        j                  |j                        }	|j                  }
|j                  j                  st        |t        j                        rN|j                  | j                               }	|j!                  t"        j$                  | j                               }n|ry|j                  j&                  r4|j)                  | j                               }	t        j*                  |	      }|j!                  t"        j$                  | j                               }nk|S t#        j,                  |j                  t"        j$                        s|S t        |t        j                        r|j                  | j                               }	|
j                  s|j                  }
|
j/                  | j                               s|S |
j0                  }t#        j2                  t"        j4                  t#        j6                  d|
d      g      }t        j                  |j                  d|z  | j8                  ||	|t        j                  j;                  |j                  |
j<                  rdnd      t        j>                  |j                  t"        j@                  |
jC                               t        j>                  |j                  ||      gd
|j                  t        d            S |S )z\Optimistic optimisation as X.pop([n]) is almost always
        referring to a list.
        r   List*'NoneType' object has no attribute '%.30s'r  rJ   r  Objectr   z__Pyx_Py%s_PopTr  r   intvalNz__Pyx_Py%s_PopIndex	pop_index)"r  rL   r   rY  r   PyObject_Pop_func_typer  r$   r,   r  rE   r  r(   r   r  r   r   r	   r.  r   r  r  numeric_type_fitscreate_to_py_utility_codeto_py_functionr  r  r  PyObject_PopIndex_func_typer   signedRawCNameExprNodec_void_typeempty_declaration_code)r\   r*   r   r   r_  r   r8   r]  r"  r  orig_index_typeconvert_funcconversion_types                r#   r!  z5OptimizeBuiltinCalls._handle_simple_method_object_pop  s    K1gI''<,"G ( %C
 !It9>//*Y6++U $+E2  Y!^'Q0E ))%))4H#jjO::$$eY%6%67$778H8H8JKH!OOJ,H,H$JZJZJ\]Ezz--#(#9#9$:J:J:L#M ) 3 3H =!OOJ,H,H$JZJZJ\]EK11%**j>Z>Z[E9#4#45 33D4D4D4FG"))"'**"<<T=M=M=OP*99L(22))J,C,CHo_c,d+egO///);008U''//		@V@V1\]^00J<R<R1@1W1W1Y[00O\Z	\
 !%+K8  r%   c           	          t        |      dk7  r|S | j                  ||d| j                  d||      j                  |j                  | j
                        S )z?Call PyList_Sort() instead of the 0-argument l.sort().
        r   PyList_Sortsort)rL   _substitute_method_callsingle_param_func_typer   rE   r   r  s        r#   _handle_simple_method_list_sortz4OptimizeBuiltinCalls._handle_simple_method_list_sort  sU     t9>K++(M4+F+F%t--6Ytyy$BRBR-S	Tr%   keydefaultc                    t        |      dk(  r/|j                  t        j                  |j                               n$t        |      dk7  r| j                  d||d       |S | j                  ||d| j                  d||dt        d      		      S )
z:Replace dict.get() by a call to PyDict_GetItem().
        r   r   zdict.get2 or 3__Pyx_PyDict_GetItemDefaultr2  Tdict_getitem_defaultr  ro  )	rL   rN   r   r  r   r  r8  Pyx_PyDict_GetItem_func_typer$   r  s        r#   _handle_simple_method_dict_getz3OptimizeBuiltinCalls._handle_simple_method_dict_get  s     t9>KK	**48845Y!^''
D$IK++()4+L+L$d")*@A , C 	Cr%   is_safe_typec                 4   t        |      dk(  r/|j                  t        j                  |j                               n$t        |      dk7  r| j                  d||d       |S | j                  ||d| j                  d||dt        j                  dd	      
	      S )zUReplace dict.setdefault() by calls to PyDict_GetItem() and PyDict_SetItem().
        r   r   zdict.setdefaultr>  __Pyx_PyDict_SetDefault
setdefaultTdict_setdefaultrO  rA  )
rL   rN   r   r  r   r  r8  Pyx_PyDict_SetDefault_func_typer   r!   r  s        r#   %_handle_simple_method_dict_setdefaultz:OptimizeBuiltinCalls._handle_simple_method_dict_setdefault  s     t9>KK	**48845Y!^''(94xPK++(%t'K'K+T $001BLQ , S 	Sr%   c                 d   d}d}| j                   }t        |      dk(  r/|j                  t        j                  |j
                               nAt        |      dk(  r|j                  s'd}d}| j                  }n| j                  d||d       |S | j                  ||||d	||d
t        |      	      S )z7Replace dict.pop() by a call to _PyDict_Pop().
        __Pyx_PyDict_Poppy_dict_popr   r   __Pyx_PyDict_Pop_ignorepy_dict_pop_ignorezdict.popr>  rJ   TrA  )PyDict_Pop_func_typerL   rN   r   r  r   rn  PyDict_Pop_ignore_func_typer  r8  r$   )r\   r*   r   r   r_  	capi_funcr  r  s           r#   _handle_simple_method_dict_popz3OptimizeBuiltinCalls._handle_simple_method_dict_pop  s     '	)--	t9>KK	**48845Y!^&&5	$8! <<	''
D$IK++(y$d '(9: , < 	<r%   op1op2cvalr)  zerodiv_checkc                 ,    | j                  d||||      S NAdd_optimise_num_binopr  s        r#   $_handle_simple_method_object___add__z9OptimizeBuiltinCalls._handle_simple_method_object___add__F      ''tXtEVWWr%   c                 ,    | j                  d||||      S NSubtractr[  r  s        r#   $_handle_simple_method_object___sub__z9OptimizeBuiltinCalls._handle_simple_method_object___sub__I      ''
D(DJ[\\r%   c                 ,    | j                  d||||      S )NMultiplyr[  r  s        r#   $_handle_simple_method_object___mul__z9OptimizeBuiltinCalls._handle_simple_method_object___mul__L  rc  r%   c                 ,    | j                  d||||      S NEqr[  r  s        r#   #_handle_simple_method_object___eq__z8OptimizeBuiltinCalls._handle_simple_method_object___eq__O      ''dHdDUVVr%   c                 ,    | j                  d||||      S NNer[  r  s        r#   #_handle_simple_method_object___ne__z8OptimizeBuiltinCalls._handle_simple_method_object___ne__R  rk  r%   c                 ,    | j                  d||||      S )NAndr[  r  s        r#   $_handle_simple_method_object___and__z9OptimizeBuiltinCalls._handle_simple_method_object___and__U  r^  r%   c                 ,    | j                  d||||      S )NOrr[  r  s        r#   #_handle_simple_method_object___or__z8OptimizeBuiltinCalls._handle_simple_method_object___or__X  rk  r%   c                 ,    | j                  d||||      S )NXorr[  r  s        r#   $_handle_simple_method_object___xor__z9OptimizeBuiltinCalls._handle_simple_method_object___xor__[  r^  r%   c                     t        |      dk7  st        |d   t        j                        s|S |d   j	                         rd|d   j
                  cxk  rdk  s|S  |S | j                  d||||      S )Nr   r   ?   RshiftrL   r(   r   r   r  r=   r\  r  s        r#   '_handle_simple_method_object___rshift__z<OptimizeBuiltinCalls._handle_simple_method_object___rshift__^  v    t9>DGY5F5F!GKAw**,Q$q':Q:Q5WUW5WK 6XK''$$HYZZr%   c                     t        |      dk7  st        |d   t        j                        s|S |d   j	                         rd|d   j
                  cxk  rdk  s|S  |S | j                  d||||      S )Nr   r   rz  Lshiftr|  r  s        r#   '_handle_simple_method_object___lshift__z<OptimizeBuiltinCalls._handle_simple_method_object___lshift__e  r~  r%   c                 ,    | j                  d||||      S N	Remainder_optimise_num_divr  s        r#   $_handle_simple_method_object___mod__z9OptimizeBuiltinCalls._handle_simple_method_object___mod__l  s    %%k44IZ[[r%   c                 ,    | j                  d||||      S )NFloorDivider  r  s        r#   )_handle_simple_method_object___floordiv__z>OptimizeBuiltinCalls._handle_simple_method_object___floordiv__o  s    %%mT8TK\]]r%   c                 ,    | j                  d||||      S N
TrueDivider  r  s        r#   (_handle_simple_method_object___truediv__z=OptimizeBuiltinCalls._handle_simple_method_object___truediv__r  s    %%lD(DJ[\\r%   c                 ,    | j                  d||||      S NDivider  r  s        r#   $_handle_simple_method_object___div__z9OptimizeBuiltinCalls._handle_simple_method_object___div__u  s    %%hhFWXXr%   c                    t        |      dk7  s%|d   j                         r|d   j                  dk(  r|S t        |d   t        j
                        rd|d   j                  cxk  rdk  sA|S  |S t        |d   t        j                        rd|d   j                  cxk  rdk  s|S  |S |S | j                  |||||      S )Nr   r   r   r   r   l       l          )rL   r  r=   r(   r   r   r  r\  )r\   r~   r*   r   r   r_  s         r#   r  z&OptimizeBuiltinCalls._optimise_num_div  s    t9>a!<!<!>$q'BYBY]^B^Kd1gy001d1g55>> ?Q!4!45d1g55>> ?K''$$HYZZr%   c                 ,    | j                  d||||      S rY  r[  r  s        r#   #_handle_simple_method_float___add__z8OptimizeBuiltinCalls._handle_simple_method_float___add__  r^  r%   c                 ,    | j                  d||||      S r`  r[  r  s        r#   #_handle_simple_method_float___sub__z8OptimizeBuiltinCalls._handle_simple_method_float___sub__  rc  r%   c                 ,    | j                  d||||      S r  r[  r  s        r#   '_handle_simple_method_float___truediv__z<OptimizeBuiltinCalls._handle_simple_method_float___truediv__  s    ''dHdL]^^r%   c                 ,    | j                  d||||      S r  r[  r  s        r#   #_handle_simple_method_float___div__z8OptimizeBuiltinCalls._handle_simple_method_float___div__  s    ''$$HYZZr%   c                 ,    | j                  d||||      S r  r[  r  s        r#   #_handle_simple_method_float___mod__z8OptimizeBuiltinCalls._handle_simple_method_float___mod__  s    ''T8TK\]]r%   c                 ,    | j                  d||||      S rh  r[  r  s        r#   "_handle_simple_method_float___eq__z7OptimizeBuiltinCalls._handle_simple_method_float___eq__  rk  r%   c                 ,    | j                  d||||      S rm  r[  r  s        r#   "_handle_simple_method_float___ne__z7OptimizeBuiltinCalls._handle_simple_method_float___ne__  rk  r%   c                    t        |dd      r|S t        |      dk7  r|S |j                  j                  rt        j
                  }n3|j                  t        j                  u r|dv rt        j                  }n|S t        ||||d   |d         }|s|S |\  }}	}
}t        |D cg c]  }|j                  j                   c}      sJ t        |      |
z   }| j                  |||| j                  ||f   d|dd j                         z  ||d	d
|	
      }|j                  j                  r;|j                  s/t        j                  || j                         |j                        }|S c c}w )zY
        Optimise math operators for (likely) float or small integer operations.
        special_bool_cmp_functionNr   ri  rn  r   r   z__%s__r   TF)r  with_none_checkro  )r  rL   rE   r   r	   r  r_  optimise_numeric_binopr  r  r8  Pyx_BinopInt_func_typeslowerr   r   r   )r\   r~   r*   r   r   r_  ret_typer  
func_cnamero  
extra_argsnum_typer)   ra  s                 r#   r\  z(OptimizeBuiltinCalls._optimise_num_binop  sa    44d;Kt9>K99  !00HYY*000X5M!--HK'$$q'4PQ7SK9?6
L*hD9SCHH((9::DzJ&00((((H)=>x|))++-> !% 1 '	 99  )=)=!44Y@P@P@RTXT]T]^I :s   #E(ucharc           
         |st        |      dk7  r|S |d   }t        |t        j                        r |j                  j
                  j                  s|S |j                  }|j                  }t        j                  ddt        |            }d|j                         z  }	| j                  |||	| j                  |||g|      }
|j
                  j                  r|
j                  | j                         }
|
S )	Nr   r   py_unicode_predicaterh  )r  r   z__Pyx_Py_UNICODE_%sr  )rL   r(   r   r   r)   rE   r<  r9   r   r!   r   upperr8  #PyUnicode_uchar_predicate_func_typer   r  r   )r\   r*   r   r   r_  ustringr  r  ro  r  	func_calls              r#   _inject_unicode_predicatez.OptimizeBuiltinCalls._inject_unicode_predicate  s    D	QKq''9#?#?@;;##33K(()55"O[1
 .0A0A0CC00(4CC*UG'	 1 )	
 99  !44T5E5EFIr%   r  keependsc           	          t        |      dvr| j                  d||d       |S | j                  ||dd       | j                  ||d| j                  d||      S )zfReplace unicode.splitlines(...) by a direct call to the
        corresponding C-API function.
        r  zunicode.splitlinesz1 or 2r   FPyUnicode_Splitlines
splitlines)rL   r  _inject_bint_default_argumentr8  PyUnicode_Splitlines_func_typer  s        r#   (_handle_simple_method_unicode_splitlinesz=OptimizeBuiltinCalls._handle_simple_method_unicode_splitlines  si     t9E!''(<dD(SK**4q%@++("D$G$G+T3 	3r%   sepmaxsplitc           	      n   t        |      dvr| j                  d||d       |S t        |      dk  r/|j                  t        j                  |j
                               n| j                  |d       | j                  ||dt        j                  d       | j                  ||d| j                  d||      S )	zaReplace unicode.split(...) by a direct call to the
        corresponding C-API function.
        )r   r   r   zunicode.split1-3r   r   -1PyUnicode_Splitsplit)rL   r  rN   r   r  r   _inject_null_for_none_inject_int_default_argumentr	   r.  r8  PyUnicode_Split_func_typer  s        r#   #_handle_simple_method_unicode_splitz8OptimizeBuiltinCalls._handle_simple_method_unicode_split2  s     t9G#''tUKKt9q=KK	**48845&&tQ/))$:77	? ++(t==&. 	.r%   seqc           	         t        |      dk7  r| j                  d||d       |S t        |d   t        j                        r|d   }|j
                  }t        |      }|rt        j                  |j                  |dt        j                        }|D ]H  \  }	}
t        j                  |	j                  |	|j                        }t        j                  ||
|       J ||d<   | j                  ||d| j                   d	||      S )
z^
        unicode.join() builds a list first => see if we can do this more efficiently
        r   zunicode.join2r   r  r  r  PyUnicode_Joinr  )rL   r  r(   r   r  r  rr   r  r   r
   r  r  r   r   r  r8  PyUnicode_Join_func_type)r\   r*   r   r   r_  r  rK  rs   inlined_genexprr  r  r  s               r#   "_handle_simple_method_unicode_joinz7OptimizeBuiltinCalls._handle_simple_method_unicode_joinK  s    t9>''dCHKd1gy@@A GM%**I5i@"+"J"JHHmv'.'8'8#: :J b5$o"+"C"C(,,-.55#7K
 44]OU`ab *Q++(d;;%t- 	-r%   	substringrV  end	directionc           
      :    | j                  ||||ddt        d      S )Nr  endswithr   _inject_tailmatchunicode_tailmatch_utility_coder  s        r#   &_handle_simple_method_unicode_endswithz;OptimizeBuiltinCalls._handle_simple_method_unicode_endswithu  s(    %%(D"3UJ*B0 	0r%   c           
      :    | j                  ||||ddt        d      S )Nr  
startswithrI   r  r  s        r#   (_handle_simple_method_unicode_startswithz=OptimizeBuiltinCalls._handle_simple_method_unicode_startswithz  s(    %%(D"3UL*B0 	0r%   c	           
      *   t        |      dvr| j                  | d| ||d       |S | j                  ||dt        j                  d       | j                  ||dt        j                  d       |j                  t        j                  j                  |j                  |             |dk(  rd	}	nd
|j                          d}	| j                  |||	| j                  ||||      }
|
j                  t        j                  | j!                               S )zReplace unicode.startswith(...) and unicode.endswith(...)
        by a direct call to the corresponding C-API function.
        r   r      r}  2-4r   0r   PY_SSIZE_T_MAXr  __Pyx_PyUnicode_Tailmatch__Pyx_Py
_Tailmatchr  )rL   r  r  r	   r.  rN   r   r   r   r   
capitalizer8  PyString_Tailmatch_func_typer   r
   r+  r   )r\   r*   r   r   r_  r]  r  ro  r  r  method_calls              r#   r  z&OptimizeBuiltinCalls._inject_tailmatch  s   
 t9G#''9+Q{m(DdDRWXK))$:77	>))$:779I	KI%%--dhh	BC3I"9#7#7#9":*EI22(t88*D'	 3 )
 $$W%6%68H8H8JKKr%   r  c                 .    | j                  ||||dd      S )Nfindr   _inject_unicode_findr  s        r#   "_handle_simple_method_unicode_findz7OptimizeBuiltinCalls._handle_simple_method_unicode_find  s%    (((D"3VRA 	Ar%   c                 .    | j                  ||||dd      S )NrfindrI   r  r  s        r#   #_handle_simple_method_unicode_rfindz8OptimizeBuiltinCalls._handle_simple_method_unicode_rfind  s%    (((D"3WbB 	Br%   c           	         t        |      dvr| j                  d|z  ||d       |S | j                  ||dt        j                  d       | j                  ||dt        j                  d       |j                  t        j                  j                  |j                  |             | j                  ||d| j                  |||      }|j                  | j                               S )	zwReplace unicode.find(...) and unicode.rfind(...) by a
        direct call to the corresponding C-API function.
        r  z
unicode.%sr  r   r  r   r  PyUnicode_Find)rL   r  r  r	   r.  rN   r   r   r   r   r8  PyUnicode_Find_func_typer  r   )r\   r*   r   r   r_  r  r  r  s           r#   r  z)OptimizeBuiltinCalls._inject_unicode_find  s    
 t9G#''{(BD$PUVK))$:77	>))$:779I	KI%%--dhh	BC22(,d.K.K*D2 --d.>.>.@AAr%   c           	      T   t        |      dvr| j                  d||d       |S | j                  ||dt        j                  d       | j                  ||dt        j                  d       | j                  ||d| j                  d	||      }|j                  | j                               S )
zaReplace unicode.count(...) by a direct call to the
        corresponding C-API function.
        r  zunicode.countr  r   r  r   r  PyUnicode_Countcount)	rL   r  r  r	   r.  r8  PyUnicode_Count_func_typer  r   )r\   r*   r   r   r_  r  s         r#   #_handle_simple_method_unicode_countz8OptimizeBuiltinCalls._handle_simple_method_unicode_count  s     t9G#''tUKK))$:77	>))$:779I	K 22(-t/M/M&. --d.>.>.@AAr%   replstrmaxcountc           	          t        |      dvr| j                  d||d       |S | j                  ||dt        j                  d       | j                  ||d| j                  d||      S )zcReplace unicode.replace(...) by a direct call to the
        corresponding C-API function.
        )r   r  zunicode.replacez3-4r   r  PyUnicode_Replacer  )rL   r  r  r	   r.  r8  PyUnicode_Replace_func_typer  s        r#   %_handle_simple_method_unicode_replacez:OptimizeBuiltinCalls._handle_simple_method_unicode_replace  sv     t9E!''(94uMK))$:77	? ++(/1Q1Q($0 	0r%   r  errors)UTF8UTF16UTF-16LEUTF-16BELatin1ASCIIunicode_escaperaw_unicode_escapec                    t        |      dk  st        |      dkD  r| j                  d||d       |S |d   }| j                  |j                  |      }||S |\  }}}	}
|j	                         r]	 |j
                  j                  ||	      }t        ||xs d      }t        j                  |j                  |t        j                        S t        |      dk(  rCt        j                  |j                        }| j                  ||d| j                  d	||||g      S |rC|	d
k(  r>| j                  |      }|+d|vr'd|z  }| j                  |||| j                   d	||g      S | j                  ||d| j                  d	||||
g      S #  Y xY w)z_Replace unicode.encode(...) by a direct C-API call to the
        corresponding codec.
        r   r   zunicode.encoder  r   zUTF-8r  PyUnicode_AsEncodedStringrq  strictr'  zPyUnicode_As%sString)rL   r  _unpack_encoding_and_error_moder   r  r=   rq  r   r   rr  r
   r   r  r8  #PyUnicode_AsEncodedString_func_type_find_special_codec_namePyUnicode_AsXyzString_func_type)r\   r*   r   r   r_  string_node
parametersr  encoding_nodeerror_handlingerror_handling_noder   	null_node
codec_nameencode_functions                  r#   $_handle_simple_method_unicode_encodez9OptimizeBuiltinCalls._handle_simple_method_unicode_encode   s    t9q=CIM''(8$eLK1g99$((DI
KGQD-1D**,b#33::8^T
 &eX-@A **;??%gN`N`aat9>!**4884I//h ;88+k9i-PR R
 (266x@J%#Z*?"8:"E33(O88/+@ @
 ++(744'-)<=	? 	?1s   0F F
stringr  rX  decode_funcc                 |   dt        |      cxk  rdk  sn | j                  d||d       |S |d   }| j                  |j                  |      }||S |\  }}}	}
|j	                         rH	 |j
                  j                  ||	      }t        |j                  t        |      |j
                        S dx}}t        |t        j                        r9|}|j                  }|j                   |j"                  }}|r|j
                  dk(  rd}t        |t        j$                        r|j&                  }|j(                  }|t*        j,                  t*        j.                  fv r8|r |j1                  dd	|j2                  g
      }n0|j1                  ddd	g      }n|j4                  s|j6                  s|S |s+t        j8                  j;                  |j                  d      }nD|j(                  j<                  s.|j?                  t@        jB                  | jE                               }|rD|j(                  j<                  s.|j?                  t@        jB                  | jE                               }d}|| jG                  |      }|k|dv rd|jI                  dd      z  }nd|z  }t        jJ                  |j                  | jL                  |      }t        jN                  |j                        }nt        jN                  |j                        }g }|j4                  rs|sa|jP                  s&tS        jT                  |      }|jW                  |       t        jX                  |j                  d| jZ                  |gd      }| j\                  }d}n|j6                  rI|s0t        j8                  |j                  dt        j^                        }| j`                  tA        jb                  t*        jd                  tA        jf                  d|d      tA        jf                  dt@        jB                  d      tA        jf                  dt@        jB                  d      tA        jf                  dt@        jh                  d      tA        jf                  dt@        jh                  d      tA        jf                  d| jL                  d      g      | _0        | j`                  }d |j2                   }nU|s0t        j8                  |j                  dt        j^                        }| jj                  }|t*        j,                  u rd!}nd"}t        jX                  |j                  d#|z  ||||||
|g|jl                  to        jp                  |d$      %      }|ddd&   D ]  }tS        jr                  ||      } |S # t        t        t        f$ r Y 	w xY w)'zReplace char*.decode() by a direct C-API call to the
        corresponding codec, possibly resolving a slice on the char*.
        r   r   zbytes.decoder  r   Nr   r  @descriptor '%s' requires a '%s' object but received a 'NoneType'decoder  r%  r  r  )r  r   r  z__Pyx_PyUnicode_Decode%sr'  r  zPyUnicode_Decode%s)rE   r$  r  TrT  decode_c_stringr  r  r  rV  rX  r  r  r  decode_cpp_decode_bytesdecode_bytearrayz__Pyx_%srh  r  rI   ):rL   r  r	  r   r  r=   r  r   r   r%  
ValueErrorUnicodeDecodeErrorr(   r   r\  r   rV  rX  r   r)   rE   r
   r   r   r  r"   r  is_cpp_stringr   r/  r  r   r	   r.  r   r  r  r/  !PyUnicode_DecodeXyz_func_ptr_typer  r   r   r+  rN   rY  r  _decode_c_string_func_typer   _decode_cpp_string_func_typer  r   r  rs  _decode_bytes_func_typer  r   r!   r  )r\   r*   r   r   r_  r  r  r  r  r  r  r=   rV  rX  rz  string_typer  codec_cnamedecode_functionr   helper_func_typer  r  s                          r#   "_handle_simple_method_bytes_decodez7OptimizeBuiltinCalls._handle_simple_method_bytes_decodeN  s&    SY#!#''dEJK 1g99$((DI
KGQD-1D**,	"-"="="D"DX~"^ #OO'8 + ; ;  k9#;#;<$J$//K$**JOO4EE11Q6k9#?#?@%//K!&&7--w/E/EFF );;V!);+;+; < < > *;;@0!)
 < , &&{/H/HK%%..txx;E""OOJ$@$@$BRBRBTUE		((>>*">">@P@P@RSD 
66x@J!>>8:;M;McSU;VV2Z?'88tEE[ZO%..txx8M'00:O   "**"+"6"6{"CKLL- 33OO%94;Z;Z% 
  $>> 1&& ((9I9B9Q9QS0084>4H4H(("//+tL"//9U9UW[\"//
8T8TVZ["//
J<\<\^bc"//*:Z:Z\`a"//t?e?egkl+51  $@@"-k.>.>-? @  ((9I9B9Q9QS#;;g000$2!$6!++HHj#446FudM;NP_`LL$001BOT	
 $B$K 	>D11$=D	>_ #J0BC s   *V# #V;:V;c                    	 t        j                  |      }| j                  D ]N  \  }}||k(  sd|v r<dj	                  |j                  d      D cg c]  }|j                          c}      }|c S  y # t        $ r Y y w xY wc c}w )Nr6  r  )r   
getencoderLookupError_special_codecsr  r  r  )r\   r  requested_codecr"   codecrN  s         r#   r  z-OptimizeBuiltinCalls._find_special_codec_name  s    	$//9O  // 	KD%'$;77-1ZZ_$>() %&LLN $> ?D	   		
$>s   A5 B
5	B Bc                     t        j                  |      }t        |      dk\  r| j                  |d         \  }}|y d }|}t        |      dk(  r"| j                  |d         \  }}|y |dk(  r|}nd}|}||||fS )Nr   r   r   r  )r   r  rL   _unpack_string_and_cstring_node)r\   r   r   r  r  r  r  r  s           r#   r	  z4OptimizeBuiltinCalls._unpack_encoding_and_error_mode  s    &&s+	t9>&*&J&J4PQ7&S#Hm$H%Mt9>262V2VW[\]W^2_/N/"*)&/#%N"+-9LMMr%   c                    t        |t        j                        r|j                  }t        |t        j                        rN|j
                  }t        j                  |j                  |j                         t        j                        }||fS t        |t        j                        rY|j
                  j                  d      }t        j                  |j                  |j
                  t        j                        }||fS |j                  t        j                  u r4d }|j                  t        j                  | j!                               }||fS |j                  j"                  rd }||fS d x}}||fS )Nr  z
ISO-8859-1)r(   r   r   r)   r   r   rr  r   as_utf8_stringr	   rs  r  rE   r
   r   r   r   r  )r\   r*   r  s      r#   r4  z4OptimizeBuiltinCalls._unpack_string_and_cstring_node  s=   dI88988DdI112zzH&& 7 7 9
@`@`bD ~ i112zz((6H&&

1Q1QSD ~ YY',,,H>>*"B"BDDTDTDVWD
 ~	 YY  H ~ #"Ht~r%   c           
      :    | j                  ||||ddt        d      S )Nr  r  r   r  bytes_tailmatch_utility_coder  s        r#   $_handle_simple_method_bytes_endswithz9OptimizeBuiltinCalls._handle_simple_method_bytes_endswith  s(    %%(D"3Wj(". 	.r%   c           
      :    | j                  ||||ddt        d      S )Nr  r  rI   r8  r  s        r#   &_handle_simple_method_bytes_startswithz;OptimizeBuiltinCalls._handle_simple_method_bytes_startswith  s(    %%(D"3Wl(". 	.r%   re   c           
          t        |      }|r|r| j                  |d   |||      |d<   |	|j                  }	t        j                  |j
                  ||||	||
|j                        S )Nr   )r   r  ro  r  rn  )r  r  r  r   rY  r   rn  )r\   r*   r   r"   r  r^  r_  r   ro  r  r  r  s               r#   r8  z,OptimizeBuiltinCalls._substitute_method_call#  ss    
 Dzt))$q'8=NPYZDG?llG++HHdI'-!00 	r%   c                     |j                   r|S |r+|j                  d||j                  j                  g      }|S |j                  dj	                  t        |      dk  rdnd      d|g      }|S )	Nr  r  r  r  r  r  r  r  )rp  r  rE   r"   r  rL   )r\   self_argr   r_  r^  s        r#   r  z#OptimizeBuiltinCalls._wrap_self_arg6  s    O11R&(:(:; 2 =H 	  11;BBCPYN^`L`5fhi,&K 2 )H r%   c           	      J   t        |      |k  ry ||   }|j                         sy |j                  r#t        j                  |j
                        ||<   y t        j                  |j
                  d| j                  |j                  | j                               gd      ||<   y )N__Pyx_NoneAsNullr   rT  )
rL   rm  rD   r   r  r   rY  obj_to_obj_func_typer  r   )r\   r   r"  r)   s       r#   r  z*OptimizeBuiltinCalls._inject_null_for_noneI  s    t95k 58[[i((1UiFbFbGG'%%&&t'7'7'9:;	G
Ur%   c                 T   t        |      |k\  sJ t        |      |k(  s||   j                  rt        |t              s(t	        |      j                  d      j                         r4t        j                  j                  |j                  t        |            }n+t        j                  |j                  t	        |      |      }|j                  |       y ||   j                  || j                               }t        |t        j                        rt	        |      |_        |||<   y )Nz+-r  )rL   rD   r(   r  r  lstrip	isdecimalr   r   r   r   rN   r   r   r6  special_none_cvalue)r\   r*   r   	arg_indexrE   default_valueint_noder)   s           r#   r  z1OptimizeBuiltinCalls._inject_int_default_argumentX  s     4yI%%t9	!T)_%<%<--]1C1J1J41P1Z1Z1\$,,44TXXs=?QR$,,TXXS=OVZ[KK!y/++D$2B2B2DEC#y==>*-m*<'!DOr%   c                     t        |      |k\  sJ t        |      |k(  r:|j                  t        j                  |j                  t        |                   y ||   j                  | j                               ||<   y Nr   )rL   rN   r   r   r   r  r,  r   )r\   r*   r   rG  rH  s        r#   r  z2OptimizeBuiltinCalls._inject_bint_default_argumenti  s`    4yI%%t9	!KK	**4884;NOP"9o??@P@P@RSDOr%   r'   r  )rl   rm   rn   ro   r#  r%  rc   r.  r	   r  r  r  r7  r9  r>  c_float_typer  c_longdouble_typerH  r=  rv  r   rP  rQ  rE  r  rV  rb  rZ  r
   r   rn  ro  _handle_simple_function_strrt  r   rw  r  r  r  r  r  r|  r}  r   r  r  r   r  r  r  r  r  r  r  r  r  memoryview_typer  r  r  r  r.  rs  r  c_const_py_unicode_ptr_typer  r  r   r   r2  r  r  r  rM   r  r  r_  r  r  r  r  r  r  r  r	  r  r  r  r  r  r  r)  r-  r"  r!  r9  r:  rB  rC  rI  rJ  rP  rQ  rQ  rS  r  r   r  r]  rb  rf  rj  ro  rr  ru  rx  r}  r  r  r  r  r  !_handle_simple_method_int___add__!_handle_simple_method_int___sub__!_handle_simple_method_int___mul__ _handle_simple_method_int___eq__ _handle_simple_method_int___ne__!_handle_simple_method_int___and__ _handle_simple_method_int___or__!_handle_simple_method_int___xor__$_handle_simple_method_int___rshift__$_handle_simple_method_int___lshift__!_handle_simple_method_int___mod__&_handle_simple_method_int___floordiv__%_handle_simple_method_int___truediv__r  r  r  r  r  r  r  r  r\  r  r  %_handle_simple_method_unicode_isalnum%_handle_simple_method_unicode_isalpha'_handle_simple_method_unicode_isdecimal%_handle_simple_method_unicode_isdigit%_handle_simple_method_unicode_islower'_handle_simple_method_unicode_isnumeric%_handle_simple_method_unicode_isspace%_handle_simple_method_unicode_istitle%_handle_simple_method_unicode_isupper)_handle_simple_method_unicode_isprintable$PyUnicode_uchar_conversion_func_typer  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r
  r  _special_encodingsr   r.  r0  r  r  r$  r%  r'  r&  r,  &_handle_simple_method_bytearray_decoder  r	  r4  r:  r<  r   rY  r  r8  r  rB  r  r  r  )r   r  r	   ctyper  r"   r   s   0000000r#   r   r   x  sl    	 
  4z33!!#J##C)B)BDI$ 
. N &22J4L4LjNjNjk 
 	 	J((''z4@ 	3j 0://#J##E:+D+DdK 
 	 3j22  #J##E:+D+DdK#
 	
3>$(BX5  "6!5!5#J##E:+D+DdK"
. #B
 1J00#J##FG,=,=tD
 !5
 4 4	 	 	 z'@'@$	GH!J
"  4z33#J##FG,=,=tD 
U$ /*..#J##D**C*CTJ

 < !5
 4 4#J##D**C*CTJ!
!
!  #7*"6"6  #J##E:+D+DdK# )# 4l 2Z11#J##C)B)BDI
 #7*"6"6#J##GZ-E-EtL#
,B  )=
(<(<#J##GZ-F-FM")%
 )=
(<(<#J##GW-C-CTJ")%
4 "6!5!5$$#J##GZ-M-MtT'
 	" ';j&:&:$$#J##Iz/U/UW[\'
 	'# 3j22$$#J##E:+D+DdK'
 	 	!=!9!=!8!9!7!7	! 
c  442h .--#J##Hj.G.GN
	C 3j22#J##E:+D+DdK!
Vp$ 0://!!#J##Fj.G.GN#J##Fg.@.@$G$ #7*"6"6!!#J##Fj.G.GN#J##Fg.@.@$G#J##Hg.?.?F$
# ;?GT ;? !5
 4 4$$#J##FJ,E,EtL#J##FJ,E,EtL' !
 =~ $8:#7#7$$#J##K1J1JDQ#J##GZ-B-BDI' $  *>)=)=$$#J##K1J1JDQ#J##GZ-F-FM' *&B 2Z11!!#J##FJ,E,EtL$
 #7*"6"6!!#J##FJ,E,EtL#J##J
0I0I4P#J##Iz/K/KTR#J##K1F1FM	$
 #C@D 2Z11$$#J##E:+D+DdK' 	T $8:#7#7!!#J##FJ,E,EtL#J##E:+D+DdK#J##Iz/H/H$O$$ C  ';j&:&:!!#J##FJ,E,EtL#J##E:+D+DdK#J##Iz/H/H$O#J##NJ4I4I4P	$'#S  0://!!#J##FJ,E,EtL#J##E:+D+DdK#J##Iz/H/H$O$ #7*"6"6#J##FJ,E,EtL#J##E:+D+DdK#J##Iz/H/H$O 
 '11AA#<F !,,j.F.FG
 
 #22J4J4JK
  
://''z/H/H$O''z/H/H$O''t<''	:3I3I4P''9O9OQUV (0';';tAYAY[ 	[

X]]WWXWX[[\^]Y )M%(L%(L%'J$'J$(L%'J$(L%+R(+R((L%-V*,T)[X]_[^WW#N +?**>*>#J##GZ-F-FM! 	+ '0 /H).G).G+.G).G).G+.G).G).G)0I-+?:+?+?!!#J##GZ-F-FM$,(0 &:Z%9%9#J##E7+?+?F#J##J
0F0FM&"3 !5
 4 4#J##E7+?+?F#J##E:+D+DdK#J##J
0L0LdS!
.&  4z33#J##E7+?+?F#J##E:+D+DdK -@ $8:#7#7#J##E:+D+DdK#J##K1J1JDQ#J##GZ-I-I4P#J##E:+G+GN#J##K1F1FM! $ 0
0
L4  4z33$$#J##E7+?+?F#J##K1J1JDQ#J##GZ-I-I4P#J##E:+G+GN#J##K1F1FM'  ABB& !5
 4 4$$#J##E7+?+?F#J##K1J1JDQ#J##GZ-I-I4P#J##E:+G+GN	' !B" #7*"6"6#J##E7+?+?F#J##K1J1JDQ#J##Iz/H/H$O#J##J
0L0LdS	#0 +?**>*>#J##E7+?+?F#J##J
0P0PRVW#J##Hj.N.NPTU+' ';j&:&:#J##E7+?+?F'#
B %79 9  v0067 9O/?b )<
(;(;<PJ<P<P#J##Hj.N.NPTU#J##FJ,H,H$O#J##Hj.N.NPTU
= )% "6!5!5#J##Hj.N.NPTU#J##GZ-I-I4P#J##FJ,H,H$O#J##J
0P0PRVW#J##Hj.N.NPTU#J##M3TVZ[
" 3j22#J##Hj.G.GN#J##GZ-I-I4P#J##FJ,H,H$O#J##J
0P0PRVW#J##Hj.N.NPTU#J##M3TVZ[
 $( AF .P*N.(.
.

 DF-14090L0L0\0\04	& 0://!!#J##E:+D+DdK$


""Tw;V"
H9s   :4AO*DAO
D# AOr   c           	      P   t         j                  t         j                  f}t        ||      r>|j                  t
        j                  ur|j                  t        j                  ury|}d}nKt        ||      r>|j                  t
        j                  ur|j                  t        j                  ury|}d}ny|j                         syt        |t         j                        }|rt
        j                  nt
        j                  }	|r| dvr y| dk(  ryt        |j                        dkD  ry| dv r|j                  dk(  ryg }
|
j                   |rt         j                  nt         j                  |j                  |j                   |j                  |		             t        |t         j"                        r|j$                  nd
}|
j                  t        j&                  |j                  |             |s| dvr`|dk(  xr) t        |t         j(                        r|j*                   nd
}|
j                  t        j&                  |j                  |             t-        j.                  |rdn| dv rdnddt1        | ||            }d|rdndd|j2                  rdnd| |}|||
|	fS )zQ
    Optimise math operators for (likely) float or small integer operations.
    NObjCCObj)rZ  ra  r  r  r  ri  rn  r  r   )r  r  r  r  r   re  Fr   r  PyFloatBinopPyLongComparePyLongBinopr    )oporderr  r  r  FloatLongr6  r  Bool)r   r   r  r(   rE   r	   r  r
   r  r  r  r  r  r=   rN   r   r   NumBinopNoder)  r   r  	cdivisionr   r!   r   r   )r~   r*   r  arg0arg1	num_nodesnumval	arg_orderr;  r  r  r)  zerodivision_checkro  r  s                  r#   r  r  q  sV    ""I$7$78I$	"99J555$))7K[K[:[		D)	$99J555$))7K[K[:[	%%' &)"5"56H+3z''9O9OH__	X		V##	$u	,GG1$JMhy**I<M<M

&,,8N8N  )y/E/EFdllEGi((AB8</&&0 R",T93D3D"E5 	),,TXX=OPQ%11"8|;SYf	HEGL '"".	J |Z99r%   unicode_tailmatchrh  bytes_tailmatchc                       e Zd ZdZd( fd	Zd Zej                  ej                  ej                  ej                  gZd Zd Zd Zd Zdd	d
ddj                   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*d& Z+d' Z,e-j\                  j^                  Z0 xZ1S ))ConstantFoldingaF  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                 0    t         |           || _        y)z
        The reevaluate argument specifies whether constant values that were
        previously computed should be recomputed.
        N)superrY   
reevaluate)r\   r  	__class__s     r#   rY   zConstantFolding.__init__  s    
 	$r%   c                    | j                   s|j                  t        j                  ury t        j                  }||_        | j                  |      }|j                         D ]>  }t        |      t        u r|D ]  }t        |d|      |u s  y  .t        |d|      |u s> y  	 |j                          y # t        t        t        t        t        t         f$ r Y y t"        $ r' dd l}dd l}|j)                  |j*                         Y y w xY w)Nr=   r   )file)r  r=   r   constant_value_not_setr   r^   r   rE   r  r  calculate_constant_resultr!  	TypeErrorrv   
IndexErrorr%  ArithmeticError	Exception	tracebacksys	print_excstdout)r\   r*   r   childrenchild_resultchildr  r  s           r#   _calculate_constz ConstantFolding._calculate_const  s    $$I,L,LL #11- %%d+$OO- 	LL!T)) Eu&7HNZ '8.I^[	
	1**, Ix^_] 	 	1!SZZ0	1s   $B5 5#D	,D	D	c           
          	 | j                   t        t        | j                   j                  t        t        |                     S # t
        $ r Y y w xY wr'   )NODE_TYPE_ORDERmaxr   r"  rE   r!  )r\   nodess     r#   _widest_node_classz"ConstantFolding._widest_node_class  sP    	''C,,22Ce4DEFH H 		s   AA 	AAc                 V    t        j                  |j                  t        |            S rK  )r   r   r   r  )r\   r*   r   s      r#   
_bool_nodezConstantFolding._bool_node  s    !!$(($u+>>r%   c                 (    | j                  |       |S r'   )r  r_   s     r#   visit_ExprNodezConstantFolding.visit_ExprNode   s    d#r%   c                 T   | j                  |       |j                         s"|j                  dk(  r| j                  |      S |S |j                  j
                  s|S |j                  dk(  r| j                  ||j                        S t        |j                  t        j                        r=t        j                  j                  |j                  t        |j                              S |j                  dk(  r| j                  |      S |j                  dk(  r| j!                  |      S |S )N!r(  r'  )r  r  r~   _handle_NotNoder   rp  r  r=   r(   r   r   r   r   r   r  _handle_UnaryPlusNode_handle_UnaryMinusNoder_   s     r#   visit_UnopNodezConstantFolding.visit_UnopNode  s    d#'')}}#++D11K||&&K==C??4)=)=>>i&8&89$$,,TXXs4;O;O7PQQ]]c!--d33]]c!..t44r%   r   rV  is_notr  )rV  r   r  r  c                     |j                   }t        |t        j                        rJ| j	                  |j
                        }|r-t        j                  |      }||_        | j                  |      }|S r'   )r   r(   r   r   _negate_operatorr~   r   r   )r\   r*   r   r~   s       r#   r  zConstantFolding._handle_NotNode  s^    ,,gy778,,W-=-=>Hyy) (006r%   c                 V   d }|j                   j                  }t        |j                   t        j                        rGt        j                  |j
                   ||j                   j                        ||j                        S |j                  r|j                  s0t        |j                   t        j                        rh|j                  r\t        j                  |j
                   ||j                   j                        ||j                   j                  |j                        S |S )Nc                 @    | j                  d      r| dd  } | S d| z   } | S )Nr'  r   )r  r   s    r#   _negatez7ConstantFolding._handle_UnaryMinusNode.<locals>._negate(  s2    $ab	 L eLr%   )r   rE   r=   )r   rE   longnessr=   )r   rE   r(   r   r  r   r   r=   r  r.  r   r   r  )r\   r*   r  	node_types       r#   r  z&ConstantFolding._handle_UnaryMinusNode'  s    	 LL%%	dllI$7$78&&txxwt||?Q?Q7R,57;7K7KM M 	 0 04<<):):;	@U@U$$TXXWT\\=O=O5P*3.2ll.C.C595I5IK K r%   c                     |j                   j                         r/|j                  |j                   j                  k(  r|j                   S |S r'   )r   r  r=   r_   s     r#   r  z%ConstantFolding._handle_UnaryPlusNode=  s9    LL,,.((DLL,H,HH<<r%   c                 $   | j                  |       |j                  j                         s|S |j                  j                  r'|j                  dk(  r|j
                  S |j                  S |j                  dk(  r|j                  S |j
                  S )Nr!  )r  rB   r  r=   r~   rC   r_   s     r#   rC  z#ConstantFolding.visit_BoolBinopNodeC  sr    d#}}002K==((}}%}}$}}$}}%}}$}}$r%   c                    | j                  |       |j                  t        j                  u r|S t	        |j                  t
              r|S |j                  |j                  }}|j                  r|j                  s|S 	 |j                  |j                  }}|||S 	 |j                  r#|j                  rt        j                  ||      }nt        j                  }| j                  ||      }||S |t        j                   u r|j"                  dv rt        j$                  }n0|t        j&                  u r|j"                  dv rt        j$                  }|t        j$                  u rt)        |dd      xr t)        |dd      }dd t+        t-        t)        |dd            t-        t)        |dd                   }	t/        t1        |j                              }
t3        j4                  |
      }
t        j$                  |j6                  ||	|
t1        |j                              }|j8                  s|j                  j8                  rt        j                  |_	        |S t        j                  ||j                        |_	        |S |t        j                   u r.t        j                   |j6                  |j                  |      }|S  ||j6                  |t;        |j                        |j                  	      }|S # t        $ r |cY S w xY w)
Nz+-//<<%**>>z+-//<<%**>>&|^unsignedr  LLr  )r   r  r  r   r=   r  )r   rE   r   r=   )r  r=   r   r   r(   r  rB   rC   rp  rE   r%  rF  r	   widest_numeric_typer  r  r   r~   r   r  r  r  rL   hexr  r   strip_py2_long_suffixr   r   r  )r\   r*   rB   rC   type1type2widest_typetarget_classr  r  r   r   s               r#   visit_BinopNodezConstantFolding.visit_BinopNodeR  s   d#9#;#;;Kd**E2K!]]DMM(""(*=*=K	#==(--5E} !.
  0 0$88FK$33K..xBKY///DMM]4R$,,LY///DMMEU4U$,,L9,,,xR8 9xR8  ISWXz2%F!G!$WXz2%F!GI JHD0012E//6E ((TXX2:X/49<T=Q=Q9RTH &&(--*C*C * 9 9  !+ > >{HMM Z  Y/// ))$(($:N:NU`aH
  ${*-d.B.B*C484H4HJH S  	K	s   ?K9 9LLc                    | j                  |       t        |j                  t              r>t	        j
                  |j                  j                  t        |j                              S |j                  |j                  }}t        |t        j                        rt        |t        j                        rK|j                  j                  |j                         t        j                  |_        | j                  |      S t        |j                  t              r]|j                  s|S t        |t        j
                        s+t	        j
                  |j                  |j                        }|j                  j                  |       t        j                  |_        | j                  |      S t        |t        j                        rt        |j                  t              r|j                  s|S t        |t        j
                        s+t	        j
                  |j                  |j                        }|j                  j!                  d|       t        j                  |_        | j                  |      S |j                  t        j"                  u r|S |j$                  r|j$                  rt        |t        j
                        rt        |t        j
                        rd }|j&                  p|j&                  d|j&                  j(                  |j&                  j(                  k(  r7t+        |j&                  |j&                  z   |j&                  j(                        }t        |j                        }t	        j
                  |j                  ||      S t        |t        j,                        rt        |t        j,                        r|j.                  j(                  |j.                  j(                  k(  rVt+        |j                  |j.                  j(                        }t	        j,                  |j                  ||j                        S | j1                  |      S )Nr   r   r  r  )r  r(   r=   r  r   r   rB   r   r   rC   JoinedStrNoder   r   r  simplify_JoinedStrNoderN   insertr   r   r  r  r   rr  r   r  )r\   r*   rB   rC   r  string_values         r#   visit_AddNodezConstantFolding.visit_AddNode  s1   d#d**C0((!!t7K7K)LN N "]]DMM( h	 7 78(I$;$;<&&x7+4+K+K(228<<(22C8//#O!(I,A,AB(44 H,D,D FH&&x0+4+K+K(228<<)"9"9:(22C8//#O!(I,A,AB(44 H,D,D FH&&q(3+4+K+K(228<<9#;#;;K%%(*D*D(I$9$9:z(T]TiTi?j"''38L8L8X++448L8L8U8UU&3$0083G3GG$0099';  -T-A-AB ,,X\\[fggHi&9&9:z(T]TgTg?h>>**hnn.E.EE"/0D0DhnnF]F]"^K$..x||;`d`t`tuu##D))r%   c                 v   | j                  |       |j                  j                  r'| j                  ||j                  |j                        S t        |j                  t        j                        r=|j                  j                  r'| j                  ||j                  |j                        S |j                  j                  r'| j                  ||j                  |j                        S |j                  j                  r'| j                  ||j                  |j                        S | j                  |      S r'   )r  rB   r   _calculate_constant_seqrC   r(   r   r   r   _multiply_stringr  r_   s     r#   visit_MulNodezConstantFolding.visit_MulNode  s    d#==00//dmmT]]SSdmmY%6%6755//dmmT]]SS==**((t}}dmmLL]],,((t}}dmmLL##D))r%   c                 t   |j                   }t        |t              s|S |j                         rt        |j                   t              s|S t        |j                         dkD  r|S t        |t        j                        rt        }nrt        |t        j                        rEt        }|j                  Ft        |j                  |z  |j                  j                        |_        nJ dt        |      z          ||j                  |z  |j                  j                        |_        |j                  |_         |S )N   zunknown string node type: %s)r=   r(   r  r  _py_string_typesrL   r   rr  r   r   r   r  r  rE   r   )r\   r*   r  multiplier_node
multiplierbuild_strings         r#   r  z ConstantFolding._multiply_string  s   $44
*c*K((*z$:N:NP`/aKt##$s*Kk9#6#67(LY%:%:;)L&&2*7++j8++44+6' M84;LLL(
*&&( '2&7&7#r%   c                 B   |j                   dk7  r|j                  rt        |j                   t              r'|j                   dk  r|j                  d d = d |_        |S |j                  t        |j                   t              rt        |j                  j                   t              r^|j                  j                   |j                   z  }t
        j                  j                  |j                  j                  |      |_        |S | j                  |      S ||_        |S r  )
r=   r   r(   r  r  r   r   r/  r   r  )r\   r*   sequence_nodefactorr   s        r#   r  z'ConstantFolding._calculate_constant_seq  s    !!Q&=+=+=&00#66;Q;QUV;V!&&q),0)  **6v55s;"=#<#<#L#LcR)55EEH^H^^E090A0A0J0J=KdKdKhKhjo0pM-   //55,2)r%   c                    | j                  |       t        |j                  t        j                        rt        |j
                  t        j                        ri|j
                  j                  sS| j                  |j                  j                  |j                  j                  |j
                  j                        }||S | j                  |      S r'   )r^   r(   rB   r   r   rC   r\  r  _build_fstringr   r   r   r  )r\   r*   fstrings      r#   visit_ModNodezConstantFolding.visit_ModNode  s    4 dmmY%:%:;
4==ZcZmZm@n==,,--dmm.?.?ATATVZVcVcVhVhi&"N##D))r%   z'(%(?:(?:[-0-9]+|[ ])?(?:[.][0-9]+)?)?.)c                    t        |      }g }d}t        j                  | j                  |      D ]f  }|s|dk(  r0|j	                  t        j                  |t        d                   <|d   dk7  rO|d   dk(  rt        |d|dd   d	d
       d}|j	                  t        j                  |t        |                   |d   }	 t        |      }	|	j                  rd} n|dv r|d
d  }
d }|dv rd|
v rd}n,|dv r!|
d d }
|}|
j                  d      rd|
d
d  z   }
n|dk(  rd}|
j                  d      rd|
d
d  z   }
|j	                  t        j                  |	j                  |	||
r t        j                  |t        |
            nd              ed} n |sy 	 t        |       t        |dd
       y # t        $ r t        |dd
       d}Y  :w xY w# t        $ r Y nw xY wt        j                  ||      }| j!                  |      S )NTz%%%r   r   rI   zIncomplete format: '...'r   )levelFz)Too few arguments for format placeholdersasrfdoxXdoxXr}  arsr  r  dr'  r   )r   rs  rr  z*Too many arguments for format placeholders)r   )iterr   r  _parse_string_format_regexrN   r   r   r   r   nextStopIterationr   r  FormattedValueNoder   r  visit_JoinedStrNode)r\   r   r  r  r   
substringscan_be_optimisedrN  format_typer)   rr  rs  r*   s                r#   r  zConstantFolding._build_fstring  sP   K 
$997C 1	ADy!!)"7"7=QTCU"VWts{R5C<C#:1RS6(!!DAN',$!!)"7"7=QRCS"TUB%K4j
 ~~#( j(e"&&(SK-?',$ E)"-cr"2K&1O"--c2&)KO&; C'&)O))#."%AB"7K!!)">">GG3$3& !* 5 5c{A[ \,0	#  $) c1	f  	J CEQO[ ! HPQR#( T "d"
 &&s:>''--s$   	F8G 8GG	G$#G$c                 f   | j                  |       |j                  xs d}|j                  3|j                  j                  r|j                  j                  sd |_        |j                  |j                  j                         rwt        |j                  j                  t              rSt        t        |j                  j                              }t        j                  |j                  j                  |      S |j                  '|dk(  r"|j                  j                  r|j                  S |S )NrN  r   )r^   rs  rr  r   r   r  r(   r=   r  r   r  r   r   r   )r\   r*   rs  r   s       r#   rt  z(ConstantFolding.visit_FormattedValueNodeR  s    4 ..5#'D,<,<,N,NW[WgWgWmWm#D#

(F(F(HZX\XbXbXrXrtwMx!#djj&@&@"ABE((uEE#3(>zz++zz!r%   c                 F    | j                  |       | j                  |      S r'   )r^   r  r_   s     r#   r  z#ConstantFolding.visit_JoinedStrNode_  s!    4 **400r%   c                    g }t        j                  |j                  t        d            D ]  \  }}|rt	        |      }|d   }t        |      dkD  rBt        dj                  d |D                    }t        j                  |j                  |      }|j                  su|j                  |       |j                  |        |s,t        j                  |j                  t        d            }|S t        |      dk(  r|d   }|S t        |      dk(  r#t        j                  |j                  d	g| }|S ||_        |S )
z
        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.
        r   )r;  r   r   r  c              3   4   K   | ]  }|j                     y wr'   r   )r   r   s     r#   r   z9ConstantFolding.simplify_JoinedStrNode.<locals>.<genexpr>o  s     1V%%++1Vr   r   r   r(  )r   groupbyr   r   r  rL   r   r  r   r   r   r   rN   r   r7  )r\   r*   r   is_unode_groupr  unoder   s          r#   r  z&ConstantFolding.simplify_JoinedStrNodec  s'    *3*;*;DKKZXkMl*m 	*&NJ!*-
"1z?Q&)"''1V:1V*VWE%11%))5IE;;MM%(j)	* ((r9JKD  [A!9D  [A''#??D  !DKr%   c                 T   | j                  |       g g fd|j                  D ]  } ||        rj                         t              dk(  r-d   }|j                  st        |t        j                        r|S |j                  dd | j                  |       |S )z!Unpack **args in place if we can.c                    |j                   rYrEd   j                  |j                  k(  r)d   j                  j                  |j                         y j	                  |       y t        |t        j                        r4| j                  |j                  k(  r|j                  D ]  } ||        y rj                         d d = j	                  |       y )NrI   )	is_dict_literalreject_duplicatesr  r   rN   r(   r   MergedDictNoder  )parentr)   	child_argr!  r   r   s      r#   r!  z1ConstantFolding.visit_MergedDictNode.<locals>.add  s    ""U2Y88C<Q<QQ"I--44S5H5HILL%C!9!9:v?W?W[^[p[p?p!$!1!1 (IY'( KK&aC r%   r   r   N)	r^   r  r   rL   r  r(   r   r  r  )r\   r*   r)   r!  r   r   s      @@@r#   visit_MergedDictNodez$ConstantFolding.visit_MergedDictNode  s    4 	! $$ 	CcN	KKt9>q'C""ji6N6N&O
#!d#r%   c                    | j                  |       |j                  t        j                  u g g fd|j                  D ]
  } |        rj                  d          t              dk(  rSd   }r|j                  s>|j                  r|j                  |j                  u st        |t        j                        r|S |j                  dd | j                  |       |S ) Unpack *args in place if we can.c                    r| j                   s| j                  rI| j                  s=r)d   j                  j	                  | j                         y j                  |        y t        | t        j                        r| j                  D ]
  } |        y rj                  d          d d = j                  |        y )Nr   )	is_set_literalr   r  r   r   rN   r(   r   MergedSequenceNode)r)   r  r!  r   r  r   s     r#   r!  z5ConstantFolding.visit_MergedSequenceNode.<locals>.add  s    3--33N3NWZWfWf1INN))#((3MM#&C!=!=>!$ #I	N# KKq	*q	C r%   r   r   N)r^   rE   r
   r   r   rN   rL   r  r   r(   r   r  r  )r\   r*   r)   r!  r   r  r   s      @@@@r#   visit_MergedSequenceNodez(ConstantFolding.visit_MergedSequenceNode  s    4 g...	! 99 	CH	KKq	"t9>q'CC..00SXX5JsI$@$@A
		!d#r%   c                    | j                  |       g }|j                  D ]  }|j                  s|j                  |       !|j                  j
                  r<|j                  j                  s&|j                  |j                  j                         s|j                  |        ||j                  dd | j                  |       |S )r  N)	r^   r   r   rN   r   r   r  r   r  )r\   r*   r   r)   s       r#   visit_SequenceNodez"ConstantFolding.visit_SequenceNode  s    4 99 	!C>>C 33CJJ<R<RCJJOO,C 	! 		!d#r%   c                 t   | j                  |dg       |j                  }|}|w| j                  |dg       |j                  }t        |_        |j                         r,|j                         r	 |j                  |j                         |}|j                  }|w|j                  s.|j                         r| j                  ||j                        S |S |j                  gg}g }|}|~|j                         rK|j                  s"|j                  | j                  |d             n@|j                  |j                  g       n|d   j                  |       |j                  }|~g }|D ]  }t!        |      dk  r|d   }t#        j$                  |j&                  |d   |j(                  |j                  t              }	|j                  |	       |	}
|dd  D ]  }||
_        |}
 d |
_         |r|j                  |d          n|s| j                  |d	      S |d   }t!        |      dk(  r.|j                         r| j                  ||j                        S |S |dd  D ]*  }t#        j*                  |j&                  |d
|t              }, |S # t        t        t        t        t        t        f$ r Y ,w xY w)NrB   rC   FrI   r   r   r   )rB   r~   rC   r=   Tr!  )r^   rB   rC   r   r=   r  "calculate_cascaded_constant_resultr!  r  rv   r  r%  r  r  r  rN   rL   r   r   r   r~   r0  )r\   r*   	left_noder   
right_nodecascadesfinal_false_result	cmp_nodesr  	pcmp_nodelast_cmp_nodes              r#   r   z$ConstantFolding.visit_PrimaryCmpNode  s   4*.MM	"x*6!**J'5H$,,.:3Q3Q3S??	@Y@YZ #I''H " ||'')tT-A-ABBK ]]O$"++-//&--dooh.NO OOX%6%6$78 ##H-''H " 	 	)G7|aqzH!00 !**!** .0I Y'%M#ABK )(0% () %)M!!	)$ /23??4..|y>Q'')tT-A-ABB  &abM 4 ..HH!"%$244 E #Ix^Ude s   /J #J76J7c                     | j                  |       |j                  j                         s|S |j                  j                  r|j                  S |j
                  S r'   )r  r/  r  r=   r<  r=  r_   s     r#   r?  z"ConstantFolding.visit_CondExprNode)  sF    d#yy,,.K99$$== >>!r%   c                 l   | j                  |       g }|j                  D ]O  }|j                  }|j                         r |j                  s,|j
                  |_         n|j                  |       Q |r	||_        |S |j                  r|j                  S t        j                  |j                  g       S Nr   )r^   r   r   r  r=   r   r   rN   r   r   r   )r\   r*   r   r5  r   s        r#   r9  z ConstantFolding.visit_IfStatNode2  s    4 
 
	-I!++I,,.,,'0~~D$ !!),
	- (DOK###%%dhhb99r%   c                    | j                  |       |j                  |j                  j                  
d x}|_        n|j                  j                  }|j                  |j                  j                  
d x}|_        n|j                  j                  }|j                  t        ur\|j
                  }|j                  r"|j                  |j                  || |_        |S |j                  r|j                  ||      }||S |S r'   )r  rV  r=   rX  r   r   r   r  r   r   as_sliced_node)r\   r*   rV  rX  r   s        r#   visit_SliceIndexNodez$ConstantFolding.visit_SliceIndexNodeI  s    d#::!;!;!C!%%EDJJJ..E99		 9 9 A##D4999,,D~599D++0@0@0H IIeD1	''**5$7#Kr%   c                     | j                  |       t        |j                  t        j                        r|j                  j
                  s|j                  t        j                  u r"t        j                  |j                  g g       S |j                  t        j                  u r*t        j                  |j                  g t                     S |j                  t        j                  u r"t        j                   |j                  g i       S |S )Nr  r  )r^   r(   r  r   r   r   rE   r
   r  r   r   r   r   r]  rK   r   r
  r_   s     r#   visit_ComprehensionNodez'ConstantFolding.visit_ComprehensionNode`  s    4 dii!3!34TYY__yyG--- ))HH2r; ;g... ((HH2su> >g/// ))HHb"F Fr%   c                    | j                  |       |j                  j                  }t        |t        j
                        r~|j                  s9|j                  r|j                  S t        j                  |j                  g       S t        |t        j                        r|j                         |j                  _        |S r  )r^   r   r   r(   r   SequenceNoder   r   r   r   r   r   r  )r\   r*   r   s      r#   r   z#ConstantFolding.visit_ForInStatNodeo  s    4 ==))h	 6 67==##+++ !--dhhbAA(I$6$67)1):):)<&r%   c                     | j                  |       |j                  rL|j                  j                         r2|j                  j                  rd |_        d |_        |S |j                  S |S r'   )r^   r   r  r=   r   r_   s     r#   visit_WhileStatNodez#ConstantFolding.visit_WhileStatNode~  s\    4 >>dnn@@B~~--!%#'   '''r%   c                     | j                  |       t        |j                  t        j                        s|S |j                  j                         ry |S r'   )r^   r(   rb   r   ExprNoder  r_   s     r#   rc   z"ConstantFolding.visit_ExprStatNode  sA    4 $))Y%7%78K99((*r%   c                     | j                  |       |j                  |S |j                  j                         r+|j                  j                  r	d |_        |S |j                  S |S r'   )r^   r   r  r=   r   r_   s     r#   visit_GILStatNodez!ConstantFolding.visit_GILStatNode  s_    4 >>!K>>--/ ~~--!%  yy  r%   r  )2rl   rm   rn   ro   rY   r  r   r   r  r   r  r  r  r  r  r  r2  r  r  r  r  rC  r  r  r  r  r  r  r  r  rt  r  r  r  r  r  r   r?  r9  r	  r  r   r  rc   r  r   rQ  rR  rp   __classcell__)r  s   @r#   r  r    s    %1@ !))9+=+= (()*=*=?O?& 	
 
c ,%8t5*n*6"*	 D.L1> D$LN`":..6 ))==Jr%   r  c                   r    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ddZdej                   fdZy)FinalOptimizePhasea  
    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
        - inject branch hints for unlikely if-cases that only raise exceptions
        - replace Python function calls that look like method calls by a faster PyMethodCallNode
        - replace duplicate FormattedValueNodes in f-strings with CloneNodes
    Fc                 f    | j                  |       |j                  r|j                  }d|_        |S )zaAvoid redundant initialisation of local variables before their
        first assignment.
        T)r^   rG  r   lhs_of_first_assignment)r\   r*   r   s      r#   visit_SingleAssignmentNodez-FinalOptimizePhase.visit_SingleAssignmentNode  s/     	4 ::((C*.C'r%   c                    |j                   }|j                  }|j                  s|j                  r|j                  nd }| j                         }|j                  xs2 |j                  xs$ |j                  xr |j                  j                  }|j                         xr` |j                  xrR |t        j                  uxr> |xr |j                   xr+ | j                  j!                  | j"                  s|rdnd      S )Nz&optimize.unpack_method_calls_in_pyinitzoptimize.unpack_method_calls)r   rE   r   r   r   r   is_module_scopeis_c_class_scopeis_py_class_scopeouter_scoper  r   r
   rM   r   r1  r2  in_loop)r\   r*   r   function_typer   r  in_global_scopes          r#   _check_optimize_method_callsz/FinalOptimizePhase._check_optimize_method_calls  s    == "*"2"2h6K6KQU  H  H""Fs'F'F 	 ! 5%%5!2!225 +5++,5 ##''|| 935		
r%   c                    | j                  |       |j                  }|j                  j                  r|j                  r|j
                  dk(  rt        |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<   |S t        j"                  j%                  |j&                  d      rt        j"                  j)                  |      r|j*                  rm|j,                  rat/        |j0                  t        j2                        r=|j0                  j4                  |j*                  u r|j0                  j4                  |_        | j7                  |t        j"                  j9                  |||j&                  |j                  | j;                  |      	            }|S )
z
        Replace generic calls to isinstance(x, type) by a more efficient type check.
        Replace likely Python method calls by a specialised PyMethodCallNode.
        r(   r   r   rE   PyObject_TypeCheckr  F)
has_kwargs)r   r   rE   unpack)r^   r   rE   is_cfunctionr   r"   rL   r   rC  r   r  r-  r   r	   r  r   r  PyMethodCallNodecan_be_used_for_posargsr   can_be_used_for_functionr\   r   r(   r8   r  r)   r  	from_noder"  )r\   r*   r   r  r  r  s         r#   r  z'FinalOptimizePhase.visit_SimpleCallNode  s   
 	4 ====%%(*:*:}},TYY11D99Q<==00X]]5G5G65Q#'<<#<#<L%1%8%89M%NHN$,NN$7$7HM&0&9&9,:M:Mn:]:b:b&cO#,#5#5diilO#TDIIaL  ))AA$..]bAc--FFxP		h&;&;&x||Y5H5HIhllN^N^bfbkbkNk'/||'7'7<<i.H.H.R.Rx4>>PTPYPY#@@F /S /H ID r%   c                    | j                  |       t        |j                        }t        |j                  t        j
                        }t        j                  j                  |j                  ||      s|S |j                  }t        j                  j                  |      s|S | j                  |t        j                  j                  |||j                  |j                  |j                  | j                  |                  }|S )zW
        Replace likely Python method calls by a specialised PyMethodCallNode.
        )r%  has_explicit_kwargs)r   r   kwdictrE   r&  )r^   r  r  r(   r   r
  r(  r)  r  r   r*  r  r+  rE   r"  )r\   r*   r%  r-  r   s        r#   r  z(FinalOptimizePhase.visit_GeneralCallNode  s     	4 $++,
():):I<N<NO))AA$$Qd B fK==))BB8LK||D)"<"<"F"F8t/C/CDL]L]4#D#DT#J #G #L M r%   c                 (    | j                  |       |S r'   )r^   r_   s     r#   visit_NumPyMethodCallNodez,FinalOptimizePhase.visit_NumPyMethodCallNode  s    4 r%   c                     | j                  |       |j                  s!|j                  j                         sd|_        |S )zRemove tests for alternatively allowed None values from
        type tests when we know that the argument cannot be None
        anyway.
        T)r^   notnoner)   rm  r_   s     r#   r#  z'FinalOptimizePhase.visit_PyTypeTestNode  s5    
 	4 ||88'')#r%   c                 t    | j                  |       |j                  j                         s|j                  S |S )z_Remove None checks from expressions that definitely do not
        carry a None value.
        )r^   r)   rm  r_   s     r#   visit_NoneCheckNodez&FinalOptimizePhase.visit_NoneCheckNode   s0     	4 xx##%88Or%   c                 \    | j                   }d| _         | j                  |       || _         |S )zeRemember when we enter a loop as some expensive optimisations might still be worth it there.
        T)r  r^   )r\   r*   old_vals      r#   visit_LoopNodez!FinalOptimizePhase.visit_LoopNode)  s.     ,,4 r%   c                    | j                  |       d}t        |j                        D ]0  \  }}| j                  ||j                         |j
                  r/|}2 |j                  r |r| j                  ||j                  d       |S )zQAssign 'unlikely' branch hints to if-clauses that only raise exceptions.
        NT)inverse)r^   r   r   _set_ifclause_branch_hintr   branch_hintr   )r\   r*   last_non_unlikely_clauser  r5  s        r#   r9  z#FinalOptimizePhase.visit_IfStatNode2  s     	4 #' %doo6 	5LAy**9innE((+4(	5  8**+CTEUEU_c*dr%   c                 h   |j                   syt        j                  t        j                  t        j                  t        j
                  t        j                  t        j                  f}|g}t        |d      D ]  \  }}t        |t        j                        r|j                  ||j                         =t        |t        j                        r|j                  ||| gt        ||      rt|t        |      k(  r5t        |t        j                   t        j"                  f      r|rdnd|_         y y)z\Inject a branch hint if the if-clause unconditionally leads to a 'raise' statement.
        Nr   likelyunlikely)is_terminatorr   rz  AssignmentNodeAssertStatNodeDelStatNode
GlobalNodeNonlocalNoder   r(   GILStatNoder  r   r   r   rL   RaiseStatNodeReraiseStatNoder;  )r\   clausestatements_noder9  non_branch_nodes
statementsnext_node_posr*   s           r#   r:  z,FinalOptimizePhase._set_ifclause_branch_hint@  s     ,,     
 &&
#,Z#; 	M4$ 1 12!!-;$ 2 23:>**
=7d$45 C
O3
4%J]J]_d_t_tIu8v5<*F&	r%   r*   c                    t         j                  }t         j                  }i }|j                  dd }t	        |j                        D ]  \  }}t        ||      s|j                  }t        |j                  |      r|j                  }n%|j                  n|j                  j                  rng|j                  r|j                         s|j                  |j                  |j                  |j                  xs df}	|j!                  |	|      }
|
|u rt        j"                  |
      }|j$                  |_        |||<    ||j                  dd |S )a  
        Deduplicate repeatedly formatted (C) values by replacing them with CloneNodes.
        It's not uncommon for a formatting expression to appear multiple times in an f-string.

        Note that this is somewhat handwavy since it's potentially possible even for simple
        expressions to change their value while processing an f-string, e.g. by modifying the
        world in a ".__format__" method.  However, this seems unlikely enough to appear in
        real-world code that we ignore the case here.
        NrN  )r   r  r   r   r   r(   r   r)   rq  rE   rC  r   r  r"   rr  rs  rG  r  r   )r\   r*   r  r   r'  r   r  fnodefnode_value_noder;  
seen_fnodededup_fnodes               r#   r  z&FinalOptimizePhase.visit_JoinedStrNode\  sA    '99&99Q!$++. "	$HAue%78${{%++'9:#3#7#7 $$0!&&66  $,,1A1K1K1M
 #((%*=*=u?P?PRWRgRgRnknoCe4JU"#--j9K#iiKO#F1IE"	$H  Ar%   Nr  )rl   rm   rn   ro   r  r  r"  r  r  r0  r#  r4  r7  r9  r:  r   r  r  re   r%   r#   r  r    sR     G
*<&
	84	(?(? 4r%   r  c                        e Zd ZdZdZd Zd Zy)ConsolidateOverflowChecka5  
    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.
    Nc                     | j                   -| j                   }d | _         | j                  |       || _         |S | j                  |       |S r'   )overflow_bit_noder^   )r\   r*   saveds      r#   rp   z#ConsolidateOverflowCheck.visit_Node  sS    !!-**E%)D"t$%*D"  t$r%   c                     |j                   rX|j                  rL| j                  d u }|r|| _        n| j                  |_        d|_         | j                  |       |rd | _        |S | j                  |       |S r3   )overflow_checkoverflow_foldrV  r^   )r\   r*   top_level_overflows      r#   visit_NumBinopNodez+ConsolidateOverflowCheck.visit_NumBinopNode  sz    4#5#5!%!7!74!?!)-&)-)?)?&&+#t$!)-&  t$r%   )rl   rm   rn   ro   rV  rp   r\  re   r%   r#   rT  rT    s     r%   rT  re   )Gcythondeclarer  r   r   r   r   	functoolsr   r   r~   r   r  r   r   r   r   r  r  r  r   r	   r   r
   r   r   Coder   r   StringEncodingr   r   r   Errorsr   r   ParseTreeTransformsr   r   r$   r   r6  r,   r1   r7   r>   r  rT   rX   rV   rt   rr   EnvTransformrz   r  rQ  rT  rc  r  NodeRefCleanupMixinr  MethodDispatcherTransformr   r  r!   r  r9  r  r  CythonTransformrT  re   r%   r#   <module>rh     s~     .6 . .v .^d ..'-.:@.JP..)/.7=. .  &. /5. AG. TZ. 	. '-	. 
    %   23<         1 H H " 1 7 /8.J.JILjLj-k #$t #$L'-- @t-- tn!y>g** y>xF>W557G F>Rq&w77 q&hCw33 CL44g6J6J DvT766"<<vTr?B:J "9!8!89Lo!^ 6{667H/Z s>g..0@ s>l`--w/J/J `F w66  r%   