
    Aex5                       d dl mZ d dlZd dlZd dlZd dlZd dlZddlmZ ddl	m
Z
 d dlZ ej                  eeeeeeeeee
       ej                  d    dk\  reZeefZneefZeefZddlmZ dd	lm	Z	 dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZmZ ddlm Z m!Z!m"Z" ddl#m$Z$m%Z% ddl&m'Z' 	 d dl(m)Z) 	 d dl(m,Z, d Z-e	j\                  e	j^                  ffdZ0d Z1d Z2d Z3 G d dejh                        Z5d Z6d Z7 G d dejp                        Z9 G d  d!ejp                        Z: G d" d#ejv                  e'      Z< G d$ d%ejv                        Z= G d& d'ejp                        Z> G d( d)ej~                  ejp                        Z@ G d* d+ej~                  ej                        ZB ej                  d,d-      ZD ej                  d.d-      ZE ej                  d/d-      ZF G d0 d1ejv                  e'      ZG G d2 d3ejp                  ej~                        ZH G d4 d5ej                        ZJy# e*$ r
 d dl+m)Z) Y w xY w# e*$ r eZ,Y w xY w)6    )absolute_importN   )	TypeSlots)not_a_constant)
UtilityCodeEncodedStringbytes_literalencoded_stringNodes	ExprNodes
PyrexTypesBuiltin	UtilNodes_py_int_types   )r   )r   )r   )Visitor)r   )r   )Options)r   TempitaUtilityCode)r   r	   r
   )errorwarning)SkipDeclarations)reduce)
basestringc                 .    t        j                  | d      S )N
Optimize.c)r   load_cached)names    8lib/python3.12/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'   3   s    $'xxKr    c                     t        | t        j                        r'| j                  } t        | t        j                        r'| S r"   )r#   r   ResultRefNode
expressionr%   s    r   unwrap_noder,   9   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)
r,   r#   r   NameNoder   AttributeNode
is_py_attris_common_valueobj	attribute)abs     r   r2   r2   ?   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_resultr+   s    r   filter_none_noder9   I   s    D008Kr    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   r>   z_YieldNodeCollector.__init__S   s&    $$T* "r    c                 \    | j                   j                  |       | j                  |       y r"   )r@   appendvisitchildrenrA   r%   s     r   visit_YieldExprNodez'_YieldNodeCollector.visit_YieldExprNodeZ   s$    %4 r    c                     | j                  |       |j                  | j                  v r|| j                  |j                  <   y y r"   )rD   exprr@   r?   rE   s     r   visit_ExprStatNodez&_YieldNodeCollector.visit_ExprStatNode^   s;    4 99(((/3D!!$)), )r    c                      y r"    rE   s     r   visit_GeneratorExpressionNodez1_YieldNodeCollector.visit_GeneratorExpressionNodee       r    c                      y r"   rK   rE   s     r   visit_LambdaNodez$_YieldNodeCollector.visit_LambdaNodeh   rM   r    c                      y r"   rK   rE   s     r   visit_FuncDefNodez%_YieldNodeCollector.visit_FuncDefNodek   rM   r    N)__name__
__module____qualname____doc__r>   r   r=   rD   
visit_NoderF   rI   rL   rO   rQ   rK   r    r   r;   r;   O   s8    
 $$22J!4r    r;   c                 @    t        |       }t        |      dk7  ry|d   S )Nr   )NNr   )_find_yield_statementslen)r%   yield_statementss     r   _find_single_yield_expressionr[   o   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"   )r;   rD   r@   r$   r?   KeyError)r%   	collector
yield_noderZ   s       r   rX   rX   v   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 ej                  ej                   ej                  dej                  d      g      Z ej                  ej                   ej                  dej                  d      g      ZddZ ej                  ej$                   ej                  d	ej&                  d       ej                  d
ej(                  d       ej                  dej                  d      g      Z ej                  ej&                   ej                  dej,                  d       ej                  dej.                  d       ej                  d
ej0                  d       ej                  d	ej2                  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j.                  d       ej                  dej2                  d      g      Z" ej                  ej,                   ej                  dej,                  d       ej                  dej&                  d       ej                  dej.                  d       ej                  dej2                  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==)operatoroperand1operand2r   valuelhsrhsstats	conditionbody)
if_clauseselse_clause)sequencer   )targetiteratorrp   rr   tempsrp   not_inoperand)is_ptr_containsposr   r)   rf   is_subscriptbasetype	base_type
TempHandlerefr   PrimaryCmpNodere   r   StatListNodeSingleAssignmentNodeBoolNodeBreakStatNode
IfStatNodeIfClauseNodeTempsBlockNodeForInStatNodeIteratorNodeanalyse_expressionscurrent_envvisitTempResultFromStatNoderd   NotNoderD   )rA   r%   r|   
result_refr   target_handlert   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 //edmmfNH((33CZYM_M_`cklMmn,,S134G &&!..shWUV "G !//&**!&33DMM4E4EPTP]P]^  % : :3JT]TfTfgjrsTt uwxH  33D4D4D4FGHzz(+H 77
HMH}}($,,S(CO t$Kr    c                 p    | j                  |       | j                  ||j                  j                        S r"   )rD   _optimise_for_loopru   rs   rE   s     r   visit_ForInStatNodez&IterationTransform.visit_ForInStatNode   s-    4 &&tT]]-C-CDDr    c                    d }|j                   s|j                  r|j                  r|j                  j                  r|j                  j                  }|j                  r|j
                  }|j                   r|j                  r*|j                  j                  dk(  rt        j                  }n|j                  dk(  rt        j                  }|j                  r)|j                  j                  dv rt        j                  }n|j                  dv rt        j                  }t        j                  |j                  |fv r|r|S | j                  ||d dd      S t        j                  |j                  |fv st        j                  |j                  |fv r|r|S | j                  ||      S |j                  j                  s|j                  j                   r| j#                  |||      S |j                  t        j$                  u r| j'                  |||      S |j                  t        j(                  u r| j+                  |||      S t-        |t.        j0                        s|S |j2                  2|j4                  xr t7        |j4                  j2                        xs d	}n(t7        |j2                        }|r|j8                  |d
z  }|j:                  }|j                  r	|s|s|j8                  xs |j<                  }|j>                  }	| jA                         jB                  jD                  dk\  }
|
si|	dv ret-        |t.        jF                        rK|j:                  }|j                   r3|j                  dk(  r$|j                  r|j                  jH                  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 |j8                  x|j                   rl|j                  r`|j                  jH                  rJ|j                  dk(  r|r|S | jK                  ||      S |j                  dk(  r|r|S | jM                  ||      S tN        jP                  r_d
|cxk  rdk  rSn |S |j8                  B|j                   r5|j                  dv r&|j                  r|j                  jH                  r|jR                  j                  jT                  s |jR                  j                  jV                  r| jY                  |||      S |jR                  j                  jZ                  r|j2                  |j4                  j2                  n|j2                  D ]I  }t-        |t.        j\                        r+|j_                         rd|j`                  cxk  rdk  rn  |S H |S  | jY                  |||      S |S )Nztyping.DictDict)z
typing.Setztyping.FrozenSet)Set	FrozenSetTF)dict_objmethodkeysvaluesreversedr   r   r   )r   r   itemsdictiterkeysr   
itervaluesr   	iteritemsr   	enumerater   )rangexrange      @)1is_nameis_attributeentry
annotationr}   r~   qualified_namer   	dict_typer   set_typer   _transform_dict_iterationfrozenset_type_transform_set_iterationis_ptris_array_transform_carray_iteration
bytes_type_transform_bytes_iterationunicode_type_transform_unicode_iterationr#   r   SimpleCallNodeargs	arg_tuplerY   rA   functionr3   r4   global_scopecontextlanguage_levelCallNode
is_builtin_transform_enumerate_iteration_transform_reversed_iterationr   convert_rangert   is_intis_enum_transform_range_iterationis_pyobjectIntNodehas_constant_resultr8   )rA   r%   iterabler   annotation_typer   	arg_countr   base_objr   is_safe_iterinner_functionr   r   r$   s                  r   r   z%IterationTransform._optimise_for_loop   s"    5 58>>hnnNgNg!22J&&'__
!!##
(8(8(G(G=(X&-&7&7O__.&-&7&7O##
(8(8(G(GKm(m&-&6&6O__(<<&-&6&6O @@11x4 2 O O  @@&&8==/*JJ00x@@ ==8==#9#933D(X3VV==G...224H2UU==G00044T8h4WW (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\:]]r    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   rY   r   r|   r   r   
tuple_type	list_typeas_none_safe_noderu   rs   r   r   )rA   r%   reversed_functionr   r$   s        r   r   z0IterationTransform._transform_reversed_iteration2  s     **//t9>#''<>KY]#''79K1g 88**G,=,=>>%(%:%:;^%_DMM"%)DMM"K&&tS4&@@r    sNc                    |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 )	N'NoneType' is not iterablePyBytes_AS_STRINGr   r   is_tempPyBytes_GET_SIZEr   )r~   startstepstopr   r   r   )rt   r   r   r   r   r   
LetRefNoder   r   PythonCapiCallNoder|   PyBytes_AS_STRING_func_typePyBytes_GET_SIZE_func_typeLetNoder   SliceIndexNode)rA   r%   
slice_noder   target_typeunpack_temp_nodeslice_base_nodelen_nodes           r   r   z-IterationTransform._transform_bytes_iterationP  s   kk&&!!k9K9K&K K$//(()EFH $66NN/,,$%	 //NN.++$%	   ,,((NN* #*// $ - %& 	&r    kinddataindexlength-1exception_valuec                 
   |j                   r	 t        |j                  j                  d      d      }t	        j
                  |j                  t	        j                  |j                  ||t        j                        j                  t        j                  | j                               d t	        j                  |j                  t        t        |            t        |      t        j                         t"        j$                        }| j'                  |||      S t+        j,                  |j/                  d            }t	        j                  |j                  ddt        j                         }t+        j0                  t        j                         }|j3                  |j                        }	|r
d\  }
}|	|}	}nd	\  }
}t+        j0                  t        j4                        }t+        j0                  t        j6                        }t+        j0                  t        j                         }t	        j8                  |j                  d
| j:                  |j3                  |j                        |j3                  |j                        |j3                  |j<                  j                        gd      }|j>                  |j<                  j>                  k7  r4|j                  |j<                  j>                  | j                               }tA        jB                  |j<                  j                  |j<                  |      }tA        jD                  |j                  ||jF                  g      }tA        jH                  |j                  ||
|j3                  |j<                  j                        ||	d ||jJ                  d
      }tA        jL                  |j                  t	        j8                  |j                  d| jN                  |t	        jP                  |j                  |j3                  |j                        t        jR                        t	        jP                  |j                  |j3                  |j                        t        jT                        t	        jP                  |j                  |j3                  |j                        t        jV                        gddtY        jZ                  dd                  }t+        j\                  |t+        j^                  |j                  ||||gtA        jD                  |j                  ||g                  S # t(        $ r Y Fw xY w)Nlatin1z	iso8859-1rh   r8   r   )r~   r   r   r   r   0r   >>=<=<__Pyx_PyUnicode_READFr   r|   rj   rk   rl   T	bound1	relation1rt   	relation2bound2r   rp   rr   
from_range__Pyx_init_unicode_iterationrz   r   unicode_iterr   )r   r   result_is_usedutility_coderH   rv   )0
is_literalr	   rh   encoder   r   r|   	BytesNoder   c_const_char_ptr_type	coerce_toc_const_uchar_ptr_typer   r   strrY   c_py_ssize_t_typer   r   r   UnicodeEncodeErrorr   r   r   r   r   
c_int_typec_void_ptr_typer   PyUnicode_READ_func_typert   r   r   r   r   rp   ForFromStatNoderr   ExprStatNode init_unicode_iteration_func_typeAmpersandNodec_py_ssize_t_ptr_typec_void_ptr_ptr_typec_int_ptr_typer   r   r   r   )rA   r%   r   r   bytes_valuebytes_slicer   
start_nodelength_tempend_noder
  r  	kind_temp	data_tempcounter_temptarget_valuetarget_assignrp   	loop_node
