Cython 3.1.0__py3-none-any.whl

Cython/Compiler/UFuncs.py

@@ -0,0 +1,311 @@
+from . import (
+    Nodes,
+    ExprNodes,
+    FusedNode,
+    Naming,
+)
+from .Errors import error
+from . import PyrexTypes
+from .UtilityCode import CythonUtilityCode
+from .Code import TempitaUtilityCode, UtilityCode
+from .Visitor import TreeVisitor
+from . import Symtab
+
+
+class _FindCFuncDefNode(TreeVisitor):
+    """
+    Finds the CFuncDefNode in the tree
+
+    The assumption is that there's only one CFuncDefNode
+    """
+
+    found_node = None
+
+    def visit_Node(self, node):
+        if self.found_node:
+            return
+        else:
+            self.visitchildren(node)
+
+    def visit_CFuncDefNode(self, node):
+        self.found_node = node
+
+    def __call__(self, tree):
+        self.visit(tree)
+        return self.found_node
+
+
+def get_cfunc_from_tree(tree):
+    return _FindCFuncDefNode()(tree)
+
+
+class _ArgumentInfo:
+    """
+    Everything related to defining an input/output argument for a ufunc
+
+    type  - PyrexType
+    type_constant  - str such as "NPY_INT8" representing numpy dtype constants
+    injected_typename - str representing a name that can be used to look up the type
+                        in Cython code
+    """
+
+    def __init__(self, type, type_constant, injected_typename):
+        self.type = type
+        self.type_constant = type_constant
+        self.injected_typename = injected_typename
+
+
+class UFuncConversion:
+    def __init__(self, node):
+        self.node = node
+        self.global_scope = node.local_scope.global_scope()
+
+        self.injected_typename = "ufunc_typename"
+        while self.node.entry.cname.startswith(self.injected_typename):
+            self.injected_typename += "_"
+        self.injected_types = []
+        self.in_definitions = self.get_in_type_info()
+        self.out_definitions = self.get_out_type_info()
+
+    def _handle_typedef_type_constant(self, type_, macro_name):
+        decl = type_.empty_declaration_code()
+        substituted_cname = decl.strip().replace('_', '__').replace(' ', '_')
+        context = dict(
+            type_substituted_cname=substituted_cname,
+            macro_name=macro_name,
+            type_cname=decl,
+        )
+        self.global_scope.use_utility_code(
+            TempitaUtilityCode.load(
+                'UFuncTypedef',
+                'UFuncs_C.c',
+                context=context
+            ))
+        return f"__Pyx_typedef_ufunc_{substituted_cname}"
+
+    def _get_type_constant(self, pos, type_):
+        base_type = type_
+        if base_type.is_typedef:
+            base_type = base_type.typedef_base_type
+        base_type = PyrexTypes.remove_cv_ref(base_type)
+        if base_type is PyrexTypes.c_bint_type:
+            # TODO - this would be nice but not obvious it works
+            error(pos, "Type '%s' cannot be used as a ufunc argument" % type_)
+            return
+        if type_.is_complex:
+            return self._handle_typedef_type_constant(
+                    type_,
+                    "__PYX_GET_NPY_COMPLEX_TYPE")
+        elif type_.is_int:
+            signed = ""
+            if type_.signed == PyrexTypes.SIGNED:
+                signed = "S"
+            elif type_.signed == PyrexTypes.UNSIGNED:
+                signed = "U"
+            return self._handle_typedef_type_constant(
+                type_,
+                f"__PYX_GET_NPY_{signed}INT_TYPE")
+        elif type_.is_float:
+            return self._handle_typedef_type_constant(
+                type_,
+                "__PYX_GET_NPY_FLOAT_TYPE")
+        elif type_.is_pyobject:
+            return "NPY_OBJECT"
+        # TODO possible NPY_BOOL to bint but it needs a cast?
+        # TODO NPY_DATETIME, NPY_TIMEDELTA, NPY_STRING, NPY_UNICODE and maybe NPY_VOID might be handleable
+        error(pos, "Type '%s' cannot be used as a ufunc argument" % type_)
+
+    def get_in_type_info(self):
+        definitions = []
+        for n, arg in enumerate(self.node.args):
+            injected_typename = f"{self.injected_typename}_in_{n}"
+            self.injected_types.append(injected_typename)
+            type_const = self._get_type_constant(self.node.pos, arg.type)
+            definitions.append(_ArgumentInfo(arg.type, type_const, injected_typename))
+        return definitions
+
+    def get_out_type_info(self):
+        if self.node.return_type.is_ctuple:
+            components = self.node.return_type.components
+        else:
+            components = [self.node.return_type]
+        definitions = []
+        for n, type in enumerate(components):
+            injected_typename = f"{self.injected_typename}_out_{n}"
+            self.injected_types.append(injected_typename)
+            type_const = self._get_type_constant(self.node.pos, type)
+            definitions.append(
+                _ArgumentInfo(type, type_const, injected_typename)
+            )
+        return definitions
+
+    def generate_cy_utility_code(self):
+        arg_types = [(a.injected_typename, a.type) for a in self.in_definitions]
+        out_types = [(a.injected_typename, a.type) for a in self.out_definitions]
+        context_types = dict(arg_types + out_types)
+        self.node.entry.used = True
+
+        ufunc_cname = self.global_scope.next_id(self.node.entry.name + "_ufunc_def")
+
+        will_be_called_without_gil = not (any(t.is_pyobject for _, t in arg_types) or
+            any(t.is_pyobject for _, t in out_types))
+
+        context = dict(
+            func_cname=ufunc_cname,
+            in_types=arg_types,
+            out_types=out_types,
+            inline_func_call=self.node.entry.cname,
+            nogil=self.node.entry.type.nogil,
+            will_be_called_without_gil=will_be_called_without_gil,
+            **context_types
+        )
+
+        ufunc_global_scope = Symtab.ModuleScope(
+            "ufunc_module", None, self.global_scope.context
+        )
+        ufunc_global_scope.declare_cfunction(
+            name=self.node.entry.cname,
+            cname=self.node.entry.cname,
+            type=self.node.entry.type,
+            pos=self.node.pos,
+            visibility="extern",
+        )
+
+        code = CythonUtilityCode.load(
+            "UFuncDefinition",
+            "UFuncs.pyx",
+            context=context,
+            from_scope = ufunc_global_scope,
+            #outer_module_scope=ufunc_global_scope,
+        )
+
+        tree = code.get_tree(entries_only=True)
+        return tree
+
+    def use_generic_utility_code(self):
+        # use the invariant C utility code
+        self.global_scope.use_utility_code(
+            UtilityCode.load_cached("UFuncsInit", "UFuncs_C.c")
+        )
+        self.global_scope.use_utility_code(
+            UtilityCode.load_cached("UFuncTypeHandling", "UFuncs_C.c")
+        )
+        self.global_scope.use_utility_code(
+            UtilityCode.load_cached("NumpyImportUFunc", "NumpyImportArray.c")
+        )
+
+
+def convert_to_ufunc(node):
+    if isinstance(node, Nodes.CFuncDefNode):
+        if node.local_scope.parent_scope.is_c_class_scope:
+            error(node.pos, "Methods cannot currently be converted to a ufunc")
+            return node
+        converters = [UFuncConversion(node)]
+        original_node = node
+    elif isinstance(node, FusedNode.FusedCFuncDefNode) and isinstance(
+        node.node, Nodes.CFuncDefNode
+    ):
+        if node.node.local_scope.parent_scope.is_c_class_scope:
+            error(node.pos, "Methods cannot currently be converted to a ufunc")
+            return node
+        converters = [UFuncConversion(n) for n in node.nodes]
+        original_node = node.node
+    else:
+        error(node.pos, "Only C functions can be converted to a ufunc")
+        return node
+
+    if not converters:
+        return  # this path probably shouldn't happen
+
+    del converters[0].global_scope.entries[original_node.entry.name]
+    # the generic utility code is generic, so there's no reason to do it multiple times
+    converters[0].use_generic_utility_code()
+    return [node] + _generate_stats_from_converters(converters, original_node)
+
+
+def generate_ufunc_initialization(converters, cfunc_nodes, original_node):
+    global_scope = converters[0].global_scope
+    ufunc_funcs_name = global_scope.next_id(Naming.pyrex_prefix + "funcs")
+    ufunc_types_name = global_scope.next_id(Naming.pyrex_prefix + "types")
+    ufunc_data_name = global_scope.next_id(Naming.pyrex_prefix + "data")
+    type_constants = []
+    narg_in = None
+    narg_out = None
+    for c in converters:
+        in_const = [d.type_constant for d in c.in_definitions]
+        if narg_in is not None:
+            assert narg_in == len(in_const)
+        else:
+            narg_in = len(in_const)
+        type_constants.extend(in_const)
+        out_const = [d.type_constant for d in c.out_definitions]
+        if narg_out is not None:
+            assert narg_out == len(out_const)
+        else:
+            narg_out = len(out_const)
+        type_constants.extend(out_const)
+
+    func_cnames = [cfnode.entry.cname for cfnode in cfunc_nodes]
+
+    context = dict(
+        ufunc_funcs_name=ufunc_funcs_name,
+        func_cnames=func_cnames,
+        ufunc_types_name=ufunc_types_name,
+        type_constants=type_constants,
+        ufunc_data_name=ufunc_data_name,
+    )
+    global_scope.use_utility_code(
+        TempitaUtilityCode.load("UFuncConsts", "UFuncs_C.c", context=context)
+    )
+
+    pos = original_node.pos
+    func_name = original_node.entry.name
+    docstr = original_node.doc
+
+    args_to_func = '%s(), %s, %s(), %s, %s, %s, PyUFunc_None, "%s", %s, 0' % (
+        ufunc_funcs_name,
+        ufunc_data_name,
+        ufunc_types_name,
+        len(func_cnames),
+        narg_in,
+        narg_out,
+        func_name,
+        docstr.as_c_string_literal() if docstr else "NULL",
+    )
+
+    call_node = ExprNodes.PythonCapiCallNode(
+        pos,
+        function_name="PyUFunc_FromFuncAndData",
+        # use a dummy type because it's honestly too fiddly
+        func_type=PyrexTypes.CFuncType(
+            PyrexTypes.py_object_type,
+            [PyrexTypes.CFuncTypeArg("dummy", PyrexTypes.c_void_ptr_type, None)],
+        ),
+        args=[
+            ExprNodes.ConstNode(
+                pos, type=PyrexTypes.c_void_ptr_type, value=args_to_func
+            )
+        ],
+    )
+    lhs_entry = global_scope.declare_var(func_name, PyrexTypes.py_object_type, pos)
+    assgn_node = Nodes.SingleAssignmentNode(
+        pos,
+        lhs=ExprNodes.NameNode(
+            pos, name=func_name, type=PyrexTypes.py_object_type, entry=lhs_entry
+        ),
+        rhs=call_node,
+    )
+    return assgn_node
+
+
+def _generate_stats_from_converters(converters, node):
+    stats = []
+    for converter in converters:
+        tree = converter.generate_cy_utility_code()
+        ufunc_node = get_cfunc_from_tree(tree)
+        # merge in any utility code
+        converter.global_scope.utility_code_list.extend(tree.scope.utility_code_list)
+        stats.append(ufunc_node)
+
+    stats.append(generate_ufunc_initialization(converters, stats, node))
+    return stats

