Lines Matching refs:node
38 def unwrap_coerced_node(node, coercion_nodes=(ExprNodes.CoerceToPyTypeNode, ExprNodes.CoerceFromPyTypeNode)):
39 if isinstance(node, coercion_nodes):
40 return node.arg
41 return node
43 def unwrap_node(node):
44 while isinstance(node, UtilNodes.ResultRefNode):
45 node = node.expression
46 return node
57 def filter_none_node(node):
58 if node is not None and node.constant_result is None:
60 return node
69 def visit_PrimaryCmpNode(self, node):
70 if node.is_ptr_contains():
79 pos = node.pos
80 result_ref = UtilNodes.ResultRefNode(node)
81 if isinstance(node.operand2, ExprNodes.IndexNode):
82 base_type = node.operand2.base.type.base_type
84 base_type = node.operand2.type.base_type
88 pos, operator=u'==', operand1=node.operand1, operand2=target)
103 iterator=ExprNodes.IteratorNode(node.operand2.pos, sequence=node.operand2),
110 if node.operator == 'not_in':
115 self.visitchildren(node)
116 return node
118 def visit_ForInStatNode(self, node):
119 self.visitchildren(node)
120 return self._optimise_for_loop(node, node.iterator.sequence)
122 def _optimise_for_loop(self, node, iterator, reversed=False):
127 return node
129 node, dict_obj=iterator, method=None, keys=True, values=False)
133 return self._transform_carray_iteration(node, iterator, reversed=reversed)
135 return self._transform_bytes_iteration(node, iterator, reversed=reversed)
137 return self._transform_unicode_iteration(node, iterator, reversed=reversed)
141 return node
178 node, base_obj, method, keys, values)
186 return node
187 return self._transform_enumerate_iteration(node, iterator)
191 return node
192 return self._transform_reversed_iteration(node, iterator)
195 if Options.convert_range and node.target.type.is_int:
199 return self._transform_range_iteration(node, iterator, reversed=reversed)
201 return node
203 def _transform_reversed_iteration(self, node, reversed_function):
208 return node
212 return node
217 node.iterator.sequence = arg.as_none_safe_node("'NoneType' object is not iterable")
218 node.iterator.reversed = True
219 return node
221 return self._optimise_for_loop(node, arg, reversed=True)
233 def _transform_bytes_iteration(self, node, slice_node, reversed=False):
234 target_type = node.target.type
238 return node
259 node,
287 def _transform_unicode_iteration(self, node, slice_node, reversed=False):
309 return self._transform_carray_iteration(node, bytes_slice, reversed)
315 node.pos, value='0', constant_result=0, type=PyrexTypes.c_py_ssize_t_type)
317 end_node = length_temp.ref(node.pos)
333 counter_temp.ref(node.target.pos)],
336 if target_value.type != node.target.type:
337 target_value = target_value.coerce_to(node.target.type,
340 pos = node.target.pos,
341 lhs = node.target,
344 node.pos,
345 stats = [target_assign, node.body])
348 node.pos,
350 target=counter_temp.ref(node.target.pos),
353 else_clause=node.else_clause,
357 node.pos,
376 node.pos, temps=[counter_temp, length_temp, data_temp, kind_temp],
377 body=Nodes.StatListNode(node.pos, stats=[setup_node, loop_node])))
379 def _transform_carray_iteration(self, node, slice_node, reversed=False):
389 return node
405 return node
419 return node
430 return node
442 return node
478 counter_temp = counter.ref(node.target.pos)
480 if slice_base.type.is_string and node.target.type.is_pyobject:
485 node.target.pos, operand=counter_temp,
488 node.target.type, self.current_env())
492 node.target.pos,
493 start=ExprNodes.IntNode(node.target.pos, value='0',
496 stop=ExprNodes.IntNode(node.target.pos, value='1',
502 elif node.target.type.is_ptr and not node.target.type.assignable_from(ptr_type.base_type):
508 node.target.pos,
509 index=ExprNodes.IntNode(node.target.pos, value='0',
516 if target_value.type != node.target.type:
517 target_value = target_value.coerce_to(node.target.type,
521 pos = node.target.pos,
522 lhs = node.target,
526 node.pos,
527 stats = [target_assign, node.body])
532 node.pos,
537 else_clause=node.else_clause,
541 node.pos, temps=[counter],
544 def _transform_enumerate_iteration(self, node, enumerate_function):
549 return node
553 return node
555 if not node.target.is_sequence_constructor:
557 return node
558 targets = node.target.args
561 return node
568 return node
582 operand2 = ExprNodes.IntNode(node.pos, value='1',
602 if isinstance(node.body, Nodes.StatListNode):
603 node.body.stats = loop_body + node.body.stats
605 loop_body.append(node.body)
606 node.body = Nodes.StatListNode(
607 node.body.pos,
610 node.target = iterable_target
611 node.item = node.item.coerce_to(iterable_target.type, self.current_env())
612 node.iterator.sequence = args[0]
615 return UtilNodes.LetNode(temp, self._optimise_for_loop(node, node.iterator.sequence))
629 def _transform_range_iteration(self, node, range_function, reversed=False):
641 return node
645 return node
648 return node
683 node.pos,
684 target=node.target,
687 step=step, body=node.body,
688 else_clause=node.else_clause,
696 def _transform_dict_iteration(self, node, dict_obj, method, keys, values):
703 pos_temp = temp.ref(node.pos)
707 if node.target.is_sequence_constructor:
708 if len(node.target.args) == 2:
709 key_target, value_target = node.target.args
712 return node
714 tuple_target = node.target
716 key_target = node.target
718 value_target = node.target
720 if isinstance(node.body, Nodes.StatListNode):
721 body = node.body
723 body = Nodes.StatListNode(pos = node.body.pos,
724 stats = [node.body])
730 node.pos, operand=dict_len_temp.ref(dict_obj.pos),
734 is_dict_temp = temp.ref(node.pos)
736 node.pos, operand=is_dict_temp,
759 return ExprNodes.IntNode(node.pos, value=str(value), constant_result=value)
763 node.pos,
765 rhs = ExprNodes.IntNode(node.pos, value='0',
781 node.pos,
784 else_clause = node.else_clause
789 node.pos, temps=temps,
791 node.pos,
919 def visit_IfStatNode(self, node):
922 for if_clause in node.if_clauses:
926 self.visitchildren(node)
927 return node
935 self.visitchildren(node)
936 return node
938 self.visitchildren(node)
939 return node
942 switch_node = Nodes.SwitchStatNode(pos = node.pos,
945 else_clause = node.else_clause)
948 def visit_CondExprNode(self, node):
950 None, node.test, True)
954 self.visitchildren(node)
955 return node
957 node, common_var, conditions, not_in,
958 node.true_val, node.false_val)
960 def visit_BoolBinopNode(self, node):
962 None, node, True)
966 self.visitchildren(node)
967 return node
970 node, common_var, conditions, not_in,
971 ExprNodes.BoolNode(node.pos, value=True, constant_result=True),
972 ExprNodes.BoolNode(node.pos, value=False, constant_result=False))
974 def visit_PrimaryCmpNode(self, node):
976 None, node, True)
980 self.visitchildren(node)
981 return node
984 node, common_var, conditions, not_in,
985 ExprNodes.BoolNode(node.pos, value=True, constant_result=True),
986 ExprNodes.BoolNode(node.pos, value=False, constant_result=False))
988 def build_simple_switch_statement(self, node, common_var, conditions,
990 result_ref = UtilNodes.ResultRefNode(node)
992 node.pos,
997 node.pos,
1005 cases = [Nodes.SwitchCaseNode(pos = node.pos,
1010 switch_node = Nodes.SwitchStatNode(pos = node.pos,
1017 def visit_EvalWithTempExprNode(self, node):
1019 orig_expr = node.subexpression
1020 temp_ref = node.lazy_temp
1021 self.visitchildren(node)
1022 if node.subexpression is not orig_expr:
1023 # node was restructured => check if temp is still used
1024 if not Visitor.tree_contains(node.subexpression, temp_ref):
1025 return node.subexpression
1026 return node
1037 def visit_PrimaryCmpNode(self, node):
1038 self.visitchildren(node)
1039 if node.cascade is not None:
1040 return node
1041 elif node.operator == 'in':
1044 elif node.operator == 'not_in':
1048 return node
1050 if not isinstance(node.operand2, (ExprNodes.TupleNode,
1053 return node
1055 args = node.operand2.args
1058 return node
1060 lhs = UtilNodes.ResultRefNode(node.operand1)
1078 pos = node.pos,
1084 pos = node.pos,
1089 pos = node.pos,
1108 def visit_ParallelAssignmentNode(self, node):
1116 for stat in node.stats:
1120 return node
1123 return node
1126 return node
1128 return node
1135 return node
1137 return node
1146 return node
1152 return node
1156 return node
1158 return node
1162 return node
1175 return node
1177 def _extract_operand(self, node, names, indices, temps):
1178 node = unwrap_node(node)
1179 if not node.type.is_pyobject:
1181 if isinstance(node, ExprNodes.CoerceToTempNode):
1182 temps.append(node)
1183 node = node.arg
1185 obj_node = node
1193 names.append( ('.'.join(name_path[::-1]), node) )
1194 elif isinstance(node, ExprNodes.IndexNode):
1195 if node.base.type != Builtin.list_type:
1197 if not node.index.type.is_int:
1199 if not isinstance(node.base, ExprNodes.NameNode):
1201 indices.append(node)
1234 def visit_SimpleCallNode(self, node):
1235 self.visitchildren(node)
1236 function = node.function
1238 return node
1239 return self._dispatch_to_handler(node, function, node.args)
1241 def visit_GeneralCallNode(self, node):
1242 self.visitchildren(node)
1243 function = node.function
1245 return node
1246 arg_tuple = node.positional_args
1248 return node
1251 node, function, args, node.keyword_args)
1263 def _dispatch_to_handler(self, node, function, args, kwargs=None):
1271 return handle_call(node, args)
1273 return handle_call(node, args, kwargs)
1274 return node
1276 def _inject_capi_function(self, node, cname, func_type, utility_code=None):
1277 node.function = ExprNodes.PythonCapiFunctionNode(
1278 node.function.pos, node.function.name, cname, func_type,
1281 def _error_wrong_arg_count(self, function_name, node, args, expected=None):
1294 error(node.pos, "%s(%s) called with wrong number of args, %sfound %d" % (
1299 def _handle_simple_function_float(self, node, pos_args):
1301 return ExprNodes.FloatNode(node.pos, value='0.0')
1303 self._error_wrong_arg_count('float', node, pos_args, 1)
1307 return node
1317 def __visit_YieldExprNode(self, node):
1318 self.yield_nodes.append(node)
1319 self.visitchildren(node)
1321 def __visit_ExprStatNode(self, node):
1322 self.visitchildren(node)
1323 if node.expr in self.yield_nodes:
1324 self.yield_stat_nodes[node.expr] = node
1326 def __visit_GeneratorExpressionNode(self, node):
1329 # everything below this node is out of scope
1332 def _find_single_yield_expression(self, node):
1334 collector.visitchildren(node)
1343 def _handle_simple_function_all(self, node, pos_args):
1361 return self._transform_any_all(node, pos_args, False)
1363 def _handle_simple_function_any(self, node, pos_args):
1381 return self._transform_any_all(node, pos_args, True)
1383 def _transform_any_all(self, node, pos_args, is_any):
1385 return node
1387 return node
1392 return node
1399 result_ref = UtilNodes.ResultRefNode(pos=node.pos, type=PyrexTypes.c_bint_type)
1407 node.pos,
1410 node.pos,
1414 Nodes.BreakStatNode(node.pos)
1427 node.pos,
1438 def _handle_simple_function_sorted(self, node, pos_args):
1446 return node
1456 return node
1470 return node
1475 node.pos, lhs = result_node, rhs = listcomp_node, first = True)
1478 node.pos, obj = result_node, attribute = EncodedString('sort'),
1482 node.pos, expr = ExprNodes.SimpleCallNode(
1483 node.pos, function = sort_method, args = []))
1489 Nodes.StatListNode(node.pos, stats = [ listcomp_assign_node, sort_node ]))
1491 def _handle_simple_function_sum(self, node, pos_args):
1495 return node
1498 return node
1505 return node
1511 return node
1513 return node # in case we don't have a type yet
1518 start = ExprNodes.IntNode(node.pos, value='0', constant_result=0)
1522 result_ref = UtilNodes.ResultRefNode(pos=node.pos, type=PyrexTypes.py_object_type)
1526 rhs = ExprNodes.binop_node(node.pos, '+', result_ref, yield_expression)
1532 node.pos,
1536 lhs = UtilNodes.ResultRefNode(pos=node.pos, expression=result_ref),
1547 def _handle_simple_function_min(self, node, pos_args):
1548 return self._optimise_min_max(node, pos_args, '<')
1550 def _handle_simple_function_max(self, node, pos_args):
1551 return self._optimise_min_max(node, pos_args, '>')
1553 def _optimise_min_max(self, node, args, operator):
1561 return node
1586 def _DISABLED_handle_simple_function_tuple(self, node, pos_args):
1588 return ExprNodes.TupleNode(node.pos, args=[], constant_result=())
1592 # easily do without explicit node support. Instead, we read
1596 result = self._transform_list_set_genexpr(node, pos_args, Builtin.list_type)
1597 if result is not node:
1598 return ExprNodes.AsTupleNode(node.pos, arg=result)
1599 return node
1601 def _handle_simple_function_frozenset(self, node, pos_args):
1605 return node
1610 return node
1612 def _handle_simple_function_list(self, node, pos_args):
1614 return ExprNodes.ListNode(node.pos, args=[], constant_result=[])
1615 return self._transform_list_set_genexpr(node, pos_args, Builtin.list_type)
1617 def _handle_simple_function_set(self, node, pos_args):
1619 return ExprNodes.SetNode(node.pos, args=[], constant_result=set())
1620 return self._transform_list_set_genexpr(node, pos_args, Builtin.set_type)
1622 def _transform_list_set_genexpr(self, node, pos_args, target_type):
1626 return node
1628 return node
1634 return node
1643 node.pos,
1652 def _handle_simple_function_dict(self, node, pos_args):
1656 return ExprNodes.DictNode(node.pos, key_value_pairs=[], constant_result={})
1658 return node
1660 return node
1666 return node
1669 return node
1671 return node
1681 node.pos,
1692 def _handle_general_function_dict(self, node, pos_args, kwargs):
1697 return node
1699 return node
1718 def visit_SimpleCallNode(self, node):
1719 self.visitchildren(node)
1721 return node
1722 function_name = node.function
1724 return node
1727 return node
1729 node.pos, function_name=function_name,
1730 function=function, args=node.args)
1732 return self.replace(node, inlined)
1733 return node
1746 def _visit_PyTypeTestNode(self, node):
1751 old_arg = node.arg
1752 self.visitchildren(node)
1753 if old_arg is node.arg or node.arg.type != node.type:
1754 return node
1755 return node.arg
1757 def _visit_TypecastNode(self, node):
1763 self.visitchildren(node)
1764 if node.type == node.operand.type:
1765 return node.operand
1766 return node
1768 def visit_ExprStatNode(self, node):
1772 self.visitchildren(node)
1773 if isinstance(node.expr, ExprNodes.CoerceToPyTypeNode):
1774 node.expr = node.expr.arg
1775 return node
1777 def visit_CoerceToBooleanNode(self, node):
1780 self.visitchildren(node)
1781 arg = node.arg
1787 return node
1789 def visit_CoerceFromPyTypeNode(self, node):
1796 self.visitchildren(node)
1797 arg = node.arg
1800 if node.type == arg.type:
1803 return arg.coerce_to(node.type, self.current_env())
1807 if (node.type.is_int and isinstance(arg, ExprNodes.IntNode) or
1808 node.type.is_float and isinstance(arg, ExprNodes.FloatNode) or
1809 node.type.is_int and isinstance(arg, ExprNodes.BoolNode)):
1810 return arg.coerce_to(node.type, self.current_env())
1813 if node.type.assignable_from(arg.arg.type):
1815 return arg.arg.coerce_to(node.type, self.current_env())
1817 if node.type.is_int or node.type.is_float:
1818 return self._optimise_numeric_cast_call(node, arg)
1824 return self._optimise_int_indexing(node, arg, index_node)
1825 return node
1845 node = ExprNodes.PythonCapiCallNode(
1857 node = node.coerce_to(coerce_node.type, env)
1858 return node
1861 def _optimise_numeric_cast_call(self, node, arg):
1866 return node
1869 return node
1875 return node
1877 if func_arg.type.is_int or node.type.is_int:
1878 if func_arg.type == node.type:
1880 elif node.type.assignable_from(func_arg.type) or func_arg.type.is_float:
1882 node.pos, operand=func_arg, type=node.type)
1884 if func_arg.type.is_float or node.type.is_float:
1885 if func_arg.type == node.type:
1887 elif node.type.assignable_from(func_arg.type) or func_arg.type.is_float:
1889 node.pos, operand=func_arg, type=node.type)
1890 return node
1892 def _error_wrong_arg_count(self, function_name, node, args, expected=None):
1905 error(node.pos, "%s(%s) called with wrong number of args, %sfound %d" % (
1910 def _handle_function(self, node, function_name, function, arg_list, kwargs):
1911 return node
1913 def _handle_method(self, node, type_name, attr_name, function,
1922 return node
1926 return node
1929 return node
1931 node.function.pos,
1940 return node
1941 args = node.args
1942 if args is None and node.arg_tuple:
1943 args = node.arg_tuple.args
1945 node.pos,
1952 return call_node.coerce_to(node.type, self.current_env())
1961 def _handle_simple_function_dict(self, node, function, pos_args):
1965 return node
1970 node.pos, "PyDict_Copy", self.PyDict_Copy_func_type,
1972 is_temp = node.is_temp
1974 return node
1981 def _handle_simple_function_tuple(self, node, function, pos_args):
1985 return node
1990 return node
1995 node.pos, "PyList_AsTuple", self.PyList_AsTuple_func_type,
1997 is_temp = node.is_temp
2005 def _handle_simple_function_set(self, node, function, pos_args):
2007 return node
2021 result = ExprNodes.SetNode(node.pos, is_temp=1, args=args)
2028 node.pos, "PySet_New",
2031 is_temp=node.is_temp,
2040 def _handle_simple_function_frozenset(self, node, function, pos_args):
2042 pos_args = [ExprNodes.NullNode(node.pos)]
2044 return node
2049 node.pos, "__Pyx_PyFrozenSet_New",
2052 is_temp=node.is_temp,
2063 def _handle_simple_function_float(self, node, function, pos_args):
2071 node, value="0.0", constant_result=0.0
2074 self._error_wrong_arg_count('float', node, pos_args, '0 or 1')
2075 return node
2081 elif node.type.assignable_from(func_arg.type) or func_arg.type.is_numeric:
2083 node.pos, operand=func_arg, type=node.type)
2085 node.pos, "__Pyx_PyObject_AsDouble",
2088 is_temp = node.is_temp,
2097 def _handle_simple_function_int(self, node, function, pos_args):
2101 return ExprNodes.IntNode(node, value="0", constant_result=0,
2104 return node # int(x, base)
2107 return node # handled in visit_CoerceFromPyTypeNode()
2108 if func_arg.type.is_pyobject and node.type.is_pyobject:
2110 node.pos, "PyNumber_Int", self.PyNumber_Int_func_type,
2112 return node
2114 def _handle_simple_function_bool(self, node, function, pos_args):
2119 node.pos, value=False, constant_result=False
2122 self._error_wrong_arg_count('bool', node, pos_args, '0 or 1')
2123 return node
2127 operand = ExprNodes.NotNode(node.pos, operand = operand)
2128 operand = ExprNodes.NotNode(node.pos, operand = operand)
2162 def _handle_simple_function_len(self, node, function, pos_args):
2168 self._error_wrong_arg_count('len', node, pos_args, 1)
2169 return node
2175 node.pos, "strlen", self.Pyx_strlen_func_type,
2177 is_temp = node.is_temp,
2181 node.pos, "__Pyx_Py_UNICODE_strlen", self.Pyx_Py_UNICODE_strlen_func_type,
2183 is_temp = node.is_temp)
2192 return node
2196 node.pos, cfunc_name, self.PyObject_Size_func_type,
2198 is_temp = node.is_temp)
2200 return ExprNodes.IntNode(node.pos, value='1', constant_result=1,
2201 type=node.type)
2203 return node
2204 if node.type not in (PyrexTypes.c_size_t_type, PyrexTypes.c_py_ssize_t_type):
2205 new_node = new_node.coerce_to(node.type, self.current_env())
2213 def _handle_simple_function_type(self, node, function, pos_args):
2217 return node
2218 node = ExprNodes.PythonCapiCallNode(
2219 node.pos, "Py_TYPE", self.Pyx_Type_func_type,
2222 return ExprNodes.CastNode(node, PyrexTypes.py_object_type)
2229 def _handle_simple_function_isinstance(self, node, function, pos_args):
2234 return node
2244 return node
2271 return node
2280 or_node = make_binop_node(node.pos, 'or', a, b)
2285 test_node = reduce(join_with_or, test_nodes).coerce_to(node.type, env)
2290 def _handle_simple_function_ord(self, node, function, pos_args):
2294 return node
2300 ).coerce_to(node.type, self.current_env())
2307 ).coerce_to(node.type, self.current_env())
2315 ).coerce_to(node.type, self.current_env())
2316 return node
2333 def _handle_any_slot__new__(self, node, function, args,
2339 return node
2343 return node
2346 return node
2349 return node
2354 return node
2356 args_tuple = ExprNodes.TupleNode(node.pos, args=args[1:])
2380 kwargs = ExprNodes.NullNode(node.pos, type=PyrexTypes.py_object_type) # hack?
2382 node.pos, slot_func_cname,
2394 node.pos, "__Pyx_tp_new_kwargs", self.Pyx_tp_new_kwargs_func_type,
2397 is_temp=node.is_temp
2401 node.pos, "__Pyx_tp_new", self.Pyx_tp_new_func_type,
2404 is_temp=node.is_temp
2416 def _handle_simple_method_object_append(self, node, function, args, is_unbound_method):
2420 if len(args) != 2 or node.result_is_used:
2421 return node
2424 node.pos, "__Pyx_PyObject_Append", self.PyObject_Append_func_type,
2427 is_temp=node.is_temp,
2446 def _handle_simple_method_bytearray_append(self, node, function, args, is_unbound_method):
2448 return node
2458 return node
2466 return node
2469 node.pos, func_name, func_type,
2472 is_temp=node.is_temp,
2475 if node.result_is_used:
2476 new_node = new_node.coerce_to(node.type, self.current_env())
2490 def _handle_simple_method_list_pop(self, node, function, args, is_unbound_method):
2492 node, function, args, is_unbound_method, is_list=True)
2494 def _handle_simple_method_object_pop(self, node, function, args, is_unbound_method, is_list=False):
2499 return node
2511 node.pos, "__Pyx_Py%s_Pop" % type_name,
2515 is_temp=node.is_temp,
2528 node.pos, "__Pyx_Py%s_PopIndex" % type_name,
2532 is_temp=node.is_temp,
2536 return node
2544 def _handle_simple_method_list_sort(self, node, function, args, is_unbound_method):
2548 return node
2550 node, function, "PyList_Sort", self.single_param_func_type,
2551 'sort', is_unbound_method, args).coerce_to(node.type, self.current_env)
2560 def _handle_simple_method_dict_get(self, node, function, args, is_unbound_method):
2564 args.append(ExprNodes.NoneNode(node.pos))
2566 self._error_wrong_arg_count('dict.get', node, args, "2 or 3")
2567 return node
2570 node, function,
2584 def _handle_simple_method_dict_setdefault(self, node, function, args, is_unbound_method):
2588 args.append(ExprNodes.NoneNode(node.pos))
2590 self._error_wrong_arg_count('dict.setdefault', node, args, "2 or 3")
2591 return node
2601 node.pos, value=str(is_safe_type), constant_result=is_safe_type))
2604 node, function,
2618 def _inject_unicode_predicate(self, node, function, args, is_unbound_method):
2620 return node
2624 return node
2636 node, function,
2640 if node.type.is_pyobject:
2659 def _inject_unicode_character_conversion(self, node, function, args, is_unbound_method):
2661 return node
2665 return node
2670 node, function,
2673 if node.type.is_pyobject:
2687 def _handle_simple_method_unicode_splitlines(self, node, function, args, is_unbound_method):
2692 self._error_wrong_arg_count('unicode.splitlines', node, args, "1 or 2")
2693 return node
2694 self._inject_bint_default_argument(node, args, 1, False)
2697 node, function,
2709 def _handle_simple_method_unicode_split(self, node, function, args, is_unbound_method):
2714 self._error_wrong_arg_count('unicode.split', node, args, "1-3")
2715 return node
2717 args.append(ExprNodes.NullNode(node.pos))
2719 node, args, 2, PyrexTypes.c_py_ssize_t_type, "-1")
2722 node, function,
2736 def _handle_simple_method_unicode_endswith(self, node, function, args, is_unbound_method):
2738 node, function, args, is_unbound_method, 'unicode', 'endswith',
2741 def _handle_simple_method_unicode_startswith(self, node, function, args, is_unbound_method):
2743 node, function, args, is_unbound_method, 'unicode', 'startswith',
2746 def _inject_tailmatch(self, node, function, args, is_unbound_method, type_name,
2752 self._error_wrong_arg_count('%s.%s' % (type_name, method_name), node, args, "2-4")
2753 return node
2755 node, args, 2, PyrexTypes.c_py_ssize_t_type, "0")
2757 node, args, 3, PyrexTypes.c_py_ssize_t_type, "PY_SSIZE_T_MAX")
2759 node.pos, value=str(direction), type=PyrexTypes.c_int_type))
2762 node, function,
2779 def _handle_simple_method_unicode_find(self, node, function, args, is_unbound_method):
2781 node, function, args, is_unbound_method, 'find', +1)
2783 def _handle_simple_method_unicode_rfind(self, node, function, args, is_unbound_method):
2785 node, function, args, is_unbound_method, 'rfind', -1)
2787 def _inject_unicode_find(self, node, function, args, is_unbound_method,
2793 self._error_wrong_arg_count('unicode.%s' % method_name, node, args, "2-4")
2794 return node
2796 node, args, 2, PyrexTypes.c_py_ssize_t_type, "0")
2798 node, args, 3, PyrexTypes.c_py_ssize_t_type, "PY_SSIZE_T_MAX")
2800 node.pos, value=str(direction), type=PyrexTypes.c_int_type))
2803 node, function, "PyUnicode_Find", self.PyUnicode_Find_func_type,
2816 def _handle_simple_method_unicode_count(self, node, function, args, is_unbound_method):
2821 self._error_wrong_arg_count('unicode.count', node, args, "2-4")
2822 return node
2824 node, args, 2, PyrexTypes.c_py_ssize_t_type, "0")
2826 node, args, 3, PyrexTypes.c_py_ssize_t_type, "PY_SSIZE_T_MAX")
2829 node, function, "PyUnicode_Count", self.PyUnicode_Count_func_type,
2841 def _handle_simple_method_unicode_replace(self, node, function, args, is_unbound_method):
2846 self._error_wrong_arg_count('unicode.replace', node, args, "3-4")
2847 return node
2849 node, args, 3, PyrexTypes.c_py_ssize_t_type, "-1")
2852 node, function, "PyUnicode_Replace", self.PyUnicode_Replace_func_type,
2873 def _handle_simple_method_unicode_encode(self, node, function, args, is_unbound_method):
2878 self._error_wrong_arg_count('unicode.encode', node, args, '1-3')
2879 return node
2884 null_node = ExprNodes.NullNode(node.pos)
2886 node, function, "PyUnicode_AsEncodedString",
2890 parameters = self._unpack_encoding_and_error_mode(node.pos, args)
2892 return node
2914 node, function, encode_function,
2919 node, function, "PyUnicode_AsEncodedString",
2953 def _handle_simple_method_bytes_decode(self, node, function, args, is_unbound_method):
2958 self._error_wrong_arg_count('bytes.decode', node, args, '1-3')
2959 return node
2986 return node
2988 parameters = self._unpack_encoding_and_error_mode(node.pos, args)
2990 return node
2994 start = ExprNodes.IntNode(node.pos, value='0', constant_result=0)
3006 node.pos, type=self.PyUnicode_DecodeXyz_func_ptr_type,
3008 encoding_node = ExprNodes.NullNode(node.pos)
3010 decode_function = ExprNodes.NullNode(node.pos)
3032 stop = ExprNodes.IntNode(node.pos, value='PY_SSIZE_T_MAX',
3050 stop = ExprNodes.IntNode(node.pos, value='PY_SSIZE_T_MAX',
3058 node = ExprNodes.PythonCapiCallNode(
3059 node.pos, '__Pyx_%s' % utility_code_name, helper_func_type,
3061 is_temp=node.is_temp,
3066 node = UtilNodes.EvalWithTempExprNode(temp, node)
3067 return node
3107 def _unpack_string_and_cstring_node(self, node):
3108 if isinstance(node, ExprNodes.CoerceToPyTypeNode):
3109 node = node.arg
3110 if isinstance(node, ExprNodes.UnicodeNode):
3111 encoding = node.value
3112 node = ExprNodes.BytesNode(
3113 node.pos, value=BytesLiteral(encoding.utf8encode()),
3115 elif isinstance(node, (ExprNodes.StringNode, ExprNodes.BytesNode)):
3116 encoding = node.value.decode('ISO-8859-1')
3117 node = ExprNodes.BytesNode(
3118 node.pos, value=node.value, type=PyrexTypes.c_char_ptr_type)
3119 elif node.type is Builtin.bytes_type:
3121 node = node.coerce_to(PyrexTypes.c_char_ptr_type, self.current_env())
3122 elif node.type.is_string:
3125 encoding = node = None
3126 return encoding, node
3128 def _handle_simple_method_str_endswith(self, node, function, args, is_unbound_method):
3130 node, function, args, is_unbound_method, 'str', 'endswith',
3133 def _handle_simple_method_str_startswith(self, node, function, args, is_unbound_method):
3135 node, function, args, is_unbound_method, 'str', 'startswith',
3138 def _handle_simple_method_bytes_endswith(self, node, function, args, is_unbound_method):
3140 node, function, args, is_unbound_method, 'bytes', 'endswith',
3143 def _handle_simple_method_bytes_startswith(self, node, function, args, is_unbound_method):
3145 node, function, args, is_unbound_method, 'bytes', 'startswith',
3149 def _handle_simple_method_bytearray_endswith(self, node, function, args, is_unbound_method):
3151 node, function, args, is_unbound_method, 'bytearray', 'endswith',
3154 def _handle_simple_method_bytearray_startswith(self, node, function, args, is_unbound_method):
3156 node, function, args, is_unbound_method, 'bytearray', 'startswith',
3162 def _substitute_method_call(self, node, function, name, func_type,
3180 is_temp = node.is_temp
3182 node.pos, name, func_type,
3187 result_is_used = node.result_is_used,
3190 def _inject_int_default_argument(self, node, args, arg_index, type, default_value):
3193 args.append(ExprNodes.IntNode(node.pos, value=str(default_value),
3198 def _inject_bint_default_argument(self, node, args, arg_index, default_value):
3202 args.append(ExprNodes.BoolNode(node.pos, value=default_value,
3222 node to prevent any loss of precision.
3227 into a single node.
3238 def _calculate_const(self, node):
3240 node.constant_result is not ExprNodes.constant_value_not_set):
3245 node.constant_result = not_a_constant
3248 children = self.visitchildren(node)
3259 node.calculate_constant_result()
3260 # if node.constant_result is not ExprNodes.not_a_constant:
3261 # print node.__class__.__name__, node.constant_result
3280 def _bool_node(self, node, value):
3282 return ExprNodes.BoolNode(node.pos, value=value, constant_result=value)
3284 def visit_ExprNode(self, node):
3285 self._calculate_const(node)
3286 return node
3288 def visit_UnopNode(self, node):
3289 self._calculate_const(node)
3290 if not node.has_constant_result():
3291 if node.operator == '!':
3292 return self._handle_NotNode(node)
3293 return node
3294 if not node.operand.is_literal:
3295 return node
3296 if node.operator == '!':
3297 return self._bool_node(node, node.constant_result)
3298 elif isinstance(node.operand, ExprNodes.BoolNode):
3299 return ExprNodes.IntNode(node.pos, value=str(int(node.constant_result)),
3301 constant_result=int(node.constant_result))
3302 elif node.operator == '+':
3303 return self._handle_UnaryPlusNode(node)
3304 elif node.operator == '-':
3305 return self._handle_UnaryMinusNode(node)
3306 return node
3315 def _handle_NotNode(self, node):
3316 operand = node.operand
3320 node = copy.copy(operand)
3321 node.operator = operator
3322 node = self.visit_PrimaryCmpNode(node)
3323 return node
3325 def _handle_UnaryMinusNode(self, node):
3333 node_type = node.operand.type
3334 if isinstance(node.operand, ExprNodes.FloatNode):
3336 return ExprNodes.FloatNode(node.pos, value=_negate(node.operand.value),
3338 constant_result=node.constant_result)
3340 isinstance(node.operand, ExprNodes.IntNode) and node_type.is_pyobject:
3341 return ExprNodes.IntNode(node.pos, value=_negate(node.operand.value),
3343 longness=node.operand.longness,
3344 constant_result=node.constant_result)
3345 return node
3347 def _handle_UnaryPlusNode(self, node):
3348 if (node.operand.has_constant_result() and
3349 node.constant_result == node.operand.constant_result):
3350 return node.operand
3351 return node
3353 def visit_BoolBinopNode(self, node):
3354 self._calculate_const(node)
3355 if not node.operand1.has_constant_result():
3356 return node
3357 if node.operand1.constant_result:
3358 if node.operator == 'and':
3359 return node.operand2
3361 return node.operand1
3363 if node.operator == 'and':
3364 return node.operand1
3366 return node.operand2
3368 def visit_BinopNode(self, node):
3369 self._calculate_const(node)
3370 if node.constant_result is ExprNodes.not_a_constant:
3371 return node
3372 if isinstance(node.constant_result, float):
3373 return node
3374 operand1, operand2 = node.operand1, node.operand2
3376 return node
3378 # now inject a new constant node with the calculated value
3382 return node
3384 return node
3393 return node
3394 elif target_class is ExprNodes.BoolNode and node.operator in '+-//<<%**>>':
3397 elif target_class is ExprNodes.CharNode and node.operator in '+-//<<%**>>&|^':
3406 new_node = ExprNodes.IntNode(pos=node.pos,
3408 value=str(int(node.constant_result)),
3409 constant_result=int(node.constant_result))
3418 node_value = node.constant_result
3420 node_value = str(node.constant_result)
3421 new_node = target_class(pos=node.pos, type = widest_type,
3423 constant_result = node.constant_result)
3426 def visit_MulNode(self, node):
3427 self._calculate_const(node)
3428 if node.operand1.is_sequence_constructor:
3429 return self._calculate_constant_seq(node, node.operand1, node.operand2)
3430 if isinstance(node.operand1, ExprNodes.IntNode) and \
3431 node.operand2.is_sequence_constructor:
3432 return self._calculate_constant_seq(node, node.operand2, node.operand1)
3433 return self.visit_BinopNode(node)
3435 def _calculate_constant_seq(self, node, sequence_node, factor):
3449 return self.visit_BinopNode(node)
3454 def visit_PrimaryCmpNode(self, node):
3456 self.visitchildren(node, ['operand1'])
3457 left_node = node.operand1
3458 cmp_node = node
3471 if not node.cascade:
3472 if node.has_constant_result():
3473 return self._bool_node(node, node.constant_result)
3474 return node
3477 cascades = [[node.operand1]]
3495 split_cascades(node)
3521 return self._bool_node(node, True)
3522 node = cmp_nodes[0]
3524 if node.has_constant_result():
3525 return self._bool_node(node, node.constant_result)
3528 node = ExprNodes.BoolBinopNode(
3529 node.pos,
3530 operand1=node,
3534 return node
3536 def visit_CondExprNode(self, node):
3537 self._calculate_const(node)
3538 if not node.test.has_constant_result():
3539 return node
3540 if node.test.constant_result:
3541 return node.true_val
3543 return node.false_val
3545 def visit_IfStatNode(self, node):
3546 self.visitchildren(node)
3549 for if_clause in node.if_clauses:
3554 node.else_clause = if_clause.body
3561 node.if_clauses = if_clauses
3562 return node
3563 elif node.else_clause:
3564 return node.else_clause
3566 return Nodes.StatListNode(node.pos, stats=[])
3568 def visit_SliceIndexNode(self, node):
3569 self._calculate_const(node)
3571 if node.start is None or node.start.constant_result is None:
3572 start = node.start = None
3574 start = node.start.constant_result
3575 if node.stop is None or node.stop.constant_result is None:
3576 stop = node.stop = None
3578 stop = node.stop.constant_result
3580 if node.constant_result is not not_a_constant:
3581 base = node.base
3589 return node
3591 def visit_ComprehensionNode(self, node):
3592 self.visitchildren(node)
3593 if isinstance(node.loop, Nodes.StatListNode) and not node.loop.stats:
3595 if node.type is Builtin.list_type:
3597 node.pos, args=[], constant_result=[])
3598 elif node.type is Builtin.set_type:
3600 node.pos, args=[], constant_result=set())
3601 elif node.type is Builtin.dict_type:
3603 node.pos, key_value_pairs=[], constant_result={})
3604 return node
3606 def visit_ForInStatNode(self, node):
3607 self.visitchildren(node)
3608 sequence = node.iterator.sequence
3611 if node.else_clause:
3612 return node.else_clause
3615 return Nodes.StatListNode(node.pos, stats=[])
3618 node.iterator.sequence = sequence.as_tuple()
3619 return node
3621 def visit_WhileStatNode(self, node):
3622 self.visitchildren(node)
3623 if node.condition and node.condition.has_constant_result():
3624 if node.condition.constant_result:
3625 node.condition = None
3626 node.else_clause = None
3628 return node.else_clause
3629 return node
3631 def visit_ExprStatNode(self, node):
3632 self.visitchildren(node)
3633 if not isinstance(node.expr, ExprNodes.ExprNode):
3635 return node
3637 if node.expr.has_constant_result():
3639 return node
3642 # that can replace them with a constant result node
3657 def visit_SingleAssignmentNode(self, node):
3661 self.visitchildren(node)
3662 if node.first:
3663 lhs = node.lhs
3665 return node
3667 def visit_SimpleCallNode(self, node):
3671 self.visitchildren(node)
3672 if node.function.type.is_cfunction and isinstance(node.function, ExprNodes.NameNode):
3673 if node.function.name == 'isinstance' and len(node.args) == 2:
3674 type_arg = node.args[1]
3677 node.function.entry = cython_scope.lookup('PyObject_TypeCheck')
3678 node.function.type = node.function.entry.type
3680 node.args[1] = ExprNodes.CastNode(node.args[1], PyTypeObjectPtr)
3681 return node
3683 def visit_PyTypeTestNode(self, node):
3688 self.visitchildren(node)
3689 if not node.notnone:
3690 if not node.arg.may_be_none():
3691 node.notnone = True
3692 return node
3694 def visit_NoneCheckNode(self, node):
3698 self.visitchildren(node)
3699 if not node.arg.may_be_none():
3700 return node.arg
3701 return node
3712 def visit_Node(self, node):
3716 self.visitchildren(node)
3719 self.visitchildren(node)
3720 return node
3722 def visit_NumBinopNode(self, node):
3723 if node.overflow_check and node.overflow_fold:
3726 self.overflow_bit_node = node
3728 node.overflow_bit_node = self.overflow_bit_node
3729 node.overflow_check = False
3730 self.visitchildren(node)
3734 self.visitchildren(node)
3735 return node