setup_nodes                       r   r   z/IterationTransform._transform_unicode_iteration  sC     U+J,<,<,C,CH,M{[ (66NN",,"k(3'==? @Iy&==t?O?O?Q@S"**"c#k2B.C(+K(8'99; !-- 77k8TT$//(()EFH &&HHC9U9UW
**:+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$++2B2B262B2B2DFL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c & s   %U 	U%$U%c                    d}t        |t        j                        ri|j                  }t	        |j
                        }t	        |j                        }d }|sr|j                  j                  st        |j                  d       |S |j                  r\t        |j                  t        j                        sJ |j                  }|j                  }	t	        |	j
                        }t	        |	j                        }t	        |	j                        }|rt        |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                  t$        j&                  t)        t+        |
            t+        |
            }n|j                  j,                  r|j                  j.                  t        |j                  d       |S |}d }t        j"                  |j                  t)        |j                  j.                        t$        j&                  |j                  j.                        }d }n.|j                  j                  st        |j                  d       |S |r.|j1                  t$        j&                  | j3                               }|r.|j1                  t$        j&                  | j3                               }|L|r2t        j"                  |j                  dt$        j&                  d      }nt        |j                  d       |S |r7|s1t        j"                  |j                  d	dt$        j&                  
      }||}}|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                  ry|jB                  j                  j                  rX|j                  tF        jH                  u rt        jJ                  t        jL                  |jB                  j                  ||jN                        t$        jP                        j1                  |jB                  j                  | j3                               }nrt        j                  |jB                  j                  t        j"                  |jB                  j                  d	dt$        jR                  
      t        j"                  |jB                  j                  ddt$        jR                  
      |tF        jT                  d      }n|jB                  j                  jV                  r2|jB                  j                  jY                  |jN                        s|}npt        jZ                  |jB                  j                  t        j"                  |jB                  j                  d	dt$        jR                  
      ||jN                        }|j                  |jB                  j                  k7  r4|j1                  |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 indexr   rh   r8   rh   r   r8   r   r   r   +re   rd   rf   r   r  1r   )r   r   r~   r   r   )r   r~   r   r  rl   Tr  rv   )6r#   r   r   r~   r9   r   r   r   r   r   r|   r}   r   	SliceNoder   r8   r   r   r   r  r  absr   sizer  r   element_ptr_typecoerce_to_simpleAddNode	CloneNoder   r   r   rt   	is_stringr   r   CastNodeDereferenceNoder   c_py_ucs4_typer  r   r   assignable_from	IndexNoder   r   r   rp   _find_for_from_node_relationsr   rr   r   )rA   r%   r   r   neg_step
slice_baser   r   r   r   
step_valueptr_type
carray_ptrstart_ptr_nodestop_ptr_nodecounterr.  r/  r0  rp   r
  r  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F..!3..24..25%??66dhh(bcK "&!5!5J&0[
)A~H$,,TXXJ<X<X36s:3G=@_ND __%%##+jnn&RS#JE$$c*//*>*>&?11:??CWCWYD D ??..jnn&RSKOOJ$@$@$BRBRBTUE>>*">">@P@P@RSD< ((NN$Z5Q5Qceg jnn&`a!))*..VW/9/K/KM 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#++DKKOO3<=1;1F1FH #**4;;??#;<0:0E0EG & ++
  [[$$T[[-=-=-M-MhN`N`-a'L %..''s89-7-B-BD "'')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                  d|d      }t        j                   |      }	t        j"                  |j                  |	t        j                  |j                  d|d      d	||j                  
      }
t%        j&                  |j                  ||	      t%        j&                  |j                  |	|
      g}t)        |j*                  t$        j,                        r)||j*                  j.                  z   |j*                  _        nK|j1                  |j*                         t%        j,                  |j*                  j                  |      |_        ||_        |j2                  j                  |j                  | j                               |_        |d   |j4                  _        t        j8                  |	| j;                  ||j4                  j6                              S )Nr   z)enumerate() requires an iterable argument   z%enumerate() takes at most 2 argumentsr   r   r5  r9  r7  )re   rf   rd   r   r   r  rl   )r   r   rY   r   r|   rt   is_sequence_constructorr   r   r   r'   r  r   r   r   r   r   r?  r   r   r#   rp   r   rm   rC   itemru   rs   r   r   )rA   r%   enumerate_functionr   targetsenumerate_targetiterable_targetcounter_typer   tempinc_expression	loop_bodys               r   r   z1IterationTransform._transform_enumerate_iteration  sv   !++00t9>$((=?KY]$((9;K{{22K++""w<1K,3)/',,''0C0CKt9>'Q0::<IYIYI[\E%%&8&<&<,/+7679E ##E*"**"" ((.:9:< "..
 &&&**& &&&**$&		 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  rK   )rA   neg_step_valuer   s      r   rG  z0IterationTransform._find_for_from_node_relations  s        r    c                    |j                   j                  }t        |      dk  r'|j                  }d}t	        j
                  |dd      }na|d   }|j                  }t        |j                  t              s|S |j                  }|dk(  r|S t	        j
                  |t        |      |      }t        |      dk(  rEt	        j
                  |j                  d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                  t        |      |t        j                  |j                   |	j                               }n)t#        j$                  |	      }| j'                  ||||      }|dk  r| }t        |      |_        ||_        |j                  | j                               }|	j*                  sd	}|xs t#        j$                  |	      }	nd
}t-        j.                  |j                  |j0                  ||
||	||j2                  |j4                  d	
      }|j7                  | j                                |rt#        j8                  |	|      }|S )Nr   r   r9  rh   r8   rR  r   r   r   TF)	rt   r	  r
  r  r  r   rp   rr   r  )r   r   rY   r|   r   r   r#   r8   r   r  coerce_to_integerr   rG  r;  r   spanning_typer   r   r   _build_range_step_calculationrh   r  r   r   rt   rp   rr   set_up_loopr   )rA   r%   range_functionr   r   step_posrJ  r   r	  r  r
  r  bound2_ref_nodeabs_stepbegin_value	end_valuebound1_valuebound2_is_temprP  s                      r   r   z-IterationTransform._transform_range_iteration  s3   '',,t9q=%))HJ$$XS!LD7DxxHd22MB--JQ$$XS_5?AD t9>&&~'9'978:F!W..t/?/?/ABF!W..t/?/?/ABF!W..t/?/?/ABF#AA*q.RZ[	9#VFF:H1}v55}E"6#9#9=I!A~&,&<&<$*$:$:	'2X+PYBY\]B]bjAj5k'kno'o&,&<&<$*$:$:	'08i@WZ[@[`h?h3i'ilm'm&..

#l*;\'55fkk6;;OQF
 '0&:&:6&BO!??zCF >$J_
)%%d&6&6&89  !N$D	(<(<V(DF"N((HH;;YDII(( 	T--/0 ((:Hr    c                    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                  t        |      ||      dt        j                  |j                  t        j                  |j                  t        j                  |j                  |d|	|      dt        j                  |j                  dd	
      |      dt        j                  |j                  t        |      ||      |      |      |      |
t        j                  |j                  dd	
      |      }|S )Ni  r   -r7  r   *r8  r9  r   r`  z//)r;  r   rb  r   r   r  r   
binop_noder|   MulNoder   r  DivNodeSubNode)rA   r	  rg  r   rJ  rh  rb  spanning_step_typeri  rj  final_opstep_calculation_nodes               r   rc  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&..

!(m(0/	1
 !&..

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

)4),)2%2&4 &)%.%6%6 &

&)01&3 "4"5 "&!*!2!2"JJ"%h-,4!3	"5
 0-1. ,?-@ (I$)J &&

 !# Y,! Z %$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 |rWt!        j2                  |j                  d|      }|j5                  dj7                  t        |      dk  rd	nd
      d|g      }n0t!        j8                  |j                        }|j5                  d      }fd}t        j:                  j                  |	t!        j<                  j                  dd            t        j:                  |j                  |t!        j>                  |j                  d| j@                  tC        jD                  dd      | ||j&                  tF        jH                  u       |||gd            t        jJ                  j                  d |jL                        g}t        jN                  j                  |t        j                  j                  |            S )NrR  r|   rm   r  r   T)is_identifierrh   *'NoneType' object has no attribute '%{0}s'   .30 PyExc_AttributeErrorr   format_argsr   c                 n    | xr dxs d} t        j                  j                  t        |       |       S Nr   r   r`  r   r   r|   r  rh   r%   s    r   	flag_nodez?IterationTransform._transform_dict_iteration.<locals>.flag_node  /    Ka$1E$$TXXSZQVWWr    r   r`  ri   __Pyx_dict_iterator	dict_iterr   r  r   r   ro   rp   rr   rl   rv   )(r   r   r   py_object_typerC   r   r|   r  rt   rS  rY   r   r#   rp   r   r   r   r#  
c_ptr_typer   r  DictIterationNextNoder   r   rm   
StringNoder   formatNullNoder   r   r   PyDict_Iterator_func_typer   r   r   r   WhileStatNoderr   r   )rA   r%   r   r   r   r   rw   rZ  	dict_temppos_temp
key_targetvalue_targettuple_targetrp   dict_len_tempdict_len_temp_addris_dict_tempis_dict_temp_addriter_next_nodemethod_noder  result_codes    `                    r   r   z,IterationTransform._transform_dict_iterationn  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#..D@K11<CCSQW[\^M^Edfg.%h 2 (H
 $,,X\\:K112UVH	X
 &&''89;<
 &&22LL)22#.#:#:;#U$iARAR0R&S');=N !	  "..	'6 ''HHE### 	r    r   is_dictmethod_namep_orig_length	p_is_dictset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 fd}t        j,                  j                  |t        j.                  j                  dd            t        j,                  |j                  |t        j0                  |j                  d| j2                  t5        j6                  d	d
      | ||j                  t8        j:                  u       |	|gd            t        j<                  j                  d |j>                        g}t        j@                  j                  |t        j                  j                  |            S )Nrx  r  r   c                 n    | xr dxs d} t        j                  j                  t        |       |       S r  r  r  s    r   r  z>IterationTransform._transform_set_iteration.<locals>.flag_node  r  r    r   r`  ri   __Pyx_set_iteratorset_iterr   Tr  r  rl   rv   )!r   r   r   r  rC   r   r|   r  r#   rp   r   r   r   r#  r  r   r  rt   SetIterationNextNoder   r   rm   r   r   r   PySet_Iterator_func_typer   r   r   r   r  rr   r   )rA   r%   set_objrw   rZ  set_tempr  rp   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	X
 &&%%dhhc1MO &&00KK(11!,!8!8\!R!9W\\W=M=M-M#N+-= !	  ,,	%4 ''HHE### 	r    F)%rR   rS   rT   rU   r   r   r   r   r   	CFuncTypec_char_ptr_typeCFuncTypeArgr   r   r   r  r   r   rD  r  r  r  r  r$  r%  r&  r"  r   r   r   rG  r   rc  r   r  r  r   rK   r    r   ra   ra      s
   /bEpdA( #7*"6"6""#J##C););TB%#
 "6!5!5$$#J##C););TB'"
$&L  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	 
 ( $ZSxbHG^R
!Qf>%@aF !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	$ Er    ra   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                    	 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                        r~|j                  | j                  S |j                         rt        |j                  t        j                   t        j"                  f      r|j$                  dk(  }|r|s| j                  S t        |j                  t        j                         r&|j                  j'                         r| 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                  j0                  r||j(                  |j                  gfS t3        |j                  dd       r:|j                  j4                  j6                  r||j(                  |j                  gfS t/        |j                  |j                        r|j(                  j0                  r||j                  |j(                  gfS t3        |j(                  dd       r:|j(                  j4                  j6                  r||j                  |j(                  gfS | j                  S t        |t        j8                        r|j$                  dk(  s|r}|j$                  dk(  rn|j$                  dk(  }| j;                  |j(                  |      \  }}}| j;                  |j                  |      \  }}}	|||k(  rt/        ||      r|r|r||||	z   fS | j                  S )	NTrx   rc   F!=r   orand)r#   r   CoerceToTempNodeCoerceToBooleanNoder$   BoolBinopResultNoder   EvalWithTempExprNodesubexpressionTypecastNoderz   r   cascadeNO_MATCHis_c_string_containsrf   UnicodeNoder  rd   contains_surrogatesre   extract_in_string_conditionsis_python_comparisonr2   r  getattrr   is_constBoolBinopNodeextract_conditions)
rA   condallow_not_inrx   not_in_1t1c1not_in_2t2c2s
             r   r  z"SwitchTransform.extract_conditions2  s   $!;!;!*!>!>!@ AxxD)"?"?@xx||D)"@"@A))D)"8"89||  dI445||'}}$**,dmmi.C.CYEXEX-YZ(2,==(dmmY-B-BC}}88:  ==(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                 J   t        |t        j                        rut        t	        t
        t        |j                                    }|j                          |D cg c]-  }t        j                  |j                  t        |      |      / c}S |j                  }t        t        t        t        |            D cg c]
  }|||dz     c}            }|j                          |D cg c]$  }t        j                  |j                  ||      & c}S c c}w c c}w c c}w )Nr`  r   )r#   r   r  listmapordr  rh   sortr   r|   r  r   rY   CharNode)rA   string_literalcharvalscharval
