360 lines
11 KiB
Python
360 lines
11 KiB
Python
#
|
|
# Nodes used as utilities and support for transforms etc.
|
|
# These often make up sets including both Nodes and ExprNodes
|
|
# so it is convenient to have them in a separate module.
|
|
#
|
|
|
|
from __future__ import absolute_import
|
|
|
|
from . import Nodes
|
|
from . import ExprNodes
|
|
from .Nodes import Node
|
|
from .ExprNodes import AtomicExprNode
|
|
from .PyrexTypes import c_ptr_type
|
|
|
|
|
|
class TempHandle(object):
|
|
# THIS IS DEPRECATED, USE LetRefNode instead
|
|
temp = None
|
|
needs_xdecref = False
|
|
def __init__(self, type, needs_cleanup=None):
|
|
self.type = type
|
|
if needs_cleanup is None:
|
|
self.needs_cleanup = type.is_pyobject
|
|
else:
|
|
self.needs_cleanup = needs_cleanup
|
|
|
|
def ref(self, pos):
|
|
return TempRefNode(pos, handle=self, type=self.type)
|
|
|
|
|
|
class TempRefNode(AtomicExprNode):
|
|
# THIS IS DEPRECATED, USE LetRefNode instead
|
|
# handle TempHandle
|
|
|
|
def analyse_types(self, env):
|
|
assert self.type == self.handle.type
|
|
return self
|
|
|
|
def analyse_target_types(self, env):
|
|
assert self.type == self.handle.type
|
|
return self
|
|
|
|
def analyse_target_declaration(self, env):
|
|
pass
|
|
|
|
def calculate_result_code(self):
|
|
result = self.handle.temp
|
|
if result is None: result = "<error>" # might be called and overwritten
|
|
return result
|
|
|
|
def generate_result_code(self, code):
|
|
pass
|
|
|
|
def generate_assignment_code(self, rhs, code, overloaded_assignment=False):
|
|
if self.type.is_pyobject:
|
|
rhs.make_owned_reference(code)
|
|
# TODO: analyse control flow to see if this is necessary
|
|
code.put_xdecref(self.result(), self.ctype())
|
|
code.putln('%s = %s;' % (
|
|
self.result(),
|
|
rhs.result() if overloaded_assignment else rhs.result_as(self.ctype()),
|
|
))
|
|
rhs.generate_post_assignment_code(code)
|
|
rhs.free_temps(code)
|
|
|
|
|
|
class TempsBlockNode(Node):
|
|
# THIS IS DEPRECATED, USE LetNode instead
|
|
|
|
"""
|
|
Creates a block which allocates temporary variables.
|
|
This is used by transforms to output constructs that need
|
|
to make use of a temporary variable. Simply pass the types
|
|
of the needed temporaries to the constructor.
|
|
|
|
The variables can be referred to using a TempRefNode
|
|
(which can be constructed by calling get_ref_node).
|
|
"""
|
|
|
|
# temps [TempHandle]
|
|
# body StatNode
|
|
|
|
child_attrs = ["body"]
|
|
|
|
def generate_execution_code(self, code):
|
|
for handle in self.temps:
|
|
handle.temp = code.funcstate.allocate_temp(
|
|
handle.type, manage_ref=handle.needs_cleanup)
|
|
self.body.generate_execution_code(code)
|
|
for handle in self.temps:
|
|
if handle.needs_cleanup:
|
|
if handle.needs_xdecref:
|
|
code.put_xdecref_clear(handle.temp, handle.type)
|
|
else:
|
|
code.put_decref_clear(handle.temp, handle.type)
|
|
code.funcstate.release_temp(handle.temp)
|
|
|
|
def analyse_declarations(self, env):
|
|
self.body.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.body = self.body.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.body.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.body.annotate(code)
|
|
|
|
|
|
class ResultRefNode(AtomicExprNode):
|
|
# A reference to the result of an expression. The result_code
|
|
# must be set externally (usually a temp name).
|
|
|
|
subexprs = []
|
|
lhs_of_first_assignment = False
|
|
|
|
def __init__(self, expression=None, pos=None, type=None, may_hold_none=True, is_temp=False):
|
|
self.expression = expression
|
|
self.pos = None
|
|
self.may_hold_none = may_hold_none
|
|
if expression is not None:
|
|
self.pos = expression.pos
|
|
if hasattr(expression, "type"):
|
|
self.type = expression.type
|
|
if pos is not None:
|
|
self.pos = pos
|
|
if type is not None:
|
|
self.type = type
|
|
if is_temp:
|
|
self.is_temp = True
|
|
assert self.pos is not None
|
|
|
|
def clone_node(self):
|
|
# nothing to do here
|
|
return self
|
|
|
|
def type_dependencies(self, env):
|
|
if self.expression:
|
|
return self.expression.type_dependencies(env)
|
|
else:
|
|
return ()
|
|
|
|
def update_expression(self, expression):
|
|
self.expression = expression
|
|
if hasattr(expression, "type"):
|
|
self.type = expression.type
|
|
|
|
def analyse_types(self, env):
|
|
if self.expression is not None:
|
|
if not self.expression.type:
|
|
self.expression = self.expression.analyse_types(env)
|
|
self.type = self.expression.type
|
|
return self
|
|
|
|
def infer_type(self, env):
|
|
if self.type is not None:
|
|
return self.type
|
|
if self.expression is not None:
|
|
if self.expression.type is not None:
|
|
return self.expression.type
|
|
return self.expression.infer_type(env)
|
|
assert False, "cannot infer type of ResultRefNode"
|
|
|
|
def may_be_none(self):
|
|
if not self.type.is_pyobject:
|
|
return False
|
|
return self.may_hold_none
|
|
|
|
def _DISABLED_may_be_none(self):
|
|
# not sure if this is safe - the expression may not be the
|
|
# only value that gets assigned
|
|
if self.expression is not None:
|
|
return self.expression.may_be_none()
|
|
if self.type is not None:
|
|
return self.type.is_pyobject
|
|
return True # play safe
|
|
|
|
def is_simple(self):
|
|
return True
|
|
|
|
def result(self):
|
|
try:
|
|
return self.result_code
|
|
except AttributeError:
|
|
if self.expression is not None:
|
|
self.result_code = self.expression.result()
|
|
return self.result_code
|
|
|
|
def generate_evaluation_code(self, code):
|
|
pass
|
|
|
|
def generate_result_code(self, code):
|
|
pass
|
|
|
|
def generate_disposal_code(self, code):
|
|
pass
|
|
|
|
def generate_assignment_code(self, rhs, code, overloaded_assignment=False):
|
|
if self.type.is_pyobject:
|
|
rhs.make_owned_reference(code)
|
|
if not self.lhs_of_first_assignment:
|
|
code.put_decref(self.result(), self.ctype())
|
|
code.putln('%s = %s;' % (
|
|
self.result(),
|
|
rhs.result() if overloaded_assignment else rhs.result_as(self.ctype()),
|
|
))
|
|
rhs.generate_post_assignment_code(code)
|
|
rhs.free_temps(code)
|
|
|
|
def allocate_temps(self, env):
|
|
pass
|
|
|
|
def release_temp(self, env):
|
|
pass
|
|
|
|
def free_temps(self, code):
|
|
pass
|
|
|
|
|
|
class LetNodeMixin:
|
|
def set_temp_expr(self, lazy_temp):
|
|
self.lazy_temp = lazy_temp
|
|
self.temp_expression = lazy_temp.expression
|
|
|
|
def setup_temp_expr(self, code):
|
|
self.temp_expression.generate_evaluation_code(code)
|
|
self.temp_type = self.temp_expression.type
|
|
if self.temp_type.is_array:
|
|
self.temp_type = c_ptr_type(self.temp_type.base_type)
|
|
self._result_in_temp = self.temp_expression.result_in_temp()
|
|
if self._result_in_temp:
|
|
self.temp = self.temp_expression.result()
|
|
else:
|
|
self.temp_expression.make_owned_reference(code)
|
|
self.temp = code.funcstate.allocate_temp(
|
|
self.temp_type, manage_ref=True)
|
|
code.putln("%s = %s;" % (self.temp, self.temp_expression.result()))
|
|
self.temp_expression.generate_disposal_code(code)
|
|
self.temp_expression.free_temps(code)
|
|
self.lazy_temp.result_code = self.temp
|
|
|
|
def teardown_temp_expr(self, code):
|
|
if self._result_in_temp:
|
|
self.temp_expression.generate_disposal_code(code)
|
|
self.temp_expression.free_temps(code)
|
|
else:
|
|
if self.temp_type.is_pyobject:
|
|
code.put_decref_clear(self.temp, self.temp_type)
|
|
code.funcstate.release_temp(self.temp)
|
|
|
|
|
|
class EvalWithTempExprNode(ExprNodes.ExprNode, LetNodeMixin):
|
|
# A wrapper around a subexpression that moves an expression into a
|
|
# temp variable and provides it to the subexpression.
|
|
|
|
subexprs = ['temp_expression', 'subexpression']
|
|
|
|
def __init__(self, lazy_temp, subexpression):
|
|
self.set_temp_expr(lazy_temp)
|
|
self.pos = subexpression.pos
|
|
self.subexpression = subexpression
|
|
# if called after type analysis, we already know the type here
|
|
self.type = self.subexpression.type
|
|
|
|
def infer_type(self, env):
|
|
return self.subexpression.infer_type(env)
|
|
|
|
def may_be_none(self):
|
|
return self.subexpression.may_be_none()
|
|
|
|
def result(self):
|
|
return self.subexpression.result()
|
|
|
|
def analyse_types(self, env):
|
|
self.temp_expression = self.temp_expression.analyse_types(env)
|
|
self.lazy_temp.update_expression(self.temp_expression) # overwrite in case it changed
|
|
self.subexpression = self.subexpression.analyse_types(env)
|
|
self.type = self.subexpression.type
|
|
return self
|
|
|
|
def free_subexpr_temps(self, code):
|
|
self.subexpression.free_temps(code)
|
|
|
|
def generate_subexpr_disposal_code(self, code):
|
|
self.subexpression.generate_disposal_code(code)
|
|
|
|
def generate_evaluation_code(self, code):
|
|
self.setup_temp_expr(code)
|
|
self.subexpression.generate_evaluation_code(code)
|
|
self.teardown_temp_expr(code)
|
|
|
|
|
|
LetRefNode = ResultRefNode
|
|
|
|
|
|
class LetNode(Nodes.StatNode, LetNodeMixin):
|
|
# Implements a local temporary variable scope. Imagine this
|
|
# syntax being present:
|
|
# let temp = VALUE:
|
|
# BLOCK (can modify temp)
|
|
# if temp is an object, decref
|
|
#
|
|
# Usually used after analysis phase, but forwards analysis methods
|
|
# to its children
|
|
|
|
child_attrs = ['temp_expression', 'body']
|
|
|
|
def __init__(self, lazy_temp, body):
|
|
self.set_temp_expr(lazy_temp)
|
|
self.pos = body.pos
|
|
self.body = body
|
|
|
|
def analyse_declarations(self, env):
|
|
self.temp_expression.analyse_declarations(env)
|
|
self.body.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.temp_expression = self.temp_expression.analyse_expressions(env)
|
|
self.body = self.body.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
self.setup_temp_expr(code)
|
|
self.body.generate_execution_code(code)
|
|
self.teardown_temp_expr(code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.temp_expression.generate_function_definitions(env, code)
|
|
self.body.generate_function_definitions(env, code)
|
|
|
|
|
|
class TempResultFromStatNode(ExprNodes.ExprNode):
|
|
# An ExprNode wrapper around a StatNode that executes the StatNode
|
|
# body. Requires a ResultRefNode that it sets up to refer to its
|
|
# own temp result. The StatNode must assign a value to the result
|
|
# node, which then becomes the result of this node.
|
|
|
|
subexprs = []
|
|
child_attrs = ['body']
|
|
|
|
def __init__(self, result_ref, body):
|
|
self.result_ref = result_ref
|
|
self.pos = body.pos
|
|
self.body = body
|
|
self.type = result_ref.type
|
|
self.is_temp = 1
|
|
|
|
def analyse_declarations(self, env):
|
|
self.body.analyse_declarations(env)
|
|
|
|
def analyse_types(self, env):
|
|
self.body = self.body.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_result_code(self, code):
|
|
self.result_ref.result_code = self.result()
|
|
self.body.generate_execution_code(code)
|