Cython/Compiler/UtilNodes.py

@@ -0,0 +1,389 @@
+#
+# 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 . import Nodes
+from . import ExprNodes
+from .Nodes import Node
+from .ExprNodes import AtomicExprNode
+from .PyrexTypes import c_ptr_type, c_int_type
+
+
+class TempHandle:
+    # 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
+            self.type = getattr(expression, "type", None)
+        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
+        type = getattr(expression, "type", None)
+        if type:
+            self.type = type
+
+    def analyse_target_declaration(self, env):
+        pass  # OK - we can assign to this
+
+    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 it 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:
+            if self.temp_type.is_memoryviewslice:
+                self.temp_expression.make_owned_memoryviewslice(code)
+            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.needs_refcounting:
+                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 may_be_none(self):
+        return self.result_ref.may_be_none()
+
+    def generate_result_code(self, code):
+        self.result_ref.result_code = self.result()
+        self.body.generate_execution_code(code)
+
+    def generate_function_definitions(self, env, code):
+        self.body.generate_function_definitions(env, code)
+
+
+class HasNoGilNode(AtomicExprNode):
+    """
+    Simple node that evaluates to
+    * 0 if gil
+    * 1 if nogil
+    * 2 if maybe gil
+    """
+    type = c_int_type
+
+    def analyse_types(self, env):
+        return self
+
+    def generate_result_code(self, code):
+        pass
+
+    def calculate_result_code(self):
+        return str(int(self.in_nogil_context))