charactersis         r   r  z,SwitchTransform.extract_in_string_conditionso  s    ni&;&;<CS)=)=%>?@HMMO %-/  &&~'9'9W7>@ / / (--JcuS_?U"W!Jq1$5"WXYJOO %/1  ''(:(:'8?A 1 1/ #X1s   2D<D*)D 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  r2   r   r   r   sum)rA   
common_varro   r  rx   var
conditionsr  s           r   extract_common_conditionsz)SwitchTransform.extract_common_conditions  s    "&"9"9)\"RZ;== #OC,L== ((//SXX%5%5#  xB  ?CosDIIDTDTDiX\XaXaXiXi?j  ?C  ;D== sJ&& ?Cs   46Cc                 @   t               }|D ]  }|j                         r,|j                  |v r y|j                  |j                         ?	 |j                  j
                  |v r y	 |j                  |j                  j
                          y# t        $ r Y  yw xY w)NTF)r  r   r8   addr   cnameAttributeError)rA   condition_valuesseenrh   s       r   has_duplicate_valuesz$SwitchTransform.has_duplicate_values  s    u% 	,E((*((D0../ {{((D0# 1 **+	,  &   s   B	BB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  rp   rR  rr   rp   r|   testcasesrr   )current_directivesgetrD   rq   r  ro   rC   r   SwitchCaseNoder|   rp   r  rY   r  r,   SwitchStatNoderr   )rA   r%   r  r  	if_clause_r  caser  r  switch_nodes              r   visit_IfStatNodez SwitchTransform.visit_IfStatNode  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  TrR  )
r  r  rD   r  r  rY   r  build_simple_switch_statementtrue_val	false_valrA   r%   rx   r  r  s        r   visit_CondExprNodez"SwitchTransform.visit_CondExprNode  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d      t        j                  |j                  dd            S Nr  TrR  r`  F)r  r  rD   r  rY   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&txxtTJtxxueLN 	Nr    c                    | j                   j                  d      s| j                  |       |S | j                  d |d      \  }}}|t	        |      dk  s| j                  |      r| j                  |       |S | j                  ||||t        j                  |j                  dd      t        j                  |j                  dd            S r  )
r  r  rD   r  rY   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&txxtTJtxxueLN 	Nr    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rj   rk   firstr  r  )r   r)   r   r   r|   r  r   r   r  r,   r  r   )rA   r%   r  r  rx   r  r  r   	true_body
false_bodyr  r  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  )r  r  rD   r  	lazy_tempr   tree_contains)rA   r%   	orig_exprtemp_refs       r   visit_EvalWithTempExprNodez*SwitchTransform.visit_EvalWithTempExprNode  s    &&**+@At$K &&	>>4 Y.((););XF)))r    N)rR   rS   rT   rU   r  r  r  r  r  r  r  r  r   r  r  r   VisitorTransformrecurse_to_childrenrV   rK   r    r   r  r  *  sW    
 "H;z1$'&$L+"N&N$: ))==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                 
   | 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                  }t        |      dk(  rS t        |D cg c]  }|j                   c}      rS t        j                  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 # t"        $ r d}Y w xY w)Ninr  rc   rx   r  r  r   F)r|   re   rd   rf   r  )r|   rz   r   c                 J    t        j                  j                  | |      S )N)r|   rd   re   rf   )r   r  r|   )leftrightconjunctionr%   s     r   concatz;FlattenInListTransform.visit_PrimaryCmpNode.<locals>.concate  s&    **&*hh+6+/+0	2 2r    r6  )rD   r  rd   r#   rf   r   	TupleNodeListNodeSetNoder   rY   any
is_starredr   r)   re   	is_simple	Exceptionr   rC   r   r|   r  r   c_bint_typer   r  )rA   r%   	eq_or_neqr   r$   rj   condsrw   is_simple_argr  r  ro   r   rZ  r  s    `            @r   r   z+FlattenInListTransform.visit_PrimaryCmpNode/  s   4 <<#K]]d"KI]]h&KIK$--)*=*=*3*<*<*3*;*;*= > K}}!!t9>K$/3/0K%%dmm4 	@C&
 !$ !**3/S!++&*hh+.+4+.*.0D LL//&*hh*.'1'='=? @'	@.	2 65)	11#yA$B$K 	FD 55dHEH	FU 0  & %&s    G/G44HHN)	rR   rS   rT   rU   r   r   r  r  rV   rK   r    r   r  r  )  s!    
AF ))==Jr    r  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)rm   r#   r   r   _extract_operandrj   rk   CascadedAssignmentNoder  rY   _extract_index_idrC   r$   use_managed_ref)rA   r%   
left_namesright_namesleft_indicesright_indicesrw   statpathnlnamesrnameslindiceslhs_nodeindex_idrindicesrhs_nodet	temp_argsrZ  r  	name_node
index_nodes                          r   visit_ParallelAssignmentNodez5DropRefcountingTransform.visit_ParallelAssignmentNodez  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.r6  T)r,   r   r   r#   r   r  rC   r$   r   r1   memberr3   r   r   joinr}   r~   r   r   r   r   )rA   r%   namesindicesrw   	name_pathobj_nodes          r   r,  z)DropRefcountingTransform._extract_operand  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   r/   r   	ConstNode)rA   rA  r~   r   	index_vals        r   r.  z*DropRefcountingTransform._extract_index_id  sT      eY//0

Iy223		9%%r    N)rR   rS   rT   rU   r   r  r  rV   rB  r,  r.  rK   r    r   r*  r*  u  s)    ))==JCJ:
&r    r*  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"   )rD   r   _function_is_builtin_name_dispatch_to_handlerr   )rA   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"   )
rD   r   rQ  positional_argsr#   r   r  r   rR  keyword_args)rA   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   lookupr   builtin_scopelookup_here)rA   r   envr   s       r   rQ  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  )rA   r%   r   r   kwargshandler_namehandle_calls          r   rR  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r  )r   PythonCapiFunctionNoder   r|   r   )rA   r%   r  	func_typer  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|   rY   rA   function_namer%   r   expectedarg_strexpected_strs          r   _error_wrong_arg_countz/EarlyReplaceBuiltinCalls._error_wrong_arg_count'  n    G*-A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.0rg   r   floatr   r   )
r   	FloatNoder|   rY   ro  r  r   c_double_typer   
float_type)rA   r%   pos_argsarg_types       r   _handle_simple_function_floatz6EarlyReplaceBuiltinCalls._handle_simple_function_float9  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   rR  r   slice)r   r   r   )rY   ro  r   r:  r|   NoneNode)rA   r%   rw  r   r   r   r   s          r   _handle_simple_function_slicez6EarlyReplaceBuiltinCalls._handle_simple_function_sliceC  s    M	>ED!^"KE4!^ (E4''x@K""HH79--dhh75++DHH5	7 	7r    c           	         t        |      dk7  r|S |d   }t        |t        j                  t        j                  f      rzt        |j
                        dk(  r`t        j                  |j                  t        j                  t        t        |j
                              t        |j
                              S |S t        |t        j                        r|j                  rt        |j                        dk(  rxt        |j                        dk  r`t        j                  |j                  t        j                  t        t        |j                              t        |j                              S |S )zUnpack ord('X').
        r   r   r4     )rY   r#   r   r  r  rh   r   r|   r   c_long_typer  r  r  unicode_valuer  )rA   r%   rw  r$   s       r   _handle_simple_function_ordz4EarlyReplaceBuiltinCalls._handle_simple_function_ordU  s    x=AKqkcI1193F3FGH399~" ((GG*"8"8c#))n-$'		N   Y112  S):):%;q%@C--.#5 ((GG*"7"7c#"3"345$'(9(9$: 
 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rA   r%   rw  s      r   _handle_simple_function_allz4EarlyReplaceBuiltinCalls._handle_simple_function_alln  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                 6   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   ry   r`  rg   rn   )rr   rq   r!  all)gen	orig_func)rY   r#   r   GeneratorExpressionNodedef_nodegbodyrp   r[   r   r|   r   r   r   ReturnStatNoder   rr   r   recursively_replace_nodeInlinedGeneratorExpressionNode)rA   r%   rw  is_anygen_expr_nodegenerator_bodyr1  yield_expressionyield_stat_nodero   	test_nodes              r   r  z+EarlyReplaceBuiltinCalls._transform_any_all  s|   x=AK(1+y'H'HIK &//55"''	,I),T)/#K(I!))*:*>*>HXYI$$  d""$(('--'001A1E1EVekln@	
	 !& 4 4HH$$%5%9%9Vag]gh!j	 	((S77=VEX 	XQVX 	Xr    itc                    t        |      dk7  r|S |d   }t        |t        j                        r/|j                  t
        j                  u r|d   }|j                  }nt        |t        j                        r|}|j                  }t        |      }|s|S t        j                  |j                  |dt
        j                        }|D ]H  \  }}	t        j                  |j                  ||j                        }
t        j                  ||	|
       J nO|j                   r|j#                         x}}n0t        j$                  |j                  d| j&                  |d      x}}t)        j*                  |j                  t
        j                  d	
      }t-        j.                  |j                  ||d      }t        j0                  |j                  |t3        d      d	      }t-        j4                  |j                  t        j6                  |j                  |g             }|j9                  | j;                                t)        j<                  |t-        j>                  |j                  ||g            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   sortedr  comprehension_typerH   rt   PySequence_ListTr   F)r|   r   may_hold_noner  r  )r3   r4   needs_none_checkr   r   r  rl   ) rY   r#   r   ComprehensionNoder   r   r   loopr  rX   r  r|   ComprehensionAppendNodert   r   r  rS  as_listr   PySequence_List_func_typer   r)   r   r   r0   r   r!  r   analyse_declarationsr   r   r   )rA   r%   rw  r$   	list_noder1  r  rZ   r  r  append_noderesult_nodelist_assign_nodesort_method	sort_nodes                  r   _handle_simple_function_sortedz7EarlyReplaceBuiltinCalls._handle_simple_function_sorted  s-    x=AKqkc9667CHHHYHY<Y I!IY>>?M%**I5i@#!@@-8#*#4#46I 6F ^1 /'??$(()$++- 00Q\]^ (( %(KKM1I	
 %.$@$@+T-K-Kt%- -I	  --G$5$5UL 55HH+9DB  --HH+v1F"$ &&HH933;R9:	 	&&t'7'7'9://txx0@)/LMO 	Or    c           
      N   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                  dd      }n|d   }t        j                   |j                  t"        j$                        }t'        j(                  |j                  |t        j*                  |j                  d||      	      }	t-        j.                  |||	       t'        j0                  |j                  t'        j(                  |j                  t        j                   |j                  |
      |d      |g      }
t        j2                  |j                  |
||j4                  d|j6                        S # t        $ r |cY S w xY w)zLTransform sum(genexpr) into an equivalent inlined aggregation loop.
        r   rR  r   Nr   r   r`  )r|   r   r7  ri   )r|   r*   Tr  rl   r  )r  r  
expr_scoper  has_local_scope)rY   r#   r   r  r  r  r[   rC   rH   r  r   r   r  r   r|   r   r)   r   r  r   r   rp  r   r  r   r  r  r  )rA   r%   rw  r  r1  r  r  r   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%%dhhc1ME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_min0      %%dHc::r    c                 (    | j                  ||d      S )Nr  r  r  s      r   _handle_simple_function_maxz4EarlyReplaceBuiltinCalls._handle_simple_function_max3  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)re   rd   rf   )r  r  r  r6  )rY   rS  r   r  r  r   r)   r   CondExprNoder|   r   r  )	rA   r%   r   rd   cascaded_nodeslast_resultarg_noder   ref_nodes	            r   r  z*EarlyReplaceBuiltinCalls._optimise_min_max6  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 )NrK   r   r8   )r$   )r   r  r|   _transform_list_set_genexprr   r   AsTupleNode)rA   r%   rw  results       r   &_DISABLED_handle_simple_function_tuplez?EarlyReplaceBuiltinCalls._DISABLED_handle_simple_function_tupleY  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   )rY   rS  r   r#   r   r  as_tupler  s      r   !_handle_simple_function_frozensetz:EarlyReplaceBuiltinCalls._handle_simple_function_frozenseth  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_lists  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|   r  r  r   r   r  s      r   _handle_simple_function_setz4EarlyReplaceBuiltinCalls._handle_simple_function_setx  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   r  r  r  r  )rY   r#   r   r  r  rX   r  r|   r   r   r  rt   r   r  )rA   r%   rw  r   r  r1  rZ   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_pairsr8   r   rR  r   r  )key_expr
value_exprrt   )rY   r   DictNoder|   r#   r  r  rX   r  r   r  r   r   DictComprehensionAppendNodert   r   r  )rA   r%   rw  r  r1  rZ   r  r  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   )rY   r#   r   r  )rA   r%   rw  r^  s       r   _handle_general_function_dictz6EarlyReplaceBuiltinCalls._handle_general_function_dict  s/     x=1K&)"4"45Kr    r"   )'rR   rS   rT   rU   r   r  r  rV   rS  rW  rQ  rR  re  ro  ry  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  rK   r    r   rO  rO    s    
 ))==JD
5)
>$7$2> = "XH !5
 4 4	 	 	 z'@'@$	GH!J>O@8=t;;F	S
R
8"Lr    rO  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   rY  r   cf_assignmentsrY   rk   )rA   r@  r   s      r   get_constant_value_nodez*InlineDefNodeCalls.get_constant_value_node  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                         r| j                  ||      S |S )Nzoptimize.inline_defnode_calls)rk  r   r   )rD   r  r  r   r   r  r#   r   PyCFunctionNodeInlinedDefNodeCallNoder|   r   can_be_inlinedreplace)rA   r%   rk  r   inlineds        r   rS  z'InlineDefNodeCalls.visit_SimpleCallNode  s    4 &&**+JKK$$K//>(I$=$=>K22HHMDII/ !!#<<g..r    N)	rR   rS   rT   r   r  r  rV   r  rS  rK   r    r   r  r    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                  d
ej"                  d       ej                  dej$                  d       ej                  dej&                  d      gdd      Zd Z ed ej.                  ej0                  ej2                  f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"d Z# ej                  ejH                   ej                  dejH                  d      g      Z%d Z& ej                  ejN                   ej                  dej                  d      g      Z(d Z) ej                  ejT                   ej                  dejN                  d      g      Z+d Z, ej                  ejZ                   ej                  dej                  d      g      Z.d  Z/ ej                  ej`                   ej                  dej                  d      g      Z1d! Z2 ej                  ej0                   ej                  dej                  d      gd"d      Z3d# Z4 ej                  ej                   ej                  dej                  d      g      Z5 ej                  ej                   ej                  d$ej0                  d      g      Z6d% Z7d& Z8 ej                  ejr                   ej                  d
ejt                  d      g      Z; ej                  ejr                   ej                  d'ejx                  d      g      Z= ej                  ej$                   ej                  dej                  d      gd()      Z>ej@                  d*ej"                  d+ej~                  d,ejN                  d-ejT                  d.ejZ                  d/ej`                  d/ejH                  d0ij                  ZA eBd1g      ZCd2 ZD ej                  ej                   ej                  d3ej                  d      g      ZFd4 ZG ej                  ej                   ej                  d5ej                  d      g      ZId6 ZJd7 ZK ej                  ej                   ej                  d8ej                  d       ej                  d9ejT                  d      g      ZL ej                  ej                   ej                  d8ej                  d       ej                  d9ejT                  d       ej                  d:ejH                  d      g      ZM	 dd;ZN ej                  ej                   ej                  dej                  d       ej                  d<ej                  d      gd()      ZPd= ZQd> ZR ej                  ej                   ej                  d?ej                  d       ej                  d$ej&                  d      gd()      ZS ej                  ej                   ej                  d?ej                  d       ej                  d$ej                  d      gd()      ZTd@ ZU ej                  ej                   ej                  dej                  d      g      ZV ej                  ej                   ej                  dej                  d       ej                  dAej                  d       ej                  dBej$                  d       ej                  dCej&                  d      gdD      ZWdE ZXddFZY ej                  ej                   ej                  dej                  d      gd()      ZZdG Z[ ej                  ej                   ej                  dej                  d       ej                  dHej                  d       ej                  dIej                  d      g      Z\dJ Z] ej                  ej                   ej                  dej                  d       ej                  dHej                  d       ej                  dIej                  d       ej                  dKej&                  d      g      Z^dL Z_ ej                  ej                   ej                  dej                  d       ej                  dHej                  d       ej                  dIej                  d      g      Z`dM Za edN ej                  ej0                  fD              ZcdO ZddP ZedQ ZfdR ZgdS ZhdT ZidU ZjdV ZkdW ZldX ZmdY ZndZ Zod[ Zpd\ Zqd] Zrd^ Zsd_ Ztd` Zuda Zvdb Zwdc Zxdd Zy ej                  ej                   ej                  deej                  d      g      Z{df Z|e|Z}e|Z~e|Ze|Ze|Ze|Ze|Ze|Ze|Z ej                  ej                   ej                  deej                  d      g      Zdg ZeZeZeZ ej                  ejN                   ej                  dhej@                  d       ej                  diej                  d      g      Zdj Z ej                  ejN                   ej                  dhej@                  d       ej                  dkej                  d       ej                  dlej$                  d      g      Zdm Z ej                  ej@                   ej                  dhej@                  d       ej                  dnej                  d      g      Zdo Z ej                  ej                   ej                  dhej                  d       ej                  dpej                  d       ej                  dqej$                  d       ej                  drej$                  d       ej                  dsej&                  d      gd()      Zdt Zdu Zdv Z ej                  ej$                   ej                  dhej@                  d       ej                  dpej                  d       ej                  dqej$                  d       ej                  drej$                  d       ej                  dsej&                  d      gdw)      Zdx Zdy Zdz Z ej                  ej$                   ej                  dhej@                  d       ej                  dpej                  d       ej                  dqej$                  d       ej                  drej$                  d      gd()      Zd{ Z ej                  ej@                   ej                  dhej@                  d       ej                  dpej                  d       ej                  d|ej                  d       ej                  d}ej$                  d      g      Zd~ Z ej                  ej"                   ej                  dej@                  d       ej                  dejt                  d       ej                  dejt                  d      g      Z ej                  ej"                   ej                  dej@                  d      g      Zg dZeD  cg c]  }|tA        jB                  |      f c}}} Zd Z ejH                   ej                  ej@                   ej                  dejt                  d       ej                  dej$                  d       ej                  dejt                  d      g            Z ej                  ej@                   ej                  dejt                  d       ej                  dqej$                  d       ej                  dej$                  d       ej                  dejt                  d       ej                  dejt                  d       ej                  ded      g      Z ej                  ej@                   ej                  dej                  d       ej                  dqej$                  d       ej                  dej$                  d       ej                  dejt                  d       ej                  dejt                  d       ej                  ded      g      ZdZd ZeZd Zd Zd Zd Zd Zd Zd Z	 dddejf                  jh                  dfdZd Zd Zd Zy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.
        )rD   	reanalyserE   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.
        )rD   r   rz   rE   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)rD   r#   rH   r   CoerceToPyTypeNoder$   is_noner  r   r   is_localis_arg)rA   r%   rH   s      r   rI   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.
        )rD   r$   r#   r   PyTypeTestNoder  r   r   r  r   	bool_typecoerce_to_booleanr   )rA   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(  rt        |j                        dk(  r|j                  d   }|j                  t        j                  u r|j                  d      S |j                  j                  rmt        j
                  |j                  d| j                   |gd|j"                  |j$                        j'                  |j                  | j)                               S |S )z3Drop redundant conversion nodes after tree changes.rs  r   r   z=float() argument must be a string or a number, not 'NoneType'__Pyx_PyNumber_Float)r   py_namer   r  )rD   r$   r#   r   CoerceFromPyTypeNoder   r   r   rY   r   r   r   rv  r   r   r|   PyNumber_Float_func_typer   r  r  r   )rA   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]]..$77"8$:W:W&Z ' $'+':':  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 |j0                  r[|j2                  }t        |t        j                        r|j                  }|j                  j                  r| j5                  |||      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.
        )rD   r$   r   r   r  r   r#   r   r  r  r   r   is_floatrt  r   r  r   r  rE  r   r   is_unicode_charr   _optimise_numeric_cast_callr}   r   _optimise_int_indexing)rA   r%   r$   rA  s       r   visit_CoerceFromPyTypeNodez/OptimizeBuiltinCalls.visit_CoerceFromPyTypeNode>  sH    	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  J*i&B&BC'^^
%%224jIIr    bytesr   check_boundsz
((char)-1)T)r   exception_checkc                    | j                         }|j                  d   xr dxs d}|j                  j                  t        j
                  u r|j                  t        j                  t        j                  fv rt        j                  |j                  t        |      |      }t        j                  |j                  d| j                  |j                  j                  d      |j!                  t        j"                  |      |gdt%        j&                  dd	      
      }|j                  t        j                  ur|j!                  |j                  |      }|S |S )Nboundscheckr   r   r`  __Pyx_PyBytes_GetItemIntz&'NoneType' object is not subscriptableTbytes_indexStringTools.cr   r   r  )r   
directivesr~   r   r   r   r   c_char_typec_uchar_typer   r   r|   r  r   PyBytes_GetItemInt_func_typer   r  r  r   r   )rA   coerce_noder$   rA  r\  bound_check_boolbound_check_noder%   s           r   r	  z+OptimizeBuiltinCalls._optimise_int_indexingo  s&    >>-8>QC!88==G...J$:$:J<S<S#TT#,#4#4OO3/?+@$4$6  !33OO%?55223[\",,Z-I-I3O(
 !!,!8!8%"8
9 ##:+A+AA>>+*:*:C@Dr    c           
   #   x   K   | ]2  }|t        j                  |t        j                  d |d      g      f 4 yw)r$   N)r   r  r  ).0rv  s     r   	<genexpr>zOptimizeBuiltinCalls.<genexpr>  sH      "m
 	 
Z))''z4@ 	"ms   8: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                  j!                  |j                        s|j                  j"                  rt        j$                  |j&                  ||j                        S |j                  j"                  r|j                  j(                  r|j                  j*                  dk(  rd}nd|j                  j*                  z   }t        j                  |j&                  || j,                  |j                     |gd|j.                  |j0                        j3                  |j                  | j5                               S |S |j                  d	k(  r|j                  j"                  s|j                  j"                  r|j                  |j                  k(  r|S |j                  j!                  |j                        s|j                  j"                  r,t        j$                  |j&                  ||j                        S |S )
Nr   r   intr  l__Pyx_truncltrunc)rd  r   r   r   r  rs  )r   r#   r   r   r   r/   r   is_builtin_typer   r  rY   r  r$   r   r   r   rE  r  r  r|   
is_numericmath_h_modifierfloat_float_func_typesr   r  r  r   )rA   r%   r$   r   r   r  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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YY..x}}=AWAW$11(D D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 rg  ri  rj  s          r   ro  z+OptimizeBuiltinCalls._error_wrong_arg_count  rp  r    c                     |S r"   rK   )rA   r%   rk  r   arg_listr^  s         r   _handle_functionz%OptimizeBuiltinCalls._handle_function  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   r   T)r3   r4   	is_calledr  )r   r3   r   r   rY  r   r0   r   r|   r/   r   analyse_as_type_attribute%_optimise_generic_builtin_method_callr   r   r   rA   analyse_c_function_callanalysedr  )rA   r%   	type_name	attr_namer   r*  is_unbound_methodr^  
type_entryr   r   	call_nodes               r   _handle_methodz#OptimizeBuiltinCalls._handle_method  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                 *   t        |      }|s|dk\  s|j                  r|j                  s|S |j                  j                  j
                  s|S |j                  j                  j                  dv 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   )r   r   )	rY   r   r1   r3   r   r#  r   r   CachedBuiltinMethodCallNode)rA   r%   r3  r   r*  r4  r   s          r   r/  z:OptimizeBuiltinCalls._optimise_generic_builtin_method_call  s    
 M		Qx7L7LQYQdQdK||  00K<<!!%;;K44(,,	85 	5r    r3   c           	         t        |      dk7  r:t        |      dk(  r*t        j                  |j                  t	               d      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}  r`  __Pyx_PyUnicode_UnicodePyUnicode_Unicoder  __Pyx_PyObject_UnicodePyObject_Unicodeunicoder   r   r  r   )rY   r   r  r|   r   r   r   r   may_be_noner   r   r   PyObject_Unicode_func_typer   )rA   r%   r   rw  r$   r  r  s          r   _handle_simple_function_unicodez4OptimizeBuiltinCalls._handle_simple_function_unicode	  s     x=A8}! ,,TXX]_^abb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.
        r   N)	rD   rh   r   r   r   c_format_specformat_specconversion_charrC  rE   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_Copyr   )
rY   r   r   r   r   r   r   r|   PyDict_Copy_func_typer   rA   r%   r   rw  r$   s        r   r  z1OptimizeBuiltinCalls._handle_simple_function_dict<	  sx     x=AKqk88w(((''(DEC//-)C)Cu,, 
 r    r  c                     t        |      dk7  r|S |d   }t        j                  |j                  d| j                  ||j
                        S )z0Turn list(ob) into PySequence_List(ob).
        r   r   r  r   )rY   r   r   r|   r  r   rL  s        r   r  z1OptimizeBuiltinCalls._handle_simple_function_listO	  sL     x=AKqk++HH')G)G4<<1 	1r    r  c                    t        |      dk7  s|j                  s|S |d   }|j                  t        j                  u r|j                         s|S |j                  t        j                  u rL|j                  d      |d<   t        j                  |j                  d| j                  ||j                        S t        j                  |j                  |t        j                        S )zDReplace tuple([...]) by PyList_AsTuple or PySequence_Tuple.
        r   r   r   PyList_AsTupler   )r$   r   )rY   r   r   r   r   rA  r   r   r   r   r|   PyList_AsTuple_func_typer  rL  s        r   _handle_simple_function_tuplez2OptimizeBuiltinCalls._handle_simple_function_tuple^	  s     x=AT\\Kqk88w)))#//2CJ88w(((//35HQK //*D,I,It||5 5 ((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   r6  	PySet_Newr  r   r   r   )rY   rS  r   r#  r   r   rC   r   r   r|   r  r  r   PySet_New_func_typer   )	rA   r%   r   rw  r   rw   r$   r  rZ  s	            r   r  z0OptimizeBuiltinCalls._handle_simple_function_setu	  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_newz
Builtins.c	frozensetr@  )r   r  r|   rY   r   r   r   rA  r   PyFrozenSet_New_func_typer   r   r   rA   r%   r   rw  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)c           
         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                  j                  |j                        s|j                  j                  r,t        j                   |j"                  ||j                        S t        j$                  |j"                  d	| j&                  ||j(                  t+        d
      d      S )zYTransform float() into either a C type cast or a faster C
        function call.
        r   rr  g        r`  r   rs  0 or 1r  __Pyx_PyObject_AsDoublepyobject_as_doubler@  )rY   r   rt  r  r   rv  r   ro  r#   r  r$   r   r   ru  rE  r$  r  r|   r   PyObject_AsDouble_func_typer   r   rA   r%   r   rw  r  s        r   ry  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YY&&x}}59Q9Q))(< <++HH/,,ll)*>? 	r    rh   c                 z   t        |      dk(  r1t        j                  |j                  ddt        j
                        S t        |      dk7  r|S |d   }t        |t        j                        rq|j                  j                  j                  rOt        j                  |j                  d| j                  |j                  gddt        j                  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   r   __Pyx_PyInt_FromDoubleTr  PyIntFromDoublezTypeConversion.c)r   r   r   r  __Pyx_PyNumber_IntrT  )rY   r   r   r|   r   r  r#   r  r$   r   r  r   PyInt_FromDouble_func_typer   r   r   PyNumber_Int_func_typera  s        r   _handle_simple_function_intz0OptimizeBuiltinCalls._handle_simple_function_int	  s    x=A$$TXXS!*4*C*CE E]aKA;h	 < <=||  )) 33HH68W8W",,u!,!8!89JL^!_a a
 ==$$)>)>//.0K0KtU< < r    c                    t        |      dk(  rNt        j                  |j                  dd      j	                  t
        j                  | 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   Fr`  r   boolr]  ry   )rY   r   r   r|   r  r   r  r   ro  r  r   coerce_to_pyobject)rA   r%   r   rw  rz   s        r   _handle_simple_function_boolz1OptimizeBuiltinCalls._handle_simple_function_bool	  s     x=A%%u)G--t/?/?/ABC ]a''hIK qk33D4D4D4FGG''GDG''GDG--d.>.>.@AAr    r?  r   r   __Pyx_PyUnicode_GET_LENGTHr   PyByteArray_GET_SIZEPyList_GET_SIZEPyTuple_GET_SIZEPySet_GET_SIZEPyDict_Sizezcpython.array.arrayc                    t        |      dk7  r| j                  d||d       |S |d   }t        |t        j                        r|j
                  }|j                  j                  rPt        j                  |j                  d| j                  |g|j                  t        j                  dd            }n|j                  j                  r;t        j                  |j                  d| j                  |g|j                  	      }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                  	      }nE|j                  j<                  r-t        j>                  |j                  dd|j                        S |S |j                  t"        j&                  t"        j@                  fvr*|jC                  |j                  | jE                               }|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   rY   r   strlenIncludeStringHr  r  __Pyx_Py_UNICODE_strlenr   memoryviewsliceNT)nogil__Pyx_MemoryView_LenPy_SIZEz&object of type 'NoneType' has no len()r9  r   )#rY   ro  r#   r   r  r$   r   rA  r   r|   Pyx_strlen_func_typer   r   r   is_pyunicode_ptrPyx_Py_UNICODE_strlen_func_typeis_memoryviewslicer   r  c_size_t_typer  r   _map_to_capi_len_functionis_extension_typer#  r   r   _ext_types_with_pysizer   PyObject_Size_func_typer  r   r  r  r   )	rA   r%   r   rw  r$   r   rd  
cfunc_namerx  s	            r   _handle_simple_function_lenz0OptimizeBuiltinCalls._handle_simple_function_len
  sc   
 x=A''tXqAKqkc9778''C88 33(D$=$=u,,*667GY	[H
 XX&& 333T5Y5Yu,,(H XX((",,((++,=sxxN+I !330)UDLL2H XX!!77AJ!88//83K3K 559T9TT!*JK''8:C 33*d&B&BUDLL2H XX%%$$TXXS!*.))5 5 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_TYPEFr   )rY   r   r   r|   Pyx_Type_func_typerB  r   r  r[  s       r   _handle_simple_function_typez1OptimizeBuiltinCalls._handle_simple_function_typeX
  sW     x=AK++HHi!8!8 !!$
(A(ABBr    r$   c           
         t        |      dk7  rS |\  }}g }t        |t        j                        r~|j                  }t        |      dk(  r!|d   j
                  t        j                  urS |j                  s|j                         sIt        j                  |      }|j                  |       n"|j
                  t        j                  u r|g}nS g }g }| j                         |D ]  }	d}
|	j                  ra|	j                  rUj!                  |	j                  j"                        }|r.|j
                  r"|j
                  j$                  r|j
                  }
|
t        j                  u r3j"                  dk7  s"|j&                  r|j&                  j(                  sd}
|
6j
                  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.                  |	j0                  || j2                  |d
              t        j4                  ffd	}t7        ||      j9                  j
                        }|ddd   D ]  }t        j:                  ||      } |S )zcReplace isinstance() checks against builtin types by the
        corresponding C-API call.
        rR  r   r   Nr   F)exact__Pyx_TypeCheckPyObject_IsInstanceTr   c                 ~     |j                   d| |      }t        j                  |_        |j	                         |S )Nr  )r|   r   r%  r   r  )r5   r6   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    r6  )rY   r#   r   r  r   r   r   	type_typer   r#  r   r)   rC   r   r   r   rY  r   r#  scopeis_builtin_scopetype_check_functionr  r   r|   Py_type_check_func_typerp  r   r  r  )rA   r%   r   rw  r$   typesrw   tests
test_nodestest_type_nodebuiltin_typer   r  type_check_argsr  r  rZ  r\  s    `               @r   "_handle_simple_function_isinstancez7OptimizeBuiltinCalls._handle_simple_function_isinstanceh
  s    x=AK
UeY001JJE5zQuQx}}8I8I'Is}}--c2S!ZZ7,,,GEK
 #  	NL%%!''JJ~';';'@'@AE

0J0J',zzw000::'(D(D#'L'&+jj&D&D5&D&Q#&%/01#&%$$(9(99&7##&"7%00%.%<%<^%LNLL0&;##&"7,,"&&(;T=Y=Y( 7 	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                        rt        |j                        dk(  rt        j                  |j                  t        j                   t#        t%        |j                              t%        |j                              j                  |j
                  | j                               S |S t        |t        j&                        r|j(                  rt        |j(                        dk(  rt%        |j(                        dk  rt        j                  |j                  t        j                   t#        t%        |j(                              t%        |j(                              j                  |j
                  | j                               S |S )z-Unpack ord(Py_UNICODE) and ord('X').
        r   r   r  r4  r  )rY   r#   r   r  r$   r   r  r  r|   r   r  r  r   r  rh   r   r  r  r  r  r  rL  s        r   r  z0OptimizeBuiltinCalls._handle_simple_function_ord
  s    x=AKqkc9778ww||++ --GGSWW:3I3Ii		4+;+;+=>?$  Y223399~" ((GG*"7"7c#))n-$'		N  i		4+;+;+=>	?  Y112  S):):%;q%@C--.#5 ((GG*"7"7c#"3"345$'(9(9$:  i		4+;+;+=>	?
 r    r   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   N)r   T)skip_childrentp_new__new__PyTypeObjectr   r   r^  r   F)r   may_return_noner   z4object.__new__(X): X is not a type object (NoneType)zObjectHandling.c__Pyx_tp_new_kwargs)r   r  r   __Pyx_tp_new)%r3   rY   r   r   r   r  r5  r   r   r  r|   analyse_typesr   r  typeobj_cnamer  r   r   ConstructorSlotget_slot_functionr   cython_scoper   CPtrTyperY  r  r  r  rB  r  r   r   r   r   Pyx_tp_new_kwargs_func_typer   Pyx_tp_new_func_type)rA   r%   r   r   r4  r^  r3   type_arg
args_tupleext_typetp_slotslot_func_cnamer  PyTypeObjectPtrpyx_tp_new_kwargs_func_typer  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    rT  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.
        rR  __Pyx_PyObject_AppendFrC   )r   r  r   r  r  )
rY   r  r   r   r   r   r|   PyObject_Append_func_typer   r   rA   r%   r   r   r4  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.
        rR  N   r   Textendr6  __Pyx_PyList_Append
ListAppendr  |__Pyx_ListComp_AppendListCompAppend)r   r   r   r  r  )rY   rS  r  r   mult_factorr#   r   r  r  r  r   r   r  _wrap_self_argr  r#  r   r   rC   r   r|   r  r   rp  r   c_returncode_typer  )rA   r%   r   r   r4  r3   rh   r   
tuple_nodewrapped_obj
cloned_objrw   r$   r   rZ  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 )NrR  __Pyx_PyByteArray_Appendr   ByteArrayAppendr  __Pyx_PyByteArray_AppendObjectByteArrayAppendObjectr   Fr   r  r   r  )rY   PyByteArray_Append_func_typer'   r   r   r#   r   r   r  r   r  r   r   r   is_string_literalcan_coerce_to_char_literalr  r   "PyByteArray_AppendObject_func_typer   r|   r   r  )
rA   r%   r   r   r4  	func_namerd  rh   r  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                 T   |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(  rt        |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                  t;        |
j<                  xr dxs d      |
j<                  xr dxs dt"        j>                        t        j@                  |j                  t"        jB                  |
jE                               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~  popr  Objectr   z__Pyx_Py%s_PopTr  rR  intvalNz__Pyx_Py%s_PopIndexr   	pop_index)#r   rY   r   r   r|   PyObject_Pop_func_typer   r   r'   r|  r   r   r#   r   rk  r   r  r   r  r   r>  r@  numeric_type_fitscreate_to_py_utility_codeto_py_functionr  r  r  PyObject_PopIndex_func_typer  signedr  RawCNameExprNodec_void_typeempty_declaration_code)rA   r%   r   r   r4  r  r3   r2  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''		_=S=S=YXY=^]^9_8G8N8N8TST8YXY-7-B-BD  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_Sortr  )rY   _substitute_method_callsingle_param_func_typer  r   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().
        rR  r   zdict.get2 or 3__Pyx_PyDict_GetItemDefaultr  Tdict_getitem_defaultr  r  )	rY   rC   r   r|  r|   ro  r  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                 &   t        |      dk(  r/|j                  t        j                  |j                               n$t        |      dk7  r| j                  d||d       |S |d   j                  }|j                  rt        |j                  dv       }n|t        j                  u rd}nd}|j                  t        j                  |j                  t        |      |	             | j                  ||d
| j                  d||dt!        d      	      S )zUReplace dict.setdefault() by calls to PyDict_GetItem() and PyDict_SetItem().
        rR  r   zdict.setdefaultr  r   z%str bytes unicode float int long boolr6  r   r`  __Pyx_PyDict_SetDefault
setdefaultTdict_setdefaultr  )rY   rC   r   r|  r|   ro  r   r#  r  r   r   r  r   r  r  Pyx_PyDict_SetDefault_func_typer   )rA   r%   r   r   r4  key_typer  s          r   %_handle_simple_method_dict_setdefaultz:OptimizeBuiltinCalls._handle_simple_method_dict_setdefault-  s     t9>KK	**48845Y!^''(94xPK7<<##x}}F G HL222LLI%%HHC-|M 	N ++(%t'K'K+T '(9: , < 	<r    c                    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 )
z7Replace dict.pop() by a call to _PyDict_Pop().
        rR  r   zdict.popr  __Pyx_PyDict_Popr  Tpy_dict_popr  )	rY   rC   r   r  r|   ro  r  PyDict_Pop_func_typer   r  s        r   _handle_simple_method_dict_popz3OptimizeBuiltinCalls._handle_simple_method_dict_popN  s     t9>KK	**48845Y!^''
D$IK++( 9 9$d '6 , 8 	8r    c              #     K   | ]  }t         j                  t         j                  fD ]  }||ft        j                  |t        j                  d t         j                  d      t        j                  dt         j                  d      t        j                  d|d      t        j                  dt         j                  d      t        j                  dt         j                  d      g|j
                  rdn|j                        f   yw)op1Nop2cvalinplacezerodiv_checkr   )r   r  r%  r  r  r   r   )r  ctyperet_types      r   r  zOptimizeBuiltinCalls.<genexpr>^  s      #
 #22J4J4JK#
  	J00''z/H/H$O''z/H/H$O''t<''	:3I3I4P''9O9OQUV (0';';tAYAY[ 	\#
	\#
s   DDc                 ,    | j                  d||||      S NAdd_optimise_num_binopr  s        r   $_handle_simple_method_object___add__z9OptimizeBuiltinCalls._handle_simple_method_object___add__k      ''tXtEVWWr    c                 ,    | j                  d||||      S NSubtractr  r  s        r   $_handle_simple_method_object___sub__z9OptimizeBuiltinCalls._handle_simple_method_object___sub__n      ''
D(DJ[\\r    c                 ,    | j                  d||||      S NEqr  r  s        r   #_handle_simple_method_object___eq__z8OptimizeBuiltinCalls._handle_simple_method_object___eq__q      ''dHdDUVVr    c                 ,    | j                  d||||      S NNer  r  s        r   #_handle_simple_method_object___ne__z8OptimizeBuiltinCalls._handle_simple_method_object___ne__t  r)  r    c                 ,    | j                  d||||      S )NAndr  r  s        r   $_handle_simple_method_object___and__z9OptimizeBuiltinCalls._handle_simple_method_object___and__w  r  r    c                 ,    | j                  d||||      S )NOrr  r  s        r   #_handle_simple_method_object___or__z8OptimizeBuiltinCalls._handle_simple_method_object___or__z  r)  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 )NrR  r   ?   RshiftrY   r#   r   r   r   r8   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 )NrR  r   r8  Lshiftr:  r  s        r   '_handle_simple_method_object___lshift__z<OptimizeBuiltinCalls._handle_simple_method_object___lshift__  r<  r    c                 ,    | j                  d||||      S N	Remainder_optimise_num_divr  s        r   $_handle_simple_method_object___mod__z9OptimizeBuiltinCalls._handle_simple_method_object___mod__  s    %%k44IZ[[r    c                 ,    | j                  d||||      S )NFloorDividerC  r  s        r   )_handle_simple_method_object___floordiv__z>OptimizeBuiltinCalls._handle_simple_method_object___floordiv__  s    %%mT8TK\]]r    c                 ,    | j                  d||||      S N
TrueDividerC  r  s        r   (_handle_simple_method_object___truediv__z=OptimizeBuiltinCalls._handle_simple_method_object___truediv__  s    %%lD(DJ[\\r    c                 ,    | j                  d||||      S NDividerC  r  s        r   $_handle_simple_method_object___div__z9OptimizeBuiltinCalls._handle_simple_method_object___div__  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 )NrR  r   r   r   r   l       l          )rY   r   r8   r#   r   r   rt  r  )rA   rd   r%   r   r   r4  s         r   rD  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 r  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__  r$  r    c                 ,    | j                  d||||      S rJ  r  r  s        r   '_handle_simple_method_float___truediv__z<OptimizeBuiltinCalls._handle_simple_method_float___truediv__  s    ''dHdL]^^r    c                 ,    | j                  d||||      S rN  r  r  s        r   #_handle_simple_method_float___div__z8OptimizeBuiltinCalls._handle_simple_method_float___div__  s    ''$$HYZZr    c                 ,    | j                  d||||      S rA  r  r  s        r   #_handle_simple_method_float___mod__z8OptimizeBuiltinCalls._handle_simple_method_float___mod__  s    ''T8TK\]]r    c                 ,    | j                  d||||      S r&  r  r  s        r   "_handle_simple_method_float___eq__z7OptimizeBuiltinCalls._handle_simple_method_float___eq__  r)  r    c                 ,    | j                  d||||      S r+  r  r  s        r   "_handle_simple_method_float___ne__z7OptimizeBuiltinCalls._handle_simple_method_float___ne__  r)  r    c                    t        |      dk7  r|S |j                  j                  rt        j                  }n3|j                  t        j
                  u r|dv rt        j
                  }n|S t        j                  t        j                  f}t        |d   |      r)|d   j                  t        j                  ur|S |d   }d}	n:t        |d   |      r)|d   j                  t        j                  ur|S |d   }d}	n|S |j                         s|S t        |t        j                        }
|
rt        j                  nt        j                  }|
r|dvr#|S |dk(  r|S t        |j                        d	kD  r|S |d
v r|d   j                  dk(  r|S t        |      }|j!                   |
rt        j                  nt        j                  |j"                  |j$                  |j                  |             t        |t        j&                        r|j(                  nd}|j!                  t        j*                  |j"                  ||             |
s|dvra|	dk(  xr) t        |t        j,                        r|j.                   nd}|j!                  t        j*                  |j"                  ||             t1        j2                  |
rdn|dv rdnddt5        ||	|            }| j7                  ||d|
rdndd|j                  rdnd||	| j8                  ||f   d|dd j;                         z  ||dd|
      }|j                  j                  r;|j                  s/t        j<                  || j?                         |j                        }|S )zY
        Optimise math operators for (likely) float or small integer operations.
        rR  )r'  r,  r   r   ObjCCObj)r  r"  rB  rK  rO  r'  r,  rO  r   )rK  rG  rO  rB  r   Fr`  PyFloatBinopPyIntCompare
PyIntBinopr   )oporderr  )r   __Pyx_PyFloatIntr  r}  Boolz__%s__Nr   T)r  with_none_checkr  ) rY   r   r   r   r  r%  r   r   rt  r#   r   ru  r  r;  r8   r  rC   r|   rh   NumBinopNoder  r   rr  	cdivisionr   r   r   r  Pyx_BinopInt_func_typeslowerr  r   )rA   rd   r%   r   r   r4  r  	num_nodesnumval	arg_orderr  num_typer  zerodivision_checkr  r6  s                   r   r  z(OptimizeBuiltinCalls._optimise_num_binop  s8    t9>K99  !00HYY*000X5M!--HK &&	(;(;<	d1gy)Aw||:#<#<<!WFIQ+Aw||:#<#<<!WFIK))+Kfi&9&9:/7:++Z=S=Scc!K''(50KKKAw&&!+DzKHY(():K:KJJfllF<R<R 	 #-T93I3I"J$,,PUI&&txxwPWXYx|3!*f!4 "V&0y7H7H&IDNN"u KK	**488;M_qrs)55&Nh,>VN\hHIIK
 00(#.**6	
 (((H)=>x|))++-> !% 1 '	 99  )=)=!44Y@P@P@RTXT]T]^Ir    ucharc           
         |st        |      dk7  r|S |d   }t        |t        j                        r |j                  j
                  j                  s|S |j                  }|j                  }|dk(  rt        j                  dd      }d}	nd }d|j                         z  }	| j                  |||	| j                  |||g|      }
|j
                  j                  r|
j                  | j                        }
|
S )	Nr   r   istitlepy_unicode_istitler  __Pyx_Py_UNICODE_ISTITLEzPy_UNICODE_%srb  )rY   r#   r   r  r$   r   r  r4   r   r   upperr  #PyUnicode_uchar_predicate_func_typer   rk  r   )rA   r%   r   r   r4  ustringrv  r  r  rk  	func_calls              r   _inject_unicode_predicatez.OptimizeBuiltinCalls._inject_unicode_predicate  s    D	QKq''9#?#?@;;##33K(()#&22$o7L6ML+k.?.?.AAM00(4CC*UG'	 1 )	
 99  !44T5E5EFIr    c           	         |st        |      dk7  r|S |d   }t        |t        j                        r |j                  j
                  j                  s|S |j                  }|j                  }d|j                         z  }| j                  |||| j                  |||g      }	|j
                  j                  r|	j                  | j                        }	|	S )Nr   r   zPy_UNICODE_TO%s)rY   r#   r   r  r$   r   r  r4   r{  r  $PyUnicode_uchar_conversion_func_typer   rk  r   )
rA   r%   r   r   r4  r}  rv  r  rk  r~  s
             r   $_inject_unicode_character_conversionz9OptimizeBuiltinCalls._inject_unicode_character_conversion@  s    D	QKq''9#?#?@;;##33K(()K,=,=,??00(4DD*UG5	 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)rY   ro  _inject_bint_default_argumentr  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           	      H   t        |      dvr| j                  d||d       |S t        |      dk  r.|j                  t        j                  |j
                               | j                  ||dt        j                  d       | j                  ||d| j                  d||      S )zaReplace unicode.split(...) by a direct call to the
        corresponding C-API function.
        )r   rR  r   zunicode.split1-3rR  r   PyUnicode_Splitsplit)rY   ro  rC   r   r  r|   _inject_int_default_argumentr   r  r  PyUnicode_Split_func_typer  s        r   #_handle_simple_method_unicode_splitz8OptimizeBuiltinCalls._handle_simple_method_unicode_splitr  s     t9G#''tUKKt9q=KK	**48845))$: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
        rR  zunicode.join2r   r  r  r  PyUnicode_JoinrF  )rY   ro  r#   r   r  r  rX   r  r|   r   r   r  rt   r   r  r  PyUnicode_Join_func_type)rA   r%   r   r   r4  r  r1  rZ   inlined_genexprr  r  r  s               r   "_handle_simple_method_unicode_joinz7OptimizeBuiltinCalls._handle_simple_method_unicode_join  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    	substringr   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_endswith  s(    %%(D"3Y
*B0 	0r    c           
      :    | j                  ||||ddt        d      S )Nr?  
startswithr6  r  r  s        r   (_handle_simple_method_unicode_startswithz=OptimizeBuiltinCalls._handle_simple_method_unicode_startswith  s(    %%(D"3Y*B0 	0r    c	           
      2   t        |      dvr| j                  |d|||d       |S | j                  ||dt        j                  d       | j                  ||dt        j                  d       |j                  t        j                  |j                  t        |      t        j                               | j                  ||d	|j                         z  | j                  ||||
      }	|	j                  t        j                   | j#                               S )zReplace unicode.startswith(...) and unicode.endswith(...)
        by a direct call to the corresponding C-API function.
        rR  r      rD  2-4rR  r   r   PY_SSIZE_T_MAXrh   r   z__Pyx_Py%s_Tailmatchrb  )rY   ro  r  r   r  rC   r   r   r|   r  r  r  
capitalizePyString_Tailmatch_func_typer  r   r  r   )
rA   r%   r   r   r4  r2  r  r  r  method_calls
             r   r  z&OptimizeBuiltinCalls._inject_tailmatch  s   
 t9G#''9k(JDRVX]^K))$:77	>))$:779I	KI%%HHC	N1F1FH 	I 22("Y%9%9%;;--*D' 3 ) $$W%6%68H8H8JKKr    z-2c                 .    | 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rfindr6  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                  t        |      t        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  rR  r   r   r  r  PyUnicode_Find)rY   ro  r  r   r  rC   r   r   r|   r  r  r  PyUnicode_Find_func_typerk  r   )rA   r%   r   r   r4  r  r  r  s           r   r  z)OptimizeBuiltinCalls._inject_unicode_find  s    
 t9G#''{(BD$PUVK))$:77	>))$:779I	KI%%HHC	N1F1FH 	I 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  rR  r   r   r  PyUnicode_Countcount)	rY   ro  r  r   r  r  PyUnicode_Count_func_typerk  r   )rA   r%   r   r   r4  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  )rY   ro  r  r   r  r  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    encoding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   }t        |      dk(  rCt        j                  |j                        }| j                  ||d| j                  d||||g      S | j                  |j                  |      }||S |\  }}	}
}|rst        |t        j                        rY	 |j                  j                  ||
      }t        ||      }t        j                  |j                  |t        j                        S |rC|
d	k(  r>| j!                  |      }|+d
|vr'd|z  }| j                  |||| j"                  d||g      S | j                  ||d| j                  d|||	|g      S #  Y mxY w)z_Replace unicode.encode(...) by a direct C-API call to the
        corresponding codec.
        r   r   zunicode.encoder  r   PyUnicode_AsEncodedStringr  r  strictrn  zPyUnicode_As%sString)rY   ro  r   r  r|   r  #PyUnicode_AsEncodedString_func_type_unpack_encoding_and_error_moder#   r  rh   r  r	   r  r   r   _find_special_codec_namePyUnicode_AsXyzString_func_type)rA   r%   r   r   r4  string_node	null_node
parametersr  encoding_nodeerror_handlingerror_handling_noderh   
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t9>!**4884I//h ;88+k9i-PR R
 99$((DI
KGQD-1D
;	0E0EFb#))00>J
 &eX6 **;??%gN`N`aa(266x@J%#Z*?"8:"E33(O88/+@ @
 ++(744'-)<=	? 	?#s   F Fstringr<  r   decode_funcc                 
   dt        |      cxk  rdk  sn | j                  d||d       |S |d   }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 |j                  dd|	j                   g	      }n0|j                  d
ddg      }n|	j"                  s|	j$                  s|S | j'                  |j(                  |      }
|
|S |
\  }}}}|s#t        j*                  |j(                  dd      }nD|j                  j,                  s.|j/                  t0        j2                  | j5                               }|rD|j                  j,                  s.|j/                  t0        j2                  | j5                               }d}|| j7                  |      }|k|dv rd|j9                  dd      z  }nd|z  }t        j:                  |j(                  | j<                  |      }t        j>                  |j(                        }nt        j>                  |j(                        }g }|	j"                  r|s|j@                  s&tC        jD                  |      }|jG                  |       t        jH                  |j(                  d| jJ                  |gdtM        jN                  dd            j/                  t0        j2                  | j5                               }| jP                  }d}n|	j$                  r<|s0t        j*                  |j(                  dt        jR                        }| jT                  t1        jV                  t        jX                  t1        jZ                  d|	d      t1        jZ                  dt0        j2                  d      t1        jZ                  dt0        j2                  d      t1        jZ                  dt0        j\                  d      t1        jZ                  d t0        j\                  d      t1        jZ                  d!| j<                  d      g      | _*        | jT                  }d"}nU|s0t        j*                  |j(                  dt        jR                        }| j^                  }|	t        j                  u rd#}nd$}t        jH                  |j(                  d%|z  |||||||g|j`                  tM        jN                  |d            }|ddd&   D ]  }tC        jb                  ||      } |S )'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@descriptor '%s' requires a '%s' object but received a 'NoneType'decoder  r  r~  r  r   r`  )r  r  r  z__Pyx_PyUnicode_Decode%srn  r}  zPyUnicode_Decode%s)r   r  rt  Fru  r  r  decode_c_stringr  r  r   r   r  r  r  decode_cpp_stringdecode_bytesdecode_bytearrayz__Pyx_%sr6  )2rY   ro  r#   r   r   r~   r   r   r8   r  r$   r   r   r   bytearray_typer   r   rA  is_cpp_stringr  r|   r   r   r  r   r  r   r  r  r  !PyUnicode_DecodeXyz_func_ptr_typer  r   r   r   rC   r   r{  r   r   _decode_c_string_func_typer   _decode_cpp_string_func_typer  r   r  r  _decode_bytes_func_typer   r  )rA   r%   r   r   r4  r  r   r   rA  string_typer  r  r  r  r  r  codec_cnamedecode_functionrw   helper_func_typeutility_code_namerZ  s                         r   "_handle_simple_method_bytes_decodez7OptimizeBuiltinCalls._handle_simple_method_bytes_decode  s    SY#!#''dEJK 1gk9#;#;<$J$//K$**JOO4EE11Q6k9#?#?@%//K!&&7--w/E/EFF );;V!);+;+; < < > *;;@0!)
 < , &&{/H/HK99$((DI
KGQD-1D%%dhhc1ME""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OOXt/H/H%!!,!8!89I?![	
 )J88$:J:J:LM   $>> 1&& ((9I9B9Q9QS0084>4H4H(("//+tL"//9U9UW[\"//
8T8TVZ["//
J<\<\^bc"//*:Z:Z\`a"//t?e?egkl+51  $@@ 3  ((9I9B9Q9QS#;;g000$2!$6!++HHj#446FudM;NP_`LL$001BOT	
 $B$K 	>D11$=D	>r    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 )Nr  r}  )codecs
getencoderLookupError_special_codecsrF  r  r  )rA   r  requested_codecr   codecr   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 )NrR  r   r   r  )r   r  rY   _unpack_string_and_cstring_node)rA   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                  t        j                  f      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  rh   r  r|   as_utf8_stringr   r  r  r  r   r   r   r  r   rA  )rA   r%   r  s      r   r  z4OptimizeBuiltinCalls._unpack_string_and_cstring_node'  sH   dI88988DdI112zzH&& 7 7 9
@`@`bD ~ y33Y5H5HIJ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  str_tailmatch_utility_coder  s        r   "_handle_simple_method_str_endswithz7OptimizeBuiltinCalls._handle_simple_method_str_endswith;  s(    %%(D"3UJ&, 	,r    c           
      :    | j                  ||||ddt        d      S )Nr  r  r6  r  r  s        r   $_handle_simple_method_str_startswithz9OptimizeBuiltinCalls._handle_simple_method_str_startswith@  s(    %%(D"3UL&, 	,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_endswithE  s(    %%(D"3Wj(". 	.r    c           
      :    | j                  ||||ddt        d      S )Nr  r  r6  r  r  s        r   &_handle_simple_method_bytes_startswithz;OptimizeBuiltinCalls._handle_simple_method_bytes_startswithJ  s(    %%(D"3Wl(". 	.r    rK   c           
          t        |      }|r|r| j                  |d   |||      |d<   |	|j                  }	t        j                  |j
                  ||||	||
|j                        S )Nr   )r   r   r  r  r  )r  r  r   r   r   r|   r  )rA   r%   r   r   rd  r3  r4  r   r  r   r  rl  s               r   r  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  rz  r{  r|  r}  r~  r  )r  r   r   r   r  rY   )rA   self_argr   r4  r3  s        r   r  z#OptimizeBuiltinCalls._wrap_self_argp  s    O11R&(:(:; 2 =H 	  11<CCSQZ^_aMaEgij,&K 2 )H r    c                    t        |      |k\  sJ t        |      |k(  r<|j                  t        j                  |j                  t        |      ||             y ||   j                  || j                               ||<   y )Nr5  )rY   rC   r   r   r|   r  r  r   )rA   r%   r   	arg_indexr   default_values         r   r  z1OptimizeBuiltinCalls._inject_int_default_argument~  so    4yI%%t9	!KK	))$((#m:L/3]T U #9o77d>N>N>PQDOr    c                    t        |      |k\  sJ t        |      |k(  r=t        |      }|j                  t        j                  |j
                  ||             y ||   j                  | j                               ||<   y Nr`  )rY   rj  rC   r   r   r|   r  r   )rA   r%   r   r  r  s        r   r  z2OptimizeBuiltinCalls._inject_bint_default_argument  sp    4yI%%t9	! /MKK	**488=;HJ K #9o??@P@P@RSDOr    r"   r  )rR   rS   rT   rU   r  r  rI   r  r   r  r  r  r  r  r
  r  r   r   r  r  r  r	  r   c_float_typeru  c_longdouble_typer&  r  ro  r+  r7  r/  r   rB  rC  rH  r   rK  r  r   r  r  r   rP  rQ  r   rU  r  r   rZ  r  r`  ry  rg  rf  rh  rl  r  r  r{  c_const_py_unicode_ptr_typer}  r  r  r  r  r  r  r  r  r  r  r%  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r	  r  r  r  r  ro  r  r#  r(  r-  r0  r3  r6  r;  r?  rE  rH  rL  rP  rD  rS  rU  rW  rY  r[  r]  r_  r  rD  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_isupperr  r  #_handle_simple_method_unicode_lower#_handle_simple_method_unicode_upper#_handle_simple_method_unicode_titler  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  _special_encodingsr  r  r  r  r  r  r  r  r  r  &_handle_simple_method_bytearray_decoder  r  r  r  r  r	  r  r   r   r  r  r  r  r  )r  r   r  s   000r   r  r    s    	 
  4z33!!#J##C)B)BDI$ 
,&P $8:#7#7#J##GW-?-?F#J##GZ-I-I4P#J##NJ4I4I4P!
 '$  2 " "m
 &22J4L4LjNjNjk"m m-^>$(BX5  "6!5!5#J##E:+D+DdK"
.
 1J00#J##FG,=,=tD
 !5
 4 4	 	 	 z'@'@$	GH!J1  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# )# : 2Z11!!#J##C)B)BDI$
 "6!5!5!!#J##GZ-E-EtL$"
.B( 0://  #J##GZ-M-MtT#

 ';j&:&:  #J##Iz/U/UW[\#
'#
 3j22$$#J##E:+D+DdK'
 	 	!=!3!7!2!3!1!1	! 
c  !"7!893j .--#J##Hj.G.GN
	C 3j22#J##E:+D+DdK!
BH< 0://!!#J##Fj.G.GN#J##Fg.@.@$G$ #7*"6"6!!#J##Fj.G.GN#J##Fg.@.@$G#J##Hg.?.?F$
# ;?IZ !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BH 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	$'#<4 0://!!#J##FJ,E,EtL#J##E:+D+DdK#J##Iz/H/H$O$8  # #
 !,,j.F.FG#
 
X]WWXWX[[\^]Y[X]_[^WWRl +?**>*>#J##GZ-F-FM!+'
4 /H).G).G+.G).G).G+.G).G).G)+?:+?+?!!#J##GZ-F-FM$,(
$ +O'*N'*N'%9Z%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.  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[
 $( un .P*N.(,
,
.
.

 DF-14090L0L0\0\04	&RT[
9s    AEr  unicode_tailmatchr  bytes_tailmatchstr_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*e+jX                  jZ                  Z. xZ/S )'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                 8    t         t        |           || _        y)z
        The reevaluate argument specifies whether constant values that were
        previously computed should be recomputed.
        N)superr)  r>   
reevaluate)rA   r,  	__class__s     r   r>   zConstantFolding.__init__  s    
 	ot-/$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)Nr8   r   )file)r,  r8   r   constant_value_not_setr   rD   r   r   r  r  calculate_constant_result
ValueError	TypeErrorr]   
IndexErrorr  ArithmeticErrorr$  	tracebacksys	print_excstdout)rA   r%   r   childrenchild_resultchildr6  r7  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   r   r2  )rA   nodess     r   _widest_node_classz"ConstantFolding._widest_node_class  sP    	''C,,22Ce4DEFH H 		s   AA 	AAc                 \    t        |      }t        j                  |j                  ||      S r  )rj  r   r   r|   )rA   r%   rh   s      r   
_bool_nodezConstantFolding._bool_node  s$    U!!$((%OOr    c                 (    | j                  |       |S r"   )r=  rE   s     r   visit_ExprNodezConstantFolding.visit_ExprNode  s    d#r    c                    | 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                  t        t        |j                              t        j                   t        |j                              S |j                  dk(  r| j#                  |      S |j                  dk(  r| j%                  |      S |S )N!r5  r7  rn  )r=  r   rd   _handle_NotNoderz   r  rD  r8   r#   r   r   r   r|   r  r  r   r  _handle_UnaryPlusNode_handle_UnaryMinusNoderE   s     r   visit_UnopNodezConstantFolding.visit_UnopNode  s   d#'')}}#++D11K||&&K==C??4)=)=>>i&8&89$$TXXST=Q=Q9R5S*4*?*?589M9M5NP P ]]c!--d33]]c!..t44r    rx   r  is_notis)r  rx   rN  rM  c                     |j                   }t        |t        j                        rJ| j	                  |j
                        }|r-t        j                  |      }||_        | j                  |      }|S r"   )rz   r#   r   r   _negate_operatorrd   copyr   )rA   r%   rz   rd   s       r   rI  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 )Nrn  r   )r  rg   s    r   _negatez7ConstantFolding._handle_UnaryMinusNode.<locals>._negate  s2    $ab	 L eLr    r5  )rh   r   longnessr8   )rz   r   r#   r   rt  r|   rh   r8   r   r  r   r   rU  )rA   r%   rT  	node_types       r   rK  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"   )rz   r   r8   rE   s     r   rJ  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=  re   r   r8   rd   rf   rE   s     r   r  z#ConstantFolding.visit_BoolBinopNode!  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        j$                  |j.                  ||	t1        t3        |j                              t3        |j                              }
|j4                  s|
j                  j4                  rt        j                  |
_	        |
S t        j                  ||
j                        |
_	        |
S |t        j                   u r|j                  }nt1        |j                        } ||j.                  |||j                        }
|
S # t        $ r |cY S w xY w)	Nz+-//<<%**>>z+-//<<%**>>&|^unsignedr}  LLrU  )r|   rZ  rU  rh   r8   )r|   r   rh   r8   )r=  r8   r   r   r#   rs  re   rf   r  r   r  r$  r   widest_numeric_typer  rB  r   rd   r   r  r  r@  rY   r|   r  r  r   )rA   r%   re   rf   type1type2widest_typetarget_classrZ  rU  r   
node_values               r   visit_BinopNodezConstantFolding.visit_BinopNode0  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 ((TXX2:X/23t7K7K3L/M9<T=Q=Q9RTH &&(--*C*C * 9 9  !+ > >{HMM Z  y111!11
 !5!56
#,66:6J6JLH S  	K	s   ?K KKc                 d   | j                  |       |j                  t        j                  u r|S |j                  j
                  r|j                  j
                  r|j                  |j                  }}t        |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                  ||j                  |      S t        |t        j                        rt        |t        j                        r|j                  j                  |j                  j                  k(  rVt        |j                  |j                  j                        }t        j                  |j                  ||j                        S | j!                  |      S )N)rh   r8   r'  r`  )r=  r8   r   r   re   r  rf   r#   r  r'  r  r	   r   r|   r  rh   rb  )rA   r%   str1str2r'  string_values         r   visit_AddNodezConstantFolding.visit_AddNodej  s   d#9#;#;;K==**t}}/N/N$D$	 5 56:dILaLa;b"##/D4D4D4P''00D4D4D4M4MM&3 ,,t/?/?? ,,55'7  -T-A-AB ,,HHL$BVBVdoq qD)"5"56:dIL_L_;`::&&$***=*=="/0D0DdjjFYFY"ZK$..txx{\`\p\pqq ##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=  re   rS  _calculate_constant_seqrf   r#   r   r   r  _multiply_stringrb  rE   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                    |j                   }t        |t              s|S |j                         rt        |j                   t              s|S t        |j                         dkD  r|S t        }t        |t        j                        rt        }nt        |t        j                        ra|j                  2t        |j                  |z  |j                  j                        |_        |j                  j                  rt        nt        }nlt        |t        j                        r?|j                   Ft        |j                   |z  |j                   j                        |_        nJ dt#        |      z          ||j                  |z  |j                  j                        |_        t        |t        j                        r|j                  |j                  |_         |S |j                  |_         |S )N   zunknown string node type: %s)r8   r#   r   r   _py_string_typesrY   r
   r   r  r	   r  r  r  rh   
is_unicoder  r'  r   )rA   r%   r  multiplier_node
multiplierbuild_strings         r   rj  z ConstantFolding._multiply_string  s   $44
*m4K((*z$:N:NP`/aKt##$s*K%k9#6#67(LY%9%9:((4,:--
:--66-8) .9->->-I-I>}LY%:%:;&&2*7++j8++44+6' M84;LLL(
*&&( k9#7#78[=V=V=b*5*C*CK'  +6*;*;K'r    c                 D   |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                  t        |      |      |_        |S | j                  |      S ||_        |S r  )
r8   r   r#   r   r  r   r   r|   r  rb  )rA   r%   sequence_nodefactorrh   s        r   ri  z'ConstantFolding._calculate_constant_seq  s    !!Q&=+=+=&00-@VE[E[_`E`!&&q),0)  **6v55}E"=#<#<#L#Lm\)55EEH^H^^E090A0A%1155!%j%1AM-   //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"   )rD   r#   re   r   r  rf   r  r  _build_fstringr|   rh   r   rb  )rA   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 ]h  }|s|dk(  r1|j	                  t        j                  |t        d      d             =|d   dk7  rO|d   dk(  rt        |d|dd  z  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              gd} 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   r6  zIncomplete format: '...%s'r   )levelFz)Too few arguments for format placeholdersasrfdoxXdoxXrD  arsr   r  drn  r  )rh   rG  rF  z*Too many arguments for format placeholders)r   )iterrer  _parse_string_format_regexrC   r   r  r   r   nextStopIterationr"  r  FormattedValueNoder|   JoinedStrNodevisit_JoinedStrNode)rA   r|   r}  r  r   
substringscan_be_optimisedr   format_typer$   rF  rG  r%   s                r   rw  zConstantFolding._build_fstring  sZ   K 
$997C 2	AEz!!)"7"7=QUCVhl"mntt|R5D=C!="#!FaP',$!!)"7"7=QRCSef"ghB%K4j
 ~~#( k)e"&')dk.A',$ F*"-cr"2K&1O"--c2&)KO&; D(&)O))#."%AB"7K!!)">">GG3$3 ' !* 5 5=#={!\,0#  $) e2	h  	J CEQO] ! HPQR#( V "d"
 &&s:>''--s$   
F: G :GG	G&%G&c                 L   | j                  |       |j                  xs d}t        |j                  t        j
                        r|j                  j                  sd |_        |j                  t        |j                  t        j                        r[t        |j                  j                        }|j                         r,t	        j
                  |j                  j                  ||      S |j                  |dk(  rd }t        |j                  t        j
                        r|j                  j                  }n:t        |j                  t        j                        r|j                  j                  }|,t	        j
                  |j                  j                  ||      S |S )Nr   r`  )rD   rG  r#   rF  r   r  rh   r   r   isdigitr|   r  r  )rA   r%   rG  rh   s       r   rH  z(ConstantFolding.visit_FormattedValueNode  s-   4 ..5#d&&	(=(=>tGWGWG]G]#D#
4::y?P?P(Q!$**"2"23E}} ,,TZZ^^5Z_``#3(>E$**i&;&;<

((DJJ	(<(<=

00  ,,TZZ^^5Z_``r    c                    | j                  |       t        j                  g }t        j                  |j
                  fd      D ]  \  }}|rt        |      }|d   }t        |      dkD  rCt        dj                  d |D                    }t        j                  |j                  ||      }|j                  sv|j                  |       |j                  |        |s/t        d      }t        j                  |j                  ||      }|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.
        c                     t        |       S r"   )r#   )vunicode_nodes    r   <lambda>z5ConstantFolding.visit_JoinedStrNode.<locals>.<lambda>;  s    S]^_amSn r    r   r   r}  c              3   4   K   | ]  }|j                     y wr"   rg   )r  rh   s     r   r  z6ConstantFolding.visit_JoinedStrNode.<locals>.<genexpr>@  s     2W55;;2Ws   r`  rR  r7  )rD   r   r  	itertoolsgroupbyr   r  rY   r   rF  r|   rh   rC   r  rp  )rA   r%   r   is_unode_groupr  unoderh   r  s          @r   r  z#ConstantFolding.visit_JoinedStrNode1  sG    	4  ,,*3*;*;DKKIn*o 	*&NJ!*-
"1z?Q&)#((2WJ2W*WXE%11%))5Z_`E;;MM%(j)	* !"%E((PUVD  [A!9D  [A''#??D  !DKr    c                 X   | j                  |       g g fd|j                  D ]
  } |        rj                  d          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                 X   | j                   r=r)d   j                  j                  | j                         y j                  |        y t	        | t
        j                        r| j                  D ]
  } |        y rj                  d          d d = j                  |        y Nr   )is_dict_literalr  r  rC   r#   r   MergedDictNoderV  )r$   	child_argr  r   r   s     r   r  z1ConstantFolding.visit_MergedDictNode.<locals>.addZ  s    ""!H,,33C4G4GHLL%C!9!9:!$!1!1 #I	N# KKa)aC r    r   r   N)	rD   rV  rC   rY   r  r#   r   r  r=  )rA   r%   r$   r  r   r   s      @@@r   visit_MergedDictNodez$ConstantFolding.visit_MergedDictNodeT  s    4 	! $$ 	CH	KKa!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 r  )	is_set_literalrS  r  r   r  rC   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)rD   r   r   r   r   rC   rY   r  rS  r#   r   r  r=  )rA   r%   r$   r  r   r  r   s      @@@@r   visit_MergedSequenceNodez(ConstantFolding.visit_MergedSequenceNodev  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)	rD   r   r"  rC   rt   rS  r  r  r=  )rA   r%   r   r$   s       r   visit_SequenceNodez"ConstantFolding.visit_SequenceNode  s    4 99 	!C>>C 33CJJ<R<RCJJOO,C 	! 		!d#r    c                    	
  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 
	
 fd |       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)
Nre   rf   c                 "   | j                         rK| j                  s"j                  j                  | d             y j                  | j                  g       nd   j                  |        | j
                  r | j
                         y y )NFr6  )r   r8   rC   rD  rf   r  )r   cascadesfinal_false_resultrA   split_cascadess    r   r  z<ConstantFolding.visit_PrimaryCmpNode.<locals>.split_cascades  s{    ++-//&--dooh.NO OOX%6%6$78 ##H-x//0  r    rR  r   r   )re   rd   rf   r8   Tr  )rD   re   rf   r   r8   r   "calculate_cascaded_constant_resultr2  r3  r]   r4  r  r5  r  rD  rY   r   r   r|   rd   rC   r  )rA   r%   	left_noder   
right_node	cmp_nodesr  	pcmp_nodelast_cmp_noder  r  r  s   `        @@@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$	1 	t	 	)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 I #Ix^Ude s   3H" "#I	I	c                     | j                  |       |j                  j                         s|S |j                  j                  r|j                  S |j
                  S r"   )r=  r  r   r8   r  r  rE   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 Nrl   )rD   rq   ro   r   r8   rp   rr   rC   r   r   r|   )rA   r%   rq   r  ro   s        r   r  z ConstantFolding.visit_IfStatNode  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=  r   r8   r   r   r~   rS  r  r   r  as_sliced_node)rA   r%   r   r   r~   s        r   visit_SliceIndexNodez$ConstantFolding.visit_SliceIndexNode  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  )rD   r#   r  r   r   rm   r   r   r   r   r  r|   r   r   r  r   r  rE   s     r   visit_ComprehensionNodez'ConstantFolding.visit_ComprehensionNode4  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  )rD   ru   rs   r#   r   SequenceNoder   rr   r   r   r|   r  r  )rA   r%   rs   s      r   r   z#ConstantFolding.visit_ForInStatNodeC  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"   )rD   ro   r   r8   rr   rE   s     r   visit_WhileStatNodez#ConstantFolding.visit_WhileStatNodeR  s\    4 >>dnn@@B~~--!%#'   '''r    c                     | j                  |       t        |j                  t        j                        s|S |j                  j                         ry |S r"   )rD   r#   rH   r   ExprNoder   rE   s     r   rI   z"ConstantFolding.visit_ExprStatNode\  sA    4 $))Y%7%78K99((*r    r  )0rR   rS   rT   rU   r>   r=  r   r   r  r   rt  r?  rB  rD  rF  rL  r  rP  rI  rK  rJ  r  rb  rg  rk  rj  ri  ry  r  rw  rH  r  r  r  r  r   r  r  r  r  r   r  rI   r   r  r  rV   __classcell__)r-  s   @r   r)  r)    s    %1@ !))9+=+= (()*=*=?OP* 	
 
c ,%8t*2*"H&*	 E.N&!F D$LPd":.. ))==Jr    r)  c                   8    e Zd ZdZdZd Zd Zd Zd Zd Z	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
        - replace Python function calls that look like method calls by a faster PyMethodCallNode
    Fc                 f    | j                  |       |j                  r|j                  }d|_        |S )zaAvoid redundant initialisation of local variables before their
        first assignment.
        T)rD   r	  rj   lhs_of_first_assignment)rA   r%   rj   s      r   visit_SingleAssignmentNodez-FinalOptimizePhase.visit_SingleAssignmentNodez  s/     	4 ::((C*.C'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 |j"                  r|j                  j$                  rm| j&                  j)                  | j*                  s| j-                         j.                  rdnd      r)t1        |j2                  t        j4                        r|j2                  j6                  s|j2                  j8                  r#t        |j2                  j                        dkD  sd	}|j                  t:        j<                  u rd
}n|j>                  r/|j                  r|j                  j                  j                  rd
}n|j                  r|j                  }|j@                  s|j                  j                  rd
}nY|jB                  rMt        jD                  t        jF                  t        jH                  ftK        fd|jB                  D              }|r|jL                  rm|j>                  rat1        |jN                  t        jP                        r=|jN                  jR                  |jL                  u r|jN                  jR                  |_'        | jU                  |t        jV                  jY                  |||j2                  |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#   rR  r   r   PyObject_TypeCheckr  z&optimize.unpack_method_calls_in_pyinitzoptimize.unpack_method_callsTFc              3   h   K   | ])  }|j                   xr t        |j                           + y wr"   )rk   r#   )r  
assignmentnon_method_nodess     r   r  z:FinalOptimizePhase.visit_SimpleCallNode.<locals>.<genexpr>  s6      .D * 'NN_:jnnN^3_/__.Ds   /2)r   r   r   )-rD   r   r   is_cfunctionr   r   rY   r   r#  r   r  rY  r   r   r  r   rB  r   r   r  r  in_loopr   is_module_scoper#   r   r  r  r  r   r  r   r   r  r  	ClassNodePy3ClassNoder!  rA   r3   r@  r$   r  PyMethodCallNode	from_node)	rA   r%   r   r  r  r  may_be_a_methodr   r  s	           @r   rS  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#TDIIaLB A llx}}88T=T=T=X=X||(8(8(:(J(J 93>5
 $..)*=*=>NN..4>>3L3LQTUYUcUcUhUhQilmQm"&==G$5$55&+O**~~(..*=*=*J*J*/%%$NNE''5::+B+B*/--,5,E,EyGZGZ\e\r\r+s(*- .D.3.B.B.D +D #		h&;&;&x||Y5H5HIhllN^N^bfbkbkNk'/||'7'7<<i.H.H.R.Rx4>>PTPYPY /S /[ \Dr    c                 (    | j                  |       |S r"   )rD   rE   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)rD   notnoner$   rA  rE   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.
        )rD   r$   rA  rE   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  rD   )rA   r%   old_vals      r   visit_LoopNodez!FinalOptimizePhase.visit_LoopNode  s.     ,,4 r    N)rR   rS   rT   rU   r  r  rS  r  r  r  r  rK   r    r   r  r  l  s-    
 G0d
	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_noderD   )rA   r%   saveds      r   rV   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 r.   )overflow_checkoverflow_foldr  rD   )rA   r%   top_level_overflows      r   visit_NumBinopNodez+ConsolidateOverflowCheck.visit_NumBinopNode  sz    4#5#5!%!7!74!?!)-&)-)?)?&&+#t$!)-&  t$r    )rR   rS   rT   rU   r  rV   r  rK   r    r   r  r    s     r    r  )K
__future__r   r  r7  rQ  r  r  r}  r   r   r   cythondeclarer  version_infor  r   r  r  rn  longr?  r   r   r   r   r   r   Coder   r   StringEncodingr   r	   r
   Errorsr   r   ParseTreeTransformsr   __builtin__r   ImportError	functoolsr   r   r  r  r'   r,   r2   r9   r=   r;   r[   rX   EnvTransformra   r  r  r  r*  rO  NodeRefCleanupMixinr  MethodDispatcherTransformr  r   r  r  r  r)  r  CythonTransformr  rK   r    r   <module>r     s\   & 	 
     %  6v^dv&&v7 A!Ms|$KMw'        1 H H " 1!"&
7 /8.J.JILjLj-k '-- @c-- cL|>g** |>~I>W557G I>Xq&w77 q&h^w33 ^B44g6J6J BbT766"<<bTJ= "9!8!89Lo!^ 6{667H/Z 4[44_oV T>g..0@ T>nj--w/J/J jZ w66  gU  !  !
  Js$   3H1 :I 1I ?I II