9451 lines
382 KiB
Python
9451 lines
382 KiB
Python
#
|
|
# Parse tree nodes
|
|
#
|
|
|
|
from __future__ import absolute_import
|
|
|
|
import cython
|
|
cython.declare(sys=object, os=object, copy=object,
|
|
Builtin=object, error=object, warning=object, Naming=object, PyrexTypes=object,
|
|
py_object_type=object, ModuleScope=object, LocalScope=object, ClosureScope=object,
|
|
StructOrUnionScope=object, PyClassScope=object,
|
|
CppClassScope=object, UtilityCode=object, EncodedString=object,
|
|
error_type=object, _py_int_types=object)
|
|
|
|
import sys, os, copy
|
|
from itertools import chain
|
|
|
|
from . import Builtin
|
|
from .Errors import error, warning, InternalError, CompileError
|
|
from . import Naming
|
|
from . import PyrexTypes
|
|
from . import TypeSlots
|
|
from .PyrexTypes import py_object_type, error_type
|
|
from .Symtab import (ModuleScope, LocalScope, ClosureScope,
|
|
StructOrUnionScope, PyClassScope, CppClassScope, TemplateScope)
|
|
from .Code import UtilityCode
|
|
from .StringEncoding import EncodedString
|
|
from . import Future
|
|
from . import Options
|
|
from . import DebugFlags
|
|
from .Pythran import has_np_pythran, pythran_type, is_pythran_buffer
|
|
from ..Utils import add_metaclass
|
|
|
|
|
|
if sys.version_info[0] >= 3:
|
|
_py_int_types = int
|
|
else:
|
|
_py_int_types = (int, long)
|
|
|
|
|
|
def relative_position(pos):
|
|
return (pos[0].get_filenametable_entry(), pos[1])
|
|
|
|
|
|
def embed_position(pos, docstring):
|
|
if not Options.embed_pos_in_docstring:
|
|
return docstring
|
|
pos_line = u'File: %s (starting at line %s)' % relative_position(pos)
|
|
if docstring is None:
|
|
# unicode string
|
|
return EncodedString(pos_line)
|
|
|
|
# make sure we can encode the filename in the docstring encoding
|
|
# otherwise make the docstring a unicode string
|
|
encoding = docstring.encoding
|
|
if encoding is not None:
|
|
try:
|
|
pos_line.encode(encoding)
|
|
except UnicodeEncodeError:
|
|
encoding = None
|
|
|
|
if not docstring:
|
|
# reuse the string encoding of the original docstring
|
|
doc = EncodedString(pos_line)
|
|
else:
|
|
doc = EncodedString(pos_line + u'\n' + docstring)
|
|
doc.encoding = encoding
|
|
return doc
|
|
|
|
|
|
def analyse_type_annotation(annotation, env, assigned_value=None):
|
|
base_type = None
|
|
is_ambiguous = False
|
|
explicit_pytype = explicit_ctype = False
|
|
if annotation.is_dict_literal:
|
|
warning(annotation.pos,
|
|
"Dicts should no longer be used as type annotations. Use 'cython.int' etc. directly.")
|
|
for name, value in annotation.key_value_pairs:
|
|
if not name.is_string_literal:
|
|
continue
|
|
if name.value in ('type', b'type'):
|
|
explicit_pytype = True
|
|
if not explicit_ctype:
|
|
annotation = value
|
|
elif name.value in ('ctype', b'ctype'):
|
|
explicit_ctype = True
|
|
annotation = value
|
|
if explicit_pytype and explicit_ctype:
|
|
warning(annotation.pos, "Duplicate type declarations found in signature annotation")
|
|
arg_type = annotation.analyse_as_type(env)
|
|
if annotation.is_name and not annotation.cython_attribute and annotation.name in ('int', 'long', 'float'):
|
|
# Map builtin numeric Python types to C types in safe cases.
|
|
if assigned_value is not None and arg_type is not None and not arg_type.is_pyobject:
|
|
assigned_type = assigned_value.infer_type(env)
|
|
if assigned_type and assigned_type.is_pyobject:
|
|
# C type seems unsafe, e.g. due to 'None' default value => ignore annotation type
|
|
is_ambiguous = True
|
|
arg_type = None
|
|
# ignore 'int' and require 'cython.int' to avoid unsafe integer declarations
|
|
if arg_type in (PyrexTypes.c_long_type, PyrexTypes.c_int_type, PyrexTypes.c_float_type):
|
|
arg_type = PyrexTypes.c_double_type if annotation.name == 'float' else py_object_type
|
|
elif arg_type is not None and annotation.is_string_literal:
|
|
warning(annotation.pos,
|
|
"Strings should no longer be used for type declarations. Use 'cython.int' etc. directly.")
|
|
if arg_type is not None:
|
|
if explicit_pytype and not explicit_ctype and not arg_type.is_pyobject:
|
|
warning(annotation.pos,
|
|
"Python type declaration in signature annotation does not refer to a Python type")
|
|
base_type = CAnalysedBaseTypeNode(
|
|
annotation.pos, type=arg_type, is_arg=True)
|
|
elif is_ambiguous:
|
|
warning(annotation.pos, "Ambiguous types in annotation, ignoring")
|
|
else:
|
|
warning(annotation.pos, "Unknown type declaration in annotation, ignoring")
|
|
return base_type, arg_type
|
|
|
|
|
|
def write_func_call(func, codewriter_class):
|
|
def f(*args, **kwds):
|
|
if len(args) > 1 and isinstance(args[1], codewriter_class):
|
|
# here we annotate the code with this function call
|
|
# but only if new code is generated
|
|
node, code = args[:2]
|
|
marker = ' /* %s -> %s.%s %s */' % (
|
|
' ' * code.call_level,
|
|
node.__class__.__name__,
|
|
func.__name__,
|
|
node.pos[1:])
|
|
pristine = code.buffer.stream.tell()
|
|
code.putln(marker)
|
|
start = code.buffer.stream.tell()
|
|
code.call_level += 4
|
|
res = func(*args, **kwds)
|
|
code.call_level -= 4
|
|
if start == code.buffer.stream.tell():
|
|
# no code written => undo writing marker
|
|
code.buffer.stream.truncate(pristine)
|
|
else:
|
|
marker = marker.replace('->', '<-', 1)
|
|
code.putln(marker)
|
|
return res
|
|
else:
|
|
return func(*args, **kwds)
|
|
return f
|
|
|
|
|
|
class VerboseCodeWriter(type):
|
|
# Set this as a metaclass to trace function calls in code.
|
|
# This slows down code generation and makes much larger files.
|
|
def __new__(cls, name, bases, attrs):
|
|
from types import FunctionType
|
|
from .Code import CCodeWriter
|
|
attrs = dict(attrs)
|
|
for mname, m in attrs.items():
|
|
if isinstance(m, FunctionType):
|
|
attrs[mname] = write_func_call(m, CCodeWriter)
|
|
return super(VerboseCodeWriter, cls).__new__(cls, name, bases, attrs)
|
|
|
|
|
|
class CheckAnalysers(type):
|
|
"""Metaclass to check that type analysis functions return a node.
|
|
"""
|
|
methods = set(['analyse_types',
|
|
'analyse_expressions',
|
|
'analyse_target_types'])
|
|
|
|
def __new__(cls, name, bases, attrs):
|
|
from types import FunctionType
|
|
def check(name, func):
|
|
def call(*args, **kwargs):
|
|
retval = func(*args, **kwargs)
|
|
if retval is None:
|
|
print('%s %s %s' % (name, args, kwargs))
|
|
return retval
|
|
return call
|
|
|
|
attrs = dict(attrs)
|
|
for mname, m in attrs.items():
|
|
if isinstance(m, FunctionType) and mname in cls.methods:
|
|
attrs[mname] = check(mname, m)
|
|
return super(CheckAnalysers, cls).__new__(cls, name, bases, attrs)
|
|
|
|
|
|
def _with_metaclass(cls):
|
|
if DebugFlags.debug_trace_code_generation:
|
|
return add_metaclass(VerboseCodeWriter)(cls)
|
|
#return add_metaclass(CheckAnalysers)(cls)
|
|
return cls
|
|
|
|
|
|
@_with_metaclass
|
|
class Node(object):
|
|
# pos (string, int, int) Source file position
|
|
# is_name boolean Is a NameNode
|
|
# is_literal boolean Is a ConstNode
|
|
|
|
is_name = 0
|
|
is_none = 0
|
|
is_nonecheck = 0
|
|
is_literal = 0
|
|
is_terminator = 0
|
|
is_wrapper = False # is a DefNode wrapper for a C function
|
|
temps = None
|
|
|
|
# All descendants should set child_attrs to a list of the attributes
|
|
# containing nodes considered "children" in the tree. Each such attribute
|
|
# can either contain a single node or a list of nodes. See Visitor.py.
|
|
child_attrs = None
|
|
|
|
# Subset of attributes that are evaluated in the outer scope (e.g. function default arguments).
|
|
outer_attrs = None
|
|
|
|
cf_state = None
|
|
|
|
# This may be an additional (or 'actual') type that will be checked when
|
|
# this node is coerced to another type. This could be useful to set when
|
|
# the actual type to which it can coerce is known, but you want to leave
|
|
# the type a py_object_type
|
|
coercion_type = None
|
|
|
|
def __init__(self, pos, **kw):
|
|
self.pos = pos
|
|
self.__dict__.update(kw)
|
|
|
|
gil_message = "Operation"
|
|
|
|
nogil_check = None
|
|
in_nogil_context = False # For use only during code generation.
|
|
|
|
def gil_error(self, env=None):
|
|
error(self.pos, "%s not allowed without gil" % self.gil_message)
|
|
|
|
cpp_message = "Operation"
|
|
|
|
def cpp_check(self, env):
|
|
if not env.is_cpp():
|
|
self.cpp_error()
|
|
|
|
def cpp_error(self):
|
|
error(self.pos, "%s only allowed in c++" % self.cpp_message)
|
|
|
|
def clone_node(self):
|
|
"""Clone the node. This is defined as a shallow copy, except for member lists
|
|
amongst the child attributes (from get_child_accessors) which are also
|
|
copied. Lists containing child nodes are thus seen as a way for the node
|
|
to hold multiple children directly; the list is not treated as a separate
|
|
level in the tree."""
|
|
result = copy.copy(self)
|
|
for attrname in result.child_attrs:
|
|
value = getattr(result, attrname)
|
|
if isinstance(value, list):
|
|
setattr(result, attrname, [x for x in value])
|
|
return result
|
|
|
|
|
|
#
|
|
# There are 3 phases of parse tree processing, applied in order to
|
|
# all the statements in a given scope-block:
|
|
#
|
|
# (0) analyse_declarations
|
|
# Make symbol table entries for all declarations at the current
|
|
# level, both explicit (def, cdef, etc.) and implicit (assignment
|
|
# to an otherwise undeclared name).
|
|
#
|
|
# (1) analyse_expressions
|
|
# Determine the result types of expressions and fill in the
|
|
# 'type' attribute of each ExprNode. Insert coercion nodes into the
|
|
# tree where needed to convert to and from Python objects.
|
|
# Allocate temporary locals for intermediate results. Fill
|
|
# in the 'result_code' attribute of each ExprNode with a C code
|
|
# fragment.
|
|
#
|
|
# (2) generate_code
|
|
# Emit C code for all declarations, statements and expressions.
|
|
# Recursively applies the 3 processing phases to the bodies of
|
|
# functions.
|
|
#
|
|
|
|
def analyse_declarations(self, env):
|
|
pass
|
|
|
|
def analyse_expressions(self, env):
|
|
raise InternalError("analyse_expressions not implemented for %s" % \
|
|
self.__class__.__name__)
|
|
|
|
def generate_code(self, code):
|
|
raise InternalError("generate_code not implemented for %s" % \
|
|
self.__class__.__name__)
|
|
|
|
def annotate(self, code):
|
|
# mro does the wrong thing
|
|
if isinstance(self, BlockNode):
|
|
self.body.annotate(code)
|
|
|
|
def end_pos(self):
|
|
try:
|
|
return self._end_pos
|
|
except AttributeError:
|
|
pos = self.pos
|
|
if not self.child_attrs:
|
|
self._end_pos = pos
|
|
return pos
|
|
for attr in self.child_attrs:
|
|
child = getattr(self, attr)
|
|
# Sometimes lists, sometimes nodes
|
|
if child is None:
|
|
pass
|
|
elif isinstance(child, list):
|
|
for c in child:
|
|
pos = max(pos, c.end_pos())
|
|
else:
|
|
pos = max(pos, child.end_pos())
|
|
self._end_pos = pos
|
|
return pos
|
|
|
|
def dump(self, level=0, filter_out=("pos",), cutoff=100, encountered=None):
|
|
"""Debug helper method that returns a recursive string representation of this node.
|
|
"""
|
|
if cutoff == 0:
|
|
return "<...nesting level cutoff...>"
|
|
if encountered is None:
|
|
encountered = set()
|
|
if id(self) in encountered:
|
|
return "<%s (0x%x) -- already output>" % (self.__class__.__name__, id(self))
|
|
encountered.add(id(self))
|
|
|
|
def dump_child(x, level):
|
|
if isinstance(x, Node):
|
|
return x.dump(level, filter_out, cutoff-1, encountered)
|
|
elif isinstance(x, list):
|
|
return "[%s]" % ", ".join([dump_child(item, level) for item in x])
|
|
else:
|
|
return repr(x)
|
|
|
|
attrs = [(key, value) for key, value in self.__dict__.items() if key not in filter_out]
|
|
if len(attrs) == 0:
|
|
return "<%s (0x%x)>" % (self.__class__.__name__, id(self))
|
|
else:
|
|
indent = " " * level
|
|
res = "<%s (0x%x)\n" % (self.__class__.__name__, id(self))
|
|
for key, value in attrs:
|
|
res += "%s %s: %s\n" % (indent, key, dump_child(value, level + 1))
|
|
res += "%s>" % indent
|
|
return res
|
|
|
|
def dump_pos(self, mark_column=False, marker='(#)'):
|
|
"""Debug helper method that returns the source code context of this node as a string.
|
|
"""
|
|
if not self.pos:
|
|
return u''
|
|
source_desc, line, col = self.pos
|
|
contents = source_desc.get_lines(encoding='ASCII', error_handling='ignore')
|
|
# line numbers start at 1
|
|
lines = contents[max(0, line-3):line]
|
|
current = lines[-1]
|
|
if mark_column:
|
|
current = current[:col] + marker + current[col:]
|
|
lines[-1] = current.rstrip() + u' # <<<<<<<<<<<<<<\n'
|
|
lines += contents[line:line+2]
|
|
return u'"%s":%d:%d\n%s\n' % (
|
|
source_desc.get_escaped_description(), line, col, u''.join(lines))
|
|
|
|
class CompilerDirectivesNode(Node):
|
|
"""
|
|
Sets compiler directives for the children nodes
|
|
"""
|
|
# directives {string:value} A dictionary holding the right value for
|
|
# *all* possible directives.
|
|
# body Node
|
|
child_attrs = ["body"]
|
|
|
|
def analyse_declarations(self, env):
|
|
old = env.directives
|
|
env.directives = self.directives
|
|
self.body.analyse_declarations(env)
|
|
env.directives = old
|
|
|
|
def analyse_expressions(self, env):
|
|
old = env.directives
|
|
env.directives = self.directives
|
|
self.body = self.body.analyse_expressions(env)
|
|
env.directives = old
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
env_old = env.directives
|
|
code_old = code.globalstate.directives
|
|
code.globalstate.directives = self.directives
|
|
self.body.generate_function_definitions(env, code)
|
|
env.directives = env_old
|
|
code.globalstate.directives = code_old
|
|
|
|
def generate_execution_code(self, code):
|
|
old = code.globalstate.directives
|
|
code.globalstate.directives = self.directives
|
|
self.body.generate_execution_code(code)
|
|
code.globalstate.directives = old
|
|
|
|
def annotate(self, code):
|
|
old = code.globalstate.directives
|
|
code.globalstate.directives = self.directives
|
|
self.body.annotate(code)
|
|
code.globalstate.directives = old
|
|
|
|
class BlockNode(object):
|
|
# Mixin class for nodes representing a declaration block.
|
|
|
|
def generate_cached_builtins_decls(self, env, code):
|
|
entries = env.global_scope().undeclared_cached_builtins
|
|
for entry in entries:
|
|
code.globalstate.add_cached_builtin_decl(entry)
|
|
del entries[:]
|
|
|
|
def generate_lambda_definitions(self, env, code):
|
|
for node in env.lambda_defs:
|
|
node.generate_function_definitions(env, code)
|
|
|
|
class StatListNode(Node):
|
|
# stats a list of StatNode
|
|
|
|
child_attrs = ["stats"]
|
|
|
|
@staticmethod
|
|
def create_analysed(pos, env, *args, **kw):
|
|
node = StatListNode(pos, *args, **kw)
|
|
return node # No node-specific analysis needed
|
|
|
|
def analyse_declarations(self, env):
|
|
#print "StatListNode.analyse_declarations" ###
|
|
for stat in self.stats:
|
|
stat.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
#print "StatListNode.analyse_expressions" ###
|
|
self.stats = [stat.analyse_expressions(env)
|
|
for stat in self.stats]
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
#print "StatListNode.generate_function_definitions" ###
|
|
for stat in self.stats:
|
|
stat.generate_function_definitions(env, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
#print "StatListNode.generate_execution_code" ###
|
|
for stat in self.stats:
|
|
code.mark_pos(stat.pos)
|
|
stat.generate_execution_code(code)
|
|
|
|
def annotate(self, code):
|
|
for stat in self.stats:
|
|
stat.annotate(code)
|
|
|
|
|
|
class StatNode(Node):
|
|
#
|
|
# Code generation for statements is split into the following subphases:
|
|
#
|
|
# (1) generate_function_definitions
|
|
# Emit C code for the definitions of any structs,
|
|
# unions, enums and functions defined in the current
|
|
# scope-block.
|
|
#
|
|
# (2) generate_execution_code
|
|
# Emit C code for executable statements.
|
|
#
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
pass
|
|
|
|
def generate_execution_code(self, code):
|
|
raise InternalError("generate_execution_code not implemented for %s" % \
|
|
self.__class__.__name__)
|
|
|
|
|
|
class CDefExternNode(StatNode):
|
|
# include_file string or None
|
|
# verbatim_include string or None
|
|
# body StatListNode
|
|
|
|
child_attrs = ["body"]
|
|
|
|
def analyse_declarations(self, env):
|
|
old_cinclude_flag = env.in_cinclude
|
|
env.in_cinclude = 1
|
|
self.body.analyse_declarations(env)
|
|
env.in_cinclude = old_cinclude_flag
|
|
|
|
if self.include_file or self.verbatim_include:
|
|
# Determine whether include should be late
|
|
stats = self.body.stats
|
|
if not env.directives['preliminary_late_includes_cy28']:
|
|
late = False
|
|
elif not stats:
|
|
# Special case: empty 'cdef extern' blocks are early
|
|
late = False
|
|
else:
|
|
late = all(isinstance(node, CVarDefNode) for node in stats)
|
|
env.add_include_file(self.include_file, self.verbatim_include, late)
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
pass
|
|
|
|
def annotate(self, code):
|
|
self.body.annotate(code)
|
|
|
|
|
|
class CDeclaratorNode(Node):
|
|
# Part of a C declaration.
|
|
#
|
|
# Processing during analyse_declarations phase:
|
|
#
|
|
# analyse
|
|
# Returns (name, type) pair where name is the
|
|
# CNameDeclaratorNode of the name being declared
|
|
# and type is the type it is being declared as.
|
|
#
|
|
# calling_convention string Calling convention of CFuncDeclaratorNode
|
|
# for which this is a base
|
|
|
|
child_attrs = []
|
|
|
|
calling_convention = ""
|
|
|
|
def analyse_templates(self):
|
|
# Only C++ functions have templates.
|
|
return None
|
|
|
|
|
|
class CNameDeclaratorNode(CDeclaratorNode):
|
|
# name string The Cython name being declared
|
|
# cname string or None C name, if specified
|
|
# default ExprNode or None the value assigned on declaration
|
|
|
|
child_attrs = ['default']
|
|
|
|
default = None
|
|
|
|
def analyse(self, base_type, env, nonempty=0, visibility=None, in_pxd=False):
|
|
if nonempty and self.name == '':
|
|
# May have mistaken the name for the type.
|
|
if base_type.is_ptr or base_type.is_array or base_type.is_buffer:
|
|
error(self.pos, "Missing argument name")
|
|
elif base_type.is_void:
|
|
error(self.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")
|
|
else:
|
|
self.name = base_type.declaration_code("", for_display=1, pyrex=1)
|
|
base_type = py_object_type
|
|
|
|
if base_type.is_fused and env.fused_to_specific:
|
|
base_type = base_type.specialize(env.fused_to_specific)
|
|
|
|
self.type = base_type
|
|
return self, base_type
|
|
|
|
|
|
class CPtrDeclaratorNode(CDeclaratorNode):
|
|
# base CDeclaratorNode
|
|
|
|
child_attrs = ["base"]
|
|
|
|
def analyse_templates(self):
|
|
return self.base.analyse_templates()
|
|
|
|
def analyse(self, base_type, env, nonempty=0, visibility=None, in_pxd=False):
|
|
if base_type.is_pyobject:
|
|
error(self.pos, "Pointer base type cannot be a Python object")
|
|
ptr_type = PyrexTypes.c_ptr_type(base_type)
|
|
return self.base.analyse(ptr_type, env, nonempty=nonempty, visibility=visibility, in_pxd=in_pxd)
|
|
|
|
|
|
class CReferenceDeclaratorNode(CDeclaratorNode):
|
|
# base CDeclaratorNode
|
|
|
|
child_attrs = ["base"]
|
|
|
|
def analyse_templates(self):
|
|
return self.base.analyse_templates()
|
|
|
|
def analyse(self, base_type, env, nonempty=0, visibility=None, in_pxd=False):
|
|
if base_type.is_pyobject:
|
|
error(self.pos, "Reference base type cannot be a Python object")
|
|
ref_type = PyrexTypes.c_ref_type(base_type)
|
|
return self.base.analyse(ref_type, env, nonempty=nonempty, visibility=visibility, in_pxd=in_pxd)
|
|
|
|
|
|
class CArrayDeclaratorNode(CDeclaratorNode):
|
|
# base CDeclaratorNode
|
|
# dimension ExprNode
|
|
|
|
child_attrs = ["base", "dimension"]
|
|
|
|
def analyse(self, base_type, env, nonempty=0, visibility=None, in_pxd=False):
|
|
if (base_type.is_cpp_class and base_type.is_template_type()) or base_type.is_cfunction:
|
|
from .ExprNodes import TupleNode
|
|
if isinstance(self.dimension, TupleNode):
|
|
args = self.dimension.args
|
|
else:
|
|
args = self.dimension,
|
|
values = [v.analyse_as_type(env) for v in args]
|
|
if None in values:
|
|
ix = values.index(None)
|
|
error(args[ix].pos, "Template parameter not a type")
|
|
base_type = error_type
|
|
else:
|
|
base_type = base_type.specialize_here(self.pos, values)
|
|
return self.base.analyse(base_type, env, nonempty=nonempty, visibility=visibility, in_pxd=in_pxd)
|
|
if self.dimension:
|
|
self.dimension = self.dimension.analyse_const_expression(env)
|
|
if not self.dimension.type.is_int:
|
|
error(self.dimension.pos, "Array dimension not integer")
|
|
size = self.dimension.get_constant_c_result_code()
|
|
if size is not None:
|
|
try:
|
|
size = int(size)
|
|
except ValueError:
|
|
# runtime constant?
|
|
pass
|
|
else:
|
|
size = None
|
|
if not base_type.is_complete():
|
|
error(self.pos, "Array element type '%s' is incomplete" % base_type)
|
|
if base_type.is_pyobject:
|
|
error(self.pos, "Array element cannot be a Python object")
|
|
if base_type.is_cfunction:
|
|
error(self.pos, "Array element cannot be a function")
|
|
array_type = PyrexTypes.c_array_type(base_type, size)
|
|
return self.base.analyse(array_type, env, nonempty=nonempty, visibility=visibility, in_pxd=in_pxd)
|
|
|
|
|
|
class CFuncDeclaratorNode(CDeclaratorNode):
|
|
# base CDeclaratorNode
|
|
# args [CArgDeclNode]
|
|
# templates [TemplatePlaceholderType]
|
|
# has_varargs boolean
|
|
# exception_value ConstNode
|
|
# exception_check boolean True if PyErr_Occurred check needed
|
|
# nogil boolean Can be called without gil
|
|
# with_gil boolean Acquire gil around function body
|
|
# is_const_method boolean Whether this is a const method
|
|
|
|
child_attrs = ["base", "args", "exception_value"]
|
|
|
|
overridable = 0
|
|
optional_arg_count = 0
|
|
is_const_method = 0
|
|
templates = None
|
|
|
|
def analyse_templates(self):
|
|
if isinstance(self.base, CArrayDeclaratorNode):
|
|
from .ExprNodes import TupleNode, NameNode
|
|
template_node = self.base.dimension
|
|
if isinstance(template_node, TupleNode):
|
|
template_nodes = template_node.args
|
|
elif isinstance(template_node, NameNode):
|
|
template_nodes = [template_node]
|
|
else:
|
|
error(template_node.pos, "Template arguments must be a list of names")
|
|
return None
|
|
self.templates = []
|
|
for template in template_nodes:
|
|
if isinstance(template, NameNode):
|
|
self.templates.append(PyrexTypes.TemplatePlaceholderType(template.name))
|
|
else:
|
|
error(template.pos, "Template arguments must be a list of names")
|
|
self.base = self.base.base
|
|
return self.templates
|
|
else:
|
|
return None
|
|
|
|
def analyse(self, return_type, env, nonempty=0, directive_locals=None, visibility=None, in_pxd=False):
|
|
if directive_locals is None:
|
|
directive_locals = {}
|
|
if nonempty:
|
|
nonempty -= 1
|
|
func_type_args = []
|
|
for i, arg_node in enumerate(self.args):
|
|
name_declarator, type = arg_node.analyse(
|
|
env, nonempty=nonempty,
|
|
is_self_arg=(i == 0 and env.is_c_class_scope and 'staticmethod' not in env.directives))
|
|
name = name_declarator.name
|
|
if name in directive_locals:
|
|
type_node = directive_locals[name]
|
|
other_type = type_node.analyse_as_type(env)
|
|
if other_type is None:
|
|
error(type_node.pos, "Not a type")
|
|
elif (type is not PyrexTypes.py_object_type
|
|
and not type.same_as(other_type)):
|
|
error(self.base.pos, "Signature does not agree with previous declaration")
|
|
error(type_node.pos, "Previous declaration here")
|
|
else:
|
|
type = other_type
|
|
if name_declarator.cname:
|
|
error(self.pos, "Function argument cannot have C name specification")
|
|
if i == 0 and env.is_c_class_scope and type.is_unspecified:
|
|
# fix the type of self
|
|
type = env.parent_type
|
|
# Turn *[] argument into **
|
|
if type.is_array:
|
|
type = PyrexTypes.c_ptr_type(type.base_type)
|
|
# Catch attempted C-style func(void) decl
|
|
if type.is_void:
|
|
error(arg_node.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")
|
|
func_type_args.append(
|
|
PyrexTypes.CFuncTypeArg(name, type, arg_node.pos))
|
|
if arg_node.default:
|
|
self.optional_arg_count += 1
|
|
elif self.optional_arg_count:
|
|
error(self.pos, "Non-default argument follows default argument")
|
|
|
|
exc_val = None
|
|
exc_check = 0
|
|
if self.exception_check == '+':
|
|
env.add_include_file('ios') # for std::ios_base::failure
|
|
env.add_include_file('new') # for std::bad_alloc
|
|
env.add_include_file('stdexcept')
|
|
env.add_include_file('typeinfo') # for std::bad_cast
|
|
if (return_type.is_pyobject
|
|
and (self.exception_value or self.exception_check)
|
|
and self.exception_check != '+'):
|
|
error(self.pos, "Exception clause not allowed for function returning Python object")
|
|
else:
|
|
if self.exception_value is None and self.exception_check and self.exception_check != '+':
|
|
# Use an explicit exception return value to speed up exception checks.
|
|
# Even if it is not declared, we can use the default exception value of the return type,
|
|
# unless the function is some kind of external function that we do not control.
|
|
if return_type.exception_value is not None and (visibility != 'extern' and not in_pxd):
|
|
# Extension types are more difficult because the signature must match the base type signature.
|
|
if not env.is_c_class_scope:
|
|
from .ExprNodes import ConstNode
|
|
self.exception_value = ConstNode(
|
|
self.pos, value=return_type.exception_value, type=return_type)
|
|
if self.exception_value:
|
|
self.exception_value = self.exception_value.analyse_const_expression(env)
|
|
if self.exception_check == '+':
|
|
exc_val_type = self.exception_value.type
|
|
if (not exc_val_type.is_error
|
|
and not exc_val_type.is_pyobject
|
|
and not (exc_val_type.is_cfunction
|
|
and not exc_val_type.return_type.is_pyobject
|
|
and not exc_val_type.args)
|
|
and not (exc_val_type == PyrexTypes.c_char_type
|
|
and self.exception_value.value == '*')):
|
|
error(self.exception_value.pos,
|
|
"Exception value must be a Python exception or cdef function with no arguments or *.")
|
|
exc_val = self.exception_value
|
|
else:
|
|
self.exception_value = self.exception_value.coerce_to(
|
|
return_type, env).analyse_const_expression(env)
|
|
exc_val = self.exception_value.get_constant_c_result_code()
|
|
if exc_val is None:
|
|
raise InternalError(
|
|
"get_constant_c_result_code not implemented for %s" %
|
|
self.exception_value.__class__.__name__)
|
|
if not return_type.assignable_from(self.exception_value.type):
|
|
error(self.exception_value.pos,
|
|
"Exception value incompatible with function return type")
|
|
exc_check = self.exception_check
|
|
if return_type.is_cfunction:
|
|
error(self.pos, "Function cannot return a function")
|
|
func_type = PyrexTypes.CFuncType(
|
|
return_type, func_type_args, self.has_varargs,
|
|
optional_arg_count=self.optional_arg_count,
|
|
exception_value=exc_val, exception_check=exc_check,
|
|
calling_convention=self.base.calling_convention,
|
|
nogil=self.nogil, with_gil=self.with_gil, is_overridable=self.overridable,
|
|
is_const_method=self.is_const_method,
|
|
templates=self.templates)
|
|
|
|
if self.optional_arg_count:
|
|
if func_type.is_fused:
|
|
# This is a bit of a hack... When we need to create specialized CFuncTypes
|
|
# on the fly because the cdef is defined in a pxd, we need to declare the specialized optional arg
|
|
# struct
|
|
def declare_opt_arg_struct(func_type, fused_cname):
|
|
self.declare_optional_arg_struct(func_type, env, fused_cname)
|
|
|
|
func_type.declare_opt_arg_struct = declare_opt_arg_struct
|
|
else:
|
|
self.declare_optional_arg_struct(func_type, env)
|
|
|
|
callspec = env.directives['callspec']
|
|
if callspec:
|
|
current = func_type.calling_convention
|
|
if current and current != callspec:
|
|
error(self.pos, "cannot have both '%s' and '%s' "
|
|
"calling conventions" % (current, callspec))
|
|
func_type.calling_convention = callspec
|
|
return self.base.analyse(func_type, env, visibility=visibility, in_pxd=in_pxd)
|
|
|
|
def declare_optional_arg_struct(self, func_type, env, fused_cname=None):
|
|
"""
|
|
Declares the optional argument struct (the struct used to hold the
|
|
values for optional arguments). For fused cdef functions, this is
|
|
deferred as analyse_declarations is called only once (on the fused
|
|
cdef function).
|
|
"""
|
|
scope = StructOrUnionScope()
|
|
arg_count_member = '%sn' % Naming.pyrex_prefix
|
|
scope.declare_var(arg_count_member, PyrexTypes.c_int_type, self.pos)
|
|
|
|
for arg in func_type.args[len(func_type.args) - self.optional_arg_count:]:
|
|
scope.declare_var(arg.name, arg.type, arg.pos, allow_pyobject=True, allow_memoryview=True)
|
|
|
|
struct_cname = env.mangle(Naming.opt_arg_prefix, self.base.name)
|
|
|
|
if fused_cname is not None:
|
|
struct_cname = PyrexTypes.get_fused_cname(fused_cname, struct_cname)
|
|
|
|
op_args_struct = env.global_scope().declare_struct_or_union(
|
|
name=struct_cname,
|
|
kind='struct',
|
|
scope=scope,
|
|
typedef_flag=0,
|
|
pos=self.pos,
|
|
cname=struct_cname)
|
|
|
|
op_args_struct.defined_in_pxd = 1
|
|
op_args_struct.used = 1
|
|
|
|
func_type.op_arg_struct = PyrexTypes.c_ptr_type(op_args_struct.type)
|
|
|
|
|
|
class CConstDeclaratorNode(CDeclaratorNode):
|
|
# base CDeclaratorNode
|
|
|
|
child_attrs = ["base"]
|
|
|
|
def analyse(self, base_type, env, nonempty=0, visibility=None, in_pxd=False):
|
|
if base_type.is_pyobject:
|
|
error(self.pos,
|
|
"Const base type cannot be a Python object")
|
|
const = PyrexTypes.c_const_type(base_type)
|
|
return self.base.analyse(const, env, nonempty=nonempty, visibility=visibility, in_pxd=in_pxd)
|
|
|
|
|
|
class CArgDeclNode(Node):
|
|
# Item in a function declaration argument list.
|
|
#
|
|
# base_type CBaseTypeNode
|
|
# declarator CDeclaratorNode
|
|
# not_none boolean Tagged with 'not None'
|
|
# or_none boolean Tagged with 'or None'
|
|
# accept_none boolean Resolved boolean for not_none/or_none
|
|
# default ExprNode or None
|
|
# default_value PyObjectConst constant for default value
|
|
# annotation ExprNode or None Py3 function arg annotation
|
|
# is_self_arg boolean Is the "self" arg of an extension type method
|
|
# is_type_arg boolean Is the "class" arg of an extension type classmethod
|
|
# is_kw_only boolean Is a keyword-only argument
|
|
# is_dynamic boolean Non-literal arg stored inside CyFunction
|
|
|
|
child_attrs = ["base_type", "declarator", "default", "annotation"]
|
|
outer_attrs = ["default", "annotation"]
|
|
|
|
is_self_arg = 0
|
|
is_type_arg = 0
|
|
is_generic = 1
|
|
kw_only = 0
|
|
not_none = 0
|
|
or_none = 0
|
|
type = None
|
|
name_declarator = None
|
|
default_value = None
|
|
annotation = None
|
|
is_dynamic = 0
|
|
|
|
def analyse(self, env, nonempty=0, is_self_arg=False):
|
|
if is_self_arg:
|
|
self.base_type.is_self_arg = self.is_self_arg = True
|
|
if self.type is None:
|
|
# The parser may misinterpret names as types. We fix that here.
|
|
if isinstance(self.declarator, CNameDeclaratorNode) and self.declarator.name == '':
|
|
if nonempty:
|
|
if self.base_type.is_basic_c_type:
|
|
# char, short, long called "int"
|
|
type = self.base_type.analyse(env, could_be_name=True)
|
|
arg_name = type.empty_declaration_code()
|
|
else:
|
|
arg_name = self.base_type.name
|
|
self.declarator.name = EncodedString(arg_name)
|
|
self.base_type.name = None
|
|
self.base_type.is_basic_c_type = False
|
|
could_be_name = True
|
|
else:
|
|
could_be_name = False
|
|
self.base_type.is_arg = True
|
|
base_type = self.base_type.analyse(env, could_be_name=could_be_name)
|
|
if hasattr(self.base_type, 'arg_name') and self.base_type.arg_name:
|
|
self.declarator.name = self.base_type.arg_name
|
|
|
|
# The parser is unable to resolve the ambiguity of [] as part of the
|
|
# type (e.g. in buffers) or empty declarator (as with arrays).
|
|
# This is only arises for empty multi-dimensional arrays.
|
|
if (base_type.is_array
|
|
and isinstance(self.base_type, TemplatedTypeNode)
|
|
and isinstance(self.declarator, CArrayDeclaratorNode)):
|
|
declarator = self.declarator
|
|
while isinstance(declarator.base, CArrayDeclaratorNode):
|
|
declarator = declarator.base
|
|
declarator.base = self.base_type.array_declarator
|
|
base_type = base_type.base_type
|
|
|
|
# inject type declaration from annotations
|
|
# this is called without 'env' by AdjustDefByDirectives transform before declaration analysis
|
|
if self.annotation and env and env.directives['annotation_typing'] and self.base_type.name is None:
|
|
arg_type = self.inject_type_from_annotations(env)
|
|
if arg_type is not None:
|
|
base_type = arg_type
|
|
return self.declarator.analyse(base_type, env, nonempty=nonempty)
|
|
else:
|
|
return self.name_declarator, self.type
|
|
|
|
def inject_type_from_annotations(self, env):
|
|
annotation = self.annotation
|
|
if not annotation:
|
|
return None
|
|
base_type, arg_type = analyse_type_annotation(annotation, env, assigned_value=self.default)
|
|
if base_type is not None:
|
|
self.base_type = base_type
|
|
return arg_type
|
|
|
|
def calculate_default_value_code(self, code):
|
|
if self.default_value is None:
|
|
if self.default:
|
|
if self.default.is_literal:
|
|
# will not output any code, just assign the result_code
|
|
self.default.generate_evaluation_code(code)
|
|
return self.type.cast_code(self.default.result())
|
|
self.default_value = code.get_argument_default_const(self.type)
|
|
return self.default_value
|
|
|
|
def annotate(self, code):
|
|
if self.default:
|
|
self.default.annotate(code)
|
|
|
|
def generate_assignment_code(self, code, target=None, overloaded_assignment=False):
|
|
default = self.default
|
|
if default is None or default.is_literal:
|
|
return
|
|
if target is None:
|
|
target = self.calculate_default_value_code(code)
|
|
default.generate_evaluation_code(code)
|
|
default.make_owned_reference(code)
|
|
result = default.result() if overloaded_assignment else default.result_as(self.type)
|
|
code.putln("%s = %s;" % (target, result))
|
|
if self.type.is_pyobject:
|
|
code.put_giveref(default.result())
|
|
default.generate_post_assignment_code(code)
|
|
default.free_temps(code)
|
|
|
|
|
|
class CBaseTypeNode(Node):
|
|
# Abstract base class for C base type nodes.
|
|
#
|
|
# Processing during analyse_declarations phase:
|
|
#
|
|
# analyse
|
|
# Returns the type.
|
|
|
|
def analyse_as_type(self, env):
|
|
return self.analyse(env)
|
|
|
|
|
|
class CAnalysedBaseTypeNode(Node):
|
|
# type type
|
|
|
|
child_attrs = []
|
|
|
|
def analyse(self, env, could_be_name=False):
|
|
return self.type
|
|
|
|
|
|
class CSimpleBaseTypeNode(CBaseTypeNode):
|
|
# name string
|
|
# module_path [string] Qualifying name components
|
|
# is_basic_c_type boolean
|
|
# signed boolean
|
|
# longness integer
|
|
# complex boolean
|
|
# is_self_arg boolean Is self argument of C method
|
|
# ##is_type_arg boolean Is type argument of class method
|
|
|
|
child_attrs = []
|
|
arg_name = None # in case the argument name was interpreted as a type
|
|
module_path = []
|
|
is_basic_c_type = False
|
|
complex = False
|
|
|
|
def analyse(self, env, could_be_name=False):
|
|
# Return type descriptor.
|
|
#print "CSimpleBaseTypeNode.analyse: is_self_arg =", self.is_self_arg ###
|
|
type = None
|
|
if self.is_basic_c_type:
|
|
type = PyrexTypes.simple_c_type(self.signed, self.longness, self.name)
|
|
if not type:
|
|
error(self.pos, "Unrecognised type modifier combination")
|
|
elif self.name == "object" and not self.module_path:
|
|
type = py_object_type
|
|
elif self.name is None:
|
|
if self.is_self_arg and env.is_c_class_scope:
|
|
#print "CSimpleBaseTypeNode.analyse: defaulting to parent type" ###
|
|
type = env.parent_type
|
|
## elif self.is_type_arg and env.is_c_class_scope:
|
|
## type = Builtin.type_type
|
|
else:
|
|
type = py_object_type
|
|
else:
|
|
if self.module_path:
|
|
# Maybe it's a nested C++ class.
|
|
scope = env
|
|
for item in self.module_path:
|
|
entry = scope.lookup(item)
|
|
if entry is not None and entry.is_cpp_class:
|
|
scope = entry.type.scope
|
|
else:
|
|
scope = None
|
|
break
|
|
|
|
if scope is None:
|
|
# Maybe it's a cimport.
|
|
scope = env.find_imported_module(self.module_path, self.pos)
|
|
else:
|
|
scope = env
|
|
|
|
if scope:
|
|
if scope.is_c_class_scope:
|
|
scope = scope.global_scope()
|
|
|
|
type = scope.lookup_type(self.name)
|
|
if type is not None:
|
|
pass
|
|
elif could_be_name:
|
|
if self.is_self_arg and env.is_c_class_scope:
|
|
type = env.parent_type
|
|
## elif self.is_type_arg and env.is_c_class_scope:
|
|
## type = Builtin.type_type
|
|
else:
|
|
type = py_object_type
|
|
self.arg_name = EncodedString(self.name)
|
|
else:
|
|
if self.templates:
|
|
if not self.name in self.templates:
|
|
error(self.pos, "'%s' is not a type identifier" % self.name)
|
|
type = PyrexTypes.TemplatePlaceholderType(self.name)
|
|
else:
|
|
error(self.pos, "'%s' is not a type identifier" % self.name)
|
|
if type and type.is_fused and env.fused_to_specific:
|
|
type = type.specialize(env.fused_to_specific)
|
|
if self.complex:
|
|
if not type.is_numeric or type.is_complex:
|
|
error(self.pos, "can only complexify c numeric types")
|
|
type = PyrexTypes.CComplexType(type)
|
|
type.create_declaration_utility_code(env)
|
|
elif type is Builtin.complex_type:
|
|
# Special case: optimise builtin complex type into C's
|
|
# double complex. The parser cannot do this (as for the
|
|
# normal scalar types) as the user may have redeclared the
|
|
# 'complex' type. Testing for the exact type here works.
|
|
type = PyrexTypes.c_double_complex_type
|
|
type.create_declaration_utility_code(env)
|
|
self.complex = True
|
|
if type:
|
|
return type
|
|
else:
|
|
return PyrexTypes.error_type
|
|
|
|
class MemoryViewSliceTypeNode(CBaseTypeNode):
|
|
|
|
name = 'memoryview'
|
|
child_attrs = ['base_type_node', 'axes']
|
|
|
|
def analyse(self, env, could_be_name=False):
|
|
|
|
base_type = self.base_type_node.analyse(env)
|
|
if base_type.is_error: return base_type
|
|
|
|
from . import MemoryView
|
|
|
|
try:
|
|
axes_specs = MemoryView.get_axes_specs(env, self.axes)
|
|
except CompileError as e:
|
|
error(e.position, e.message_only)
|
|
self.type = PyrexTypes.ErrorType()
|
|
return self.type
|
|
|
|
if not MemoryView.validate_axes(self.pos, axes_specs):
|
|
self.type = error_type
|
|
else:
|
|
self.type = PyrexTypes.MemoryViewSliceType(base_type, axes_specs)
|
|
self.type.validate_memslice_dtype(self.pos)
|
|
self.use_memview_utilities(env)
|
|
|
|
return self.type
|
|
|
|
def use_memview_utilities(self, env):
|
|
from . import MemoryView
|
|
env.use_utility_code(MemoryView.view_utility_code)
|
|
|
|
|
|
class CNestedBaseTypeNode(CBaseTypeNode):
|
|
# For C++ classes that live inside other C++ classes.
|
|
|
|
# name string
|
|
# base_type CBaseTypeNode
|
|
|
|
child_attrs = ['base_type']
|
|
|
|
def analyse(self, env, could_be_name=None):
|
|
base_type = self.base_type.analyse(env)
|
|
if base_type is PyrexTypes.error_type:
|
|
return PyrexTypes.error_type
|
|
if not base_type.is_cpp_class:
|
|
error(self.pos, "'%s' is not a valid type scope" % base_type)
|
|
return PyrexTypes.error_type
|
|
type_entry = base_type.scope.lookup_here(self.name)
|
|
if not type_entry or not type_entry.is_type:
|
|
error(self.pos, "'%s.%s' is not a type identifier" % (base_type, self.name))
|
|
return PyrexTypes.error_type
|
|
return type_entry.type
|
|
|
|
|
|
class TemplatedTypeNode(CBaseTypeNode):
|
|
# After parsing:
|
|
# positional_args [ExprNode] List of positional arguments
|
|
# keyword_args DictNode Keyword arguments
|
|
# base_type_node CBaseTypeNode
|
|
|
|
# After analysis:
|
|
# type PyrexTypes.BufferType or PyrexTypes.CppClassType ...containing the right options
|
|
|
|
child_attrs = ["base_type_node", "positional_args",
|
|
"keyword_args", "dtype_node"]
|
|
|
|
dtype_node = None
|
|
|
|
name = None
|
|
|
|
def analyse(self, env, could_be_name=False, base_type=None):
|
|
if base_type is None:
|
|
base_type = self.base_type_node.analyse(env)
|
|
if base_type.is_error: return base_type
|
|
|
|
if base_type.is_cpp_class and base_type.is_template_type():
|
|
# Templated class
|
|
if self.keyword_args and self.keyword_args.key_value_pairs:
|
|
error(self.pos, "c++ templates cannot take keyword arguments")
|
|
self.type = PyrexTypes.error_type
|
|
else:
|
|
template_types = []
|
|
for template_node in self.positional_args:
|
|
type = template_node.analyse_as_type(env)
|
|
if type is None:
|
|
error(template_node.pos, "unknown type in template argument")
|
|
type = error_type
|
|
template_types.append(type)
|
|
self.type = base_type.specialize_here(self.pos, template_types)
|
|
|
|
elif base_type.is_pyobject:
|
|
# Buffer
|
|
from . import Buffer
|
|
|
|
options = Buffer.analyse_buffer_options(
|
|
self.pos,
|
|
env,
|
|
self.positional_args,
|
|
self.keyword_args,
|
|
base_type.buffer_defaults)
|
|
|
|
if sys.version_info[0] < 3:
|
|
# Py 2.x enforces byte strings as keyword arguments ...
|
|
options = dict([(name.encode('ASCII'), value)
|
|
for name, value in options.items()])
|
|
|
|
self.type = PyrexTypes.BufferType(base_type, **options)
|
|
if has_np_pythran(env) and is_pythran_buffer(self.type):
|
|
self.type = PyrexTypes.PythranExpr(pythran_type(self.type), self.type)
|
|
|
|
else:
|
|
# Array
|
|
empty_declarator = CNameDeclaratorNode(self.pos, name="", cname=None)
|
|
if len(self.positional_args) > 1 or self.keyword_args.key_value_pairs:
|
|
error(self.pos, "invalid array declaration")
|
|
self.type = PyrexTypes.error_type
|
|
else:
|
|
# It would be nice to merge this class with CArrayDeclaratorNode,
|
|
# but arrays are part of the declaration, not the type...
|
|
if not self.positional_args:
|
|
dimension = None
|
|
else:
|
|
dimension = self.positional_args[0]
|
|
self.array_declarator = CArrayDeclaratorNode(
|
|
self.pos,
|
|
base=empty_declarator,
|
|
dimension=dimension)
|
|
self.type = self.array_declarator.analyse(base_type, env)[1]
|
|
|
|
if self.type.is_fused and env.fused_to_specific:
|
|
self.type = self.type.specialize(env.fused_to_specific)
|
|
|
|
return self.type
|
|
|
|
|
|
class CComplexBaseTypeNode(CBaseTypeNode):
|
|
# base_type CBaseTypeNode
|
|
# declarator CDeclaratorNode
|
|
|
|
child_attrs = ["base_type", "declarator"]
|
|
|
|
def analyse(self, env, could_be_name=False):
|
|
base = self.base_type.analyse(env, could_be_name)
|
|
_, type = self.declarator.analyse(base, env)
|
|
return type
|
|
|
|
|
|
class CTupleBaseTypeNode(CBaseTypeNode):
|
|
# components [CBaseTypeNode]
|
|
|
|
child_attrs = ["components"]
|
|
|
|
def analyse(self, env, could_be_name=False):
|
|
component_types = []
|
|
for c in self.components:
|
|
type = c.analyse(env)
|
|
if type.is_pyobject:
|
|
error(c.pos, "Tuple types can't (yet) contain Python objects.")
|
|
return error_type
|
|
component_types.append(type)
|
|
entry = env.declare_tuple_type(self.pos, component_types)
|
|
entry.used = True
|
|
return entry.type
|
|
|
|
|
|
class FusedTypeNode(CBaseTypeNode):
|
|
"""
|
|
Represents a fused type in a ctypedef statement:
|
|
|
|
ctypedef cython.fused_type(int, long, long long) integral
|
|
|
|
name str name of this fused type
|
|
types [CSimpleBaseTypeNode] is the list of types to be fused
|
|
"""
|
|
|
|
child_attrs = []
|
|
|
|
def analyse_declarations(self, env):
|
|
type = self.analyse(env)
|
|
entry = env.declare_typedef(self.name, type, self.pos)
|
|
|
|
# Omit the typedef declaration that self.declarator would produce
|
|
entry.in_cinclude = True
|
|
|
|
def analyse(self, env, could_be_name=False):
|
|
types = []
|
|
for type_node in self.types:
|
|
type = type_node.analyse_as_type(env)
|
|
|
|
if not type:
|
|
error(type_node.pos, "Not a type")
|
|
continue
|
|
|
|
if type in types:
|
|
error(type_node.pos, "Type specified multiple times")
|
|
else:
|
|
types.append(type)
|
|
|
|
# if len(self.types) == 1:
|
|
# return types[0]
|
|
|
|
return PyrexTypes.FusedType(types, name=self.name)
|
|
|
|
|
|
class CConstTypeNode(CBaseTypeNode):
|
|
# base_type CBaseTypeNode
|
|
|
|
child_attrs = ["base_type"]
|
|
|
|
def analyse(self, env, could_be_name=False):
|
|
base = self.base_type.analyse(env, could_be_name)
|
|
if base.is_pyobject:
|
|
error(self.pos,
|
|
"Const base type cannot be a Python object")
|
|
return PyrexTypes.c_const_type(base)
|
|
|
|
|
|
class CVarDefNode(StatNode):
|
|
# C variable definition or forward/extern function declaration.
|
|
#
|
|
# visibility 'private' or 'public' or 'extern'
|
|
# base_type CBaseTypeNode
|
|
# declarators [CDeclaratorNode]
|
|
# in_pxd boolean
|
|
# api boolean
|
|
# overridable boolean whether it is a cpdef
|
|
# modifiers ['inline']
|
|
|
|
# decorators [cython.locals(...)] or None
|
|
# directive_locals { string : NameNode } locals defined by cython.locals(...)
|
|
|
|
child_attrs = ["base_type", "declarators"]
|
|
|
|
decorators = None
|
|
directive_locals = None
|
|
|
|
def analyse_declarations(self, env, dest_scope=None):
|
|
if self.directive_locals is None:
|
|
self.directive_locals = {}
|
|
if not dest_scope:
|
|
dest_scope = env
|
|
self.dest_scope = dest_scope
|
|
|
|
if self.declarators:
|
|
templates = self.declarators[0].analyse_templates()
|
|
else:
|
|
templates = None
|
|
if templates is not None:
|
|
if self.visibility != 'extern':
|
|
error(self.pos, "Only extern functions allowed")
|
|
if len(self.declarators) > 1:
|
|
error(self.declarators[1].pos, "Can't multiply declare template types")
|
|
env = TemplateScope('func_template', env)
|
|
env.directives = env.outer_scope.directives
|
|
for template_param in templates:
|
|
env.declare_type(template_param.name, template_param, self.pos)
|
|
|
|
base_type = self.base_type.analyse(env)
|
|
|
|
if base_type.is_fused and not self.in_pxd and (env.is_c_class_scope or
|
|
env.is_module_scope):
|
|
error(self.pos, "Fused types not allowed here")
|
|
return error_type
|
|
|
|
self.entry = None
|
|
visibility = self.visibility
|
|
|
|
for declarator in self.declarators:
|
|
|
|
if (len(self.declarators) > 1
|
|
and not isinstance(declarator, CNameDeclaratorNode)
|
|
and env.directives['warn.multiple_declarators']):
|
|
warning(
|
|
declarator.pos,
|
|
"Non-trivial type declarators in shared declaration (e.g. mix of pointers and values). "
|
|
"Each pointer declaration should be on its own line.", 1)
|
|
|
|
create_extern_wrapper = (self.overridable
|
|
and self.visibility == 'extern'
|
|
and env.is_module_scope)
|
|
if create_extern_wrapper:
|
|
declarator.overridable = False
|
|
if isinstance(declarator, CFuncDeclaratorNode):
|
|
name_declarator, type = declarator.analyse(
|
|
base_type, env, directive_locals=self.directive_locals, visibility=visibility, in_pxd=self.in_pxd)
|
|
else:
|
|
name_declarator, type = declarator.analyse(
|
|
base_type, env, visibility=visibility, in_pxd=self.in_pxd)
|
|
if not type.is_complete():
|
|
if not (self.visibility == 'extern' and type.is_array or type.is_memoryviewslice):
|
|
error(declarator.pos, "Variable type '%s' is incomplete" % type)
|
|
if self.visibility == 'extern' and type.is_pyobject:
|
|
error(declarator.pos, "Python object cannot be declared extern")
|
|
name = name_declarator.name
|
|
cname = name_declarator.cname
|
|
if name == '':
|
|
error(declarator.pos, "Missing name in declaration.")
|
|
return
|
|
if type.is_reference and self.visibility != 'extern':
|
|
error(declarator.pos, "C++ references cannot be declared; use a pointer instead")
|
|
if type.is_cfunction:
|
|
if 'staticmethod' in env.directives:
|
|
type.is_static_method = True
|
|
self.entry = dest_scope.declare_cfunction(
|
|
name, type, declarator.pos,
|
|
cname=cname, visibility=self.visibility, in_pxd=self.in_pxd,
|
|
api=self.api, modifiers=self.modifiers, overridable=self.overridable)
|
|
if self.entry is not None:
|
|
self.entry.directive_locals = copy.copy(self.directive_locals)
|
|
if create_extern_wrapper:
|
|
self.entry.type.create_to_py_utility_code(env)
|
|
self.entry.create_wrapper = True
|
|
else:
|
|
if self.overridable:
|
|
warning(self.pos, "cpdef variables will not be supported in Cython 3; "
|
|
"currently they are no different from cdef variables", 2)
|
|
if self.directive_locals:
|
|
error(self.pos, "Decorators can only be followed by functions")
|
|
self.entry = dest_scope.declare_var(
|
|
name, type, declarator.pos,
|
|
cname=cname, visibility=visibility, in_pxd=self.in_pxd,
|
|
api=self.api, is_cdef=1)
|
|
if Options.docstrings:
|
|
self.entry.doc = embed_position(self.pos, self.doc)
|
|
|
|
|
|
class CStructOrUnionDefNode(StatNode):
|
|
# name string
|
|
# cname string or None
|
|
# kind "struct" or "union"
|
|
# typedef_flag boolean
|
|
# visibility "public" or "private"
|
|
# api boolean
|
|
# in_pxd boolean
|
|
# attributes [CVarDefNode] or None
|
|
# entry Entry
|
|
# packed boolean
|
|
|
|
child_attrs = ["attributes"]
|
|
|
|
def declare(self, env, scope=None):
|
|
self.entry = env.declare_struct_or_union(
|
|
self.name, self.kind, scope, self.typedef_flag, self.pos,
|
|
self.cname, visibility=self.visibility, api=self.api,
|
|
packed=self.packed)
|
|
|
|
def analyse_declarations(self, env):
|
|
scope = None
|
|
if self.attributes is not None:
|
|
scope = StructOrUnionScope(self.name)
|
|
self.declare(env, scope)
|
|
if self.attributes is not None:
|
|
if self.in_pxd and not env.in_cinclude:
|
|
self.entry.defined_in_pxd = 1
|
|
for attr in self.attributes:
|
|
attr.analyse_declarations(env, scope)
|
|
if self.visibility != 'extern':
|
|
for attr in scope.var_entries:
|
|
type = attr.type
|
|
while type.is_array:
|
|
type = type.base_type
|
|
if type == self.entry.type:
|
|
error(attr.pos, "Struct cannot contain itself as a member.")
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
pass
|
|
|
|
|
|
class CppClassNode(CStructOrUnionDefNode, BlockNode):
|
|
|
|
# name string
|
|
# cname string or None
|
|
# visibility "extern"
|
|
# in_pxd boolean
|
|
# attributes [CVarDefNode] or None
|
|
# entry Entry
|
|
# base_classes [CBaseTypeNode]
|
|
# templates [(string, bool)] or None
|
|
# decorators [DecoratorNode] or None
|
|
|
|
decorators = None
|
|
|
|
def declare(self, env):
|
|
if self.templates is None:
|
|
template_types = None
|
|
else:
|
|
template_types = [PyrexTypes.TemplatePlaceholderType(template_name, not required)
|
|
for template_name, required in self.templates]
|
|
num_optional_templates = sum(not required for _, required in self.templates)
|
|
if num_optional_templates and not all(required for _, required in self.templates[:-num_optional_templates]):
|
|
error(self.pos, "Required template parameters must precede optional template parameters.")
|
|
self.entry = env.declare_cpp_class(
|
|
self.name, None, self.pos, self.cname,
|
|
base_classes=[], visibility=self.visibility, templates=template_types)
|
|
|
|
def analyse_declarations(self, env):
|
|
if self.templates is None:
|
|
template_types = template_names = None
|
|
else:
|
|
template_names = [template_name for template_name, _ in self.templates]
|
|
template_types = [PyrexTypes.TemplatePlaceholderType(template_name, not required)
|
|
for template_name, required in self.templates]
|
|
scope = None
|
|
if self.attributes is not None:
|
|
scope = CppClassScope(self.name, env, templates=template_names)
|
|
def base_ok(base_class):
|
|
if base_class.is_cpp_class or base_class.is_struct:
|
|
return True
|
|
else:
|
|
error(self.pos, "Base class '%s' not a struct or class." % base_class)
|
|
base_class_types = filter(base_ok, [b.analyse(scope or env) for b in self.base_classes])
|
|
self.entry = env.declare_cpp_class(
|
|
self.name, scope, self.pos,
|
|
self.cname, base_class_types, visibility=self.visibility, templates=template_types)
|
|
if self.entry is None:
|
|
return
|
|
self.entry.is_cpp_class = 1
|
|
if scope is not None:
|
|
scope.type = self.entry.type
|
|
defined_funcs = []
|
|
def func_attributes(attributes):
|
|
for attr in attributes:
|
|
if isinstance(attr, CFuncDefNode):
|
|
yield attr
|
|
elif isinstance(attr, CompilerDirectivesNode):
|
|
for sub_attr in func_attributes(attr.body.stats):
|
|
yield sub_attr
|
|
if self.attributes is not None:
|
|
if self.in_pxd and not env.in_cinclude:
|
|
self.entry.defined_in_pxd = 1
|
|
for attr in self.attributes:
|
|
declare = getattr(attr, 'declare', None)
|
|
if declare:
|
|
attr.declare(scope)
|
|
attr.analyse_declarations(scope)
|
|
for func in func_attributes(self.attributes):
|
|
defined_funcs.append(func)
|
|
if self.templates is not None:
|
|
func.template_declaration = "template <typename %s>" % ", typename ".join(template_names)
|
|
self.body = StatListNode(self.pos, stats=defined_funcs)
|
|
self.scope = scope
|
|
|
|
def analyse_expressions(self, env):
|
|
self.body = self.body.analyse_expressions(self.entry.type.scope)
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.body.generate_function_definitions(self.entry.type.scope, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
self.body.generate_execution_code(code)
|
|
|
|
def annotate(self, code):
|
|
self.body.annotate(code)
|
|
|
|
|
|
class CEnumDefNode(StatNode):
|
|
# name string or None
|
|
# cname string or None
|
|
# items [CEnumDefItemNode]
|
|
# typedef_flag boolean
|
|
# visibility "public" or "private" or "extern"
|
|
# api boolean
|
|
# in_pxd boolean
|
|
# create_wrapper boolean
|
|
# entry Entry
|
|
|
|
child_attrs = ["items"]
|
|
|
|
def declare(self, env):
|
|
self.entry = env.declare_enum(
|
|
self.name, self.pos,
|
|
cname=self.cname, typedef_flag=self.typedef_flag,
|
|
visibility=self.visibility, api=self.api,
|
|
create_wrapper=self.create_wrapper)
|
|
|
|
def analyse_declarations(self, env):
|
|
if self.items is not None:
|
|
if self.in_pxd and not env.in_cinclude:
|
|
self.entry.defined_in_pxd = 1
|
|
for item in self.items:
|
|
item.analyse_declarations(env, self.entry)
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
if self.visibility == 'public' or self.api:
|
|
code.mark_pos(self.pos)
|
|
temp = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
|
|
for item in self.entry.enum_values:
|
|
code.putln("%s = PyInt_FromLong(%s); %s" % (
|
|
temp,
|
|
item.cname,
|
|
code.error_goto_if_null(temp, item.pos)))
|
|
code.put_gotref(temp)
|
|
code.putln('if (PyDict_SetItemString(%s, "%s", %s) < 0) %s' % (
|
|
Naming.moddict_cname,
|
|
item.name,
|
|
temp,
|
|
code.error_goto(item.pos)))
|
|
code.put_decref_clear(temp, PyrexTypes.py_object_type)
|
|
code.funcstate.release_temp(temp)
|
|
|
|
|
|
class CEnumDefItemNode(StatNode):
|
|
# name string
|
|
# cname string or None
|
|
# value ExprNode or None
|
|
|
|
child_attrs = ["value"]
|
|
|
|
def analyse_declarations(self, env, enum_entry):
|
|
if self.value:
|
|
self.value = self.value.analyse_const_expression(env)
|
|
if not self.value.type.is_int:
|
|
self.value = self.value.coerce_to(PyrexTypes.c_int_type, env)
|
|
self.value = self.value.analyse_const_expression(env)
|
|
entry = env.declare_const(
|
|
self.name, enum_entry.type,
|
|
self.value, self.pos, cname=self.cname,
|
|
visibility=enum_entry.visibility, api=enum_entry.api,
|
|
create_wrapper=enum_entry.create_wrapper and enum_entry.name is None)
|
|
enum_entry.enum_values.append(entry)
|
|
if enum_entry.name:
|
|
enum_entry.type.values.append(entry.name)
|
|
|
|
|
|
class CTypeDefNode(StatNode):
|
|
# base_type CBaseTypeNode
|
|
# declarator CDeclaratorNode
|
|
# visibility "public" or "private"
|
|
# api boolean
|
|
# in_pxd boolean
|
|
|
|
child_attrs = ["base_type", "declarator"]
|
|
|
|
def analyse_declarations(self, env):
|
|
base = self.base_type.analyse(env)
|
|
name_declarator, type = self.declarator.analyse(
|
|
base, env, visibility=self.visibility, in_pxd=self.in_pxd)
|
|
name = name_declarator.name
|
|
cname = name_declarator.cname
|
|
|
|
entry = env.declare_typedef(
|
|
name, type, self.pos,
|
|
cname=cname, visibility=self.visibility, api=self.api)
|
|
|
|
if type.is_fused:
|
|
entry.in_cinclude = True
|
|
|
|
if self.in_pxd and not env.in_cinclude:
|
|
entry.defined_in_pxd = 1
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
pass
|
|
|
|
|
|
class FuncDefNode(StatNode, BlockNode):
|
|
# Base class for function definition nodes.
|
|
#
|
|
# return_type PyrexType
|
|
# #filename string C name of filename string const
|
|
# entry Symtab.Entry
|
|
# needs_closure boolean Whether or not this function has inner functions/classes/yield
|
|
# needs_outer_scope boolean Whether or not this function requires outer scope
|
|
# pymethdef_required boolean Force Python method struct generation
|
|
# directive_locals { string : ExprNode } locals defined by cython.locals(...)
|
|
# directive_returns [ExprNode] type defined by cython.returns(...)
|
|
# star_arg PyArgDeclNode or None * argument
|
|
# starstar_arg PyArgDeclNode or None ** argument
|
|
#
|
|
# is_async_def boolean is a Coroutine function
|
|
#
|
|
# has_fused_arguments boolean
|
|
# Whether this cdef function has fused parameters. This is needed
|
|
# by AnalyseDeclarationsTransform, so it can replace CFuncDefNodes
|
|
# with fused argument types with a FusedCFuncDefNode
|
|
|
|
py_func = None
|
|
needs_closure = False
|
|
needs_outer_scope = False
|
|
pymethdef_required = False
|
|
is_generator = False
|
|
is_generator_body = False
|
|
is_async_def = False
|
|
modifiers = []
|
|
has_fused_arguments = False
|
|
star_arg = None
|
|
starstar_arg = None
|
|
is_cyfunction = False
|
|
code_object = None
|
|
|
|
def analyse_default_values(self, env):
|
|
default_seen = 0
|
|
for arg in self.args:
|
|
if arg.default:
|
|
default_seen = 1
|
|
if arg.is_generic:
|
|
arg.default = arg.default.analyse_types(env)
|
|
arg.default = arg.default.coerce_to(arg.type, env)
|
|
else:
|
|
error(arg.pos, "This argument cannot have a default value")
|
|
arg.default = None
|
|
elif arg.kw_only:
|
|
default_seen = 1
|
|
elif default_seen:
|
|
error(arg.pos, "Non-default argument following default argument")
|
|
|
|
def analyse_annotation(self, env, annotation):
|
|
# Annotations can not only contain valid Python expressions but arbitrary type references.
|
|
if annotation is None:
|
|
return None
|
|
if not env.directives['annotation_typing'] or annotation.analyse_as_type(env) is None:
|
|
annotation = annotation.analyse_types(env)
|
|
return annotation
|
|
|
|
def analyse_annotations(self, env):
|
|
for arg in self.args:
|
|
if arg.annotation:
|
|
arg.annotation = self.analyse_annotation(env, arg.annotation)
|
|
|
|
def align_argument_type(self, env, arg):
|
|
# @cython.locals()
|
|
directive_locals = self.directive_locals
|
|
orig_type = arg.type
|
|
if arg.name in directive_locals:
|
|
type_node = directive_locals[arg.name]
|
|
other_type = type_node.analyse_as_type(env)
|
|
elif isinstance(arg, CArgDeclNode) and arg.annotation and env.directives['annotation_typing']:
|
|
type_node = arg.annotation
|
|
other_type = arg.inject_type_from_annotations(env)
|
|
if other_type is None:
|
|
return arg
|
|
else:
|
|
return arg
|
|
if other_type is None:
|
|
error(type_node.pos, "Not a type")
|
|
elif orig_type is not py_object_type and not orig_type.same_as(other_type):
|
|
error(arg.base_type.pos, "Signature does not agree with previous declaration")
|
|
error(type_node.pos, "Previous declaration here")
|
|
else:
|
|
arg.type = other_type
|
|
return arg
|
|
|
|
def need_gil_acquisition(self, lenv):
|
|
return 0
|
|
|
|
def create_local_scope(self, env):
|
|
genv = env
|
|
while genv.is_py_class_scope or genv.is_c_class_scope:
|
|
genv = genv.outer_scope
|
|
if self.needs_closure:
|
|
lenv = ClosureScope(name=self.entry.name,
|
|
outer_scope=genv,
|
|
parent_scope=env,
|
|
scope_name=self.entry.cname)
|
|
else:
|
|
lenv = LocalScope(name=self.entry.name,
|
|
outer_scope=genv,
|
|
parent_scope=env)
|
|
lenv.return_type = self.return_type
|
|
type = self.entry.type
|
|
if type.is_cfunction:
|
|
lenv.nogil = type.nogil and not type.with_gil
|
|
self.local_scope = lenv
|
|
lenv.directives = env.directives
|
|
return lenv
|
|
|
|
def generate_function_body(self, env, code):
|
|
self.body.generate_execution_code(code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
from . import Buffer
|
|
if self.return_type.is_memoryviewslice:
|
|
from . import MemoryView
|
|
|
|
lenv = self.local_scope
|
|
if lenv.is_closure_scope and not lenv.is_passthrough:
|
|
outer_scope_cname = "%s->%s" % (Naming.cur_scope_cname,
|
|
Naming.outer_scope_cname)
|
|
else:
|
|
outer_scope_cname = Naming.outer_scope_cname
|
|
lenv.mangle_closure_cnames(outer_scope_cname)
|
|
# Generate closure function definitions
|
|
self.body.generate_function_definitions(lenv, code)
|
|
# generate lambda function definitions
|
|
self.generate_lambda_definitions(lenv, code)
|
|
|
|
is_getbuffer_slot = (self.entry.name == "__getbuffer__" and
|
|
self.entry.scope.is_c_class_scope)
|
|
is_releasebuffer_slot = (self.entry.name == "__releasebuffer__" and
|
|
self.entry.scope.is_c_class_scope)
|
|
is_buffer_slot = is_getbuffer_slot or is_releasebuffer_slot
|
|
if is_buffer_slot:
|
|
if 'cython_unused' not in self.modifiers:
|
|
self.modifiers = self.modifiers + ['cython_unused']
|
|
|
|
preprocessor_guard = self.get_preprocessor_guard()
|
|
|
|
profile = code.globalstate.directives['profile']
|
|
linetrace = code.globalstate.directives['linetrace']
|
|
if profile or linetrace:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("Profile", "Profile.c"))
|
|
|
|
# Generate C code for header and body of function
|
|
code.enter_cfunc_scope(lenv)
|
|
code.return_from_error_cleanup_label = code.new_label()
|
|
code.funcstate.gil_owned = not lenv.nogil
|
|
|
|
# ----- Top-level constants used by this function
|
|
code.mark_pos(self.pos)
|
|
self.generate_cached_builtins_decls(lenv, code)
|
|
# ----- Function header
|
|
code.putln("")
|
|
|
|
if preprocessor_guard:
|
|
code.putln(preprocessor_guard)
|
|
|
|
with_pymethdef = (self.needs_assignment_synthesis(env, code) or
|
|
self.pymethdef_required)
|
|
if self.py_func:
|
|
self.py_func.generate_function_header(
|
|
code, with_pymethdef=with_pymethdef, proto_only=True)
|
|
self.generate_function_header(code, with_pymethdef=with_pymethdef)
|
|
# ----- Local variable declarations
|
|
# Find function scope
|
|
cenv = env
|
|
while cenv.is_py_class_scope or cenv.is_c_class_scope:
|
|
cenv = cenv.outer_scope
|
|
if self.needs_closure:
|
|
code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))
|
|
code.putln(";")
|
|
elif self.needs_outer_scope:
|
|
if lenv.is_passthrough:
|
|
code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))
|
|
code.putln(";")
|
|
code.put(cenv.scope_class.type.declaration_code(Naming.outer_scope_cname))
|
|
code.putln(";")
|
|
self.generate_argument_declarations(lenv, code)
|
|
|
|
for entry in lenv.var_entries:
|
|
if not (entry.in_closure or entry.is_arg):
|
|
code.put_var_declaration(entry)
|
|
|
|
# Initialize the return variable __pyx_r
|
|
init = ""
|
|
if not self.return_type.is_void:
|
|
if self.return_type.is_pyobject:
|
|
init = " = NULL"
|
|
elif self.return_type.is_memoryviewslice:
|
|
init = ' = ' + MemoryView.memslice_entry_init
|
|
|
|
code.putln("%s%s;" % (
|
|
self.return_type.declaration_code(Naming.retval_cname),
|
|
init))
|
|
|
|
tempvardecl_code = code.insertion_point()
|
|
self.generate_keyword_list(code)
|
|
|
|
# ----- GIL acquisition
|
|
acquire_gil = self.acquire_gil
|
|
|
|
# See if we need to acquire the GIL for variable declarations, or for
|
|
# refnanny only
|
|
|
|
# Closures are not currently possible for cdef nogil functions,
|
|
# but check them anyway
|
|
have_object_args = self.needs_closure or self.needs_outer_scope
|
|
for arg in lenv.arg_entries:
|
|
if arg.type.is_pyobject:
|
|
have_object_args = True
|
|
break
|
|
|
|
used_buffer_entries = [entry for entry in lenv.buffer_entries if entry.used]
|
|
|
|
acquire_gil_for_var_decls_only = (
|
|
lenv.nogil and lenv.has_with_gil_block and
|
|
(have_object_args or used_buffer_entries))
|
|
|
|
acquire_gil_for_refnanny_only = (
|
|
lenv.nogil and lenv.has_with_gil_block and not
|
|
acquire_gil_for_var_decls_only)
|
|
|
|
use_refnanny = not lenv.nogil or lenv.has_with_gil_block
|
|
|
|
if acquire_gil or acquire_gil_for_var_decls_only:
|
|
code.put_ensure_gil()
|
|
code.funcstate.gil_owned = True
|
|
elif lenv.nogil and lenv.has_with_gil_block:
|
|
code.declare_gilstate()
|
|
|
|
if profile or linetrace:
|
|
if not self.is_generator:
|
|
# generators are traced when iterated, not at creation
|
|
tempvardecl_code.put_trace_declarations()
|
|
code_object = self.code_object.calculate_result_code(code) if self.code_object else None
|
|
code.put_trace_frame_init(code_object)
|
|
|
|
# ----- Special check for getbuffer
|
|
if is_getbuffer_slot:
|
|
self.getbuffer_check(code)
|
|
|
|
# ----- set up refnanny
|
|
if use_refnanny:
|
|
tempvardecl_code.put_declare_refcount_context()
|
|
code.put_setup_refcount_context(
|
|
self.entry.name, acquire_gil=acquire_gil_for_refnanny_only)
|
|
|
|
# ----- Automatic lead-ins for certain special functions
|
|
if is_getbuffer_slot:
|
|
self.getbuffer_init(code)
|
|
# ----- Create closure scope object
|
|
if self.needs_closure:
|
|
tp_slot = TypeSlots.ConstructorSlot("tp_new", '__new__')
|
|
slot_func_cname = TypeSlots.get_slot_function(lenv.scope_class.type.scope, tp_slot)
|
|
if not slot_func_cname:
|
|
slot_func_cname = '%s->tp_new' % lenv.scope_class.type.typeptr_cname
|
|
code.putln("%s = (%s)%s(%s, %s, NULL);" % (
|
|
Naming.cur_scope_cname,
|
|
lenv.scope_class.type.empty_declaration_code(),
|
|
slot_func_cname,
|
|
lenv.scope_class.type.typeptr_cname,
|
|
Naming.empty_tuple))
|
|
code.putln("if (unlikely(!%s)) {" % Naming.cur_scope_cname)
|
|
# Scope unconditionally DECREFed on return.
|
|
code.putln("%s = %s;" % (
|
|
Naming.cur_scope_cname,
|
|
lenv.scope_class.type.cast_code("Py_None")))
|
|
code.put_incref("Py_None", py_object_type)
|
|
code.putln(code.error_goto(self.pos))
|
|
code.putln("} else {")
|
|
code.put_gotref(Naming.cur_scope_cname)
|
|
code.putln("}")
|
|
# Note that it is unsafe to decref the scope at this point.
|
|
if self.needs_outer_scope:
|
|
if self.is_cyfunction:
|
|
code.putln("%s = (%s) __Pyx_CyFunction_GetClosure(%s);" % (
|
|
outer_scope_cname,
|
|
cenv.scope_class.type.empty_declaration_code(),
|
|
Naming.self_cname))
|
|
else:
|
|
code.putln("%s = (%s) %s;" % (
|
|
outer_scope_cname,
|
|
cenv.scope_class.type.empty_declaration_code(),
|
|
Naming.self_cname))
|
|
if lenv.is_passthrough:
|
|
code.putln("%s = %s;" % (Naming.cur_scope_cname, outer_scope_cname))
|
|
elif self.needs_closure:
|
|
# inner closures own a reference to their outer parent
|
|
code.put_incref(outer_scope_cname, cenv.scope_class.type)
|
|
code.put_giveref(outer_scope_cname)
|
|
# ----- Trace function call
|
|
if profile or linetrace:
|
|
# this looks a bit late, but if we don't get here due to a
|
|
# fatal error before hand, it's not really worth tracing
|
|
if not self.is_generator:
|
|
# generators are traced when iterated, not at creation
|
|
if self.is_wrapper:
|
|
trace_name = self.entry.name + " (wrapper)"
|
|
else:
|
|
trace_name = self.entry.name
|
|
code.put_trace_call(
|
|
trace_name, self.pos, nogil=not code.funcstate.gil_owned)
|
|
code.funcstate.can_trace = True
|
|
# ----- Fetch arguments
|
|
self.generate_argument_parsing_code(env, code)
|
|
# If an argument is assigned to in the body, we must
|
|
# incref it to properly keep track of refcounts.
|
|
is_cdef = isinstance(self, CFuncDefNode)
|
|
for entry in lenv.arg_entries:
|
|
if entry.type.is_pyobject:
|
|
if (acquire_gil or len(entry.cf_assignments) > 1) and not entry.in_closure:
|
|
code.put_var_incref(entry)
|
|
|
|
# Note: defaults are always incref-ed. For def functions, we
|
|
# we acquire arguments from object conversion, so we have
|
|
# new references. If we are a cdef function, we need to
|
|
# incref our arguments
|
|
elif is_cdef and entry.type.is_memoryviewslice and len(entry.cf_assignments) > 1:
|
|
code.put_incref_memoryviewslice(entry.cname, have_gil=code.funcstate.gil_owned)
|
|
for entry in lenv.var_entries:
|
|
if entry.is_arg and len(entry.cf_assignments) > 1 and not entry.in_closure:
|
|
if entry.xdecref_cleanup:
|
|
code.put_var_xincref(entry)
|
|
else:
|
|
code.put_var_incref(entry)
|
|
|
|
# ----- Initialise local buffer auxiliary variables
|
|
for entry in lenv.var_entries + lenv.arg_entries:
|
|
if entry.type.is_buffer and entry.buffer_aux.buflocal_nd_var.used:
|
|
Buffer.put_init_vars(entry, code)
|
|
|
|
# ----- Check and convert arguments
|
|
self.generate_argument_type_tests(code)
|
|
# ----- Acquire buffer arguments
|
|
for entry in lenv.arg_entries:
|
|
if entry.type.is_buffer:
|
|
Buffer.put_acquire_arg_buffer(entry, code, self.pos)
|
|
|
|
if acquire_gil_for_var_decls_only:
|
|
code.put_release_ensured_gil()
|
|
code.funcstate.gil_owned = False
|
|
|
|
# -------------------------
|
|
# ----- Function body -----
|
|
# -------------------------
|
|
self.generate_function_body(env, code)
|
|
|
|
code.mark_pos(self.pos, trace=False)
|
|
code.putln("")
|
|
code.putln("/* function exit code */")
|
|
|
|
# ----- Default return value
|
|
if not self.body.is_terminator:
|
|
if self.return_type.is_pyobject:
|
|
#if self.return_type.is_extension_type:
|
|
# lhs = "(PyObject *)%s" % Naming.retval_cname
|
|
#else:
|
|
lhs = Naming.retval_cname
|
|
code.put_init_to_py_none(lhs, self.return_type)
|
|
else:
|
|
val = self.return_type.default_value
|
|
if val:
|
|
code.putln("%s = %s;" % (Naming.retval_cname, val))
|
|
elif not self.return_type.is_void:
|
|
code.putln("__Pyx_pretend_to_initialize(&%s);" % Naming.retval_cname)
|
|
# ----- Error cleanup
|
|
if code.error_label in code.labels_used:
|
|
if not self.body.is_terminator:
|
|
code.put_goto(code.return_label)
|
|
code.put_label(code.error_label)
|
|
for cname, type in code.funcstate.all_managed_temps():
|
|
code.put_xdecref(cname, type, have_gil=not lenv.nogil)
|
|
|
|
# Clean up buffers -- this calls a Python function
|
|
# so need to save and restore error state
|
|
buffers_present = len(used_buffer_entries) > 0
|
|
#memslice_entries = [e for e in lenv.entries.values() if e.type.is_memoryviewslice]
|
|
if buffers_present:
|
|
code.globalstate.use_utility_code(restore_exception_utility_code)
|
|
code.putln("{ PyObject *__pyx_type, *__pyx_value, *__pyx_tb;")
|
|
code.putln("__Pyx_PyThreadState_declare")
|
|
code.putln("__Pyx_PyThreadState_assign")
|
|
code.putln("__Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);")
|
|
for entry in used_buffer_entries:
|
|
Buffer.put_release_buffer_code(code, entry)
|
|
#code.putln("%s = 0;" % entry.cname)
|
|
code.putln("__Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}")
|
|
|
|
if self.return_type.is_memoryviewslice:
|
|
MemoryView.put_init_entry(Naming.retval_cname, code)
|
|
err_val = Naming.retval_cname
|
|
else:
|
|
err_val = self.error_value()
|
|
|
|
exc_check = self.caller_will_check_exceptions()
|
|
if err_val is not None or exc_check:
|
|
# TODO: Fix exception tracing (though currently unused by cProfile).
|
|
# code.globalstate.use_utility_code(get_exception_tuple_utility_code)
|
|
# code.put_trace_exception()
|
|
|
|
if lenv.nogil and not lenv.has_with_gil_block:
|
|
code.putln("{")
|
|
code.put_ensure_gil()
|
|
|
|
code.put_add_traceback(self.entry.qualified_name)
|
|
|
|
if lenv.nogil and not lenv.has_with_gil_block:
|
|
code.put_release_ensured_gil()
|
|
code.putln("}")
|
|
else:
|
|
warning(self.entry.pos,
|
|
"Unraisable exception in function '%s'." %
|
|
self.entry.qualified_name, 0)
|
|
code.put_unraisable(self.entry.qualified_name, lenv.nogil)
|
|
default_retval = self.return_type.default_value
|
|
if err_val is None and default_retval:
|
|
err_val = default_retval
|
|
if err_val is not None:
|
|
if err_val != Naming.retval_cname:
|
|
code.putln("%s = %s;" % (Naming.retval_cname, err_val))
|
|
elif not self.return_type.is_void:
|
|
code.putln("__Pyx_pretend_to_initialize(&%s);" % Naming.retval_cname)
|
|
|
|
if is_getbuffer_slot:
|
|
self.getbuffer_error_cleanup(code)
|
|
|
|
# If we are using the non-error cleanup section we should
|
|
# jump past it if we have an error. The if-test below determine
|
|
# whether this section is used.
|
|
if buffers_present or is_getbuffer_slot or self.return_type.is_memoryviewslice:
|
|
code.put_goto(code.return_from_error_cleanup_label)
|
|
|
|
# ----- Non-error return cleanup
|
|
code.put_label(code.return_label)
|
|
for entry in used_buffer_entries:
|
|
Buffer.put_release_buffer_code(code, entry)
|
|
if is_getbuffer_slot:
|
|
self.getbuffer_normal_cleanup(code)
|
|
|
|
if self.return_type.is_memoryviewslice:
|
|
# See if our return value is uninitialized on non-error return
|
|
# from . import MemoryView
|
|
# MemoryView.err_if_nogil_initialized_check(self.pos, env)
|
|
cond = code.unlikely(self.return_type.error_condition(Naming.retval_cname))
|
|
code.putln(
|
|
'if (%s) {' % cond)
|
|
if env.nogil:
|
|
code.put_ensure_gil()
|
|
code.putln(
|
|
'PyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized");')
|
|
if env.nogil:
|
|
code.put_release_ensured_gil()
|
|
code.putln(
|
|
'}')
|
|
|
|
# ----- Return cleanup for both error and no-error return
|
|
code.put_label(code.return_from_error_cleanup_label)
|
|
|
|
for entry in lenv.var_entries:
|
|
if not entry.used or entry.in_closure:
|
|
continue
|
|
|
|
if entry.type.is_memoryviewslice:
|
|
code.put_xdecref_memoryviewslice(entry.cname, have_gil=not lenv.nogil)
|
|
elif entry.type.is_pyobject:
|
|
if not entry.is_arg or len(entry.cf_assignments) > 1:
|
|
if entry.xdecref_cleanup:
|
|
code.put_var_xdecref(entry)
|
|
else:
|
|
code.put_var_decref(entry)
|
|
|
|
# Decref any increfed args
|
|
for entry in lenv.arg_entries:
|
|
if entry.type.is_pyobject:
|
|
if (acquire_gil or len(entry.cf_assignments) > 1) and not entry.in_closure:
|
|
code.put_var_decref(entry)
|
|
elif (entry.type.is_memoryviewslice and
|
|
(not is_cdef or len(entry.cf_assignments) > 1)):
|
|
# decref slices of def functions and acquired slices from cdef
|
|
# functions, but not borrowed slices from cdef functions.
|
|
code.put_xdecref_memoryviewslice(entry.cname,
|
|
have_gil=not lenv.nogil)
|
|
if self.needs_closure:
|
|
code.put_decref(Naming.cur_scope_cname, lenv.scope_class.type)
|
|
|
|
# ----- Return
|
|
# This code is duplicated in ModuleNode.generate_module_init_func
|
|
if not lenv.nogil:
|
|
default_retval = self.return_type.default_value
|
|
err_val = self.error_value()
|
|
if err_val is None and default_retval:
|
|
err_val = default_retval # FIXME: why is err_val not used?
|
|
if self.return_type.is_pyobject:
|
|
code.put_xgiveref(self.return_type.as_pyobject(Naming.retval_cname))
|
|
|
|
if self.entry.is_special and self.entry.name == "__hash__":
|
|
# Returning -1 for __hash__ is supposed to signal an error
|
|
# We do as Python instances and coerce -1 into -2.
|
|
code.putln("if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;" % (
|
|
Naming.retval_cname, Naming.retval_cname))
|
|
|
|
if profile or linetrace:
|
|
code.funcstate.can_trace = False
|
|
if not self.is_generator:
|
|
# generators are traced when iterated, not at creation
|
|
if self.return_type.is_pyobject:
|
|
code.put_trace_return(
|
|
Naming.retval_cname, nogil=not code.funcstate.gil_owned)
|
|
else:
|
|
code.put_trace_return(
|
|
"Py_None", nogil=not code.funcstate.gil_owned)
|
|
|
|
if not lenv.nogil:
|
|
# GIL holding function
|
|
code.put_finish_refcount_context()
|
|
|
|
if acquire_gil or (lenv.nogil and lenv.has_with_gil_block):
|
|
# release the GIL (note that with-gil blocks acquire it on exit in their EnsureGILNode)
|
|
code.put_release_ensured_gil()
|
|
code.funcstate.gil_owned = False
|
|
|
|
if not self.return_type.is_void:
|
|
code.putln("return %s;" % Naming.retval_cname)
|
|
|
|
code.putln("}")
|
|
|
|
if preprocessor_guard:
|
|
code.putln("#endif /*!(%s)*/" % preprocessor_guard)
|
|
|
|
# ----- Go back and insert temp variable declarations
|
|
tempvardecl_code.put_temp_declarations(code.funcstate)
|
|
|
|
# ----- Python version
|
|
code.exit_cfunc_scope()
|
|
if self.py_func:
|
|
self.py_func.generate_function_definitions(env, code)
|
|
self.generate_wrapper_functions(code)
|
|
|
|
def declare_argument(self, env, arg):
|
|
if arg.type.is_void:
|
|
error(arg.pos, "Invalid use of 'void'")
|
|
elif not arg.type.is_complete() and not (arg.type.is_array or arg.type.is_memoryviewslice):
|
|
error(arg.pos, "Argument type '%s' is incomplete" % arg.type)
|
|
entry = env.declare_arg(arg.name, arg.type, arg.pos)
|
|
if arg.annotation:
|
|
entry.annotation = arg.annotation
|
|
return entry
|
|
|
|
def generate_arg_type_test(self, arg, code):
|
|
# Generate type test for one argument.
|
|
if arg.type.typeobj_is_available():
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("ArgTypeTest", "FunctionArguments.c"))
|
|
typeptr_cname = arg.type.typeptr_cname
|
|
arg_code = "((PyObject *)%s)" % arg.entry.cname
|
|
code.putln(
|
|
'if (unlikely(!__Pyx_ArgTypeTest(%s, %s, %d, "%s", %s))) %s' % (
|
|
arg_code,
|
|
typeptr_cname,
|
|
arg.accept_none,
|
|
arg.name,
|
|
arg.type.is_builtin_type and arg.type.require_exact,
|
|
code.error_goto(arg.pos)))
|
|
else:
|
|
error(arg.pos, "Cannot test type of extern C class without type object name specification")
|
|
|
|
def generate_arg_none_check(self, arg, code):
|
|
# Generate None check for one argument.
|
|
if arg.type.is_memoryviewslice:
|
|
cname = "%s.memview" % arg.entry.cname
|
|
else:
|
|
cname = arg.entry.cname
|
|
|
|
code.putln('if (unlikely(((PyObject *)%s) == Py_None)) {' % cname)
|
|
code.putln('''PyErr_Format(PyExc_TypeError, "Argument '%%.%ds' must not be None", "%s"); %s''' % (
|
|
max(200, len(arg.name)), arg.name,
|
|
code.error_goto(arg.pos)))
|
|
code.putln('}')
|
|
|
|
def generate_wrapper_functions(self, code):
|
|
pass
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
# Evaluate and store argument default values
|
|
for arg in self.args:
|
|
if not arg.is_dynamic:
|
|
arg.generate_assignment_code(code)
|
|
|
|
#
|
|
# Special code for the __getbuffer__ function
|
|
#
|
|
def _get_py_buffer_info(self):
|
|
py_buffer = self.local_scope.arg_entries[1]
|
|
try:
|
|
# Check builtin definition of struct Py_buffer
|
|
obj_type = py_buffer.type.base_type.scope.entries['obj'].type
|
|
except (AttributeError, KeyError):
|
|
# User code redeclared struct Py_buffer
|
|
obj_type = None
|
|
return py_buffer, obj_type
|
|
|
|
# Old Python 3 used to support write-locks on buffer-like objects by
|
|
# calling PyObject_GetBuffer() with a view==NULL parameter. This obscure
|
|
# feature is obsolete, it was almost never used (only one instance in
|
|
# `Modules/posixmodule.c` in Python 3.1) and it is now officially removed
|
|
# (see bpo-14203). We add an extra check here to prevent legacy code from
|
|
# from trying to use the feature and prevent segmentation faults.
|
|
def getbuffer_check(self, code):
|
|
py_buffer, _ = self._get_py_buffer_info()
|
|
view = py_buffer.cname
|
|
code.putln("if (%s == NULL) {" % view)
|
|
code.putln("PyErr_SetString(PyExc_BufferError, "
|
|
"\"PyObject_GetBuffer: view==NULL argument is obsolete\");")
|
|
code.putln("return -1;")
|
|
code.putln("}")
|
|
|
|
def getbuffer_init(self, code):
|
|
py_buffer, obj_type = self._get_py_buffer_info()
|
|
view = py_buffer.cname
|
|
if obj_type and obj_type.is_pyobject:
|
|
code.put_init_to_py_none("%s->obj" % view, obj_type)
|
|
code.put_giveref("%s->obj" % view) # Do not refnanny object within structs
|
|
else:
|
|
code.putln("%s->obj = NULL;" % view)
|
|
|
|
def getbuffer_error_cleanup(self, code):
|
|
py_buffer, obj_type = self._get_py_buffer_info()
|
|
view = py_buffer.cname
|
|
if obj_type and obj_type.is_pyobject:
|
|
code.putln("if (%s->obj != NULL) {" % view)
|
|
code.put_gotref("%s->obj" % view)
|
|
code.put_decref_clear("%s->obj" % view, obj_type)
|
|
code.putln("}")
|
|
else:
|
|
code.putln("Py_CLEAR(%s->obj);" % view)
|
|
|
|
def getbuffer_normal_cleanup(self, code):
|
|
py_buffer, obj_type = self._get_py_buffer_info()
|
|
view = py_buffer.cname
|
|
if obj_type and obj_type.is_pyobject:
|
|
code.putln("if (%s->obj == Py_None) {" % view)
|
|
code.put_gotref("%s->obj" % view)
|
|
code.put_decref_clear("%s->obj" % view, obj_type)
|
|
code.putln("}")
|
|
|
|
def get_preprocessor_guard(self):
|
|
if not self.entry.is_special:
|
|
return None
|
|
name = self.entry.name
|
|
slot = TypeSlots.method_name_to_slot.get(name)
|
|
if not slot:
|
|
return None
|
|
if name == '__long__' and not self.entry.scope.lookup_here('__int__'):
|
|
return None
|
|
if name in ("__getbuffer__", "__releasebuffer__") and self.entry.scope.is_c_class_scope:
|
|
return None
|
|
return slot.preprocessor_guard_code()
|
|
|
|
|
|
class CFuncDefNode(FuncDefNode):
|
|
# C function definition.
|
|
#
|
|
# modifiers ['inline']
|
|
# visibility 'private' or 'public' or 'extern'
|
|
# base_type CBaseTypeNode
|
|
# declarator CDeclaratorNode
|
|
# cfunc_declarator the CFuncDeclarator of this function
|
|
# (this is also available through declarator or a
|
|
# base thereof)
|
|
# body StatListNode
|
|
# api boolean
|
|
# decorators [DecoratorNode] list of decorators
|
|
#
|
|
# with_gil boolean Acquire GIL around body
|
|
# type CFuncType
|
|
# py_func wrapper for calling from Python
|
|
# overridable whether or not this is a cpdef function
|
|
# inline_in_pxd whether this is an inline function in a pxd file
|
|
# template_declaration String or None Used for c++ class methods
|
|
# is_const_method whether this is a const method
|
|
# is_static_method whether this is a static method
|
|
# is_c_class_method whether this is a cclass method
|
|
|
|
child_attrs = ["base_type", "declarator", "body", "py_func_stat"]
|
|
|
|
inline_in_pxd = False
|
|
decorators = None
|
|
directive_locals = None
|
|
directive_returns = None
|
|
override = None
|
|
template_declaration = None
|
|
is_const_method = False
|
|
py_func_stat = None
|
|
|
|
def unqualified_name(self):
|
|
return self.entry.name
|
|
|
|
@property
|
|
def code_object(self):
|
|
# share the CodeObject with the cpdef wrapper (if available)
|
|
return self.py_func.code_object if self.py_func else None
|
|
|
|
def analyse_declarations(self, env):
|
|
self.is_c_class_method = env.is_c_class_scope
|
|
if self.directive_locals is None:
|
|
self.directive_locals = {}
|
|
self.directive_locals.update(env.directives.get('locals', {}))
|
|
if self.directive_returns is not None:
|
|
base_type = self.directive_returns.analyse_as_type(env)
|
|
if base_type is None:
|
|
error(self.directive_returns.pos, "Not a type")
|
|
base_type = PyrexTypes.error_type
|
|
else:
|
|
base_type = self.base_type.analyse(env)
|
|
self.is_static_method = 'staticmethod' in env.directives and not env.lookup_here('staticmethod')
|
|
# The 2 here is because we need both function and argument names.
|
|
if isinstance(self.declarator, CFuncDeclaratorNode):
|
|
name_declarator, type = self.declarator.analyse(
|
|
base_type, env, nonempty=2 * (self.body is not None),
|
|
directive_locals=self.directive_locals, visibility=self.visibility)
|
|
else:
|
|
name_declarator, type = self.declarator.analyse(
|
|
base_type, env, nonempty=2 * (self.body is not None), visibility=self.visibility)
|
|
if not type.is_cfunction:
|
|
error(self.pos, "Suite attached to non-function declaration")
|
|
# Remember the actual type according to the function header
|
|
# written here, because the type in the symbol table entry
|
|
# may be different if we're overriding a C method inherited
|
|
# from the base type of an extension type.
|
|
self.type = type
|
|
type.is_overridable = self.overridable
|
|
declarator = self.declarator
|
|
while not hasattr(declarator, 'args'):
|
|
declarator = declarator.base
|
|
|
|
self.cfunc_declarator = declarator
|
|
self.args = declarator.args
|
|
|
|
opt_arg_count = self.cfunc_declarator.optional_arg_count
|
|
if (self.visibility == 'public' or self.api) and opt_arg_count:
|
|
error(self.cfunc_declarator.pos,
|
|
"Function with optional arguments may not be declared public or api")
|
|
|
|
if type.exception_check == '+' and self.visibility != 'extern':
|
|
warning(self.cfunc_declarator.pos,
|
|
"Only extern functions can throw C++ exceptions.")
|
|
|
|
for formal_arg, type_arg in zip(self.args, type.args):
|
|
self.align_argument_type(env, type_arg)
|
|
formal_arg.type = type_arg.type
|
|
formal_arg.name = type_arg.name
|
|
formal_arg.cname = type_arg.cname
|
|
|
|
self._validate_type_visibility(type_arg.type, type_arg.pos, env)
|
|
|
|
if type_arg.type.is_fused:
|
|
self.has_fused_arguments = True
|
|
|
|
if type_arg.type.is_buffer and 'inline' in self.modifiers:
|
|
warning(formal_arg.pos, "Buffer unpacking not optimized away.", 1)
|
|
|
|
if type_arg.type.is_buffer or type_arg.type.is_pythran_expr:
|
|
if self.type.nogil:
|
|
error(formal_arg.pos,
|
|
"Buffer may not be acquired without the GIL. Consider using memoryview slices instead.")
|
|
elif 'inline' in self.modifiers:
|
|
warning(formal_arg.pos, "Buffer unpacking not optimized away.", 1)
|
|
|
|
self._validate_type_visibility(type.return_type, self.pos, env)
|
|
|
|
name = name_declarator.name
|
|
cname = name_declarator.cname
|
|
|
|
type.is_const_method = self.is_const_method
|
|
type.is_static_method = self.is_static_method
|
|
self.entry = env.declare_cfunction(
|
|
name, type, self.pos,
|
|
cname=cname, visibility=self.visibility, api=self.api,
|
|
defining=self.body is not None, modifiers=self.modifiers,
|
|
overridable=self.overridable)
|
|
self.entry.inline_func_in_pxd = self.inline_in_pxd
|
|
self.return_type = type.return_type
|
|
if self.return_type.is_array and self.visibility != 'extern':
|
|
error(self.pos, "Function cannot return an array")
|
|
if self.return_type.is_cpp_class:
|
|
self.return_type.check_nullary_constructor(self.pos, "used as a return value")
|
|
|
|
if self.overridable and not env.is_module_scope and not self.is_static_method:
|
|
if len(self.args) < 1 or not self.args[0].type.is_pyobject:
|
|
# An error will be produced in the cdef function
|
|
self.overridable = False
|
|
|
|
self.declare_cpdef_wrapper(env)
|
|
self.create_local_scope(env)
|
|
|
|
def declare_cpdef_wrapper(self, env):
|
|
if self.overridable:
|
|
if self.is_static_method:
|
|
# TODO(robertwb): Finish this up, perhaps via more function refactoring.
|
|
error(self.pos, "static cpdef methods not yet supported")
|
|
name = self.entry.name
|
|
py_func_body = self.call_self_node(is_module_scope=env.is_module_scope)
|
|
if self.is_static_method:
|
|
from .ExprNodes import NameNode
|
|
decorators = [DecoratorNode(self.pos, decorator=NameNode(self.pos, name='staticmethod'))]
|
|
decorators[0].decorator.analyse_types(env)
|
|
else:
|
|
decorators = []
|
|
self.py_func = DefNode(pos=self.pos,
|
|
name=self.entry.name,
|
|
args=self.args,
|
|
star_arg=None,
|
|
starstar_arg=None,
|
|
doc=self.doc,
|
|
body=py_func_body,
|
|
decorators=decorators,
|
|
is_wrapper=1)
|
|
self.py_func.is_module_scope = env.is_module_scope
|
|
self.py_func.analyse_declarations(env)
|
|
self.py_func.entry.is_overridable = True
|
|
self.py_func_stat = StatListNode(self.pos, stats=[self.py_func])
|
|
self.py_func.type = PyrexTypes.py_object_type
|
|
self.entry.as_variable = self.py_func.entry
|
|
self.entry.used = self.entry.as_variable.used = True
|
|
# Reset scope entry the above cfunction
|
|
env.entries[name] = self.entry
|
|
if (not self.entry.is_final_cmethod and
|
|
(not env.is_module_scope or Options.lookup_module_cpdef)):
|
|
self.override = OverrideCheckNode(self.pos, py_func=self.py_func)
|
|
self.body = StatListNode(self.pos, stats=[self.override, self.body])
|
|
|
|
def _validate_type_visibility(self, type, pos, env):
|
|
"""
|
|
Ensure that types used in cdef functions are public or api, or
|
|
defined in a C header.
|
|
"""
|
|
public_or_api = (self.visibility == 'public' or self.api)
|
|
entry = getattr(type, 'entry', None)
|
|
if public_or_api and entry and env.is_module_scope:
|
|
if not (entry.visibility in ('public', 'extern') or
|
|
entry.api or entry.in_cinclude):
|
|
error(pos, "Function declared public or api may not have private types")
|
|
|
|
def call_self_node(self, omit_optional_args=0, is_module_scope=0):
|
|
from . import ExprNodes
|
|
args = self.type.args
|
|
if omit_optional_args:
|
|
args = args[:len(args) - self.type.optional_arg_count]
|
|
arg_names = [arg.name for arg in args]
|
|
if is_module_scope:
|
|
cfunc = ExprNodes.NameNode(self.pos, name=self.entry.name)
|
|
call_arg_names = arg_names
|
|
skip_dispatch = Options.lookup_module_cpdef
|
|
elif self.type.is_static_method:
|
|
class_entry = self.entry.scope.parent_type.entry
|
|
class_node = ExprNodes.NameNode(self.pos, name=class_entry.name)
|
|
class_node.entry = class_entry
|
|
cfunc = ExprNodes.AttributeNode(self.pos, obj=class_node, attribute=self.entry.name)
|
|
# Calling static c(p)def methods on an instance disallowed.
|
|
# TODO(robertwb): Support by passing self to check for override?
|
|
skip_dispatch = True
|
|
else:
|
|
type_entry = self.type.args[0].type.entry
|
|
type_arg = ExprNodes.NameNode(self.pos, name=type_entry.name)
|
|
type_arg.entry = type_entry
|
|
cfunc = ExprNodes.AttributeNode(self.pos, obj=type_arg, attribute=self.entry.name)
|
|
skip_dispatch = not is_module_scope or Options.lookup_module_cpdef
|
|
c_call = ExprNodes.SimpleCallNode(
|
|
self.pos,
|
|
function=cfunc,
|
|
args=[ExprNodes.NameNode(self.pos, name=n) for n in arg_names],
|
|
wrapper_call=skip_dispatch)
|
|
return ReturnStatNode(pos=self.pos, return_type=PyrexTypes.py_object_type, value=c_call)
|
|
|
|
def declare_arguments(self, env):
|
|
for arg in self.type.args:
|
|
if not arg.name:
|
|
error(arg.pos, "Missing argument name")
|
|
self.declare_argument(env, arg)
|
|
|
|
def need_gil_acquisition(self, lenv):
|
|
return self.type.with_gil
|
|
|
|
def nogil_check(self, env):
|
|
type = self.type
|
|
with_gil = type.with_gil
|
|
if type.nogil and not with_gil:
|
|
if type.return_type.is_pyobject:
|
|
error(self.pos,
|
|
"Function with Python return type cannot be declared nogil")
|
|
for entry in self.local_scope.var_entries:
|
|
if entry.type.is_pyobject and not entry.in_with_gil_block:
|
|
error(self.pos, "Function declared nogil has Python locals or temporaries")
|
|
|
|
def analyse_expressions(self, env):
|
|
self.local_scope.directives = env.directives
|
|
if self.py_func_stat is not None:
|
|
# this will also analyse the default values and the function name assignment
|
|
self.py_func_stat = self.py_func_stat.analyse_expressions(env)
|
|
elif self.py_func is not None:
|
|
# this will also analyse the default values
|
|
self.py_func = self.py_func.analyse_expressions(env)
|
|
else:
|
|
self.analyse_default_values(env)
|
|
self.analyse_annotations(env)
|
|
self.acquire_gil = self.need_gil_acquisition(self.local_scope)
|
|
return self
|
|
|
|
def needs_assignment_synthesis(self, env, code=None):
|
|
return False
|
|
|
|
def generate_function_header(self, code, with_pymethdef, with_opt_args=1, with_dispatch=1, cname=None):
|
|
scope = self.local_scope
|
|
arg_decls = []
|
|
type = self.type
|
|
for arg in type.args[:len(type.args)-type.optional_arg_count]:
|
|
arg_decl = arg.declaration_code()
|
|
entry = scope.lookup(arg.name)
|
|
if not entry.cf_used:
|
|
arg_decl = 'CYTHON_UNUSED %s' % arg_decl
|
|
arg_decls.append(arg_decl)
|
|
if with_dispatch and self.overridable:
|
|
dispatch_arg = PyrexTypes.c_int_type.declaration_code(
|
|
Naming.skip_dispatch_cname)
|
|
if self.override:
|
|
arg_decls.append(dispatch_arg)
|
|
else:
|
|
arg_decls.append('CYTHON_UNUSED %s' % dispatch_arg)
|
|
if type.optional_arg_count and with_opt_args:
|
|
arg_decls.append(type.op_arg_struct.declaration_code(Naming.optional_args_cname))
|
|
if type.has_varargs:
|
|
arg_decls.append("...")
|
|
if not arg_decls:
|
|
arg_decls = ["void"]
|
|
if cname is None:
|
|
cname = self.entry.func_cname
|
|
entity = type.function_header_code(cname, ', '.join(arg_decls))
|
|
if self.entry.visibility == 'private' and '::' not in cname:
|
|
storage_class = "static "
|
|
else:
|
|
storage_class = ""
|
|
dll_linkage = None
|
|
modifiers = code.build_function_modifiers(self.entry.func_modifiers)
|
|
|
|
header = self.return_type.declaration_code(entity, dll_linkage=dll_linkage)
|
|
#print (storage_class, modifiers, header)
|
|
needs_proto = self.is_c_class_method
|
|
if self.template_declaration:
|
|
if needs_proto:
|
|
code.globalstate.parts['module_declarations'].putln(self.template_declaration)
|
|
code.putln(self.template_declaration)
|
|
if needs_proto:
|
|
code.globalstate.parts['module_declarations'].putln(
|
|
"%s%s%s; /* proto*/" % (storage_class, modifiers, header))
|
|
code.putln("%s%s%s {" % (storage_class, modifiers, header))
|
|
|
|
def generate_argument_declarations(self, env, code):
|
|
scope = self.local_scope
|
|
for arg in self.args:
|
|
if arg.default:
|
|
entry = scope.lookup(arg.name)
|
|
if self.override or entry.cf_used:
|
|
result = arg.calculate_default_value_code(code)
|
|
code.putln('%s = %s;' % (
|
|
arg.type.declaration_code(arg.cname), result))
|
|
|
|
def generate_keyword_list(self, code):
|
|
pass
|
|
|
|
def generate_argument_parsing_code(self, env, code):
|
|
i = 0
|
|
used = 0
|
|
scope = self.local_scope
|
|
if self.type.optional_arg_count:
|
|
code.putln('if (%s) {' % Naming.optional_args_cname)
|
|
for arg in self.args:
|
|
if arg.default:
|
|
entry = scope.lookup(arg.name)
|
|
if self.override or entry.cf_used:
|
|
code.putln('if (%s->%sn > %s) {' %
|
|
(Naming.optional_args_cname,
|
|
Naming.pyrex_prefix, i))
|
|
declarator = arg.declarator
|
|
while not hasattr(declarator, 'name'):
|
|
declarator = declarator.base
|
|
code.putln('%s = %s->%s;' %
|
|
(arg.cname, Naming.optional_args_cname,
|
|
self.type.opt_arg_cname(declarator.name)))
|
|
used += 1
|
|
i += 1
|
|
for _ in range(used):
|
|
code.putln('}')
|
|
code.putln('}')
|
|
|
|
# Move arguments into closure if required
|
|
def put_into_closure(entry):
|
|
if entry.in_closure and not arg.default:
|
|
code.putln('%s = %s;' % (entry.cname, entry.original_cname))
|
|
if entry.type.is_memoryviewslice:
|
|
code.put_incref_memoryviewslice(entry.cname, have_gil=True)
|
|
else:
|
|
code.put_var_incref(entry)
|
|
code.put_var_giveref(entry)
|
|
for arg in self.args:
|
|
put_into_closure(scope.lookup_here(arg.name))
|
|
|
|
|
|
def generate_argument_conversion_code(self, code):
|
|
pass
|
|
|
|
def generate_argument_type_tests(self, code):
|
|
# Generate type tests for args whose type in a parent
|
|
# class is a supertype of the declared type.
|
|
for arg in self.type.args:
|
|
if arg.needs_type_test:
|
|
self.generate_arg_type_test(arg, code)
|
|
elif arg.type.is_pyobject and not arg.accept_none:
|
|
self.generate_arg_none_check(arg, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
if code.globalstate.directives['linetrace']:
|
|
code.mark_pos(self.pos)
|
|
code.putln("") # generate line tracing code
|
|
super(CFuncDefNode, self).generate_execution_code(code)
|
|
if self.py_func_stat:
|
|
self.py_func_stat.generate_execution_code(code)
|
|
|
|
def error_value(self):
|
|
if self.return_type.is_pyobject:
|
|
return "0"
|
|
else:
|
|
#return None
|
|
return self.entry.type.exception_value
|
|
|
|
def caller_will_check_exceptions(self):
|
|
return self.entry.type.exception_check
|
|
|
|
def generate_wrapper_functions(self, code):
|
|
# If the C signature of a function has changed, we need to generate
|
|
# wrappers to put in the slots here.
|
|
k = 0
|
|
entry = self.entry
|
|
func_type = entry.type
|
|
while entry.prev_entry is not None:
|
|
k += 1
|
|
entry = entry.prev_entry
|
|
entry.func_cname = "%s%swrap_%s" % (self.entry.func_cname, Naming.pyrex_prefix, k)
|
|
code.putln()
|
|
self.generate_function_header(
|
|
code, 0,
|
|
with_dispatch=entry.type.is_overridable,
|
|
with_opt_args=entry.type.optional_arg_count,
|
|
cname=entry.func_cname)
|
|
if not self.return_type.is_void:
|
|
code.put('return ')
|
|
args = self.type.args
|
|
arglist = [arg.cname for arg in args[:len(args)-self.type.optional_arg_count]]
|
|
if entry.type.is_overridable:
|
|
arglist.append(Naming.skip_dispatch_cname)
|
|
elif func_type.is_overridable:
|
|
arglist.append('0')
|
|
if entry.type.optional_arg_count:
|
|
arglist.append(Naming.optional_args_cname)
|
|
elif func_type.optional_arg_count:
|
|
arglist.append('NULL')
|
|
code.putln('%s(%s);' % (self.entry.func_cname, ', '.join(arglist)))
|
|
code.putln('}')
|
|
|
|
|
|
class PyArgDeclNode(Node):
|
|
# Argument which must be a Python object (used
|
|
# for * and ** arguments).
|
|
#
|
|
# name string
|
|
# entry Symtab.Entry
|
|
# annotation ExprNode or None Py3 argument annotation
|
|
child_attrs = []
|
|
is_self_arg = False
|
|
is_type_arg = False
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.entry.generate_function_definitions(env, code)
|
|
|
|
|
|
class DecoratorNode(Node):
|
|
# A decorator
|
|
#
|
|
# decorator NameNode or CallNode or AttributeNode
|
|
child_attrs = ['decorator']
|
|
|
|
|
|
class DefNode(FuncDefNode):
|
|
# A Python function definition.
|
|
#
|
|
# name string the Python name of the function
|
|
# lambda_name string the internal name of a lambda 'function'
|
|
# decorators [DecoratorNode] list of decorators
|
|
# args [CArgDeclNode] formal arguments
|
|
# doc EncodedString or None
|
|
# body StatListNode
|
|
# return_type_annotation
|
|
# ExprNode or None the Py3 return type annotation
|
|
#
|
|
# The following subnode is constructed internally
|
|
# when the def statement is inside a Python class definition.
|
|
#
|
|
# fused_py_func DefNode The original fused cpdef DefNode
|
|
# (in case this is a specialization)
|
|
# specialized_cpdefs [DefNode] list of specialized cpdef DefNodes
|
|
# py_cfunc_node PyCFunctionNode/InnerFunctionNode The PyCFunction to create and assign
|
|
#
|
|
# decorator_indirection IndirectionNode Used to remove __Pyx_Method_ClassMethod for fused functions
|
|
|
|
child_attrs = ["args", "star_arg", "starstar_arg", "body", "decorators", "return_type_annotation"]
|
|
outer_attrs = ["decorators", "return_type_annotation"]
|
|
|
|
is_staticmethod = False
|
|
is_classmethod = False
|
|
|
|
lambda_name = None
|
|
reqd_kw_flags_cname = "0"
|
|
is_wrapper = 0
|
|
no_assignment_synthesis = 0
|
|
decorators = None
|
|
return_type_annotation = None
|
|
entry = None
|
|
acquire_gil = 0
|
|
self_in_stararg = 0
|
|
py_cfunc_node = None
|
|
requires_classobj = False
|
|
defaults_struct = None # Dynamic kwrds structure name
|
|
doc = None
|
|
|
|
fused_py_func = False
|
|
specialized_cpdefs = None
|
|
py_wrapper = None
|
|
py_wrapper_required = True
|
|
func_cname = None
|
|
|
|
defaults_getter = None
|
|
|
|
def __init__(self, pos, **kwds):
|
|
FuncDefNode.__init__(self, pos, **kwds)
|
|
k = rk = r = 0
|
|
for arg in self.args:
|
|
if arg.kw_only:
|
|
k += 1
|
|
if not arg.default:
|
|
rk += 1
|
|
if not arg.default:
|
|
r += 1
|
|
self.num_kwonly_args = k
|
|
self.num_required_kw_args = rk
|
|
self.num_required_args = r
|
|
|
|
def as_cfunction(self, cfunc=None, scope=None, overridable=True, returns=None, except_val=None, modifiers=None,
|
|
nogil=False, with_gil=False):
|
|
if self.star_arg:
|
|
error(self.star_arg.pos, "cdef function cannot have star argument")
|
|
if self.starstar_arg:
|
|
error(self.starstar_arg.pos, "cdef function cannot have starstar argument")
|
|
exception_value, exception_check = except_val or (None, False)
|
|
|
|
if cfunc is None:
|
|
cfunc_args = []
|
|
for formal_arg in self.args:
|
|
name_declarator, type = formal_arg.analyse(scope, nonempty=1)
|
|
cfunc_args.append(PyrexTypes.CFuncTypeArg(name=name_declarator.name,
|
|
cname=None,
|
|
annotation=formal_arg.annotation,
|
|
type=py_object_type,
|
|
pos=formal_arg.pos))
|
|
cfunc_type = PyrexTypes.CFuncType(return_type=py_object_type,
|
|
args=cfunc_args,
|
|
has_varargs=False,
|
|
exception_value=None,
|
|
exception_check=exception_check,
|
|
nogil=nogil,
|
|
with_gil=with_gil,
|
|
is_overridable=overridable)
|
|
cfunc = CVarDefNode(self.pos, type=cfunc_type)
|
|
else:
|
|
if scope is None:
|
|
scope = cfunc.scope
|
|
cfunc_type = cfunc.type
|
|
if len(self.args) != len(cfunc_type.args) or cfunc_type.has_varargs:
|
|
error(self.pos, "wrong number of arguments")
|
|
error(cfunc.pos, "previous declaration here")
|
|
for i, (formal_arg, type_arg) in enumerate(zip(self.args, cfunc_type.args)):
|
|
name_declarator, type = formal_arg.analyse(scope, nonempty=1,
|
|
is_self_arg=(i == 0 and scope.is_c_class_scope))
|
|
if type is None or type is PyrexTypes.py_object_type:
|
|
formal_arg.type = type_arg.type
|
|
formal_arg.name_declarator = name_declarator
|
|
|
|
if exception_value is None and cfunc_type.exception_value is not None:
|
|
from .ExprNodes import ConstNode
|
|
exception_value = ConstNode(
|
|
self.pos, value=cfunc_type.exception_value, type=cfunc_type.return_type)
|
|
declarator = CFuncDeclaratorNode(self.pos,
|
|
base=CNameDeclaratorNode(self.pos, name=self.name, cname=None),
|
|
args=self.args,
|
|
has_varargs=False,
|
|
exception_check=cfunc_type.exception_check,
|
|
exception_value=exception_value,
|
|
with_gil=cfunc_type.with_gil,
|
|
nogil=cfunc_type.nogil)
|
|
return CFuncDefNode(self.pos,
|
|
modifiers=modifiers or [],
|
|
base_type=CAnalysedBaseTypeNode(self.pos, type=cfunc_type.return_type),
|
|
declarator=declarator,
|
|
body=self.body,
|
|
doc=self.doc,
|
|
overridable=cfunc_type.is_overridable,
|
|
type=cfunc_type,
|
|
with_gil=cfunc_type.with_gil,
|
|
nogil=cfunc_type.nogil,
|
|
visibility='private',
|
|
api=False,
|
|
directive_locals=getattr(cfunc, 'directive_locals', {}),
|
|
directive_returns=returns)
|
|
|
|
def is_cdef_func_compatible(self):
|
|
"""Determines if the function's signature is compatible with a
|
|
cdef function. This can be used before calling
|
|
.as_cfunction() to see if that will be successful.
|
|
"""
|
|
if self.needs_closure:
|
|
return False
|
|
if self.star_arg or self.starstar_arg:
|
|
return False
|
|
return True
|
|
|
|
def analyse_declarations(self, env):
|
|
if self.decorators:
|
|
for decorator in self.decorators:
|
|
func = decorator.decorator
|
|
if func.is_name:
|
|
self.is_classmethod |= func.name == 'classmethod'
|
|
self.is_staticmethod |= func.name == 'staticmethod'
|
|
|
|
if self.is_classmethod and env.lookup_here('classmethod'):
|
|
# classmethod() was overridden - not much we can do here ...
|
|
self.is_classmethod = False
|
|
if self.is_staticmethod and env.lookup_here('staticmethod'):
|
|
# staticmethod() was overridden - not much we can do here ...
|
|
self.is_staticmethod = False
|
|
|
|
if self.name == '__new__' and env.is_py_class_scope:
|
|
self.is_staticmethod = 1
|
|
|
|
self.analyse_argument_types(env)
|
|
if self.name == '<lambda>':
|
|
self.declare_lambda_function(env)
|
|
else:
|
|
self.declare_pyfunction(env)
|
|
|
|
self.analyse_signature(env)
|
|
self.return_type = self.entry.signature.return_type()
|
|
# if a signature annotation provides a more specific return object type, use it
|
|
if self.return_type is py_object_type and self.return_type_annotation:
|
|
if env.directives['annotation_typing'] and not self.entry.is_special:
|
|
_, return_type = analyse_type_annotation(self.return_type_annotation, env)
|
|
if return_type and return_type.is_pyobject:
|
|
self.return_type = return_type
|
|
|
|
self.create_local_scope(env)
|
|
|
|
self.py_wrapper = DefNodeWrapper(
|
|
self.pos,
|
|
target=self,
|
|
name=self.entry.name,
|
|
args=self.args,
|
|
star_arg=self.star_arg,
|
|
starstar_arg=self.starstar_arg,
|
|
return_type=self.return_type)
|
|
self.py_wrapper.analyse_declarations(env)
|
|
|
|
def analyse_argument_types(self, env):
|
|
self.directive_locals = env.directives.get('locals', {})
|
|
allow_none_for_extension_args = env.directives['allow_none_for_extension_args']
|
|
|
|
f2s = env.fused_to_specific
|
|
env.fused_to_specific = None
|
|
|
|
for arg in self.args:
|
|
if hasattr(arg, 'name'):
|
|
name_declarator = None
|
|
else:
|
|
base_type = arg.base_type.analyse(env)
|
|
# If we hare in pythran mode and we got a buffer supported by
|
|
# Pythran, we change this node to a fused type
|
|
if has_np_pythran(env) and base_type.is_pythran_expr:
|
|
base_type = PyrexTypes.FusedType([
|
|
base_type,
|
|
#PyrexTypes.PythranExpr(pythran_type(self.type, "numpy_texpr")),
|
|
base_type.org_buffer])
|
|
name_declarator, type = \
|
|
arg.declarator.analyse(base_type, env)
|
|
arg.name = name_declarator.name
|
|
arg.type = type
|
|
|
|
if type.is_fused:
|
|
self.has_fused_arguments = True
|
|
|
|
self.align_argument_type(env, arg)
|
|
if name_declarator and name_declarator.cname:
|
|
error(self.pos, "Python function argument cannot have C name specification")
|
|
arg.type = arg.type.as_argument_type()
|
|
arg.hdr_type = None
|
|
arg.needs_conversion = 0
|
|
arg.needs_type_test = 0
|
|
arg.is_generic = 1
|
|
if arg.type.is_pyobject or arg.type.is_buffer or arg.type.is_memoryviewslice:
|
|
if arg.or_none:
|
|
arg.accept_none = True
|
|
elif arg.not_none:
|
|
arg.accept_none = False
|
|
elif (arg.type.is_extension_type or arg.type.is_builtin_type
|
|
or arg.type.is_buffer or arg.type.is_memoryviewslice):
|
|
if arg.default and arg.default.constant_result is None:
|
|
# special case: def func(MyType obj = None)
|
|
arg.accept_none = True
|
|
else:
|
|
# default depends on compiler directive
|
|
arg.accept_none = allow_none_for_extension_args
|
|
else:
|
|
# probably just a plain 'object'
|
|
arg.accept_none = True
|
|
else:
|
|
arg.accept_none = True # won't be used, but must be there
|
|
if arg.not_none:
|
|
error(arg.pos, "Only Python type arguments can have 'not None'")
|
|
if arg.or_none:
|
|
error(arg.pos, "Only Python type arguments can have 'or None'")
|
|
env.fused_to_specific = f2s
|
|
|
|
if has_np_pythran(env):
|
|
self.np_args_idx = [i for i,a in enumerate(self.args) if a.type.is_numpy_buffer]
|
|
else:
|
|
self.np_args_idx = []
|
|
|
|
def analyse_signature(self, env):
|
|
if self.entry.is_special:
|
|
if self.decorators:
|
|
error(self.pos, "special functions of cdef classes cannot have decorators")
|
|
self.entry.trivial_signature = len(self.args) == 1 and not (self.star_arg or self.starstar_arg)
|
|
elif not env.directives['always_allow_keywords'] and not (self.star_arg or self.starstar_arg):
|
|
# Use the simpler calling signature for zero- and one-argument functions.
|
|
if self.entry.signature is TypeSlots.pyfunction_signature:
|
|
if len(self.args) == 0:
|
|
self.entry.signature = TypeSlots.pyfunction_noargs
|
|
elif len(self.args) == 1:
|
|
if self.args[0].default is None and not self.args[0].kw_only:
|
|
self.entry.signature = TypeSlots.pyfunction_onearg
|
|
elif self.entry.signature is TypeSlots.pymethod_signature:
|
|
if len(self.args) == 1:
|
|
self.entry.signature = TypeSlots.unaryfunc
|
|
elif len(self.args) == 2:
|
|
if self.args[1].default is None and not self.args[1].kw_only:
|
|
self.entry.signature = TypeSlots.ibinaryfunc
|
|
|
|
sig = self.entry.signature
|
|
nfixed = sig.num_fixed_args()
|
|
if (sig is TypeSlots.pymethod_signature and nfixed == 1
|
|
and len(self.args) == 0 and self.star_arg):
|
|
# this is the only case where a diverging number of
|
|
# arguments is not an error - when we have no explicit
|
|
# 'self' parameter as in method(*args)
|
|
sig = self.entry.signature = TypeSlots.pyfunction_signature # self is not 'really' used
|
|
self.self_in_stararg = 1
|
|
nfixed = 0
|
|
|
|
if self.is_staticmethod and env.is_c_class_scope:
|
|
nfixed = 0
|
|
self.self_in_stararg = True # FIXME: why for staticmethods?
|
|
|
|
self.entry.signature = sig = copy.copy(sig)
|
|
sig.fixed_arg_format = "*"
|
|
sig.is_staticmethod = True
|
|
sig.has_generic_args = True
|
|
|
|
if ((self.is_classmethod or self.is_staticmethod) and
|
|
self.has_fused_arguments and env.is_c_class_scope):
|
|
del self.decorator_indirection.stats[:]
|
|
|
|
for i in range(min(nfixed, len(self.args))):
|
|
arg = self.args[i]
|
|
arg.is_generic = 0
|
|
if sig.is_self_arg(i) and not self.is_staticmethod:
|
|
if self.is_classmethod:
|
|
arg.is_type_arg = 1
|
|
arg.hdr_type = arg.type = Builtin.type_type
|
|
else:
|
|
arg.is_self_arg = 1
|
|
arg.hdr_type = arg.type = env.parent_type
|
|
arg.needs_conversion = 0
|
|
else:
|
|
arg.hdr_type = sig.fixed_arg_type(i)
|
|
if not arg.type.same_as(arg.hdr_type):
|
|
if arg.hdr_type.is_pyobject and arg.type.is_pyobject:
|
|
arg.needs_type_test = 1
|
|
else:
|
|
arg.needs_conversion = 1
|
|
if arg.needs_conversion:
|
|
arg.hdr_cname = Naming.arg_prefix + arg.name
|
|
else:
|
|
arg.hdr_cname = Naming.var_prefix + arg.name
|
|
|
|
if nfixed > len(self.args):
|
|
self.bad_signature()
|
|
return
|
|
elif nfixed < len(self.args):
|
|
if not sig.has_generic_args:
|
|
self.bad_signature()
|
|
for arg in self.args:
|
|
if arg.is_generic and (arg.type.is_extension_type or arg.type.is_builtin_type):
|
|
arg.needs_type_test = 1
|
|
|
|
def bad_signature(self):
|
|
sig = self.entry.signature
|
|
expected_str = "%d" % sig.num_fixed_args()
|
|
if sig.has_generic_args:
|
|
expected_str += " or more"
|
|
name = self.name
|
|
if name.startswith("__") and name.endswith("__"):
|
|
desc = "Special method"
|
|
else:
|
|
desc = "Method"
|
|
error(self.pos, "%s %s has wrong number of arguments (%d declared, %s expected)" % (
|
|
desc, self.name, len(self.args), expected_str))
|
|
|
|
def declare_pyfunction(self, env):
|
|
#print "DefNode.declare_pyfunction:", self.name, "in", env ###
|
|
name = self.name
|
|
entry = env.lookup_here(name)
|
|
if entry:
|
|
if entry.is_final_cmethod and not env.parent_type.is_final_type:
|
|
error(self.pos, "Only final types can have final Python (def/cpdef) methods")
|
|
if entry.type.is_cfunction and not entry.is_builtin_cmethod and not self.is_wrapper:
|
|
warning(self.pos, "Overriding cdef method with def method.", 5)
|
|
entry = env.declare_pyfunction(name, self.pos, allow_redefine=not self.is_wrapper)
|
|
self.entry = entry
|
|
prefix = env.next_id(env.scope_prefix)
|
|
self.entry.pyfunc_cname = Naming.pyfunc_prefix + prefix + name
|
|
if Options.docstrings:
|
|
entry.doc = embed_position(self.pos, self.doc)
|
|
entry.doc_cname = Naming.funcdoc_prefix + prefix + name
|
|
if entry.is_special:
|
|
if entry.name in TypeSlots.invisible or not entry.doc or (
|
|
entry.name in '__getattr__' and env.directives['fast_getattr']):
|
|
entry.wrapperbase_cname = None
|
|
else:
|
|
entry.wrapperbase_cname = Naming.wrapperbase_prefix + prefix + name
|
|
else:
|
|
entry.doc = None
|
|
|
|
def declare_lambda_function(self, env):
|
|
entry = env.declare_lambda_function(self.lambda_name, self.pos)
|
|
entry.doc = None
|
|
self.entry = entry
|
|
self.entry.pyfunc_cname = entry.cname
|
|
|
|
def declare_arguments(self, env):
|
|
for arg in self.args:
|
|
if not arg.name:
|
|
error(arg.pos, "Missing argument name")
|
|
if arg.needs_conversion:
|
|
arg.entry = env.declare_var(arg.name, arg.type, arg.pos)
|
|
if arg.type.is_pyobject:
|
|
arg.entry.init = "0"
|
|
else:
|
|
arg.entry = self.declare_argument(env, arg)
|
|
arg.entry.is_arg = 1
|
|
arg.entry.used = 1
|
|
arg.entry.is_self_arg = arg.is_self_arg
|
|
self.declare_python_arg(env, self.star_arg)
|
|
self.declare_python_arg(env, self.starstar_arg)
|
|
|
|
def declare_python_arg(self, env, arg):
|
|
if arg:
|
|
if env.directives['infer_types'] != False:
|
|
type = PyrexTypes.unspecified_type
|
|
else:
|
|
type = py_object_type
|
|
entry = env.declare_var(arg.name, type, arg.pos)
|
|
entry.is_arg = 1
|
|
entry.used = 1
|
|
entry.init = "0"
|
|
entry.xdecref_cleanup = 1
|
|
arg.entry = entry
|
|
|
|
def analyse_expressions(self, env):
|
|
self.local_scope.directives = env.directives
|
|
self.analyse_default_values(env)
|
|
self.analyse_annotations(env)
|
|
if self.return_type_annotation:
|
|
self.return_type_annotation = self.analyse_annotation(env, self.return_type_annotation)
|
|
|
|
if not self.needs_assignment_synthesis(env) and self.decorators:
|
|
for decorator in self.decorators[::-1]:
|
|
decorator.decorator = decorator.decorator.analyse_expressions(env)
|
|
|
|
self.py_wrapper.prepare_argument_coercion(env)
|
|
return self
|
|
|
|
def needs_assignment_synthesis(self, env, code=None):
|
|
if self.is_staticmethod:
|
|
return True
|
|
if self.specialized_cpdefs or self.entry.is_fused_specialized:
|
|
return False
|
|
if self.no_assignment_synthesis:
|
|
return False
|
|
if self.entry.is_special:
|
|
return False
|
|
if self.entry.is_anonymous:
|
|
return True
|
|
if env.is_module_scope or env.is_c_class_scope:
|
|
if code is None:
|
|
return self.local_scope.directives['binding']
|
|
else:
|
|
return code.globalstate.directives['binding']
|
|
return env.is_py_class_scope or env.is_closure_scope
|
|
|
|
def error_value(self):
|
|
return self.entry.signature.error_value
|
|
|
|
def caller_will_check_exceptions(self):
|
|
return self.entry.signature.exception_check
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
if self.defaults_getter:
|
|
# defaults getter must never live in class scopes, it's always a module function
|
|
self.defaults_getter.generate_function_definitions(env.global_scope(), code)
|
|
|
|
# Before closure cnames are mangled
|
|
if self.py_wrapper_required:
|
|
# func_cname might be modified by @cname
|
|
self.py_wrapper.func_cname = self.entry.func_cname
|
|
self.py_wrapper.generate_function_definitions(env, code)
|
|
FuncDefNode.generate_function_definitions(self, env, code)
|
|
|
|
def generate_function_header(self, code, with_pymethdef, proto_only=0):
|
|
if proto_only:
|
|
if self.py_wrapper_required:
|
|
self.py_wrapper.generate_function_header(
|
|
code, with_pymethdef, True)
|
|
return
|
|
arg_code_list = []
|
|
if self.entry.signature.has_dummy_arg:
|
|
self_arg = 'PyObject *%s' % Naming.self_cname
|
|
if not self.needs_outer_scope:
|
|
self_arg = 'CYTHON_UNUSED ' + self_arg
|
|
arg_code_list.append(self_arg)
|
|
|
|
def arg_decl_code(arg):
|
|
entry = arg.entry
|
|
if entry.in_closure:
|
|
cname = entry.original_cname
|
|
else:
|
|
cname = entry.cname
|
|
decl = entry.type.declaration_code(cname)
|
|
if not entry.cf_used:
|
|
decl = 'CYTHON_UNUSED ' + decl
|
|
return decl
|
|
|
|
for arg in self.args:
|
|
arg_code_list.append(arg_decl_code(arg))
|
|
if self.star_arg:
|
|
arg_code_list.append(arg_decl_code(self.star_arg))
|
|
if self.starstar_arg:
|
|
arg_code_list.append(arg_decl_code(self.starstar_arg))
|
|
if arg_code_list:
|
|
arg_code = ', '.join(arg_code_list)
|
|
else:
|
|
arg_code = 'void' # No arguments
|
|
dc = self.return_type.declaration_code(self.entry.pyfunc_cname)
|
|
|
|
decls_code = code.globalstate['decls']
|
|
preprocessor_guard = self.get_preprocessor_guard()
|
|
if preprocessor_guard:
|
|
decls_code.putln(preprocessor_guard)
|
|
decls_code.putln(
|
|
"static %s(%s); /* proto */" % (dc, arg_code))
|
|
if preprocessor_guard:
|
|
decls_code.putln("#endif")
|
|
code.putln("static %s(%s) {" % (dc, arg_code))
|
|
|
|
def generate_argument_declarations(self, env, code):
|
|
pass
|
|
|
|
def generate_keyword_list(self, code):
|
|
pass
|
|
|
|
def generate_argument_parsing_code(self, env, code):
|
|
# Move arguments into closure if required
|
|
def put_into_closure(entry):
|
|
if entry.in_closure:
|
|
code.putln('%s = %s;' % (entry.cname, entry.original_cname))
|
|
if entry.xdecref_cleanup:
|
|
# mostly applies to the starstar arg - this can sometimes be NULL
|
|
# so must be xincrefed instead
|
|
code.put_var_xincref(entry)
|
|
code.put_var_xgiveref(entry)
|
|
else:
|
|
code.put_var_incref(entry)
|
|
code.put_var_giveref(entry)
|
|
for arg in self.args:
|
|
put_into_closure(arg.entry)
|
|
for arg in self.star_arg, self.starstar_arg:
|
|
if arg:
|
|
put_into_closure(arg.entry)
|
|
|
|
def generate_argument_type_tests(self, code):
|
|
pass
|
|
|
|
|
|
class DefNodeWrapper(FuncDefNode):
|
|
# DefNode python wrapper code generator
|
|
|
|
defnode = None
|
|
target = None # Target DefNode
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
FuncDefNode.__init__(self, *args, **kwargs)
|
|
self.num_kwonly_args = self.target.num_kwonly_args
|
|
self.num_required_kw_args = self.target.num_required_kw_args
|
|
self.num_required_args = self.target.num_required_args
|
|
self.self_in_stararg = self.target.self_in_stararg
|
|
self.signature = None
|
|
|
|
def analyse_declarations(self, env):
|
|
target_entry = self.target.entry
|
|
name = self.name
|
|
prefix = env.next_id(env.scope_prefix)
|
|
target_entry.func_cname = Naming.pywrap_prefix + prefix + name
|
|
target_entry.pymethdef_cname = Naming.pymethdef_prefix + prefix + name
|
|
|
|
self.signature = target_entry.signature
|
|
|
|
self.np_args_idx = self.target.np_args_idx
|
|
|
|
def prepare_argument_coercion(self, env):
|
|
# This is only really required for Cython utility code at this time,
|
|
# everything else can be done during code generation. But we expand
|
|
# all utility code here, simply because we cannot easily distinguish
|
|
# different code types.
|
|
for arg in self.args:
|
|
if not arg.type.is_pyobject:
|
|
if not arg.type.create_from_py_utility_code(env):
|
|
pass # will fail later
|
|
elif arg.hdr_type and not arg.hdr_type.is_pyobject:
|
|
if not arg.hdr_type.create_to_py_utility_code(env):
|
|
pass # will fail later
|
|
|
|
if self.starstar_arg and not self.starstar_arg.entry.cf_used:
|
|
# we will set the kwargs argument to NULL instead of a new dict
|
|
# and must therefore correct the control flow state
|
|
entry = self.starstar_arg.entry
|
|
entry.xdecref_cleanup = 1
|
|
for ass in entry.cf_assignments:
|
|
if not ass.is_arg and ass.lhs.is_name:
|
|
ass.lhs.cf_maybe_null = True
|
|
|
|
def signature_has_nongeneric_args(self):
|
|
argcount = len(self.args)
|
|
if argcount == 0 or (
|
|
argcount == 1 and (self.args[0].is_self_arg or
|
|
self.args[0].is_type_arg)):
|
|
return 0
|
|
return 1
|
|
|
|
def signature_has_generic_args(self):
|
|
return self.signature.has_generic_args
|
|
|
|
def generate_function_body(self, code):
|
|
args = []
|
|
if self.signature.has_dummy_arg:
|
|
args.append(Naming.self_cname)
|
|
for arg in self.args:
|
|
if arg.hdr_type and not (arg.type.is_memoryviewslice or
|
|
arg.type.is_struct or
|
|
arg.type.is_complex):
|
|
args.append(arg.type.cast_code(arg.entry.cname))
|
|
else:
|
|
args.append(arg.entry.cname)
|
|
if self.star_arg:
|
|
args.append(self.star_arg.entry.cname)
|
|
if self.starstar_arg:
|
|
args.append(self.starstar_arg.entry.cname)
|
|
args = ', '.join(args)
|
|
if not self.return_type.is_void:
|
|
code.put('%s = ' % Naming.retval_cname)
|
|
code.putln('%s(%s);' % (
|
|
self.target.entry.pyfunc_cname, args))
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
lenv = self.target.local_scope
|
|
# Generate C code for header and body of function
|
|
code.mark_pos(self.pos)
|
|
code.putln("")
|
|
code.putln("/* Python wrapper */")
|
|
preprocessor_guard = self.target.get_preprocessor_guard()
|
|
if preprocessor_guard:
|
|
code.putln(preprocessor_guard)
|
|
|
|
code.enter_cfunc_scope(lenv)
|
|
code.return_from_error_cleanup_label = code.new_label()
|
|
|
|
with_pymethdef = (self.target.needs_assignment_synthesis(env, code) or
|
|
self.target.pymethdef_required)
|
|
self.generate_function_header(code, with_pymethdef)
|
|
self.generate_argument_declarations(lenv, code)
|
|
tempvardecl_code = code.insertion_point()
|
|
|
|
if self.return_type.is_pyobject:
|
|
retval_init = ' = 0'
|
|
else:
|
|
retval_init = ''
|
|
if not self.return_type.is_void:
|
|
code.putln('%s%s;' % (
|
|
self.return_type.declaration_code(Naming.retval_cname),
|
|
retval_init))
|
|
code.put_declare_refcount_context()
|
|
code.put_setup_refcount_context('%s (wrapper)' % self.name)
|
|
|
|
self.generate_argument_parsing_code(lenv, code)
|
|
self.generate_argument_type_tests(code)
|
|
self.generate_function_body(code)
|
|
|
|
# ----- Go back and insert temp variable declarations
|
|
tempvardecl_code.put_temp_declarations(code.funcstate)
|
|
|
|
code.mark_pos(self.pos)
|
|
code.putln("")
|
|
code.putln("/* function exit code */")
|
|
|
|
# ----- Error cleanup
|
|
if code.error_label in code.labels_used:
|
|
code.put_goto(code.return_label)
|
|
code.put_label(code.error_label)
|
|
for cname, type in code.funcstate.all_managed_temps():
|
|
code.put_xdecref(cname, type)
|
|
err_val = self.error_value()
|
|
if err_val is not None:
|
|
code.putln("%s = %s;" % (Naming.retval_cname, err_val))
|
|
|
|
# ----- Non-error return cleanup
|
|
code.put_label(code.return_label)
|
|
for entry in lenv.var_entries:
|
|
if entry.is_arg and entry.type.is_pyobject:
|
|
code.put_var_decref(entry)
|
|
|
|
code.put_finish_refcount_context()
|
|
if not self.return_type.is_void:
|
|
code.putln("return %s;" % Naming.retval_cname)
|
|
code.putln('}')
|
|
code.exit_cfunc_scope()
|
|
if preprocessor_guard:
|
|
code.putln("#endif /*!(%s)*/" % preprocessor_guard)
|
|
|
|
def generate_function_header(self, code, with_pymethdef, proto_only=0):
|
|
arg_code_list = []
|
|
sig = self.signature
|
|
|
|
if sig.has_dummy_arg or self.self_in_stararg:
|
|
arg_code = "PyObject *%s" % Naming.self_cname
|
|
if not sig.has_dummy_arg:
|
|
arg_code = 'CYTHON_UNUSED ' + arg_code
|
|
arg_code_list.append(arg_code)
|
|
|
|
for arg in self.args:
|
|
if not arg.is_generic:
|
|
if arg.is_self_arg or arg.is_type_arg:
|
|
arg_code_list.append("PyObject *%s" % arg.hdr_cname)
|
|
else:
|
|
arg_code_list.append(
|
|
arg.hdr_type.declaration_code(arg.hdr_cname))
|
|
entry = self.target.entry
|
|
if not entry.is_special and sig.method_flags() == [TypeSlots.method_noargs]:
|
|
arg_code_list.append("CYTHON_UNUSED PyObject *unused")
|
|
if entry.scope.is_c_class_scope and entry.name == "__ipow__":
|
|
arg_code_list.append("CYTHON_UNUSED PyObject *unused")
|
|
if sig.has_generic_args:
|
|
arg_code_list.append(
|
|
"PyObject *%s, PyObject *%s" % (
|
|
Naming.args_cname, Naming.kwds_cname))
|
|
arg_code = ", ".join(arg_code_list)
|
|
|
|
# Prevent warning: unused function '__pyx_pw_5numpy_7ndarray_1__getbuffer__'
|
|
mf = ""
|
|
if (entry.name in ("__getbuffer__", "__releasebuffer__")
|
|
and entry.scope.is_c_class_scope):
|
|
mf = "CYTHON_UNUSED "
|
|
with_pymethdef = False
|
|
|
|
dc = self.return_type.declaration_code(entry.func_cname)
|
|
header = "static %s%s(%s)" % (mf, dc, arg_code)
|
|
code.putln("%s; /*proto*/" % header)
|
|
|
|
if proto_only:
|
|
if self.target.fused_py_func:
|
|
# If we are the specialized version of the cpdef, we still
|
|
# want the prototype for the "fused cpdef", in case we're
|
|
# checking to see if our method was overridden in Python
|
|
self.target.fused_py_func.generate_function_header(
|
|
code, with_pymethdef, proto_only=True)
|
|
return
|
|
|
|
if (Options.docstrings and entry.doc and
|
|
not self.target.fused_py_func and
|
|
not entry.scope.is_property_scope and
|
|
(not entry.is_special or entry.wrapperbase_cname)):
|
|
# h_code = code.globalstate['h_code']
|
|
docstr = entry.doc
|
|
|
|
if docstr.is_unicode:
|
|
docstr = docstr.as_utf8_string()
|
|
|
|
if not (entry.is_special and entry.name in ('__getbuffer__', '__releasebuffer__')):
|
|
code.putln('static char %s[] = %s;' % (
|
|
entry.doc_cname,
|
|
docstr.as_c_string_literal()))
|
|
|
|
if entry.is_special:
|
|
code.putln('#if CYTHON_UPDATE_DESCRIPTOR_DOC')
|
|
code.putln(
|
|
"struct wrapperbase %s;" % entry.wrapperbase_cname)
|
|
code.putln('#endif')
|
|
|
|
if with_pymethdef or self.target.fused_py_func:
|
|
code.put(
|
|
"static PyMethodDef %s = " % entry.pymethdef_cname)
|
|
code.put_pymethoddef(self.target.entry, ";", allow_skip=False)
|
|
code.putln("%s {" % header)
|
|
|
|
def generate_argument_declarations(self, env, code):
|
|
for arg in self.args:
|
|
if arg.is_generic:
|
|
if arg.needs_conversion:
|
|
code.putln("PyObject *%s = 0;" % arg.hdr_cname)
|
|
else:
|
|
code.put_var_declaration(arg.entry)
|
|
for entry in env.var_entries:
|
|
if entry.is_arg:
|
|
code.put_var_declaration(entry)
|
|
|
|
def generate_argument_parsing_code(self, env, code):
|
|
# Generate fast equivalent of PyArg_ParseTuple call for
|
|
# generic arguments, if any, including args/kwargs
|
|
old_error_label = code.new_error_label()
|
|
our_error_label = code.error_label
|
|
end_label = code.new_label("argument_unpacking_done")
|
|
|
|
has_kwonly_args = self.num_kwonly_args > 0
|
|
has_star_or_kw_args = self.star_arg is not None \
|
|
or self.starstar_arg is not None or has_kwonly_args
|
|
|
|
for arg in self.args:
|
|
if not arg.type.is_pyobject:
|
|
if not arg.type.create_from_py_utility_code(env):
|
|
pass # will fail later
|
|
|
|
if not self.signature_has_generic_args():
|
|
if has_star_or_kw_args:
|
|
error(self.pos, "This method cannot have * or keyword arguments")
|
|
self.generate_argument_conversion_code(code)
|
|
|
|
elif not self.signature_has_nongeneric_args():
|
|
# func(*args) or func(**kw) or func(*args, **kw)
|
|
self.generate_stararg_copy_code(code)
|
|
|
|
else:
|
|
self.generate_tuple_and_keyword_parsing_code(self.args, end_label, code)
|
|
|
|
code.error_label = old_error_label
|
|
if code.label_used(our_error_label):
|
|
if not code.label_used(end_label):
|
|
code.put_goto(end_label)
|
|
code.put_label(our_error_label)
|
|
if has_star_or_kw_args:
|
|
self.generate_arg_decref(self.star_arg, code)
|
|
if self.starstar_arg:
|
|
if self.starstar_arg.entry.xdecref_cleanup:
|
|
code.put_var_xdecref_clear(self.starstar_arg.entry)
|
|
else:
|
|
code.put_var_decref_clear(self.starstar_arg.entry)
|
|
code.put_add_traceback(self.target.entry.qualified_name)
|
|
code.put_finish_refcount_context()
|
|
code.putln("return %s;" % self.error_value())
|
|
if code.label_used(end_label):
|
|
code.put_label(end_label)
|
|
|
|
def generate_arg_xdecref(self, arg, code):
|
|
if arg:
|
|
code.put_var_xdecref_clear(arg.entry)
|
|
|
|
def generate_arg_decref(self, arg, code):
|
|
if arg:
|
|
code.put_var_decref_clear(arg.entry)
|
|
|
|
def generate_stararg_copy_code(self, code):
|
|
if not self.star_arg:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("RaiseArgTupleInvalid", "FunctionArguments.c"))
|
|
code.putln("if (unlikely(PyTuple_GET_SIZE(%s) > 0)) {" %
|
|
Naming.args_cname)
|
|
code.put('__Pyx_RaiseArgtupleInvalid("%s", 1, 0, 0, PyTuple_GET_SIZE(%s)); return %s;' % (
|
|
self.name, Naming.args_cname, self.error_value()))
|
|
code.putln("}")
|
|
|
|
if self.starstar_arg:
|
|
if self.star_arg or not self.starstar_arg.entry.cf_used:
|
|
kwarg_check = "unlikely(%s)" % Naming.kwds_cname
|
|
else:
|
|
kwarg_check = "%s" % Naming.kwds_cname
|
|
else:
|
|
kwarg_check = "unlikely(%s) && unlikely(PyDict_Size(%s) > 0)" % (
|
|
Naming.kwds_cname, Naming.kwds_cname)
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("KeywordStringCheck", "FunctionArguments.c"))
|
|
code.putln(
|
|
"if (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, \"%s\", %d))) return %s;" % (
|
|
kwarg_check, Naming.kwds_cname, self.name,
|
|
bool(self.starstar_arg), self.error_value()))
|
|
|
|
if self.starstar_arg and self.starstar_arg.entry.cf_used:
|
|
if all(ref.node.allow_null for ref in self.starstar_arg.entry.cf_references):
|
|
code.putln("if (%s) {" % kwarg_check)
|
|
code.putln("%s = PyDict_Copy(%s); if (unlikely(!%s)) return %s;" % (
|
|
self.starstar_arg.entry.cname,
|
|
Naming.kwds_cname,
|
|
self.starstar_arg.entry.cname,
|
|
self.error_value()))
|
|
code.put_gotref(self.starstar_arg.entry.cname)
|
|
code.putln("} else {")
|
|
code.putln("%s = NULL;" % (self.starstar_arg.entry.cname,))
|
|
code.putln("}")
|
|
self.starstar_arg.entry.xdecref_cleanup = 1
|
|
else:
|
|
code.put("%s = (%s) ? PyDict_Copy(%s) : PyDict_New(); " % (
|
|
self.starstar_arg.entry.cname,
|
|
Naming.kwds_cname,
|
|
Naming.kwds_cname))
|
|
code.putln("if (unlikely(!%s)) return %s;" % (
|
|
self.starstar_arg.entry.cname, self.error_value()))
|
|
self.starstar_arg.entry.xdecref_cleanup = 0
|
|
code.put_gotref(self.starstar_arg.entry.cname)
|
|
|
|
if self.self_in_stararg and not self.target.is_staticmethod:
|
|
# need to create a new tuple with 'self' inserted as first item
|
|
code.put("%s = PyTuple_New(PyTuple_GET_SIZE(%s)+1); if (unlikely(!%s)) " % (
|
|
self.star_arg.entry.cname,
|
|
Naming.args_cname,
|
|
self.star_arg.entry.cname))
|
|
if self.starstar_arg and self.starstar_arg.entry.cf_used:
|
|
code.putln("{")
|
|
code.put_xdecref_clear(self.starstar_arg.entry.cname, py_object_type)
|
|
code.putln("return %s;" % self.error_value())
|
|
code.putln("}")
|
|
else:
|
|
code.putln("return %s;" % self.error_value())
|
|
code.put_gotref(self.star_arg.entry.cname)
|
|
code.put_incref(Naming.self_cname, py_object_type)
|
|
code.put_giveref(Naming.self_cname)
|
|
code.putln("PyTuple_SET_ITEM(%s, 0, %s);" % (
|
|
self.star_arg.entry.cname, Naming.self_cname))
|
|
temp = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False)
|
|
code.putln("for (%s=0; %s < PyTuple_GET_SIZE(%s); %s++) {" % (
|
|
temp, temp, Naming.args_cname, temp))
|
|
code.putln("PyObject* item = PyTuple_GET_ITEM(%s, %s);" % (
|
|
Naming.args_cname, temp))
|
|
code.put_incref("item", py_object_type)
|
|
code.put_giveref("item")
|
|
code.putln("PyTuple_SET_ITEM(%s, %s+1, item);" % (
|
|
self.star_arg.entry.cname, temp))
|
|
code.putln("}")
|
|
code.funcstate.release_temp(temp)
|
|
self.star_arg.entry.xdecref_cleanup = 0
|
|
elif self.star_arg:
|
|
code.put_incref(Naming.args_cname, py_object_type)
|
|
code.putln("%s = %s;" % (
|
|
self.star_arg.entry.cname,
|
|
Naming.args_cname))
|
|
self.star_arg.entry.xdecref_cleanup = 0
|
|
|
|
def generate_tuple_and_keyword_parsing_code(self, args, success_label, code):
|
|
argtuple_error_label = code.new_label("argtuple_error")
|
|
|
|
positional_args = []
|
|
required_kw_only_args = []
|
|
optional_kw_only_args = []
|
|
for arg in args:
|
|
if arg.is_generic:
|
|
if arg.default:
|
|
if not arg.is_self_arg and not arg.is_type_arg:
|
|
if arg.kw_only:
|
|
optional_kw_only_args.append(arg)
|
|
else:
|
|
positional_args.append(arg)
|
|
elif arg.kw_only:
|
|
required_kw_only_args.append(arg)
|
|
elif not arg.is_self_arg and not arg.is_type_arg:
|
|
positional_args.append(arg)
|
|
|
|
# sort required kw-only args before optional ones to avoid special
|
|
# cases in the unpacking code
|
|
kw_only_args = required_kw_only_args + optional_kw_only_args
|
|
|
|
min_positional_args = self.num_required_args - self.num_required_kw_args
|
|
if len(args) > 0 and (args[0].is_self_arg or args[0].is_type_arg):
|
|
min_positional_args -= 1
|
|
max_positional_args = len(positional_args)
|
|
has_fixed_positional_count = not self.star_arg and \
|
|
min_positional_args == max_positional_args
|
|
has_kw_only_args = bool(kw_only_args)
|
|
|
|
if self.starstar_arg or self.star_arg:
|
|
self.generate_stararg_init_code(max_positional_args, code)
|
|
|
|
code.putln('{')
|
|
all_args = tuple(positional_args) + tuple(kw_only_args)
|
|
code.putln("static PyObject **%s[] = {%s,0};" % (
|
|
Naming.pykwdlist_cname,
|
|
','.join(['&%s' % code.intern_identifier(arg.name)
|
|
for arg in all_args])))
|
|
|
|
# Before being converted and assigned to the target variables,
|
|
# borrowed references to all unpacked argument values are
|
|
# collected into a local PyObject* array called "values",
|
|
# regardless if they were taken from default arguments,
|
|
# positional arguments or keyword arguments. Note that
|
|
# C-typed default arguments are handled at conversion time,
|
|
# so their array value is NULL in the end if no argument
|
|
# was passed for them.
|
|
self.generate_argument_values_setup_code(all_args, code)
|
|
|
|
# --- optimised code when we receive keyword arguments
|
|
code.putln("if (%s(%s)) {" % (
|
|
(self.num_required_kw_args > 0) and "likely" or "unlikely",
|
|
Naming.kwds_cname))
|
|
self.generate_keyword_unpacking_code(
|
|
min_positional_args, max_positional_args,
|
|
has_fixed_positional_count, has_kw_only_args,
|
|
all_args, argtuple_error_label, code)
|
|
|
|
# --- optimised code when we do not receive any keyword arguments
|
|
if (self.num_required_kw_args and min_positional_args > 0) or min_positional_args == max_positional_args:
|
|
# Python raises arg tuple related errors first, so we must
|
|
# check the length here
|
|
if min_positional_args == max_positional_args and not self.star_arg:
|
|
compare = '!='
|
|
else:
|
|
compare = '<'
|
|
code.putln('} else if (PyTuple_GET_SIZE(%s) %s %d) {' % (
|
|
Naming.args_cname, compare, min_positional_args))
|
|
code.put_goto(argtuple_error_label)
|
|
|
|
if self.num_required_kw_args:
|
|
# pure error case: keywords required but not passed
|
|
if max_positional_args > min_positional_args and not self.star_arg:
|
|
code.putln('} else if (PyTuple_GET_SIZE(%s) > %d) {' % (
|
|
Naming.args_cname, max_positional_args))
|
|
code.put_goto(argtuple_error_label)
|
|
code.putln('} else {')
|
|
for i, arg in enumerate(kw_only_args):
|
|
if not arg.default:
|
|
pystring_cname = code.intern_identifier(arg.name)
|
|
# required keyword-only argument missing
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("RaiseKeywordRequired", "FunctionArguments.c"))
|
|
code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' % (
|
|
self.name,
|
|
pystring_cname))
|
|
code.putln(code.error_goto(self.pos))
|
|
break
|
|
|
|
else:
|
|
# optimised tuple unpacking code
|
|
code.putln('} else {')
|
|
if min_positional_args == max_positional_args:
|
|
# parse the exact number of positional arguments from
|
|
# the args tuple
|
|
for i, arg in enumerate(positional_args):
|
|
code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (i, Naming.args_cname, i))
|
|
else:
|
|
# parse the positional arguments from the variable length
|
|
# args tuple and reject illegal argument tuple sizes
|
|
code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
|
|
if self.star_arg:
|
|
code.putln('default:')
|
|
reversed_args = list(enumerate(positional_args))[::-1]
|
|
for i, arg in reversed_args:
|
|
if i >= min_positional_args-1:
|
|
if i != reversed_args[0][0]:
|
|
code.putln('CYTHON_FALLTHROUGH;')
|
|
code.put('case %2d: ' % (i+1))
|
|
code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (i, Naming.args_cname, i))
|
|
if min_positional_args == 0:
|
|
code.putln('CYTHON_FALLTHROUGH;')
|
|
code.put('case 0: ')
|
|
code.putln('break;')
|
|
if self.star_arg:
|
|
if min_positional_args:
|
|
for i in range(min_positional_args-1, -1, -1):
|
|
code.putln('case %2d:' % i)
|
|
code.put_goto(argtuple_error_label)
|
|
else:
|
|
code.put('default: ')
|
|
code.put_goto(argtuple_error_label)
|
|
code.putln('}')
|
|
|
|
code.putln('}') # end of the conditional unpacking blocks
|
|
|
|
# Convert arg values to their final type and assign them.
|
|
# Also inject non-Python default arguments, which do cannot
|
|
# live in the values[] array.
|
|
for i, arg in enumerate(all_args):
|
|
self.generate_arg_assignment(arg, "values[%d]" % i, code)
|
|
|
|
code.putln('}') # end of the whole argument unpacking block
|
|
|
|
if code.label_used(argtuple_error_label):
|
|
code.put_goto(success_label)
|
|
code.put_label(argtuple_error_label)
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("RaiseArgTupleInvalid", "FunctionArguments.c"))
|
|
code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, PyTuple_GET_SIZE(%s)); ' % (
|
|
self.name, has_fixed_positional_count,
|
|
min_positional_args, max_positional_args,
|
|
Naming.args_cname))
|
|
code.putln(code.error_goto(self.pos))
|
|
|
|
def generate_arg_assignment(self, arg, item, code):
|
|
if arg.type.is_pyobject:
|
|
# Python default arguments were already stored in 'item' at the very beginning
|
|
if arg.is_generic:
|
|
item = PyrexTypes.typecast(arg.type, PyrexTypes.py_object_type, item)
|
|
entry = arg.entry
|
|
code.putln("%s = %s;" % (entry.cname, item))
|
|
else:
|
|
if arg.type.from_py_function:
|
|
if arg.default:
|
|
# C-typed default arguments must be handled here
|
|
code.putln('if (%s) {' % item)
|
|
code.putln(arg.type.from_py_call_code(
|
|
item, arg.entry.cname, arg.pos, code))
|
|
if arg.default:
|
|
code.putln('} else {')
|
|
code.putln("%s = %s;" % (
|
|
arg.entry.cname,
|
|
arg.calculate_default_value_code(code)))
|
|
if arg.type.is_memoryviewslice:
|
|
code.put_incref_memoryviewslice(arg.entry.cname,
|
|
have_gil=True)
|
|
code.putln('}')
|
|
else:
|
|
error(arg.pos, "Cannot convert Python object argument to type '%s'" % arg.type)
|
|
|
|
def generate_stararg_init_code(self, max_positional_args, code):
|
|
if self.starstar_arg:
|
|
self.starstar_arg.entry.xdecref_cleanup = 0
|
|
code.putln('%s = PyDict_New(); if (unlikely(!%s)) return %s;' % (
|
|
self.starstar_arg.entry.cname,
|
|
self.starstar_arg.entry.cname,
|
|
self.error_value()))
|
|
code.put_gotref(self.starstar_arg.entry.cname)
|
|
if self.star_arg:
|
|
self.star_arg.entry.xdecref_cleanup = 0
|
|
code.putln('if (PyTuple_GET_SIZE(%s) > %d) {' % (
|
|
Naming.args_cname,
|
|
max_positional_args))
|
|
code.putln('%s = PyTuple_GetSlice(%s, %d, PyTuple_GET_SIZE(%s));' % (
|
|
self.star_arg.entry.cname, Naming.args_cname,
|
|
max_positional_args, Naming.args_cname))
|
|
code.putln("if (unlikely(!%s)) {" % self.star_arg.entry.cname)
|
|
if self.starstar_arg:
|
|
code.put_decref_clear(self.starstar_arg.entry.cname, py_object_type)
|
|
code.put_finish_refcount_context()
|
|
code.putln('return %s;' % self.error_value())
|
|
code.putln('}')
|
|
code.put_gotref(self.star_arg.entry.cname)
|
|
code.putln('} else {')
|
|
code.put("%s = %s; " % (self.star_arg.entry.cname, Naming.empty_tuple))
|
|
code.put_incref(Naming.empty_tuple, py_object_type)
|
|
code.putln('}')
|
|
|
|
def generate_argument_values_setup_code(self, args, code):
|
|
max_args = len(args)
|
|
# the 'values' array collects borrowed references to arguments
|
|
# before doing any type coercion etc.
|
|
code.putln("PyObject* values[%d] = {%s};" % (
|
|
max_args, ','.join('0'*max_args)))
|
|
|
|
if self.target.defaults_struct:
|
|
code.putln('%s *%s = __Pyx_CyFunction_Defaults(%s, %s);' % (
|
|
self.target.defaults_struct, Naming.dynamic_args_cname,
|
|
self.target.defaults_struct, Naming.self_cname))
|
|
|
|
# assign borrowed Python default values to the values array,
|
|
# so that they can be overwritten by received arguments below
|
|
for i, arg in enumerate(args):
|
|
if arg.default and arg.type.is_pyobject:
|
|
default_value = arg.calculate_default_value_code(code)
|
|
code.putln('values[%d] = %s;' % (i, arg.type.as_pyobject(default_value)))
|
|
|
|
def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,
|
|
has_fixed_positional_count, has_kw_only_args,
|
|
all_args, argtuple_error_label, code):
|
|
code.putln('Py_ssize_t kw_args;')
|
|
code.putln('const Py_ssize_t pos_args = PyTuple_GET_SIZE(%s);' % Naming.args_cname)
|
|
# copy the values from the args tuple and check that it's not too long
|
|
code.putln('switch (pos_args) {')
|
|
if self.star_arg:
|
|
code.putln('default:')
|
|
for i in range(max_positional_args-1, -1, -1):
|
|
code.put('case %2d: ' % (i+1))
|
|
code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (
|
|
i, Naming.args_cname, i))
|
|
code.putln('CYTHON_FALLTHROUGH;')
|
|
code.putln('case 0: break;')
|
|
if not self.star_arg:
|
|
code.put('default: ') # more arguments than allowed
|
|
code.put_goto(argtuple_error_label)
|
|
code.putln('}')
|
|
|
|
# The code above is very often (but not always) the same as
|
|
# the optimised non-kwargs tuple unpacking code, so we keep
|
|
# the code block above at the very top, before the following
|
|
# 'external' PyDict_Size() call, to make it easy for the C
|
|
# compiler to merge the two separate tuple unpacking
|
|
# implementations into one when they turn out to be identical.
|
|
|
|
# If we received kwargs, fill up the positional/required
|
|
# arguments with values from the kw dict
|
|
code.putln('kw_args = PyDict_Size(%s);' % Naming.kwds_cname)
|
|
if self.num_required_args or max_positional_args > 0:
|
|
last_required_arg = -1
|
|
for i, arg in enumerate(all_args):
|
|
if not arg.default:
|
|
last_required_arg = i
|
|
if last_required_arg < max_positional_args:
|
|
last_required_arg = max_positional_args-1
|
|
if max_positional_args > 0:
|
|
code.putln('switch (pos_args) {')
|
|
for i, arg in enumerate(all_args[:last_required_arg+1]):
|
|
if max_positional_args > 0 and i <= max_positional_args:
|
|
if i != 0:
|
|
code.putln('CYTHON_FALLTHROUGH;')
|
|
if self.star_arg and i == max_positional_args:
|
|
code.putln('default:')
|
|
else:
|
|
code.putln('case %2d:' % i)
|
|
pystring_cname = code.intern_identifier(arg.name)
|
|
if arg.default:
|
|
if arg.kw_only:
|
|
# optional kw-only args are handled separately below
|
|
continue
|
|
code.putln('if (kw_args > 0) {')
|
|
# don't overwrite default argument
|
|
code.putln('PyObject* value = __Pyx_PyDict_GetItemStr(%s, %s);' % (
|
|
Naming.kwds_cname, pystring_cname))
|
|
code.putln('if (value) { values[%d] = value; kw_args--; }' % i)
|
|
code.putln('}')
|
|
else:
|
|
code.putln('if (likely((values[%d] = __Pyx_PyDict_GetItemStr(%s, %s)) != 0)) kw_args--;' % (
|
|
i, Naming.kwds_cname, pystring_cname))
|
|
if i < min_positional_args:
|
|
if i == 0:
|
|
# special case: we know arg 0 is missing
|
|
code.put('else ')
|
|
code.put_goto(argtuple_error_label)
|
|
else:
|
|
# print the correct number of values (args or
|
|
# kwargs) that were passed into positional
|
|
# arguments up to this point
|
|
code.putln('else {')
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("RaiseArgTupleInvalid", "FunctionArguments.c"))
|
|
code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, %d); ' % (
|
|
self.name, has_fixed_positional_count,
|
|
min_positional_args, max_positional_args, i))
|
|
code.putln(code.error_goto(self.pos))
|
|
code.putln('}')
|
|
elif arg.kw_only:
|
|
code.putln('else {')
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("RaiseKeywordRequired", "FunctionArguments.c"))
|
|
code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' % (
|
|
self.name, pystring_cname))
|
|
code.putln(code.error_goto(self.pos))
|
|
code.putln('}')
|
|
if max_positional_args > 0:
|
|
code.putln('}')
|
|
|
|
if has_kw_only_args:
|
|
# unpack optional keyword-only arguments separately because
|
|
# checking for interned strings in a dict is faster than iterating
|
|
self.generate_optional_kwonly_args_unpacking_code(all_args, code)
|
|
|
|
code.putln('if (unlikely(kw_args > 0)) {')
|
|
# non-positional/-required kw args left in dict: default args,
|
|
# kw-only args, **kwargs or error
|
|
#
|
|
# This is sort of a catch-all: except for checking required
|
|
# arguments, this will always do the right thing for unpacking
|
|
# keyword arguments, so that we can concentrate on optimising
|
|
# common cases above.
|
|
if max_positional_args == 0:
|
|
pos_arg_count = "0"
|
|
elif self.star_arg:
|
|
code.putln("const Py_ssize_t used_pos_args = (pos_args < %d) ? pos_args : %d;" % (
|
|
max_positional_args, max_positional_args))
|
|
pos_arg_count = "used_pos_args"
|
|
else:
|
|
pos_arg_count = "pos_args"
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("ParseKeywords", "FunctionArguments.c"))
|
|
code.putln('if (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, values, %s, "%s") < 0)) %s' % (
|
|
Naming.kwds_cname,
|
|
Naming.pykwdlist_cname,
|
|
self.starstar_arg and self.starstar_arg.entry.cname or '0',
|
|
pos_arg_count,
|
|
self.name,
|
|
code.error_goto(self.pos)))
|
|
code.putln('}')
|
|
|
|
def generate_optional_kwonly_args_unpacking_code(self, all_args, code):
|
|
optional_args = []
|
|
first_optional_arg = -1
|
|
for i, arg in enumerate(all_args):
|
|
if not arg.kw_only or not arg.default:
|
|
continue
|
|
if not optional_args:
|
|
first_optional_arg = i
|
|
optional_args.append(arg.name)
|
|
if optional_args:
|
|
if len(optional_args) > 1:
|
|
# if we receive more than the named kwargs, we either have **kwargs
|
|
# (in which case we must iterate anyway) or it's an error (which we
|
|
# also handle during iteration) => skip this part if there are more
|
|
code.putln('if (kw_args > 0 && %s(kw_args <= %d)) {' % (
|
|
not self.starstar_arg and 'likely' or '',
|
|
len(optional_args)))
|
|
code.putln('Py_ssize_t index;')
|
|
# not unrolling the loop here reduces the C code overhead
|
|
code.putln('for (index = %d; index < %d && kw_args > 0; index++) {' % (
|
|
first_optional_arg, first_optional_arg + len(optional_args)))
|
|
else:
|
|
code.putln('if (kw_args == 1) {')
|
|
code.putln('const Py_ssize_t index = %d;' % first_optional_arg)
|
|
code.putln('PyObject* value = __Pyx_PyDict_GetItemStr(%s, *%s[index]);' % (
|
|
Naming.kwds_cname, Naming.pykwdlist_cname))
|
|
code.putln('if (value) { values[index] = value; kw_args--; }')
|
|
if len(optional_args) > 1:
|
|
code.putln('}')
|
|
code.putln('}')
|
|
|
|
def generate_argument_conversion_code(self, code):
|
|
# Generate code to convert arguments from signature type to
|
|
# declared type, if needed. Also copies signature arguments
|
|
# into closure fields.
|
|
for arg in self.args:
|
|
if arg.needs_conversion:
|
|
self.generate_arg_conversion(arg, code)
|
|
|
|
def generate_arg_conversion(self, arg, code):
|
|
# Generate conversion code for one argument.
|
|
old_type = arg.hdr_type
|
|
new_type = arg.type
|
|
if old_type.is_pyobject:
|
|
if arg.default:
|
|
code.putln("if (%s) {" % arg.hdr_cname)
|
|
else:
|
|
code.putln("assert(%s); {" % arg.hdr_cname)
|
|
self.generate_arg_conversion_from_pyobject(arg, code)
|
|
code.putln("}")
|
|
elif new_type.is_pyobject:
|
|
self.generate_arg_conversion_to_pyobject(arg, code)
|
|
else:
|
|
if new_type.assignable_from(old_type):
|
|
code.putln("%s = %s;" % (arg.entry.cname, arg.hdr_cname))
|
|
else:
|
|
error(arg.pos, "Cannot convert 1 argument from '%s' to '%s'" % (old_type, new_type))
|
|
|
|
def generate_arg_conversion_from_pyobject(self, arg, code):
|
|
new_type = arg.type
|
|
# copied from CoerceFromPyTypeNode
|
|
if new_type.from_py_function:
|
|
code.putln(new_type.from_py_call_code(
|
|
arg.hdr_cname,
|
|
arg.entry.cname,
|
|
arg.pos,
|
|
code,
|
|
))
|
|
else:
|
|
error(arg.pos, "Cannot convert Python object argument to type '%s'" % new_type)
|
|
|
|
def generate_arg_conversion_to_pyobject(self, arg, code):
|
|
old_type = arg.hdr_type
|
|
func = old_type.to_py_function
|
|
if func:
|
|
code.putln("%s = %s(%s); %s" % (
|
|
arg.entry.cname,
|
|
func,
|
|
arg.hdr_cname,
|
|
code.error_goto_if_null(arg.entry.cname, arg.pos)))
|
|
code.put_var_gotref(arg.entry)
|
|
else:
|
|
error(arg.pos, "Cannot convert argument of type '%s' to Python object" % old_type)
|
|
|
|
def generate_argument_type_tests(self, code):
|
|
# Generate type tests for args whose signature
|
|
# type is PyObject * and whose declared type is
|
|
# a subtype thereof.
|
|
for arg in self.args:
|
|
if arg.needs_type_test:
|
|
self.generate_arg_type_test(arg, code)
|
|
elif not arg.accept_none and (arg.type.is_pyobject or
|
|
arg.type.is_buffer or
|
|
arg.type.is_memoryviewslice):
|
|
self.generate_arg_none_check(arg, code)
|
|
|
|
def error_value(self):
|
|
return self.signature.error_value
|
|
|
|
|
|
class GeneratorDefNode(DefNode):
|
|
# Generator function node that creates a new generator instance when called.
|
|
#
|
|
# gbody GeneratorBodyDefNode the function implementing the generator
|
|
#
|
|
|
|
is_generator = True
|
|
is_coroutine = False
|
|
is_iterable_coroutine = False
|
|
is_asyncgen = False
|
|
gen_type_name = 'Generator'
|
|
needs_closure = True
|
|
|
|
child_attrs = DefNode.child_attrs + ["gbody"]
|
|
|
|
def __init__(self, pos, **kwargs):
|
|
# XXX: don't actually needs a body
|
|
kwargs['body'] = StatListNode(pos, stats=[], is_terminator=True)
|
|
super(GeneratorDefNode, self).__init__(pos, **kwargs)
|
|
|
|
def analyse_declarations(self, env):
|
|
super(GeneratorDefNode, self).analyse_declarations(env)
|
|
self.gbody.local_scope = self.local_scope
|
|
self.gbody.analyse_declarations(env)
|
|
|
|
def generate_function_body(self, env, code):
|
|
body_cname = self.gbody.entry.func_cname
|
|
name = code.intern_identifier(self.name)
|
|
qualname = code.intern_identifier(self.qualname)
|
|
module_name = code.intern_identifier(self.module_name)
|
|
|
|
code.putln('{')
|
|
code.putln('__pyx_CoroutineObject *gen = __Pyx_%s_New('
|
|
'(__pyx_coroutine_body_t) %s, %s, (PyObject *) %s, %s, %s, %s); %s' % (
|
|
self.gen_type_name,
|
|
body_cname, self.code_object.calculate_result_code(code) if self.code_object else 'NULL',
|
|
Naming.cur_scope_cname, name, qualname, module_name,
|
|
code.error_goto_if_null('gen', self.pos)))
|
|
code.put_decref(Naming.cur_scope_cname, py_object_type)
|
|
if self.requires_classobj:
|
|
classobj_cname = 'gen->classobj'
|
|
code.putln('%s = __Pyx_CyFunction_GetClassObj(%s);' % (
|
|
classobj_cname, Naming.self_cname))
|
|
code.put_incref(classobj_cname, py_object_type)
|
|
code.put_giveref(classobj_cname)
|
|
code.put_finish_refcount_context()
|
|
code.putln('return (PyObject *) gen;')
|
|
code.putln('}')
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
env.use_utility_code(UtilityCode.load_cached(self.gen_type_name, "Coroutine.c"))
|
|
self.gbody.generate_function_header(code, proto=True)
|
|
super(GeneratorDefNode, self).generate_function_definitions(env, code)
|
|
self.gbody.generate_function_definitions(env, code)
|
|
|
|
|
|
class AsyncDefNode(GeneratorDefNode):
|
|
gen_type_name = 'Coroutine'
|
|
is_coroutine = True
|
|
|
|
|
|
class IterableAsyncDefNode(AsyncDefNode):
|
|
gen_type_name = 'IterableCoroutine'
|
|
is_iterable_coroutine = True
|
|
|
|
|
|
class AsyncGenNode(AsyncDefNode):
|
|
gen_type_name = 'AsyncGen'
|
|
is_asyncgen = True
|
|
|
|
|
|
class GeneratorBodyDefNode(DefNode):
|
|
# Main code body of a generator implemented as a DefNode.
|
|
#
|
|
|
|
is_generator_body = True
|
|
is_inlined = False
|
|
is_async_gen_body = False
|
|
inlined_comprehension_type = None # container type for inlined comprehensions
|
|
|
|
def __init__(self, pos=None, name=None, body=None, is_async_gen_body=False):
|
|
super(GeneratorBodyDefNode, self).__init__(
|
|
pos=pos, body=body, name=name, is_async_gen_body=is_async_gen_body,
|
|
doc=None, args=[], star_arg=None, starstar_arg=None)
|
|
|
|
def declare_generator_body(self, env):
|
|
prefix = env.next_id(env.scope_prefix)
|
|
name = env.next_id('generator')
|
|
cname = Naming.genbody_prefix + prefix + name
|
|
entry = env.declare_var(None, py_object_type, self.pos,
|
|
cname=cname, visibility='private')
|
|
entry.func_cname = cname
|
|
entry.qualified_name = EncodedString(self.name)
|
|
# Work-around for https://github.com/cython/cython/issues/1699
|
|
# We don't currently determine whether the generator entry is used or not,
|
|
# so mark it as used to avoid false warnings.
|
|
entry.used = True
|
|
self.entry = entry
|
|
|
|
def analyse_declarations(self, env):
|
|
self.analyse_argument_types(env)
|
|
self.declare_generator_body(env)
|
|
|
|
def generate_function_header(self, code, proto=False):
|
|
header = "static PyObject *%s(__pyx_CoroutineObject *%s, CYTHON_UNUSED PyThreadState *%s, PyObject *%s)" % (
|
|
self.entry.func_cname,
|
|
Naming.generator_cname,
|
|
Naming.local_tstate_cname,
|
|
Naming.sent_value_cname)
|
|
if proto:
|
|
code.putln('%s; /* proto */' % header)
|
|
else:
|
|
code.putln('%s /* generator body */\n{' % header)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
lenv = self.local_scope
|
|
|
|
# Generate closure function definitions
|
|
self.body.generate_function_definitions(lenv, code)
|
|
|
|
# Generate C code for header and body of function
|
|
code.enter_cfunc_scope(lenv)
|
|
code.return_from_error_cleanup_label = code.new_label()
|
|
|
|
# ----- Top-level constants used by this function
|
|
code.mark_pos(self.pos)
|
|
self.generate_cached_builtins_decls(lenv, code)
|
|
# ----- Function header
|
|
code.putln("")
|
|
self.generate_function_header(code)
|
|
closure_init_code = code.insertion_point()
|
|
# ----- Local variables
|
|
code.putln("PyObject *%s = NULL;" % Naming.retval_cname)
|
|
tempvardecl_code = code.insertion_point()
|
|
code.put_declare_refcount_context()
|
|
code.put_setup_refcount_context(self.entry.name or self.entry.qualified_name)
|
|
profile = code.globalstate.directives['profile']
|
|
linetrace = code.globalstate.directives['linetrace']
|
|
if profile or linetrace:
|
|
tempvardecl_code.put_trace_declarations()
|
|
code.funcstate.can_trace = True
|
|
code_object = self.code_object.calculate_result_code(code) if self.code_object else None
|
|
code.put_trace_frame_init(code_object)
|
|
|
|
# ----- Resume switch point.
|
|
code.funcstate.init_closure_temps(lenv.scope_class.type.scope)
|
|
resume_code = code.insertion_point()
|
|
first_run_label = code.new_label('first_run')
|
|
code.use_label(first_run_label)
|
|
code.put_label(first_run_label)
|
|
code.putln('%s' %
|
|
(code.error_goto_if_null(Naming.sent_value_cname, self.pos)))
|
|
|
|
# ----- prepare target container for inlined comprehension
|
|
if self.is_inlined and self.inlined_comprehension_type is not None:
|
|
target_type = self.inlined_comprehension_type
|
|
if target_type is Builtin.list_type:
|
|
comp_init = 'PyList_New(0)'
|
|
elif target_type is Builtin.set_type:
|
|
comp_init = 'PySet_New(NULL)'
|
|
elif target_type is Builtin.dict_type:
|
|
comp_init = 'PyDict_New()'
|
|
else:
|
|
raise InternalError(
|
|
"invalid type of inlined comprehension: %s" % target_type)
|
|
code.putln("%s = %s; %s" % (
|
|
Naming.retval_cname, comp_init,
|
|
code.error_goto_if_null(Naming.retval_cname, self.pos)))
|
|
code.put_gotref(Naming.retval_cname)
|
|
|
|
# ----- Function body
|
|
self.generate_function_body(env, code)
|
|
# ----- Closure initialization
|
|
if lenv.scope_class.type.scope.var_entries:
|
|
closure_init_code.putln('%s = %s;' % (
|
|
lenv.scope_class.type.declaration_code(Naming.cur_scope_cname),
|
|
lenv.scope_class.type.cast_code('%s->closure' %
|
|
Naming.generator_cname)))
|
|
# FIXME: this silences a potential "unused" warning => try to avoid unused closures in more cases
|
|
code.putln("CYTHON_MAYBE_UNUSED_VAR(%s);" % Naming.cur_scope_cname)
|
|
|
|
if profile or linetrace:
|
|
code.funcstate.can_trace = False
|
|
|
|
code.mark_pos(self.pos)
|
|
code.putln("")
|
|
code.putln("/* function exit code */")
|
|
|
|
# on normal generator termination, we do not take the exception propagation
|
|
# path: no traceback info is required and not creating it is much faster
|
|
if not self.is_inlined and not self.body.is_terminator:
|
|
if self.is_async_gen_body:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("StopAsyncIteration", "Coroutine.c"))
|
|
code.putln('PyErr_SetNone(%s);' % (
|
|
'__Pyx_PyExc_StopAsyncIteration' if self.is_async_gen_body else 'PyExc_StopIteration'))
|
|
# ----- Error cleanup
|
|
if code.label_used(code.error_label):
|
|
if not self.body.is_terminator:
|
|
code.put_goto(code.return_label)
|
|
code.put_label(code.error_label)
|
|
if self.is_inlined and self.inlined_comprehension_type is not None:
|
|
code.put_xdecref_clear(Naming.retval_cname, py_object_type)
|
|
if Future.generator_stop in env.global_scope().context.future_directives:
|
|
# PEP 479: turn accidental StopIteration exceptions into a RuntimeError
|
|
code.globalstate.use_utility_code(UtilityCode.load_cached("pep479", "Coroutine.c"))
|
|
code.putln("__Pyx_Generator_Replace_StopIteration(%d);" % bool(self.is_async_gen_body))
|
|
for cname, type in code.funcstate.all_managed_temps():
|
|
code.put_xdecref(cname, type)
|
|
code.put_add_traceback(self.entry.qualified_name)
|
|
|
|
# ----- Non-error return cleanup
|
|
code.put_label(code.return_label)
|
|
if self.is_inlined:
|
|
code.put_xgiveref(Naming.retval_cname)
|
|
else:
|
|
code.put_xdecref_clear(Naming.retval_cname, py_object_type)
|
|
# For Py3.7, clearing is already done below.
|
|
code.putln("#if !CYTHON_USE_EXC_INFO_STACK")
|
|
code.putln("__Pyx_Coroutine_ResetAndClearException(%s);" % Naming.generator_cname)
|
|
code.putln("#endif")
|
|
code.putln('%s->resume_label = -1;' % Naming.generator_cname)
|
|
# clean up as early as possible to help breaking any reference cycles
|
|
code.putln('__Pyx_Coroutine_clear((PyObject*)%s);' % Naming.generator_cname)
|
|
if profile or linetrace:
|
|
code.put_trace_return(Naming.retval_cname,
|
|
nogil=not code.funcstate.gil_owned)
|
|
code.put_finish_refcount_context()
|
|
code.putln("return %s;" % Naming.retval_cname)
|
|
code.putln("}")
|
|
|
|
# ----- Go back and insert temp variable declarations
|
|
tempvardecl_code.put_temp_declarations(code.funcstate)
|
|
# ----- Generator resume code
|
|
if profile or linetrace:
|
|
resume_code.put_trace_call(self.entry.qualified_name, self.pos,
|
|
nogil=not code.funcstate.gil_owned)
|
|
resume_code.putln("switch (%s->resume_label) {" % (
|
|
Naming.generator_cname))
|
|
|
|
resume_code.putln("case 0: goto %s;" % first_run_label)
|
|
|
|
for i, label in code.yield_labels:
|
|
resume_code.putln("case %d: goto %s;" % (i, label))
|
|
resume_code.putln("default: /* CPython raises the right error here */")
|
|
if profile or linetrace:
|
|
resume_code.put_trace_return("Py_None",
|
|
nogil=not code.funcstate.gil_owned)
|
|
resume_code.put_finish_refcount_context()
|
|
resume_code.putln("return NULL;")
|
|
resume_code.putln("}")
|
|
|
|
code.exit_cfunc_scope()
|
|
|
|
|
|
class OverrideCheckNode(StatNode):
|
|
# A Node for dispatching to the def method if it
|
|
# is overridden.
|
|
#
|
|
# py_func
|
|
#
|
|
# args
|
|
# func_temp
|
|
# body
|
|
|
|
child_attrs = ['body']
|
|
|
|
body = None
|
|
|
|
def analyse_expressions(self, env):
|
|
self.args = env.arg_entries
|
|
if self.py_func.is_module_scope:
|
|
first_arg = 0
|
|
else:
|
|
first_arg = 1
|
|
from . import ExprNodes
|
|
self.func_node = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
|
|
call_node = ExprNodes.SimpleCallNode(
|
|
self.pos, function=self.func_node,
|
|
args=[ExprNodes.NameNode(self.pos, name=arg.name)
|
|
for arg in self.args[first_arg:]])
|
|
if env.return_type.is_void or env.return_type.is_returncode:
|
|
self.body = StatListNode(self.pos, stats=[
|
|
ExprStatNode(self.pos, expr=call_node),
|
|
ReturnStatNode(self.pos, value=None)])
|
|
else:
|
|
self.body = ReturnStatNode(self.pos, value=call_node)
|
|
self.body = self.body.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
interned_attr_cname = code.intern_identifier(self.py_func.entry.name)
|
|
# Check to see if we are an extension type
|
|
if self.py_func.is_module_scope:
|
|
self_arg = "((PyObject *)%s)" % Naming.module_cname
|
|
else:
|
|
self_arg = "((PyObject *)%s)" % self.args[0].cname
|
|
code.putln("/* Check if called by wrapper */")
|
|
code.putln("if (unlikely(%s)) ;" % Naming.skip_dispatch_cname)
|
|
code.putln("/* Check if overridden in Python */")
|
|
if self.py_func.is_module_scope:
|
|
code.putln("else {")
|
|
else:
|
|
code.putln("else if (unlikely((Py_TYPE(%s)->tp_dictoffset != 0)"
|
|
" || (Py_TYPE(%s)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) {" % (
|
|
self_arg, self_arg))
|
|
|
|
code.putln("#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS")
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("PyDictVersioning", "ObjectHandling.c"))
|
|
# TODO: remove the object dict version check by 'inlining' the getattr implementation for methods.
|
|
# This would allow checking the dict versions around _PyType_Lookup() if it returns a descriptor,
|
|
# and would (tada!) make this check a pure type based thing instead of supporting only a single
|
|
# instance at a time.
|
|
code.putln("static PY_UINT64_T %s = __PYX_DICT_VERSION_INIT, %s = __PYX_DICT_VERSION_INIT;" % (
|
|
Naming.tp_dict_version_temp, Naming.obj_dict_version_temp))
|
|
code.putln("if (unlikely(!__Pyx_object_dict_version_matches(%s, %s, %s))) {" % (
|
|
self_arg, Naming.tp_dict_version_temp, Naming.obj_dict_version_temp))
|
|
code.putln("PY_UINT64_T %s = __Pyx_get_tp_dict_version(%s);" % (
|
|
Naming.type_dict_guard_temp, self_arg))
|
|
code.putln("#endif")
|
|
|
|
func_node_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
|
|
self.func_node.set_cname(func_node_temp)
|
|
# need to get attribute manually--scope would return cdef method
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("PyObjectGetAttrStr", "ObjectHandling.c"))
|
|
err = code.error_goto_if_null(func_node_temp, self.pos)
|
|
code.putln("%s = __Pyx_PyObject_GetAttrStr(%s, %s); %s" % (
|
|
func_node_temp, self_arg, interned_attr_cname, err))
|
|
code.put_gotref(func_node_temp)
|
|
|
|
is_builtin_function_or_method = "PyCFunction_Check(%s)" % func_node_temp
|
|
is_overridden = "(PyCFunction_GET_FUNCTION(%s) != (PyCFunction)(void*)%s)" % (
|
|
func_node_temp, self.py_func.entry.func_cname)
|
|
code.putln("if (!%s || %s) {" % (is_builtin_function_or_method, is_overridden))
|
|
self.body.generate_execution_code(code)
|
|
code.putln("}")
|
|
|
|
# NOTE: it's not 100% sure that we catch the exact versions here that were used for the lookup,
|
|
# but it is very unlikely that the versions change during lookup, and the type dict safe guard
|
|
# should increase the chance of detecting such a case.
|
|
code.putln("#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS")
|
|
code.putln("%s = __Pyx_get_tp_dict_version(%s);" % (
|
|
Naming.tp_dict_version_temp, self_arg))
|
|
code.putln("%s = __Pyx_get_object_dict_version(%s);" % (
|
|
Naming.obj_dict_version_temp, self_arg))
|
|
# Safety check that the type dict didn't change during the lookup. Since CPython looks up the
|
|
# attribute (descriptor) first in the type dict and then in the instance dict or through the
|
|
# descriptor, the only really far-away lookup when we get here is one in the type dict. So we
|
|
# double check the type dict version before and afterwards to guard against later changes of
|
|
# the type dict during the lookup process.
|
|
code.putln("if (unlikely(%s != %s)) {" % (
|
|
Naming.type_dict_guard_temp, Naming.tp_dict_version_temp))
|
|
code.putln("%s = %s = __PYX_DICT_VERSION_INIT;" % (
|
|
Naming.tp_dict_version_temp, Naming.obj_dict_version_temp))
|
|
code.putln("}")
|
|
code.putln("#endif")
|
|
|
|
code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)
|
|
code.funcstate.release_temp(func_node_temp)
|
|
|
|
code.putln("#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS")
|
|
code.putln("}")
|
|
code.putln("#endif")
|
|
|
|
code.putln("}")
|
|
|
|
|
|
class ClassDefNode(StatNode, BlockNode):
|
|
pass
|
|
|
|
|
|
class PyClassDefNode(ClassDefNode):
|
|
# A Python class definition.
|
|
#
|
|
# name EncodedString Name of the class
|
|
# doc string or None
|
|
# body StatNode Attribute definition code
|
|
# entry Symtab.Entry
|
|
# scope PyClassScope
|
|
# decorators [DecoratorNode] list of decorators or None
|
|
#
|
|
# The following subnodes are constructed internally:
|
|
#
|
|
# dict DictNode Class dictionary or Py3 namespace
|
|
# classobj ClassNode Class object
|
|
# target NameNode Variable to assign class object to
|
|
|
|
child_attrs = ["body", "dict", "metaclass", "mkw", "bases", "class_result",
|
|
"target", "class_cell", "decorators"]
|
|
decorators = None
|
|
class_result = None
|
|
is_py3_style_class = False # Python3 style class (kwargs)
|
|
metaclass = None
|
|
mkw = None
|
|
|
|
def __init__(self, pos, name, bases, doc, body, decorators=None,
|
|
keyword_args=None, force_py3_semantics=False):
|
|
StatNode.__init__(self, pos)
|
|
self.name = name
|
|
self.doc = doc
|
|
self.body = body
|
|
self.decorators = decorators
|
|
self.bases = bases
|
|
from . import ExprNodes
|
|
if self.doc and Options.docstrings:
|
|
doc = embed_position(self.pos, self.doc)
|
|
doc_node = ExprNodes.StringNode(pos, value=doc)
|
|
else:
|
|
doc_node = None
|
|
|
|
allow_py2_metaclass = not force_py3_semantics
|
|
if keyword_args:
|
|
allow_py2_metaclass = False
|
|
self.is_py3_style_class = True
|
|
if keyword_args.is_dict_literal:
|
|
if keyword_args.key_value_pairs:
|
|
for i, item in list(enumerate(keyword_args.key_value_pairs))[::-1]:
|
|
if item.key.value == 'metaclass':
|
|
if self.metaclass is not None:
|
|
error(item.pos, "keyword argument 'metaclass' passed multiple times")
|
|
# special case: we already know the metaclass,
|
|
# so we don't need to do the "build kwargs,
|
|
# find metaclass" dance at runtime
|
|
self.metaclass = item.value
|
|
del keyword_args.key_value_pairs[i]
|
|
self.mkw = keyword_args
|
|
else:
|
|
assert self.metaclass is not None
|
|
else:
|
|
# MergedDictNode
|
|
self.mkw = ExprNodes.ProxyNode(keyword_args)
|
|
|
|
if force_py3_semantics or self.bases or self.mkw or self.metaclass:
|
|
if self.metaclass is None:
|
|
if keyword_args and not keyword_args.is_dict_literal:
|
|
# **kwargs may contain 'metaclass' arg
|
|
mkdict = self.mkw
|
|
else:
|
|
mkdict = None
|
|
if (not mkdict and
|
|
self.bases.is_sequence_constructor and
|
|
not self.bases.args):
|
|
pass # no base classes => no inherited metaclass
|
|
else:
|
|
self.metaclass = ExprNodes.PyClassMetaclassNode(
|
|
pos, class_def_node=self)
|
|
needs_metaclass_calculation = False
|
|
else:
|
|
needs_metaclass_calculation = True
|
|
|
|
self.dict = ExprNodes.PyClassNamespaceNode(
|
|
pos, name=name, doc=doc_node, class_def_node=self)
|
|
self.classobj = ExprNodes.Py3ClassNode(
|
|
pos, name=name, class_def_node=self, doc=doc_node,
|
|
calculate_metaclass=needs_metaclass_calculation,
|
|
allow_py2_metaclass=allow_py2_metaclass)
|
|
else:
|
|
# no bases, no metaclass => old style class creation
|
|
self.dict = ExprNodes.DictNode(pos, key_value_pairs=[])
|
|
self.classobj = ExprNodes.ClassNode(
|
|
pos, name=name, class_def_node=self, doc=doc_node)
|
|
|
|
self.target = ExprNodes.NameNode(pos, name=name)
|
|
self.class_cell = ExprNodes.ClassCellInjectorNode(self.pos)
|
|
|
|
def as_cclass(self):
|
|
"""
|
|
Return this node as if it were declared as an extension class
|
|
"""
|
|
if self.is_py3_style_class:
|
|
error(self.classobj.pos, "Python3 style class could not be represented as C class")
|
|
return
|
|
|
|
from . import ExprNodes
|
|
return CClassDefNode(self.pos,
|
|
visibility='private',
|
|
module_name=None,
|
|
class_name=self.name,
|
|
bases=self.bases or ExprNodes.TupleNode(self.pos, args=[]),
|
|
decorators=self.decorators,
|
|
body=self.body,
|
|
in_pxd=False,
|
|
doc=self.doc)
|
|
|
|
def create_scope(self, env):
|
|
genv = env
|
|
while genv.is_py_class_scope or genv.is_c_class_scope:
|
|
genv = genv.outer_scope
|
|
cenv = self.scope = PyClassScope(name=self.name, outer_scope=genv)
|
|
return cenv
|
|
|
|
def analyse_declarations(self, env):
|
|
class_result = self.classobj
|
|
if self.decorators:
|
|
from .ExprNodes import SimpleCallNode
|
|
for decorator in self.decorators[::-1]:
|
|
class_result = SimpleCallNode(
|
|
decorator.pos,
|
|
function=decorator.decorator,
|
|
args=[class_result])
|
|
self.decorators = None
|
|
self.class_result = class_result
|
|
if self.bases:
|
|
self.bases.analyse_declarations(env)
|
|
if self.mkw:
|
|
self.mkw.analyse_declarations(env)
|
|
self.class_result.analyse_declarations(env)
|
|
self.target.analyse_target_declaration(env)
|
|
cenv = self.create_scope(env)
|
|
cenv.directives = env.directives
|
|
cenv.class_obj_cname = self.target.entry.cname
|
|
self.body.analyse_declarations(cenv)
|
|
|
|
def analyse_expressions(self, env):
|
|
if self.bases:
|
|
self.bases = self.bases.analyse_expressions(env)
|
|
if self.mkw:
|
|
self.mkw = self.mkw.analyse_expressions(env)
|
|
if self.metaclass:
|
|
self.metaclass = self.metaclass.analyse_expressions(env)
|
|
self.dict = self.dict.analyse_expressions(env)
|
|
self.class_result = self.class_result.analyse_expressions(env)
|
|
cenv = self.scope
|
|
self.body = self.body.analyse_expressions(cenv)
|
|
self.target.analyse_target_expression(env, self.classobj)
|
|
self.class_cell = self.class_cell.analyse_expressions(cenv)
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.generate_lambda_definitions(self.scope, code)
|
|
self.body.generate_function_definitions(self.scope, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
code.pyclass_stack.append(self)
|
|
cenv = self.scope
|
|
if self.bases:
|
|
self.bases.generate_evaluation_code(code)
|
|
if self.mkw:
|
|
self.mkw.generate_evaluation_code(code)
|
|
if self.metaclass:
|
|
self.metaclass.generate_evaluation_code(code)
|
|
self.dict.generate_evaluation_code(code)
|
|
cenv.namespace_cname = cenv.class_obj_cname = self.dict.result()
|
|
|
|
class_cell = self.class_cell
|
|
if class_cell is not None and not class_cell.is_active:
|
|
class_cell = None
|
|
|
|
if class_cell is not None:
|
|
class_cell.generate_evaluation_code(code)
|
|
self.body.generate_execution_code(code)
|
|
self.class_result.generate_evaluation_code(code)
|
|
if class_cell is not None:
|
|
class_cell.generate_injection_code(
|
|
code, self.class_result.result())
|
|
if class_cell is not None:
|
|
class_cell.generate_disposal_code(code)
|
|
class_cell.free_temps(code)
|
|
|
|
cenv.namespace_cname = cenv.class_obj_cname = self.classobj.result()
|
|
self.target.generate_assignment_code(self.class_result, code)
|
|
self.dict.generate_disposal_code(code)
|
|
self.dict.free_temps(code)
|
|
if self.metaclass:
|
|
self.metaclass.generate_disposal_code(code)
|
|
self.metaclass.free_temps(code)
|
|
if self.mkw:
|
|
self.mkw.generate_disposal_code(code)
|
|
self.mkw.free_temps(code)
|
|
if self.bases:
|
|
self.bases.generate_disposal_code(code)
|
|
self.bases.free_temps(code)
|
|
code.pyclass_stack.pop()
|
|
|
|
|
|
class CClassDefNode(ClassDefNode):
|
|
# An extension type definition.
|
|
#
|
|
# visibility 'private' or 'public' or 'extern'
|
|
# typedef_flag boolean
|
|
# api boolean
|
|
# module_name string or None For import of extern type objects
|
|
# class_name string Unqualified name of class
|
|
# as_name string or None Name to declare as in this scope
|
|
# bases TupleNode Base class(es)
|
|
# objstruct_name string or None Specified C name of object struct
|
|
# typeobj_name string or None Specified C name of type object
|
|
# check_size 'warn', 'error', 'ignore' What to do if tp_basicsize does not match
|
|
# in_pxd boolean Is in a .pxd file
|
|
# decorators [DecoratorNode] list of decorators or None
|
|
# doc string or None
|
|
# body StatNode or None
|
|
# entry Symtab.Entry
|
|
# base_type PyExtensionType or None
|
|
# buffer_defaults_node DictNode or None Declares defaults for a buffer
|
|
# buffer_defaults_pos
|
|
|
|
child_attrs = ["body"]
|
|
buffer_defaults_node = None
|
|
buffer_defaults_pos = None
|
|
typedef_flag = False
|
|
api = False
|
|
objstruct_name = None
|
|
typeobj_name = None
|
|
check_size = None
|
|
decorators = None
|
|
shadow = False
|
|
|
|
def buffer_defaults(self, env):
|
|
if not hasattr(self, '_buffer_defaults'):
|
|
from . import Buffer
|
|
if self.buffer_defaults_node:
|
|
self._buffer_defaults = Buffer.analyse_buffer_options(
|
|
self.buffer_defaults_pos,
|
|
env, [], self.buffer_defaults_node,
|
|
need_complete=False)
|
|
else:
|
|
self._buffer_defaults = None
|
|
return self._buffer_defaults
|
|
|
|
def declare(self, env):
|
|
if self.module_name and self.visibility != 'extern':
|
|
module_path = self.module_name.split(".")
|
|
home_scope = env.find_imported_module(module_path, self.pos)
|
|
if not home_scope:
|
|
return None
|
|
else:
|
|
home_scope = env
|
|
|
|
self.entry = home_scope.declare_c_class(
|
|
name=self.class_name,
|
|
pos=self.pos,
|
|
defining=0,
|
|
implementing=0,
|
|
module_name=self.module_name,
|
|
base_type=None,
|
|
objstruct_cname=self.objstruct_name,
|
|
typeobj_cname=self.typeobj_name,
|
|
visibility=self.visibility,
|
|
typedef_flag=self.typedef_flag,
|
|
check_size = self.check_size,
|
|
api=self.api,
|
|
buffer_defaults=self.buffer_defaults(env),
|
|
shadow=self.shadow)
|
|
|
|
def analyse_declarations(self, env):
|
|
#print "CClassDefNode.analyse_declarations:", self.class_name
|
|
#print "...visibility =", self.visibility
|
|
#print "...module_name =", self.module_name
|
|
|
|
if env.in_cinclude and not self.objstruct_name:
|
|
error(self.pos, "Object struct name specification required for C class defined in 'extern from' block")
|
|
if self.decorators:
|
|
error(self.pos, "Decorators not allowed on cdef classes (used on type '%s')" % self.class_name)
|
|
self.base_type = None
|
|
# Now that module imports are cached, we need to
|
|
# import the modules for extern classes.
|
|
if self.module_name:
|
|
self.module = None
|
|
for module in env.cimported_modules:
|
|
if module.name == self.module_name:
|
|
self.module = module
|
|
if self.module is None:
|
|
self.module = ModuleScope(self.module_name, None, env.context)
|
|
self.module.has_extern_class = 1
|
|
env.add_imported_module(self.module)
|
|
|
|
if self.bases.args:
|
|
base = self.bases.args[0]
|
|
base_type = base.analyse_as_type(env)
|
|
if base_type in (PyrexTypes.c_int_type, PyrexTypes.c_long_type, PyrexTypes.c_float_type):
|
|
# Use the Python rather than C variant of these types.
|
|
base_type = env.lookup(base_type.sign_and_name()).type
|
|
if base_type is None:
|
|
error(base.pos, "First base of '%s' is not an extension type" % self.class_name)
|
|
elif base_type == PyrexTypes.py_object_type:
|
|
base_class_scope = None
|
|
elif not base_type.is_extension_type and \
|
|
not (base_type.is_builtin_type and base_type.objstruct_cname):
|
|
error(base.pos, "'%s' is not an extension type" % base_type)
|
|
elif not base_type.is_complete():
|
|
error(base.pos, "Base class '%s' of type '%s' is incomplete" % (
|
|
base_type.name, self.class_name))
|
|
elif base_type.scope and base_type.scope.directives and \
|
|
base_type.is_final_type:
|
|
error(base.pos, "Base class '%s' of type '%s' is final" % (
|
|
base_type, self.class_name))
|
|
elif base_type.is_builtin_type and \
|
|
base_type.name in ('tuple', 'str', 'bytes'):
|
|
error(base.pos, "inheritance from PyVarObject types like '%s' is not currently supported"
|
|
% base_type.name)
|
|
else:
|
|
self.base_type = base_type
|
|
if env.directives.get('freelist', 0) > 0 and base_type != PyrexTypes.py_object_type:
|
|
warning(self.pos, "freelists cannot be used on subtypes, only the base class can manage them", 1)
|
|
|
|
has_body = self.body is not None
|
|
if has_body and self.base_type and not self.base_type.scope:
|
|
# To properly initialize inherited attributes, the base type must
|
|
# be analysed before this type.
|
|
self.base_type.defered_declarations.append(lambda : self.analyse_declarations(env))
|
|
return
|
|
|
|
if self.module_name and self.visibility != 'extern':
|
|
module_path = self.module_name.split(".")
|
|
home_scope = env.find_imported_module(module_path, self.pos)
|
|
if not home_scope:
|
|
return
|
|
else:
|
|
home_scope = env
|
|
|
|
if self.visibility == 'extern':
|
|
if (self.module_name == '__builtin__' and
|
|
self.class_name in Builtin.builtin_types and
|
|
env.qualified_name[:8] != 'cpython.'): # allow overloaded names for cimporting from cpython
|
|
warning(self.pos, "%s already a builtin Cython type" % self.class_name, 1)
|
|
|
|
self.entry = home_scope.declare_c_class(
|
|
name=self.class_name,
|
|
pos=self.pos,
|
|
defining=has_body and self.in_pxd,
|
|
implementing=has_body and not self.in_pxd,
|
|
module_name=self.module_name,
|
|
base_type=self.base_type,
|
|
objstruct_cname=self.objstruct_name,
|
|
typeobj_cname=self.typeobj_name,
|
|
check_size=self.check_size,
|
|
visibility=self.visibility,
|
|
typedef_flag=self.typedef_flag,
|
|
api=self.api,
|
|
buffer_defaults=self.buffer_defaults(env),
|
|
shadow=self.shadow)
|
|
|
|
if self.shadow:
|
|
home_scope.lookup(self.class_name).as_variable = self.entry
|
|
if home_scope is not env and self.visibility == 'extern':
|
|
env.add_imported_entry(self.class_name, self.entry, self.pos)
|
|
self.scope = scope = self.entry.type.scope
|
|
if scope is not None:
|
|
scope.directives = env.directives
|
|
|
|
if self.doc and Options.docstrings:
|
|
scope.doc = embed_position(self.pos, self.doc)
|
|
|
|
if has_body:
|
|
self.body.analyse_declarations(scope)
|
|
dict_entry = self.scope.lookup_here("__dict__")
|
|
if dict_entry and dict_entry.is_variable and (not scope.defined and not scope.implemented):
|
|
dict_entry.getter_cname = self.scope.mangle_internal("__dict__getter")
|
|
self.scope.declare_property("__dict__", dict_entry.doc, dict_entry.pos)
|
|
if self.in_pxd:
|
|
scope.defined = 1
|
|
else:
|
|
scope.implemented = 1
|
|
|
|
if len(self.bases.args) > 1:
|
|
if not has_body or self.in_pxd:
|
|
error(self.bases.args[1].pos, "Only declare first base in declaration.")
|
|
# At runtime, we check that the other bases are heap types
|
|
# and that a __dict__ is added if required.
|
|
for other_base in self.bases.args[1:]:
|
|
if other_base.analyse_as_type(env):
|
|
error(other_base.pos, "Only one extension type base class allowed.")
|
|
self.entry.type.early_init = 0
|
|
from . import ExprNodes
|
|
self.type_init_args = ExprNodes.TupleNode(
|
|
self.pos,
|
|
args=[ExprNodes.IdentifierStringNode(self.pos, value=self.class_name),
|
|
self.bases,
|
|
ExprNodes.DictNode(self.pos, key_value_pairs=[])])
|
|
elif self.base_type:
|
|
self.entry.type.early_init = self.base_type.is_external or self.base_type.early_init
|
|
self.type_init_args = None
|
|
else:
|
|
self.entry.type.early_init = 1
|
|
self.type_init_args = None
|
|
|
|
env.allocate_vtable_names(self.entry)
|
|
|
|
for thunk in self.entry.type.defered_declarations:
|
|
thunk()
|
|
|
|
def analyse_expressions(self, env):
|
|
if self.body:
|
|
scope = self.entry.type.scope
|
|
self.body = self.body.analyse_expressions(scope)
|
|
if self.type_init_args:
|
|
self.type_init_args.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
if self.body:
|
|
self.generate_lambda_definitions(self.scope, code)
|
|
self.body.generate_function_definitions(self.scope, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
# This is needed to generate evaluation code for
|
|
# default values of method arguments.
|
|
code.mark_pos(self.pos)
|
|
if self.body:
|
|
self.body.generate_execution_code(code)
|
|
if not self.entry.type.early_init:
|
|
if self.type_init_args:
|
|
self.type_init_args.generate_evaluation_code(code)
|
|
bases = "PyTuple_GET_ITEM(%s, 1)" % self.type_init_args.result()
|
|
first_base = "((PyTypeObject*)PyTuple_GET_ITEM(%s, 0))" % bases
|
|
# Let Python do the base types compatibility checking.
|
|
trial_type = code.funcstate.allocate_temp(PyrexTypes.py_object_type, True)
|
|
code.putln("%s = PyType_Type.tp_new(&PyType_Type, %s, NULL);" % (
|
|
trial_type, self.type_init_args.result()))
|
|
code.putln(code.error_goto_if_null(trial_type, self.pos))
|
|
code.put_gotref(trial_type)
|
|
code.putln("if (((PyTypeObject*) %s)->tp_base != %s) {" % (
|
|
trial_type, first_base))
|
|
code.putln("PyErr_Format(PyExc_TypeError, \"best base '%s' must be equal to first base '%s'\",")
|
|
code.putln(" ((PyTypeObject*) %s)->tp_base->tp_name, %s->tp_name);" % (
|
|
trial_type, first_base))
|
|
code.putln(code.error_goto(self.pos))
|
|
code.putln("}")
|
|
code.funcstate.release_temp(trial_type)
|
|
code.put_incref(bases, PyrexTypes.py_object_type)
|
|
code.put_giveref(bases)
|
|
code.putln("%s.tp_bases = %s;" % (self.entry.type.typeobj_cname, bases))
|
|
code.put_decref_clear(trial_type, PyrexTypes.py_object_type)
|
|
self.type_init_args.generate_disposal_code(code)
|
|
self.type_init_args.free_temps(code)
|
|
|
|
self.generate_type_ready_code(self.entry, code, True)
|
|
|
|
# Also called from ModuleNode for early init types.
|
|
@staticmethod
|
|
def generate_type_ready_code(entry, code, heap_type_bases=False):
|
|
# Generate a call to PyType_Ready for an extension
|
|
# type defined in this module.
|
|
type = entry.type
|
|
typeobj_cname = type.typeobj_cname
|
|
scope = type.scope
|
|
if not scope: # could be None if there was an error
|
|
return
|
|
if entry.visibility != 'extern':
|
|
for slot in TypeSlots.slot_table:
|
|
slot.generate_dynamic_init_code(scope, code)
|
|
if heap_type_bases:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached('PyType_Ready', 'ExtensionTypes.c'))
|
|
readyfunc = "__Pyx_PyType_Ready"
|
|
else:
|
|
readyfunc = "PyType_Ready"
|
|
code.putln(
|
|
"if (%s(&%s) < 0) %s" % (
|
|
readyfunc,
|
|
typeobj_cname,
|
|
code.error_goto(entry.pos)))
|
|
# Don't inherit tp_print from builtin types, restoring the
|
|
# behavior of using tp_repr or tp_str instead.
|
|
# ("tp_print" was renamed to "tp_vectorcall_offset" in Py3.8b1)
|
|
code.putln("#if PY_VERSION_HEX < 0x030800B1")
|
|
code.putln("%s.tp_print = 0;" % typeobj_cname)
|
|
code.putln("#endif")
|
|
|
|
# Use specialised attribute lookup for types with generic lookup but no instance dict.
|
|
getattr_slot_func = TypeSlots.get_slot_code_by_name(scope, 'tp_getattro')
|
|
dictoffset_slot_func = TypeSlots.get_slot_code_by_name(scope, 'tp_dictoffset')
|
|
if getattr_slot_func == '0' and dictoffset_slot_func == '0':
|
|
if type.is_final_type:
|
|
py_cfunc = "__Pyx_PyObject_GenericGetAttrNoDict" # grepable
|
|
utility_func = "PyObject_GenericGetAttrNoDict"
|
|
else:
|
|
py_cfunc = "__Pyx_PyObject_GenericGetAttr"
|
|
utility_func = "PyObject_GenericGetAttr"
|
|
code.globalstate.use_utility_code(UtilityCode.load_cached(utility_func, "ObjectHandling.c"))
|
|
|
|
code.putln("if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) &&"
|
|
" likely(!%s.tp_dictoffset && %s.tp_getattro == PyObject_GenericGetAttr)) {" % (
|
|
typeobj_cname, typeobj_cname))
|
|
code.putln("%s.tp_getattro = %s;" % (
|
|
typeobj_cname, py_cfunc))
|
|
code.putln("}")
|
|
|
|
# Fix special method docstrings. This is a bit of a hack, but
|
|
# unless we let PyType_Ready create the slot wrappers we have
|
|
# a significant performance hit. (See trac #561.)
|
|
for func in entry.type.scope.pyfunc_entries:
|
|
is_buffer = func.name in ('__getbuffer__', '__releasebuffer__')
|
|
if (func.is_special and Options.docstrings and
|
|
func.wrapperbase_cname and not is_buffer):
|
|
slot = TypeSlots.method_name_to_slot.get(func.name)
|
|
preprocessor_guard = slot.preprocessor_guard_code() if slot else None
|
|
if preprocessor_guard:
|
|
code.putln(preprocessor_guard)
|
|
code.putln('#if CYTHON_UPDATE_DESCRIPTOR_DOC')
|
|
code.putln("{")
|
|
code.putln(
|
|
'PyObject *wrapper = PyObject_GetAttrString((PyObject *)&%s, "%s"); %s' % (
|
|
typeobj_cname,
|
|
func.name,
|
|
code.error_goto_if_null('wrapper', entry.pos)))
|
|
code.putln(
|
|
"if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {")
|
|
code.putln(
|
|
"%s = *((PyWrapperDescrObject *)wrapper)->d_base;" % (
|
|
func.wrapperbase_cname))
|
|
code.putln(
|
|
"%s.doc = %s;" % (func.wrapperbase_cname, func.doc_cname))
|
|
code.putln(
|
|
"((PyWrapperDescrObject *)wrapper)->d_base = &%s;" % (
|
|
func.wrapperbase_cname))
|
|
code.putln("}")
|
|
code.putln("}")
|
|
code.putln('#endif')
|
|
if preprocessor_guard:
|
|
code.putln('#endif')
|
|
if type.vtable_cname:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached('SetVTable', 'ImportExport.c'))
|
|
code.putln(
|
|
"if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %s" % (
|
|
typeobj_cname,
|
|
type.vtabptr_cname,
|
|
code.error_goto(entry.pos)))
|
|
if heap_type_bases:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached('MergeVTables', 'ImportExport.c'))
|
|
code.putln("if (__Pyx_MergeVtables(&%s) < 0) %s" % (
|
|
typeobj_cname,
|
|
code.error_goto(entry.pos)))
|
|
if not type.scope.is_internal and not type.scope.directives.get('internal'):
|
|
# scope.is_internal is set for types defined by
|
|
# Cython (such as closures), the 'internal'
|
|
# directive is set by users
|
|
code.putln(
|
|
'if (PyObject_SetAttr(%s, %s, (PyObject *)&%s) < 0) %s' % (
|
|
Naming.module_cname,
|
|
code.intern_identifier(scope.class_name),
|
|
typeobj_cname,
|
|
code.error_goto(entry.pos)))
|
|
weakref_entry = scope.lookup_here("__weakref__") if not scope.is_closure_class_scope else None
|
|
if weakref_entry:
|
|
if weakref_entry.type is py_object_type:
|
|
tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname
|
|
if type.typedef_flag:
|
|
objstruct = type.objstruct_cname
|
|
else:
|
|
objstruct = "struct %s" % type.objstruct_cname
|
|
code.putln("if (%s == 0) %s = offsetof(%s, %s);" % (
|
|
tp_weaklistoffset,
|
|
tp_weaklistoffset,
|
|
objstruct,
|
|
weakref_entry.cname))
|
|
else:
|
|
error(weakref_entry.pos, "__weakref__ slot must be of type 'object'")
|
|
if scope.lookup_here("__reduce_cython__") if not scope.is_closure_class_scope else None:
|
|
# Unfortunately, we cannot reliably detect whether a
|
|
# superclass defined __reduce__ at compile time, so we must
|
|
# do so at runtime.
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached('SetupReduce', 'ExtensionTypes.c'))
|
|
code.putln('if (__Pyx_setup_reduce((PyObject*)&%s) < 0) %s' % (
|
|
typeobj_cname,
|
|
code.error_goto(entry.pos)))
|
|
# Generate code to initialise the typeptr of an extension
|
|
# type defined in this module to point to its type object.
|
|
if type.typeobj_cname:
|
|
code.putln(
|
|
"%s = &%s;" % (
|
|
type.typeptr_cname, type.typeobj_cname))
|
|
|
|
def annotate(self, code):
|
|
if self.type_init_args:
|
|
self.type_init_args.annotate(code)
|
|
if self.body:
|
|
self.body.annotate(code)
|
|
|
|
|
|
class PropertyNode(StatNode):
|
|
# Definition of a property in an extension type.
|
|
#
|
|
# name string
|
|
# doc EncodedString or None Doc string
|
|
# entry Symtab.Entry
|
|
# body StatListNode
|
|
|
|
child_attrs = ["body"]
|
|
|
|
def analyse_declarations(self, env):
|
|
self.entry = env.declare_property(self.name, self.doc, self.pos)
|
|
self.entry.scope.directives = env.directives
|
|
self.body.analyse_declarations(self.entry.scope)
|
|
|
|
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 generate_execution_code(self, code):
|
|
pass
|
|
|
|
def annotate(self, code):
|
|
self.body.annotate(code)
|
|
|
|
|
|
class GlobalNode(StatNode):
|
|
# Global variable declaration.
|
|
#
|
|
# names [string]
|
|
|
|
child_attrs = []
|
|
|
|
def analyse_declarations(self, env):
|
|
for name in self.names:
|
|
env.declare_global(name, self.pos)
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
pass
|
|
|
|
|
|
class NonlocalNode(StatNode):
|
|
# Nonlocal variable declaration via the 'nonlocal' keyword.
|
|
#
|
|
# names [string]
|
|
|
|
child_attrs = []
|
|
|
|
def analyse_declarations(self, env):
|
|
for name in self.names:
|
|
env.declare_nonlocal(name, self.pos)
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
pass
|
|
|
|
|
|
class ExprStatNode(StatNode):
|
|
# Expression used as a statement.
|
|
#
|
|
# expr ExprNode
|
|
|
|
child_attrs = ["expr"]
|
|
|
|
def analyse_declarations(self, env):
|
|
from . import ExprNodes
|
|
expr = self.expr
|
|
if isinstance(expr, ExprNodes.GeneralCallNode):
|
|
func = expr.function.as_cython_attribute()
|
|
if func == u'declare':
|
|
args, kwds = expr.explicit_args_kwds()
|
|
if len(args):
|
|
error(expr.pos, "Variable names must be specified.")
|
|
for var, type_node in kwds.key_value_pairs:
|
|
type = type_node.analyse_as_type(env)
|
|
if type is None:
|
|
error(type_node.pos, "Unknown type")
|
|
else:
|
|
env.declare_var(var.value, type, var.pos, is_cdef=True)
|
|
self.__class__ = PassStatNode
|
|
elif getattr(expr, 'annotation', None) is not None:
|
|
if expr.is_name:
|
|
# non-code variable annotation, e.g. "name: type"
|
|
expr.declare_from_annotation(env)
|
|
self.__class__ = PassStatNode
|
|
elif expr.is_attribute or expr.is_subscript:
|
|
# unused expression with annotation, e.g. "a[0]: type" or "a.xyz : type"
|
|
self.__class__ = PassStatNode
|
|
|
|
def analyse_expressions(self, env):
|
|
self.expr.result_is_used = False # hint that .result() may safely be left empty
|
|
self.expr = self.expr.analyse_expressions(env)
|
|
# Repeat in case of node replacement.
|
|
self.expr.result_is_used = False # hint that .result() may safely be left empty
|
|
return self
|
|
|
|
def nogil_check(self, env):
|
|
if self.expr.type.is_pyobject and self.expr.is_temp:
|
|
self.gil_error()
|
|
|
|
gil_message = "Discarding owned Python object"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
self.expr.result_is_used = False # hint that .result() may safely be left empty
|
|
self.expr.generate_evaluation_code(code)
|
|
if not self.expr.is_temp and self.expr.result():
|
|
result = self.expr.result()
|
|
if not self.expr.type.is_void:
|
|
result = "(void)(%s)" % result
|
|
code.putln("%s;" % result)
|
|
self.expr.generate_disposal_code(code)
|
|
self.expr.free_temps(code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.expr.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.expr.annotate(code)
|
|
|
|
|
|
class AssignmentNode(StatNode):
|
|
# Abstract base class for assignment nodes.
|
|
#
|
|
# The analyse_expressions and generate_execution_code
|
|
# phases of assignments are split into two sub-phases
|
|
# each, to enable all the right hand sides of a
|
|
# parallel assignment to be evaluated before assigning
|
|
# to any of the left hand sides.
|
|
|
|
def analyse_expressions(self, env):
|
|
node = self.analyse_types(env)
|
|
if isinstance(node, AssignmentNode) and not isinstance(node, ParallelAssignmentNode):
|
|
if node.rhs.type.is_ptr and node.rhs.is_ephemeral():
|
|
error(self.pos, "Storing unsafe C derivative of temporary Python reference")
|
|
return node
|
|
|
|
# def analyse_expressions(self, env):
|
|
# self.analyse_expressions_1(env)
|
|
# self.analyse_expressions_2(env)
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
self.generate_rhs_evaluation_code(code)
|
|
self.generate_assignment_code(code)
|
|
|
|
|
|
class SingleAssignmentNode(AssignmentNode):
|
|
# The simplest case:
|
|
#
|
|
# a = b
|
|
#
|
|
# lhs ExprNode Left hand side
|
|
# rhs ExprNode Right hand side
|
|
# first bool Is this guaranteed the first assignment to lhs?
|
|
# is_overloaded_assignment bool Is this assignment done via an overloaded operator=
|
|
# exception_check
|
|
# exception_value
|
|
|
|
child_attrs = ["lhs", "rhs"]
|
|
first = False
|
|
is_overloaded_assignment = False
|
|
declaration_only = False
|
|
|
|
def analyse_declarations(self, env):
|
|
from . import ExprNodes
|
|
|
|
# handle declarations of the form x = cython.foo()
|
|
if isinstance(self.rhs, ExprNodes.CallNode):
|
|
func_name = self.rhs.function.as_cython_attribute()
|
|
if func_name:
|
|
args, kwds = self.rhs.explicit_args_kwds()
|
|
if func_name in ['declare', 'typedef']:
|
|
if len(args) > 2:
|
|
error(args[2].pos, "Invalid positional argument.")
|
|
return
|
|
if kwds is not None:
|
|
kwdict = kwds.compile_time_value(None)
|
|
if func_name == 'typedef' or 'visibility' not in kwdict:
|
|
error(kwds.pos, "Invalid keyword argument.")
|
|
return
|
|
visibility = kwdict['visibility']
|
|
else:
|
|
visibility = 'private'
|
|
type = args[0].analyse_as_type(env)
|
|
if type is None:
|
|
error(args[0].pos, "Unknown type")
|
|
return
|
|
lhs = self.lhs
|
|
if func_name == 'declare':
|
|
if isinstance(lhs, ExprNodes.NameNode):
|
|
vars = [(lhs.name, lhs.pos)]
|
|
elif isinstance(lhs, ExprNodes.TupleNode):
|
|
vars = [(var.name, var.pos) for var in lhs.args]
|
|
else:
|
|
error(lhs.pos, "Invalid declaration")
|
|
return
|
|
for var, pos in vars:
|
|
env.declare_var(var, type, pos, is_cdef=True, visibility=visibility)
|
|
if len(args) == 2:
|
|
# we have a value
|
|
self.rhs = args[1]
|
|
else:
|
|
self.declaration_only = True
|
|
else:
|
|
self.declaration_only = True
|
|
if not isinstance(lhs, ExprNodes.NameNode):
|
|
error(lhs.pos, "Invalid declaration.")
|
|
env.declare_typedef(lhs.name, type, self.pos, visibility='private')
|
|
|
|
elif func_name in ['struct', 'union']:
|
|
self.declaration_only = True
|
|
if len(args) > 0 or kwds is None:
|
|
error(self.rhs.pos, "Struct or union members must be given by name.")
|
|
return
|
|
members = []
|
|
for member, type_node in kwds.key_value_pairs:
|
|
type = type_node.analyse_as_type(env)
|
|
if type is None:
|
|
error(type_node.pos, "Unknown type")
|
|
else:
|
|
members.append((member.value, type, member.pos))
|
|
if len(members) < len(kwds.key_value_pairs):
|
|
return
|
|
if not isinstance(self.lhs, ExprNodes.NameNode):
|
|
error(self.lhs.pos, "Invalid declaration.")
|
|
name = self.lhs.name
|
|
scope = StructOrUnionScope(name)
|
|
env.declare_struct_or_union(name, func_name, scope, False, self.rhs.pos)
|
|
for member, type, pos in members:
|
|
scope.declare_var(member, type, pos)
|
|
|
|
elif func_name == 'fused_type':
|
|
# dtype = cython.fused_type(...)
|
|
self.declaration_only = True
|
|
if kwds:
|
|
error(self.rhs.function.pos,
|
|
"fused_type does not take keyword arguments")
|
|
|
|
fusednode = FusedTypeNode(self.rhs.pos,
|
|
name=self.lhs.name, types=args)
|
|
fusednode.analyse_declarations(env)
|
|
|
|
if self.declaration_only:
|
|
return
|
|
else:
|
|
self.lhs.analyse_target_declaration(env)
|
|
|
|
def analyse_types(self, env, use_temp=0):
|
|
from . import ExprNodes
|
|
|
|
self.rhs = self.rhs.analyse_types(env)
|
|
|
|
unrolled_assignment = self.unroll_rhs(env)
|
|
if unrolled_assignment:
|
|
return unrolled_assignment
|
|
|
|
self.lhs = self.lhs.analyse_target_types(env)
|
|
self.lhs.gil_assignment_check(env)
|
|
unrolled_assignment = self.unroll_lhs(env)
|
|
if unrolled_assignment:
|
|
return unrolled_assignment
|
|
|
|
if isinstance(self.lhs, ExprNodes.MemoryViewIndexNode):
|
|
self.lhs.analyse_broadcast_operation(self.rhs)
|
|
self.lhs = self.lhs.analyse_as_memview_scalar_assignment(self.rhs)
|
|
elif self.lhs.type.is_array:
|
|
if not isinstance(self.lhs, ExprNodes.SliceIndexNode):
|
|
# cannot assign to C array, only to its full slice
|
|
self.lhs = ExprNodes.SliceIndexNode(self.lhs.pos, base=self.lhs, start=None, stop=None)
|
|
self.lhs = self.lhs.analyse_target_types(env)
|
|
|
|
if self.lhs.type.is_cpp_class:
|
|
op = env.lookup_operator_for_types(self.pos, '=', [self.lhs.type, self.rhs.type])
|
|
if op:
|
|
rhs = self.rhs
|
|
self.is_overloaded_assignment = True
|
|
self.exception_check = op.type.exception_check
|
|
self.exception_value = op.type.exception_value
|
|
if self.exception_check == '+' and self.exception_value is None:
|
|
env.use_utility_code(UtilityCode.load_cached("CppExceptionConversion", "CppSupport.cpp"))
|
|
else:
|
|
rhs = self.rhs.coerce_to(self.lhs.type, env)
|
|
else:
|
|
rhs = self.rhs.coerce_to(self.lhs.type, env)
|
|
|
|
if use_temp or rhs.is_attribute or (
|
|
not rhs.is_name and not rhs.is_literal and
|
|
rhs.type.is_pyobject):
|
|
# things like (cdef) attribute access are not safe (traverses pointers)
|
|
rhs = rhs.coerce_to_temp(env)
|
|
elif rhs.type.is_pyobject:
|
|
rhs = rhs.coerce_to_simple(env)
|
|
self.rhs = rhs
|
|
return self
|
|
|
|
def unroll(self, node, target_size, env):
|
|
from . import ExprNodes, UtilNodes
|
|
|
|
base = node
|
|
start_node = stop_node = step_node = check_node = None
|
|
|
|
if node.type.is_ctuple:
|
|
slice_size = node.type.size
|
|
|
|
elif node.type.is_ptr or node.type.is_array:
|
|
while isinstance(node, ExprNodes.SliceIndexNode) and not (node.start or node.stop):
|
|
base = node = node.base
|
|
if isinstance(node, ExprNodes.SliceIndexNode):
|
|
base = node.base
|
|
start_node = node.start
|
|
if start_node:
|
|
start_node = start_node.coerce_to(PyrexTypes.c_py_ssize_t_type, env)
|
|
stop_node = node.stop
|
|
if stop_node:
|
|
stop_node = stop_node.coerce_to(PyrexTypes.c_py_ssize_t_type, env)
|
|
else:
|
|
if node.type.is_array and node.type.size:
|
|
stop_node = ExprNodes.IntNode(
|
|
self.pos, value=str(node.type.size),
|
|
constant_result=(node.type.size if isinstance(node.type.size, _py_int_types)
|
|
else ExprNodes.constant_value_not_set))
|
|
else:
|
|
error(self.pos, "C array iteration requires known end index")
|
|
return
|
|
step_node = None #node.step
|
|
if step_node:
|
|
step_node = step_node.coerce_to(PyrexTypes.c_py_ssize_t_type, env)
|
|
|
|
# TODO: Factor out SliceIndexNode.generate_slice_guard_code() for use here.
|
|
def get_const(node, none_value):
|
|
if node is None:
|
|
return none_value
|
|
elif node.has_constant_result():
|
|
return node.constant_result
|
|
else:
|
|
raise ValueError("Not a constant.")
|
|
|
|
try:
|
|
slice_size = (get_const(stop_node, None) - get_const(start_node, 0)) / get_const(step_node, 1)
|
|
except ValueError:
|
|
error(self.pos, "C array assignment currently requires known endpoints")
|
|
return
|
|
|
|
elif node.type.is_array:
|
|
slice_size = node.type.size
|
|
if not isinstance(slice_size, _py_int_types):
|
|
return # might still work when coercing to Python
|
|
else:
|
|
return
|
|
|
|
else:
|
|
return
|
|
|
|
if slice_size != target_size:
|
|
error(self.pos, "Assignment to/from slice of wrong length, expected %s, got %s" % (
|
|
slice_size, target_size))
|
|
return
|
|
|
|
items = []
|
|
base = UtilNodes.LetRefNode(base)
|
|
refs = [base]
|
|
if start_node and not start_node.is_literal:
|
|
start_node = UtilNodes.LetRefNode(start_node)
|
|
refs.append(start_node)
|
|
if stop_node and not stop_node.is_literal:
|
|
stop_node = UtilNodes.LetRefNode(stop_node)
|
|
refs.append(stop_node)
|
|
if step_node and not step_node.is_literal:
|
|
step_node = UtilNodes.LetRefNode(step_node)
|
|
refs.append(step_node)
|
|
|
|
for ix in range(target_size):
|
|
ix_node = ExprNodes.IntNode(self.pos, value=str(ix), constant_result=ix, type=PyrexTypes.c_py_ssize_t_type)
|
|
if step_node is not None:
|
|
if step_node.has_constant_result():
|
|
step_value = ix_node.constant_result * step_node.constant_result
|
|
ix_node = ExprNodes.IntNode(self.pos, value=str(step_value), constant_result=step_value)
|
|
else:
|
|
ix_node = ExprNodes.MulNode(self.pos, operator='*', operand1=step_node, operand2=ix_node)
|
|
if start_node is not None:
|
|
if start_node.has_constant_result() and ix_node.has_constant_result():
|
|
index_value = ix_node.constant_result + start_node.constant_result
|
|
ix_node = ExprNodes.IntNode(self.pos, value=str(index_value), constant_result=index_value)
|
|
else:
|
|
ix_node = ExprNodes.AddNode(
|
|
self.pos, operator='+', operand1=start_node, operand2=ix_node)
|
|
items.append(ExprNodes.IndexNode(self.pos, base=base, index=ix_node.analyse_types(env)))
|
|
return check_node, refs, items
|
|
|
|
def unroll_assignments(self, refs, check_node, lhs_list, rhs_list, env):
|
|
from . import UtilNodes
|
|
assignments = []
|
|
for lhs, rhs in zip(lhs_list, rhs_list):
|
|
assignments.append(SingleAssignmentNode(self.pos, lhs=lhs, rhs=rhs, first=self.first))
|
|
node = ParallelAssignmentNode(pos=self.pos, stats=assignments).analyse_expressions(env)
|
|
if check_node:
|
|
node = StatListNode(pos=self.pos, stats=[check_node, node])
|
|
for ref in refs[::-1]:
|
|
node = UtilNodes.LetNode(ref, node)
|
|
return node
|
|
|
|
def unroll_rhs(self, env):
|
|
from . import ExprNodes
|
|
if not isinstance(self.lhs, ExprNodes.TupleNode):
|
|
return
|
|
if any(arg.is_starred for arg in self.lhs.args):
|
|
return
|
|
|
|
unrolled = self.unroll(self.rhs, len(self.lhs.args), env)
|
|
if not unrolled:
|
|
return
|
|
check_node, refs, rhs = unrolled
|
|
return self.unroll_assignments(refs, check_node, self.lhs.args, rhs, env)
|
|
|
|
def unroll_lhs(self, env):
|
|
if self.lhs.type.is_ctuple:
|
|
# Handled directly.
|
|
return
|
|
from . import ExprNodes
|
|
if not isinstance(self.rhs, ExprNodes.TupleNode):
|
|
return
|
|
|
|
unrolled = self.unroll(self.lhs, len(self.rhs.args), env)
|
|
if not unrolled:
|
|
return
|
|
check_node, refs, lhs = unrolled
|
|
return self.unroll_assignments(refs, check_node, lhs, self.rhs.args, env)
|
|
|
|
def generate_rhs_evaluation_code(self, code):
|
|
self.rhs.generate_evaluation_code(code)
|
|
|
|
def generate_assignment_code(self, code, overloaded_assignment=False):
|
|
if self.is_overloaded_assignment:
|
|
self.lhs.generate_assignment_code(
|
|
self.rhs,
|
|
code,
|
|
overloaded_assignment=self.is_overloaded_assignment,
|
|
exception_check=self.exception_check,
|
|
exception_value=self.exception_value)
|
|
else:
|
|
self.lhs.generate_assignment_code(self.rhs, code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.rhs.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.lhs.annotate(code)
|
|
self.rhs.annotate(code)
|
|
|
|
|
|
class CascadedAssignmentNode(AssignmentNode):
|
|
# An assignment with multiple left hand sides:
|
|
#
|
|
# a = b = c
|
|
#
|
|
# lhs_list [ExprNode] Left hand sides
|
|
# rhs ExprNode Right hand sides
|
|
#
|
|
# Used internally:
|
|
#
|
|
# coerced_values [ExprNode] RHS coerced to all distinct LHS types
|
|
# cloned_values [ExprNode] cloned RHS value for each LHS
|
|
# assignment_overloads [Bool] If each assignment uses a C++ operator=
|
|
|
|
child_attrs = ["lhs_list", "rhs", "coerced_values", "cloned_values"]
|
|
cloned_values = None
|
|
coerced_values = None
|
|
assignment_overloads = None
|
|
|
|
def analyse_declarations(self, env):
|
|
for lhs in self.lhs_list:
|
|
lhs.analyse_target_declaration(env)
|
|
|
|
def analyse_types(self, env, use_temp=0):
|
|
from .ExprNodes import CloneNode, ProxyNode
|
|
|
|
# collect distinct types used on the LHS
|
|
lhs_types = set()
|
|
for i, lhs in enumerate(self.lhs_list):
|
|
lhs = self.lhs_list[i] = lhs.analyse_target_types(env)
|
|
lhs.gil_assignment_check(env)
|
|
lhs_types.add(lhs.type)
|
|
|
|
rhs = self.rhs.analyse_types(env)
|
|
# common special case: only one type needed on the LHS => coerce only once
|
|
if len(lhs_types) == 1:
|
|
# Avoid coercion for overloaded assignment operators.
|
|
if next(iter(lhs_types)).is_cpp_class:
|
|
op = env.lookup_operator('=', [lhs, self.rhs])
|
|
if not op:
|
|
rhs = rhs.coerce_to(lhs_types.pop(), env)
|
|
else:
|
|
rhs = rhs.coerce_to(lhs_types.pop(), env)
|
|
|
|
if not rhs.is_name and not rhs.is_literal and (
|
|
use_temp or rhs.is_attribute or rhs.type.is_pyobject):
|
|
rhs = rhs.coerce_to_temp(env)
|
|
else:
|
|
rhs = rhs.coerce_to_simple(env)
|
|
self.rhs = ProxyNode(rhs) if rhs.is_temp else rhs
|
|
|
|
# clone RHS and coerce it to all distinct LHS types
|
|
self.coerced_values = []
|
|
coerced_values = {}
|
|
self.assignment_overloads = []
|
|
for lhs in self.lhs_list:
|
|
overloaded = lhs.type.is_cpp_class and env.lookup_operator('=', [lhs, self.rhs])
|
|
self.assignment_overloads.append(overloaded)
|
|
if lhs.type not in coerced_values and lhs.type != rhs.type:
|
|
rhs = CloneNode(self.rhs)
|
|
if not overloaded:
|
|
rhs = rhs.coerce_to(lhs.type, env)
|
|
self.coerced_values.append(rhs)
|
|
coerced_values[lhs.type] = rhs
|
|
|
|
# clone coerced values for all LHS assignments
|
|
self.cloned_values = []
|
|
for lhs in self.lhs_list:
|
|
rhs = coerced_values.get(lhs.type, self.rhs)
|
|
self.cloned_values.append(CloneNode(rhs))
|
|
return self
|
|
|
|
def generate_rhs_evaluation_code(self, code):
|
|
self.rhs.generate_evaluation_code(code)
|
|
|
|
def generate_assignment_code(self, code, overloaded_assignment=False):
|
|
# prepare all coercions
|
|
for rhs in self.coerced_values:
|
|
rhs.generate_evaluation_code(code)
|
|
# assign clones to LHS
|
|
for lhs, rhs, overload in zip(self.lhs_list, self.cloned_values, self.assignment_overloads):
|
|
rhs.generate_evaluation_code(code)
|
|
lhs.generate_assignment_code(rhs, code, overloaded_assignment=overload)
|
|
# dispose of coerced values and original RHS
|
|
for rhs_value in self.coerced_values:
|
|
rhs_value.generate_disposal_code(code)
|
|
rhs_value.free_temps(code)
|
|
self.rhs.generate_disposal_code(code)
|
|
self.rhs.free_temps(code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.rhs.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
for rhs in self.coerced_values:
|
|
rhs.annotate(code)
|
|
for lhs, rhs in zip(self.lhs_list, self.cloned_values):
|
|
lhs.annotate(code)
|
|
rhs.annotate(code)
|
|
self.rhs.annotate(code)
|
|
|
|
|
|
class ParallelAssignmentNode(AssignmentNode):
|
|
# A combined packing/unpacking assignment:
|
|
#
|
|
# a, b, c = d, e, f
|
|
#
|
|
# This has been rearranged by the parser into
|
|
#
|
|
# a = d ; b = e ; c = f
|
|
#
|
|
# but we must evaluate all the right hand sides
|
|
# before assigning to any of the left hand sides.
|
|
#
|
|
# stats [AssignmentNode] The constituent assignments
|
|
|
|
child_attrs = ["stats"]
|
|
|
|
def analyse_declarations(self, env):
|
|
for stat in self.stats:
|
|
stat.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.stats = [stat.analyse_types(env, use_temp=1)
|
|
for stat in self.stats]
|
|
return self
|
|
|
|
# def analyse_expressions(self, env):
|
|
# for stat in self.stats:
|
|
# stat.analyse_expressions_1(env, use_temp=1)
|
|
# for stat in self.stats:
|
|
# stat.analyse_expressions_2(env)
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
for stat in self.stats:
|
|
stat.generate_rhs_evaluation_code(code)
|
|
for stat in self.stats:
|
|
stat.generate_assignment_code(code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
for stat in self.stats:
|
|
stat.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
for stat in self.stats:
|
|
stat.annotate(code)
|
|
|
|
|
|
class InPlaceAssignmentNode(AssignmentNode):
|
|
# An in place arithmetic operand:
|
|
#
|
|
# a += b
|
|
# a -= b
|
|
# ...
|
|
#
|
|
# lhs ExprNode Left hand side
|
|
# rhs ExprNode Right hand side
|
|
# operator char one of "+-*/%^&|"
|
|
#
|
|
# This code is a bit tricky because in order to obey Python
|
|
# semantics the sub-expressions (e.g. indices) of the lhs must
|
|
# not be evaluated twice. So we must re-use the values calculated
|
|
# in evaluation phase for the assignment phase as well.
|
|
# Fortunately, the type of the lhs node is fairly constrained
|
|
# (it must be a NameNode, AttributeNode, or IndexNode).
|
|
|
|
child_attrs = ["lhs", "rhs"]
|
|
|
|
def analyse_declarations(self, env):
|
|
self.lhs.analyse_target_declaration(env)
|
|
|
|
def analyse_types(self, env):
|
|
self.rhs = self.rhs.analyse_types(env)
|
|
self.lhs = self.lhs.analyse_target_types(env)
|
|
|
|
# When assigning to a fully indexed buffer or memoryview, coerce the rhs
|
|
if self.lhs.is_memview_index or self.lhs.is_buffer_access:
|
|
self.rhs = self.rhs.coerce_to(self.lhs.type, env)
|
|
elif self.lhs.type.is_string and self.operator in '+-':
|
|
# use pointer arithmetic for char* LHS instead of string concat
|
|
self.rhs = self.rhs.coerce_to(PyrexTypes.c_py_ssize_t_type, env)
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
lhs, rhs = self.lhs, self.rhs
|
|
rhs.generate_evaluation_code(code)
|
|
lhs.generate_subexpr_evaluation_code(code)
|
|
c_op = self.operator
|
|
if c_op == "//":
|
|
c_op = "/"
|
|
elif c_op == "**":
|
|
error(self.pos, "No C inplace power operator")
|
|
if lhs.is_buffer_access or lhs.is_memview_index:
|
|
if lhs.type.is_pyobject:
|
|
error(self.pos, "In-place operators not allowed on object buffers in this release.")
|
|
if c_op in ('/', '%') and lhs.type.is_int and not code.globalstate.directives['cdivision']:
|
|
error(self.pos, "In-place non-c divide operators not allowed on int buffers.")
|
|
lhs.generate_buffer_setitem_code(rhs, code, c_op)
|
|
elif lhs.is_memview_slice:
|
|
error(self.pos, "Inplace operators not supported on memoryview slices")
|
|
else:
|
|
# C++
|
|
# TODO: make sure overload is declared
|
|
code.putln("%s %s= %s;" % (lhs.result(), c_op, rhs.result()))
|
|
lhs.generate_subexpr_disposal_code(code)
|
|
lhs.free_subexpr_temps(code)
|
|
rhs.generate_disposal_code(code)
|
|
rhs.free_temps(code)
|
|
|
|
def annotate(self, code):
|
|
self.lhs.annotate(code)
|
|
self.rhs.annotate(code)
|
|
|
|
def create_binop_node(self):
|
|
from . import ExprNodes
|
|
return ExprNodes.binop_node(self.pos, self.operator, self.lhs, self.rhs)
|
|
|
|
|
|
class PrintStatNode(StatNode):
|
|
# print statement
|
|
#
|
|
# arg_tuple TupleNode
|
|
# stream ExprNode or None (stdout)
|
|
# append_newline boolean
|
|
|
|
child_attrs = ["arg_tuple", "stream"]
|
|
|
|
def analyse_expressions(self, env):
|
|
if self.stream:
|
|
stream = self.stream.analyse_expressions(env)
|
|
self.stream = stream.coerce_to_pyobject(env)
|
|
arg_tuple = self.arg_tuple.analyse_expressions(env)
|
|
self.arg_tuple = arg_tuple.coerce_to_pyobject(env)
|
|
env.use_utility_code(printing_utility_code)
|
|
if len(self.arg_tuple.args) == 1 and self.append_newline:
|
|
env.use_utility_code(printing_one_utility_code)
|
|
return self
|
|
|
|
nogil_check = Node.gil_error
|
|
gil_message = "Python print statement"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
if self.stream:
|
|
self.stream.generate_evaluation_code(code)
|
|
stream_result = self.stream.py_result()
|
|
else:
|
|
stream_result = '0'
|
|
if len(self.arg_tuple.args) == 1 and self.append_newline:
|
|
arg = self.arg_tuple.args[0]
|
|
arg.generate_evaluation_code(code)
|
|
|
|
code.putln(
|
|
"if (__Pyx_PrintOne(%s, %s) < 0) %s" % (
|
|
stream_result,
|
|
arg.py_result(),
|
|
code.error_goto(self.pos)))
|
|
arg.generate_disposal_code(code)
|
|
arg.free_temps(code)
|
|
else:
|
|
self.arg_tuple.generate_evaluation_code(code)
|
|
code.putln(
|
|
"if (__Pyx_Print(%s, %s, %d) < 0) %s" % (
|
|
stream_result,
|
|
self.arg_tuple.py_result(),
|
|
self.append_newline,
|
|
code.error_goto(self.pos)))
|
|
self.arg_tuple.generate_disposal_code(code)
|
|
self.arg_tuple.free_temps(code)
|
|
|
|
if self.stream:
|
|
self.stream.generate_disposal_code(code)
|
|
self.stream.free_temps(code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
if self.stream:
|
|
self.stream.generate_function_definitions(env, code)
|
|
self.arg_tuple.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
if self.stream:
|
|
self.stream.annotate(code)
|
|
self.arg_tuple.annotate(code)
|
|
|
|
|
|
class ExecStatNode(StatNode):
|
|
# exec statement
|
|
#
|
|
# args [ExprNode]
|
|
|
|
child_attrs = ["args"]
|
|
|
|
def analyse_expressions(self, env):
|
|
for i, arg in enumerate(self.args):
|
|
arg = arg.analyse_expressions(env)
|
|
arg = arg.coerce_to_pyobject(env)
|
|
self.args[i] = arg
|
|
env.use_utility_code(Builtin.pyexec_utility_code)
|
|
return self
|
|
|
|
nogil_check = Node.gil_error
|
|
gil_message = "Python exec statement"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
args = []
|
|
for arg in self.args:
|
|
arg.generate_evaluation_code(code)
|
|
args.append(arg.py_result())
|
|
args = tuple(args + ['0', '0'][:3-len(args)])
|
|
temp_result = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
|
|
code.putln("%s = __Pyx_PyExec3(%s, %s, %s);" % ((temp_result,) + args))
|
|
for arg in self.args:
|
|
arg.generate_disposal_code(code)
|
|
arg.free_temps(code)
|
|
code.putln(
|
|
code.error_goto_if_null(temp_result, self.pos))
|
|
code.put_gotref(temp_result)
|
|
code.put_decref_clear(temp_result, py_object_type)
|
|
code.funcstate.release_temp(temp_result)
|
|
|
|
def annotate(self, code):
|
|
for arg in self.args:
|
|
arg.annotate(code)
|
|
|
|
|
|
class DelStatNode(StatNode):
|
|
# del statement
|
|
#
|
|
# args [ExprNode]
|
|
|
|
child_attrs = ["args"]
|
|
ignore_nonexisting = False
|
|
|
|
def analyse_declarations(self, env):
|
|
for arg in self.args:
|
|
arg.analyse_target_declaration(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
for i, arg in enumerate(self.args):
|
|
arg = self.args[i] = arg.analyse_target_expression(env, None)
|
|
if arg.type.is_pyobject or (arg.is_name and arg.type.is_memoryviewslice):
|
|
if arg.is_name and arg.entry.is_cglobal:
|
|
error(arg.pos, "Deletion of global C variable")
|
|
elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
|
|
self.cpp_check(env)
|
|
elif arg.type.is_cpp_class:
|
|
error(arg.pos, "Deletion of non-heap C++ object")
|
|
elif arg.is_subscript and arg.base.type is Builtin.bytearray_type:
|
|
pass # del ba[i]
|
|
else:
|
|
error(arg.pos, "Deletion of non-Python, non-C++ object")
|
|
#arg.release_target_temp(env)
|
|
return self
|
|
|
|
def nogil_check(self, env):
|
|
for arg in self.args:
|
|
if arg.type.is_pyobject:
|
|
self.gil_error()
|
|
|
|
gil_message = "Deleting Python object"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
for arg in self.args:
|
|
if (arg.type.is_pyobject or
|
|
arg.type.is_memoryviewslice or
|
|
arg.is_subscript and arg.base.type is Builtin.bytearray_type):
|
|
arg.generate_deletion_code(
|
|
code, ignore_nonexisting=self.ignore_nonexisting)
|
|
elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
|
|
arg.generate_evaluation_code(code)
|
|
code.putln("delete %s;" % arg.result())
|
|
arg.generate_disposal_code(code)
|
|
arg.free_temps(code)
|
|
# else error reported earlier
|
|
|
|
def annotate(self, code):
|
|
for arg in self.args:
|
|
arg.annotate(code)
|
|
|
|
|
|
class PassStatNode(StatNode):
|
|
# pass statement
|
|
|
|
child_attrs = []
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
pass
|
|
|
|
|
|
class IndirectionNode(StatListNode):
|
|
"""
|
|
This adds an indirection so that the node can be shared and a subtree can
|
|
be removed at any time by clearing self.stats.
|
|
"""
|
|
|
|
def __init__(self, stats):
|
|
super(IndirectionNode, self).__init__(stats[0].pos, stats=stats)
|
|
|
|
|
|
class BreakStatNode(StatNode):
|
|
|
|
child_attrs = []
|
|
is_terminator = True
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
if not code.break_label:
|
|
error(self.pos, "break statement not inside loop")
|
|
else:
|
|
code.put_goto(code.break_label)
|
|
|
|
|
|
class ContinueStatNode(StatNode):
|
|
|
|
child_attrs = []
|
|
is_terminator = True
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
if not code.continue_label:
|
|
error(self.pos, "continue statement not inside loop")
|
|
return
|
|
code.mark_pos(self.pos)
|
|
code.put_goto(code.continue_label)
|
|
|
|
|
|
class ReturnStatNode(StatNode):
|
|
# return statement
|
|
#
|
|
# value ExprNode or None
|
|
# return_type PyrexType
|
|
# in_generator return inside of generator => raise StopIteration
|
|
# in_async_gen return inside of async generator
|
|
|
|
child_attrs = ["value"]
|
|
is_terminator = True
|
|
in_generator = False
|
|
in_async_gen = False
|
|
|
|
# Whether we are in a parallel section
|
|
in_parallel = False
|
|
|
|
def analyse_expressions(self, env):
|
|
return_type = env.return_type
|
|
self.return_type = return_type
|
|
if not return_type:
|
|
error(self.pos, "Return not inside a function body")
|
|
return self
|
|
if self.value:
|
|
if self.in_async_gen:
|
|
error(self.pos, "Return with value in async generator")
|
|
self.value = self.value.analyse_types(env)
|
|
if return_type.is_void or return_type.is_returncode:
|
|
error(self.value.pos, "Return with value in void function")
|
|
else:
|
|
self.value = self.value.coerce_to(env.return_type, env)
|
|
else:
|
|
if (not return_type.is_void
|
|
and not return_type.is_pyobject
|
|
and not return_type.is_returncode):
|
|
error(self.pos, "Return value required")
|
|
return self
|
|
|
|
def nogil_check(self, env):
|
|
if self.return_type.is_pyobject:
|
|
self.gil_error()
|
|
|
|
gil_message = "Returning Python object"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
if not self.return_type:
|
|
# error reported earlier
|
|
return
|
|
|
|
value = self.value
|
|
if self.return_type.is_pyobject:
|
|
code.put_xdecref(Naming.retval_cname, self.return_type)
|
|
if value and value.is_none:
|
|
# Use specialised default handling for "return None".
|
|
value = None
|
|
|
|
if value:
|
|
value.generate_evaluation_code(code)
|
|
if self.return_type.is_memoryviewslice:
|
|
from . import MemoryView
|
|
MemoryView.put_acquire_memoryviewslice(
|
|
lhs_cname=Naming.retval_cname,
|
|
lhs_type=self.return_type,
|
|
lhs_pos=value.pos,
|
|
rhs=value,
|
|
code=code,
|
|
have_gil=self.in_nogil_context)
|
|
value.generate_post_assignment_code(code)
|
|
elif self.in_generator:
|
|
# return value == raise StopIteration(value), but uncatchable
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("ReturnWithStopIteration", "Coroutine.c"))
|
|
code.putln("%s = NULL; __Pyx_ReturnWithStopIteration(%s);" % (
|
|
Naming.retval_cname,
|
|
value.py_result()))
|
|
value.generate_disposal_code(code)
|
|
else:
|
|
value.make_owned_reference(code)
|
|
code.putln("%s = %s;" % (
|
|
Naming.retval_cname,
|
|
value.result_as(self.return_type)))
|
|
value.generate_post_assignment_code(code)
|
|
value.free_temps(code)
|
|
else:
|
|
if self.return_type.is_pyobject:
|
|
if self.in_generator:
|
|
if self.in_async_gen:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("StopAsyncIteration", "Coroutine.c"))
|
|
code.put("PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); ")
|
|
code.putln("%s = NULL;" % Naming.retval_cname)
|
|
else:
|
|
code.put_init_to_py_none(Naming.retval_cname, self.return_type)
|
|
elif self.return_type.is_returncode:
|
|
self.put_return(code, self.return_type.default_value)
|
|
|
|
for cname, type in code.funcstate.temps_holding_reference():
|
|
code.put_decref_clear(cname, type)
|
|
|
|
code.put_goto(code.return_label)
|
|
|
|
def put_return(self, code, value):
|
|
if self.in_parallel:
|
|
code.putln_openmp("#pragma omp critical(__pyx_returning)")
|
|
code.putln("%s = %s;" % (Naming.retval_cname, value))
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
if self.value is not None:
|
|
self.value.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
if self.value:
|
|
self.value.annotate(code)
|
|
|
|
|
|
class RaiseStatNode(StatNode):
|
|
# raise statement
|
|
#
|
|
# exc_type ExprNode or None
|
|
# exc_value ExprNode or None
|
|
# exc_tb ExprNode or None
|
|
# cause ExprNode or None
|
|
|
|
child_attrs = ["exc_type", "exc_value", "exc_tb", "cause"]
|
|
is_terminator = True
|
|
|
|
def analyse_expressions(self, env):
|
|
if self.exc_type:
|
|
exc_type = self.exc_type.analyse_types(env)
|
|
self.exc_type = exc_type.coerce_to_pyobject(env)
|
|
if self.exc_value:
|
|
exc_value = self.exc_value.analyse_types(env)
|
|
self.exc_value = exc_value.coerce_to_pyobject(env)
|
|
if self.exc_tb:
|
|
exc_tb = self.exc_tb.analyse_types(env)
|
|
self.exc_tb = exc_tb.coerce_to_pyobject(env)
|
|
if self.cause:
|
|
cause = self.cause.analyse_types(env)
|
|
self.cause = cause.coerce_to_pyobject(env)
|
|
# special cases for builtin exceptions
|
|
self.builtin_exc_name = None
|
|
if self.exc_type and not self.exc_value and not self.exc_tb:
|
|
exc = self.exc_type
|
|
from . import ExprNodes
|
|
if (isinstance(exc, ExprNodes.SimpleCallNode) and
|
|
not (exc.args or (exc.arg_tuple is not None and exc.arg_tuple.args))):
|
|
exc = exc.function # extract the exception type
|
|
if exc.is_name and exc.entry.is_builtin:
|
|
self.builtin_exc_name = exc.name
|
|
if self.builtin_exc_name == 'MemoryError':
|
|
self.exc_type = None # has a separate implementation
|
|
return self
|
|
|
|
nogil_check = Node.gil_error
|
|
gil_message = "Raising exception"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
if self.builtin_exc_name == 'MemoryError':
|
|
code.putln('PyErr_NoMemory(); %s' % code.error_goto(self.pos))
|
|
return
|
|
|
|
if self.exc_type:
|
|
self.exc_type.generate_evaluation_code(code)
|
|
type_code = self.exc_type.py_result()
|
|
if self.exc_type.is_name:
|
|
code.globalstate.use_entry_utility_code(self.exc_type.entry)
|
|
else:
|
|
type_code = "0"
|
|
if self.exc_value:
|
|
self.exc_value.generate_evaluation_code(code)
|
|
value_code = self.exc_value.py_result()
|
|
else:
|
|
value_code = "0"
|
|
if self.exc_tb:
|
|
self.exc_tb.generate_evaluation_code(code)
|
|
tb_code = self.exc_tb.py_result()
|
|
else:
|
|
tb_code = "0"
|
|
if self.cause:
|
|
self.cause.generate_evaluation_code(code)
|
|
cause_code = self.cause.py_result()
|
|
else:
|
|
cause_code = "0"
|
|
code.globalstate.use_utility_code(raise_utility_code)
|
|
code.putln(
|
|
"__Pyx_Raise(%s, %s, %s, %s);" % (
|
|
type_code,
|
|
value_code,
|
|
tb_code,
|
|
cause_code))
|
|
for obj in (self.exc_type, self.exc_value, self.exc_tb, self.cause):
|
|
if obj:
|
|
obj.generate_disposal_code(code)
|
|
obj.free_temps(code)
|
|
code.putln(
|
|
code.error_goto(self.pos))
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
if self.exc_type is not None:
|
|
self.exc_type.generate_function_definitions(env, code)
|
|
if self.exc_value is not None:
|
|
self.exc_value.generate_function_definitions(env, code)
|
|
if self.exc_tb is not None:
|
|
self.exc_tb.generate_function_definitions(env, code)
|
|
if self.cause is not None:
|
|
self.cause.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
if self.exc_type:
|
|
self.exc_type.annotate(code)
|
|
if self.exc_value:
|
|
self.exc_value.annotate(code)
|
|
if self.exc_tb:
|
|
self.exc_tb.annotate(code)
|
|
if self.cause:
|
|
self.cause.annotate(code)
|
|
|
|
|
|
class ReraiseStatNode(StatNode):
|
|
|
|
child_attrs = []
|
|
is_terminator = True
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
nogil_check = Node.gil_error
|
|
gil_message = "Raising exception"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
vars = code.funcstate.exc_vars
|
|
if vars:
|
|
code.globalstate.use_utility_code(restore_exception_utility_code)
|
|
code.put_giveref(vars[0])
|
|
code.put_giveref(vars[1])
|
|
# fresh exceptions may not have a traceback yet (-> finally!)
|
|
code.put_xgiveref(vars[2])
|
|
code.putln("__Pyx_ErrRestoreWithState(%s, %s, %s);" % tuple(vars))
|
|
for varname in vars:
|
|
code.put("%s = 0; " % varname)
|
|
code.putln()
|
|
code.putln(code.error_goto(self.pos))
|
|
else:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("ReRaiseException", "Exceptions.c"))
|
|
code.putln("__Pyx_ReraiseException(); %s" % code.error_goto(self.pos))
|
|
|
|
class AssertStatNode(StatNode):
|
|
# assert statement
|
|
#
|
|
# cond ExprNode
|
|
# value ExprNode or None
|
|
|
|
child_attrs = ["cond", "value"]
|
|
|
|
def analyse_expressions(self, env):
|
|
self.cond = self.cond.analyse_boolean_expression(env)
|
|
if self.value:
|
|
value = self.value.analyse_types(env)
|
|
if value.type is Builtin.tuple_type or not value.type.is_builtin_type:
|
|
# prevent tuple values from being interpreted as argument value tuples
|
|
from .ExprNodes import TupleNode
|
|
value = TupleNode(value.pos, args=[value], slow=True)
|
|
self.value = value.analyse_types(env, skip_children=True).coerce_to_pyobject(env)
|
|
else:
|
|
self.value = value.coerce_to_pyobject(env)
|
|
return self
|
|
|
|
nogil_check = Node.gil_error
|
|
gil_message = "Raising exception"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.putln("#ifndef CYTHON_WITHOUT_ASSERTIONS")
|
|
code.putln("if (unlikely(!Py_OptimizeFlag)) {")
|
|
code.mark_pos(self.pos)
|
|
self.cond.generate_evaluation_code(code)
|
|
code.putln(
|
|
"if (unlikely(!%s)) {" % self.cond.result())
|
|
if self.value:
|
|
self.value.generate_evaluation_code(code)
|
|
code.putln(
|
|
"PyErr_SetObject(PyExc_AssertionError, %s);" % self.value.py_result())
|
|
self.value.generate_disposal_code(code)
|
|
self.value.free_temps(code)
|
|
else:
|
|
code.putln(
|
|
"PyErr_SetNone(PyExc_AssertionError);")
|
|
code.putln(
|
|
code.error_goto(self.pos))
|
|
code.putln(
|
|
"}")
|
|
self.cond.generate_disposal_code(code)
|
|
self.cond.free_temps(code)
|
|
code.putln(
|
|
"}")
|
|
code.putln("#endif")
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.cond.generate_function_definitions(env, code)
|
|
if self.value is not None:
|
|
self.value.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.cond.annotate(code)
|
|
if self.value:
|
|
self.value.annotate(code)
|
|
|
|
|
|
class IfStatNode(StatNode):
|
|
# if statement
|
|
#
|
|
# if_clauses [IfClauseNode]
|
|
# else_clause StatNode or None
|
|
|
|
child_attrs = ["if_clauses", "else_clause"]
|
|
|
|
def analyse_declarations(self, env):
|
|
for if_clause in self.if_clauses:
|
|
if_clause.analyse_declarations(env)
|
|
if self.else_clause:
|
|
self.else_clause.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.if_clauses = [if_clause.analyse_expressions(env) for if_clause in self.if_clauses]
|
|
if self.else_clause:
|
|
self.else_clause = self.else_clause.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
end_label = code.new_label()
|
|
last = len(self.if_clauses)
|
|
if self.else_clause:
|
|
# If the 'else' clause is 'unlikely', then set the preceding 'if' clause to 'likely' to reflect that.
|
|
self._set_branch_hint(self.if_clauses[-1], self.else_clause, inverse=True)
|
|
else:
|
|
last -= 1 # avoid redundant goto at end of last if-clause
|
|
for i, if_clause in enumerate(self.if_clauses):
|
|
self._set_branch_hint(if_clause, if_clause.body)
|
|
if_clause.generate_execution_code(code, end_label, is_last=i == last)
|
|
if self.else_clause:
|
|
code.mark_pos(self.else_clause.pos)
|
|
code.putln("/*else*/ {")
|
|
self.else_clause.generate_execution_code(code)
|
|
code.putln("}")
|
|
code.put_label(end_label)
|
|
|
|
def _set_branch_hint(self, clause, statements_node, inverse=False):
|
|
if not statements_node.is_terminator:
|
|
return
|
|
if not isinstance(statements_node, StatListNode) or not statements_node.stats:
|
|
return
|
|
# Anything that unconditionally raises exceptions should be considered unlikely.
|
|
if isinstance(statements_node.stats[-1], (RaiseStatNode, ReraiseStatNode)):
|
|
if len(statements_node.stats) > 1:
|
|
# Allow simple statements before the 'raise', but no conditions, loops, etc.
|
|
non_branch_nodes = (ExprStatNode, AssignmentNode, DelStatNode, GlobalNode, NonlocalNode)
|
|
for node in statements_node.stats[:-1]:
|
|
if not isinstance(node, non_branch_nodes):
|
|
return
|
|
clause.branch_hint = 'likely' if inverse else 'unlikely'
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
for clause in self.if_clauses:
|
|
clause.generate_function_definitions(env, code)
|
|
if self.else_clause is not None:
|
|
self.else_clause.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
for if_clause in self.if_clauses:
|
|
if_clause.annotate(code)
|
|
if self.else_clause:
|
|
self.else_clause.annotate(code)
|
|
|
|
|
|
class IfClauseNode(Node):
|
|
# if or elif clause in an if statement
|
|
#
|
|
# condition ExprNode
|
|
# body StatNode
|
|
|
|
child_attrs = ["condition", "body"]
|
|
branch_hint = None
|
|
|
|
def analyse_declarations(self, env):
|
|
self.body.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.condition = self.condition.analyse_temp_boolean_expression(env)
|
|
self.body = self.body.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_execution_code(self, code, end_label, is_last):
|
|
self.condition.generate_evaluation_code(code)
|
|
code.mark_pos(self.pos)
|
|
condition = self.condition.result()
|
|
if self.branch_hint:
|
|
condition = '%s(%s)' % (self.branch_hint, condition)
|
|
code.putln("if (%s) {" % condition)
|
|
self.condition.generate_disposal_code(code)
|
|
self.condition.free_temps(code)
|
|
self.body.generate_execution_code(code)
|
|
code.mark_pos(self.pos, trace=False)
|
|
if not (is_last or self.body.is_terminator):
|
|
code.put_goto(end_label)
|
|
code.putln("}")
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.condition.generate_function_definitions(env, code)
|
|
self.body.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.condition.annotate(code)
|
|
self.body.annotate(code)
|
|
|
|
|
|
class SwitchCaseNode(StatNode):
|
|
# Generated in the optimization of an if-elif-else node
|
|
#
|
|
# conditions [ExprNode]
|
|
# body StatNode
|
|
|
|
child_attrs = ['conditions', 'body']
|
|
|
|
def generate_condition_evaluation_code(self, code):
|
|
for cond in self.conditions:
|
|
cond.generate_evaluation_code(code)
|
|
|
|
def generate_execution_code(self, code):
|
|
num_conditions = len(self.conditions)
|
|
line_tracing_enabled = code.globalstate.directives['linetrace']
|
|
for i, cond in enumerate(self.conditions, 1):
|
|
code.putln("case %s:" % cond.result())
|
|
code.mark_pos(cond.pos) # Tracing code must appear *after* the 'case' statement.
|
|
if line_tracing_enabled and i < num_conditions:
|
|
# Allow fall-through after the line tracing code.
|
|
code.putln('CYTHON_FALLTHROUGH;')
|
|
self.body.generate_execution_code(code)
|
|
code.mark_pos(self.pos, trace=False)
|
|
code.putln("break;")
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
for cond in self.conditions:
|
|
cond.generate_function_definitions(env, code)
|
|
self.body.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
for cond in self.conditions:
|
|
cond.annotate(code)
|
|
self.body.annotate(code)
|
|
|
|
|
|
class SwitchStatNode(StatNode):
|
|
# Generated in the optimization of an if-elif-else node
|
|
#
|
|
# test ExprNode
|
|
# cases [SwitchCaseNode]
|
|
# else_clause StatNode or None
|
|
|
|
child_attrs = ['test', 'cases', 'else_clause']
|
|
|
|
def generate_execution_code(self, code):
|
|
self.test.generate_evaluation_code(code)
|
|
# Make sure all conditions are evaluated before going into the switch() statement.
|
|
# This is required in order to prevent any execution code from leaking into the space between the cases.
|
|
for case in self.cases:
|
|
case.generate_condition_evaluation_code(code)
|
|
code.mark_pos(self.pos)
|
|
code.putln("switch (%s) {" % self.test.result())
|
|
for case in self.cases:
|
|
case.generate_execution_code(code)
|
|
if self.else_clause is not None:
|
|
code.putln("default:")
|
|
self.else_clause.generate_execution_code(code)
|
|
code.putln("break;")
|
|
else:
|
|
# Always generate a default clause to prevent C compiler warnings
|
|
# about unmatched enum values (it was not the user who decided to
|
|
# generate the switch statement, so shouldn't be bothered).
|
|
code.putln("default: break;")
|
|
code.putln("}")
|
|
self.test.generate_disposal_code(code)
|
|
self.test.free_temps(code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.test.generate_function_definitions(env, code)
|
|
for case in self.cases:
|
|
case.generate_function_definitions(env, code)
|
|
if self.else_clause is not None:
|
|
self.else_clause.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.test.annotate(code)
|
|
for case in self.cases:
|
|
case.annotate(code)
|
|
if self.else_clause is not None:
|
|
self.else_clause.annotate(code)
|
|
|
|
|
|
class LoopNode(object):
|
|
pass
|
|
|
|
|
|
class WhileStatNode(LoopNode, StatNode):
|
|
# while statement
|
|
#
|
|
# condition ExprNode
|
|
# body StatNode
|
|
# else_clause StatNode
|
|
|
|
child_attrs = ["condition", "body", "else_clause"]
|
|
|
|
def analyse_declarations(self, env):
|
|
self.body.analyse_declarations(env)
|
|
if self.else_clause:
|
|
self.else_clause.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
if self.condition:
|
|
self.condition = self.condition.analyse_temp_boolean_expression(env)
|
|
self.body = self.body.analyse_expressions(env)
|
|
if self.else_clause:
|
|
self.else_clause = self.else_clause.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
old_loop_labels = code.new_loop_labels()
|
|
code.putln(
|
|
"while (1) {")
|
|
if self.condition:
|
|
self.condition.generate_evaluation_code(code)
|
|
self.condition.generate_disposal_code(code)
|
|
code.putln(
|
|
"if (!%s) break;" % self.condition.result())
|
|
self.condition.free_temps(code)
|
|
self.body.generate_execution_code(code)
|
|
code.put_label(code.continue_label)
|
|
code.putln("}")
|
|
break_label = code.break_label
|
|
code.set_loop_labels(old_loop_labels)
|
|
if self.else_clause:
|
|
code.mark_pos(self.else_clause.pos)
|
|
code.putln("/*else*/ {")
|
|
self.else_clause.generate_execution_code(code)
|
|
code.putln("}")
|
|
code.put_label(break_label)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
if self.condition:
|
|
self.condition.generate_function_definitions(env, code)
|
|
self.body.generate_function_definitions(env, code)
|
|
if self.else_clause is not None:
|
|
self.else_clause.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
if self.condition:
|
|
self.condition.annotate(code)
|
|
self.body.annotate(code)
|
|
if self.else_clause:
|
|
self.else_clause.annotate(code)
|
|
|
|
|
|
class DictIterationNextNode(Node):
|
|
# Helper node for calling PyDict_Next() inside of a WhileStatNode
|
|
# and checking the dictionary size for changes. Created in
|
|
# Optimize.py.
|
|
child_attrs = ['dict_obj', 'expected_size', 'pos_index_var',
|
|
'coerced_key_var', 'coerced_value_var', 'coerced_tuple_var',
|
|
'key_target', 'value_target', 'tuple_target', 'is_dict_flag']
|
|
|
|
coerced_key_var = key_ref = None
|
|
coerced_value_var = value_ref = None
|
|
coerced_tuple_var = tuple_ref = None
|
|
|
|
def __init__(self, dict_obj, expected_size, pos_index_var,
|
|
key_target, value_target, tuple_target, is_dict_flag):
|
|
Node.__init__(
|
|
self, dict_obj.pos,
|
|
dict_obj=dict_obj,
|
|
expected_size=expected_size,
|
|
pos_index_var=pos_index_var,
|
|
key_target=key_target,
|
|
value_target=value_target,
|
|
tuple_target=tuple_target,
|
|
is_dict_flag=is_dict_flag,
|
|
is_temp=True,
|
|
type=PyrexTypes.c_bint_type)
|
|
|
|
def analyse_expressions(self, env):
|
|
from . import ExprNodes
|
|
self.dict_obj = self.dict_obj.analyse_types(env)
|
|
self.expected_size = self.expected_size.analyse_types(env)
|
|
if self.pos_index_var:
|
|
self.pos_index_var = self.pos_index_var.analyse_types(env)
|
|
if self.key_target:
|
|
self.key_target = self.key_target.analyse_target_types(env)
|
|
self.key_ref = ExprNodes.TempNode(self.key_target.pos, PyrexTypes.py_object_type)
|
|
self.coerced_key_var = self.key_ref.coerce_to(self.key_target.type, env)
|
|
if self.value_target:
|
|
self.value_target = self.value_target.analyse_target_types(env)
|
|
self.value_ref = ExprNodes.TempNode(self.value_target.pos, type=PyrexTypes.py_object_type)
|
|
self.coerced_value_var = self.value_ref.coerce_to(self.value_target.type, env)
|
|
if self.tuple_target:
|
|
self.tuple_target = self.tuple_target.analyse_target_types(env)
|
|
self.tuple_ref = ExprNodes.TempNode(self.tuple_target.pos, PyrexTypes.py_object_type)
|
|
self.coerced_tuple_var = self.tuple_ref.coerce_to(self.tuple_target.type, env)
|
|
self.is_dict_flag = self.is_dict_flag.analyse_types(env)
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.dict_obj.generate_function_definitions(env, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
code.globalstate.use_utility_code(UtilityCode.load_cached("dict_iter", "Optimize.c"))
|
|
self.dict_obj.generate_evaluation_code(code)
|
|
|
|
assignments = []
|
|
temp_addresses = []
|
|
for var, result, target in [(self.key_ref, self.coerced_key_var, self.key_target),
|
|
(self.value_ref, self.coerced_value_var, self.value_target),
|
|
(self.tuple_ref, self.coerced_tuple_var, self.tuple_target)]:
|
|
if target is None:
|
|
addr = 'NULL'
|
|
else:
|
|
assignments.append((var, result, target))
|
|
var.allocate(code)
|
|
addr = '&%s' % var.result()
|
|
temp_addresses.append(addr)
|
|
|
|
result_temp = code.funcstate.allocate_temp(PyrexTypes.c_int_type, False)
|
|
code.putln("%s = __Pyx_dict_iter_next(%s, %s, &%s, %s, %s, %s, %s);" % (
|
|
result_temp,
|
|
self.dict_obj.py_result(),
|
|
self.expected_size.result(),
|
|
self.pos_index_var.result(),
|
|
temp_addresses[0],
|
|
temp_addresses[1],
|
|
temp_addresses[2],
|
|
self.is_dict_flag.result()
|
|
))
|
|
code.putln("if (unlikely(%s == 0)) break;" % result_temp)
|
|
code.putln(code.error_goto_if("%s == -1" % result_temp, self.pos))
|
|
code.funcstate.release_temp(result_temp)
|
|
|
|
# evaluate all coercions before the assignments
|
|
for var, result, target in assignments:
|
|
code.put_gotref(var.result())
|
|
for var, result, target in assignments:
|
|
result.generate_evaluation_code(code)
|
|
for var, result, target in assignments:
|
|
target.generate_assignment_code(result, code)
|
|
var.release(code)
|
|
|
|
|
|
class SetIterationNextNode(Node):
|
|
# Helper node for calling _PySet_NextEntry() inside of a WhileStatNode
|
|
# and checking the set size for changes. Created in Optimize.py.
|
|
child_attrs = ['set_obj', 'expected_size', 'pos_index_var',
|
|
'coerced_value_var', 'value_target', 'is_set_flag']
|
|
|
|
coerced_value_var = value_ref = None
|
|
|
|
def __init__(self, set_obj, expected_size, pos_index_var, value_target, is_set_flag):
|
|
Node.__init__(
|
|
self, set_obj.pos,
|
|
set_obj=set_obj,
|
|
expected_size=expected_size,
|
|
pos_index_var=pos_index_var,
|
|
value_target=value_target,
|
|
is_set_flag=is_set_flag,
|
|
is_temp=True,
|
|
type=PyrexTypes.c_bint_type)
|
|
|
|
def analyse_expressions(self, env):
|
|
from . import ExprNodes
|
|
self.set_obj = self.set_obj.analyse_types(env)
|
|
self.expected_size = self.expected_size.analyse_types(env)
|
|
self.pos_index_var = self.pos_index_var.analyse_types(env)
|
|
self.value_target = self.value_target.analyse_target_types(env)
|
|
self.value_ref = ExprNodes.TempNode(self.value_target.pos, type=PyrexTypes.py_object_type)
|
|
self.coerced_value_var = self.value_ref.coerce_to(self.value_target.type, env)
|
|
self.is_set_flag = self.is_set_flag.analyse_types(env)
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.set_obj.generate_function_definitions(env, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
code.globalstate.use_utility_code(UtilityCode.load_cached("set_iter", "Optimize.c"))
|
|
self.set_obj.generate_evaluation_code(code)
|
|
|
|
value_ref = self.value_ref
|
|
value_ref.allocate(code)
|
|
|
|
result_temp = code.funcstate.allocate_temp(PyrexTypes.c_int_type, False)
|
|
code.putln("%s = __Pyx_set_iter_next(%s, %s, &%s, &%s, %s);" % (
|
|
result_temp,
|
|
self.set_obj.py_result(),
|
|
self.expected_size.result(),
|
|
self.pos_index_var.result(),
|
|
value_ref.result(),
|
|
self.is_set_flag.result()
|
|
))
|
|
code.putln("if (unlikely(%s == 0)) break;" % result_temp)
|
|
code.putln(code.error_goto_if("%s == -1" % result_temp, self.pos))
|
|
code.funcstate.release_temp(result_temp)
|
|
|
|
# evaluate all coercions before the assignments
|
|
code.put_gotref(value_ref.result())
|
|
self.coerced_value_var.generate_evaluation_code(code)
|
|
self.value_target.generate_assignment_code(self.coerced_value_var, code)
|
|
value_ref.release(code)
|
|
|
|
|
|
def ForStatNode(pos, **kw):
|
|
if 'iterator' in kw:
|
|
if kw['iterator'].is_async:
|
|
return AsyncForStatNode(pos, **kw)
|
|
else:
|
|
return ForInStatNode(pos, **kw)
|
|
else:
|
|
return ForFromStatNode(pos, **kw)
|
|
|
|
|
|
class _ForInStatNode(LoopNode, StatNode):
|
|
# Base class of 'for-in' statements.
|
|
#
|
|
# target ExprNode
|
|
# iterator IteratorNode | AIterAwaitExprNode(AsyncIteratorNode)
|
|
# body StatNode
|
|
# else_clause StatNode
|
|
# item NextNode | AwaitExprNode(AsyncNextNode)
|
|
# is_async boolean true for 'async for' statements
|
|
|
|
child_attrs = ["target", "item", "iterator", "body", "else_clause"]
|
|
item = None
|
|
is_async = False
|
|
|
|
def _create_item_node(self):
|
|
raise NotImplementedError("must be implemented by subclasses")
|
|
|
|
def analyse_declarations(self, env):
|
|
self.target.analyse_target_declaration(env)
|
|
self.body.analyse_declarations(env)
|
|
if self.else_clause:
|
|
self.else_clause.analyse_declarations(env)
|
|
self._create_item_node()
|
|
|
|
def analyse_expressions(self, env):
|
|
self.target = self.target.analyse_target_types(env)
|
|
self.iterator = self.iterator.analyse_expressions(env)
|
|
self._create_item_node() # must rewrap self.item after analysis
|
|
self.item = self.item.analyse_expressions(env)
|
|
if (not self.is_async and
|
|
(self.iterator.type.is_ptr or self.iterator.type.is_array) and
|
|
self.target.type.assignable_from(self.iterator.type)):
|
|
# C array slice optimization.
|
|
pass
|
|
else:
|
|
self.item = self.item.coerce_to(self.target.type, env)
|
|
self.body = self.body.analyse_expressions(env)
|
|
if self.else_clause:
|
|
self.else_clause = self.else_clause.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
old_loop_labels = code.new_loop_labels()
|
|
self.iterator.generate_evaluation_code(code)
|
|
code.putln("for (;;) {")
|
|
self.item.generate_evaluation_code(code)
|
|
self.target.generate_assignment_code(self.item, code)
|
|
self.body.generate_execution_code(code)
|
|
code.mark_pos(self.pos)
|
|
code.put_label(code.continue_label)
|
|
code.putln("}")
|
|
break_label = code.break_label
|
|
code.set_loop_labels(old_loop_labels)
|
|
|
|
if self.else_clause:
|
|
# in nested loops, the 'else' block can contain a
|
|
# 'continue' statement for the outer loop, but we may need
|
|
# to generate cleanup code before taking that path, so we
|
|
# intercept it here
|
|
orig_continue_label = code.continue_label
|
|
code.continue_label = code.new_label('outer_continue')
|
|
|
|
code.putln("/*else*/ {")
|
|
self.else_clause.generate_execution_code(code)
|
|
code.putln("}")
|
|
|
|
if code.label_used(code.continue_label):
|
|
code.put_goto(break_label)
|
|
code.mark_pos(self.pos)
|
|
code.put_label(code.continue_label)
|
|
self.iterator.generate_disposal_code(code)
|
|
code.put_goto(orig_continue_label)
|
|
code.set_loop_labels(old_loop_labels)
|
|
|
|
code.mark_pos(self.pos)
|
|
if code.label_used(break_label):
|
|
code.put_label(break_label)
|
|
self.iterator.generate_disposal_code(code)
|
|
self.iterator.free_temps(code)
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.target.generate_function_definitions(env, code)
|
|
self.iterator.generate_function_definitions(env, code)
|
|
self.body.generate_function_definitions(env, code)
|
|
if self.else_clause is not None:
|
|
self.else_clause.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.target.annotate(code)
|
|
self.iterator.annotate(code)
|
|
self.body.annotate(code)
|
|
if self.else_clause:
|
|
self.else_clause.annotate(code)
|
|
self.item.annotate(code)
|
|
|
|
|
|
class ForInStatNode(_ForInStatNode):
|
|
# 'for' statement
|
|
|
|
is_async = False
|
|
|
|
def _create_item_node(self):
|
|
from .ExprNodes import NextNode
|
|
self.item = NextNode(self.iterator)
|
|
|
|
|
|
class AsyncForStatNode(_ForInStatNode):
|
|
# 'async for' statement
|
|
#
|
|
# iterator AIterAwaitExprNode(AsyncIteratorNode)
|
|
# item AwaitIterNextExprNode(AsyncIteratorNode)
|
|
|
|
is_async = True
|
|
|
|
def __init__(self, pos, **kw):
|
|
assert 'item' not in kw
|
|
from . import ExprNodes
|
|
# AwaitExprNodes must appear before running MarkClosureVisitor
|
|
kw['item'] = ExprNodes.AwaitIterNextExprNode(kw['iterator'].pos, arg=None)
|
|
_ForInStatNode.__init__(self, pos, **kw)
|
|
|
|
def _create_item_node(self):
|
|
from . import ExprNodes
|
|
self.item.arg = ExprNodes.AsyncNextNode(self.iterator)
|
|
|
|
|
|
class ForFromStatNode(LoopNode, StatNode):
|
|
# for name from expr rel name rel expr
|
|
#
|
|
# target NameNode
|
|
# bound1 ExprNode
|
|
# relation1 string
|
|
# relation2 string
|
|
# bound2 ExprNode
|
|
# step ExprNode or None
|
|
# body StatNode
|
|
# else_clause StatNode or None
|
|
#
|
|
# Used internally:
|
|
#
|
|
# from_range bool
|
|
# is_py_target bool
|
|
# loopvar_node ExprNode (usually a NameNode or temp node)
|
|
# py_loopvar_node PyTempNode or None
|
|
child_attrs = ["target", "bound1", "bound2", "step", "body", "else_clause"]
|
|
|
|
is_py_target = False
|
|
loopvar_node = None
|
|
py_loopvar_node = None
|
|
from_range = False
|
|
|
|
gil_message = "For-loop using object bounds or target"
|
|
|
|
def nogil_check(self, env):
|
|
for x in (self.target, self.bound1, self.bound2):
|
|
if x.type.is_pyobject:
|
|
self.gil_error()
|
|
|
|
def analyse_declarations(self, env):
|
|
self.target.analyse_target_declaration(env)
|
|
self.body.analyse_declarations(env)
|
|
if self.else_clause:
|
|
self.else_clause.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
from . import ExprNodes
|
|
self.target = self.target.analyse_target_types(env)
|
|
self.bound1 = self.bound1.analyse_types(env)
|
|
self.bound2 = self.bound2.analyse_types(env)
|
|
if self.step is not None:
|
|
if isinstance(self.step, ExprNodes.UnaryMinusNode):
|
|
warning(self.step.pos, "Probable infinite loop in for-from-by statement. "
|
|
"Consider switching the directions of the relations.", 2)
|
|
self.step = self.step.analyse_types(env)
|
|
|
|
self.set_up_loop(env)
|
|
target_type = self.target.type
|
|
if not (target_type.is_pyobject or target_type.is_numeric):
|
|
error(self.target.pos, "for-from loop variable must be c numeric type or Python object")
|
|
|
|
self.body = self.body.analyse_expressions(env)
|
|
if self.else_clause:
|
|
self.else_clause = self.else_clause.analyse_expressions(env)
|
|
return self
|
|
|
|
def set_up_loop(self, env):
|
|
from . import ExprNodes
|
|
|
|
target_type = self.target.type
|
|
if target_type.is_numeric:
|
|
loop_type = target_type
|
|
else:
|
|
if target_type.is_enum:
|
|
warning(self.target.pos,
|
|
"Integer loops over enum values are fragile. Please cast to a safe integer type instead.")
|
|
loop_type = PyrexTypes.c_long_type if target_type.is_pyobject else PyrexTypes.c_int_type
|
|
if not self.bound1.type.is_pyobject:
|
|
loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound1.type)
|
|
if not self.bound2.type.is_pyobject:
|
|
loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound2.type)
|
|
if self.step is not None and not self.step.type.is_pyobject:
|
|
loop_type = PyrexTypes.widest_numeric_type(loop_type, self.step.type)
|
|
self.bound1 = self.bound1.coerce_to(loop_type, env)
|
|
self.bound2 = self.bound2.coerce_to(loop_type, env)
|
|
if not self.bound2.is_literal:
|
|
self.bound2 = self.bound2.coerce_to_temp(env)
|
|
if self.step is not None:
|
|
self.step = self.step.coerce_to(loop_type, env)
|
|
if not self.step.is_literal:
|
|
self.step = self.step.coerce_to_temp(env)
|
|
|
|
if target_type.is_numeric or target_type.is_enum:
|
|
self.is_py_target = False
|
|
if isinstance(self.target, ExprNodes.BufferIndexNode):
|
|
raise error(self.pos, "Buffer or memoryview slicing/indexing not allowed as for-loop target.")
|
|
self.loopvar_node = self.target
|
|
self.py_loopvar_node = None
|
|
else:
|
|
self.is_py_target = True
|
|
c_loopvar_node = ExprNodes.TempNode(self.pos, loop_type, env)
|
|
self.loopvar_node = c_loopvar_node
|
|
self.py_loopvar_node = ExprNodes.CloneNode(c_loopvar_node).coerce_to_pyobject(env)
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
old_loop_labels = code.new_loop_labels()
|
|
from_range = self.from_range
|
|
self.bound1.generate_evaluation_code(code)
|
|
self.bound2.generate_evaluation_code(code)
|
|
offset, incop = self.relation_table[self.relation1]
|
|
if self.step is not None:
|
|
self.step.generate_evaluation_code(code)
|
|
step = self.step.result()
|
|
incop = "%s=%s" % (incop[0], step) # e.g. '++' => '+= STEP'
|
|
else:
|
|
step = '1'
|
|
|
|
from . import ExprNodes
|
|
if isinstance(self.loopvar_node, ExprNodes.TempNode):
|
|
self.loopvar_node.allocate(code)
|
|
if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
|
|
self.py_loopvar_node.allocate(code)
|
|
|
|
loopvar_type = PyrexTypes.c_long_type if self.target.type.is_enum else self.target.type
|
|
|
|
if from_range and not self.is_py_target:
|
|
loopvar_name = code.funcstate.allocate_temp(loopvar_type, False)
|
|
else:
|
|
loopvar_name = self.loopvar_node.result()
|
|
if loopvar_type.is_int and not loopvar_type.signed and self.relation2[0] == '>':
|
|
# Handle the case where the endpoint of an unsigned int iteration
|
|
# is within step of 0.
|
|
code.putln("for (%s = %s%s + %s; %s %s %s + %s; ) { %s%s;" % (
|
|
loopvar_name,
|
|
self.bound1.result(), offset, step,
|
|
loopvar_name, self.relation2, self.bound2.result(), step,
|
|
loopvar_name, incop))
|
|
else:
|
|
code.putln("for (%s = %s%s; %s %s %s; %s%s) {" % (
|
|
loopvar_name,
|
|
self.bound1.result(), offset,
|
|
loopvar_name, self.relation2, self.bound2.result(),
|
|
loopvar_name, incop))
|
|
|
|
coerced_loopvar_node = self.py_loopvar_node
|
|
if coerced_loopvar_node is None and from_range:
|
|
coerced_loopvar_node = ExprNodes.RawCNameExprNode(self.target.pos, loopvar_type, loopvar_name)
|
|
if coerced_loopvar_node is not None:
|
|
coerced_loopvar_node.generate_evaluation_code(code)
|
|
self.target.generate_assignment_code(coerced_loopvar_node, code)
|
|
|
|
self.body.generate_execution_code(code)
|
|
code.put_label(code.continue_label)
|
|
|
|
if not from_range and self.py_loopvar_node:
|
|
# This mess is to make for..from loops with python targets behave
|
|
# exactly like those with C targets with regards to re-assignment
|
|
# of the loop variable.
|
|
if self.target.entry.is_pyglobal:
|
|
# We know target is a NameNode, this is the only ugly case.
|
|
target_node = ExprNodes.PyTempNode(self.target.pos, None)
|
|
target_node.allocate(code)
|
|
interned_cname = code.intern_identifier(self.target.entry.name)
|
|
if self.target.entry.scope.is_module_scope:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("GetModuleGlobalName", "ObjectHandling.c"))
|
|
lookup_func = '__Pyx_GetModuleGlobalName(%s, %s); %s'
|
|
else:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("GetNameInClass", "ObjectHandling.c"))
|
|
lookup_func = '__Pyx_GetNameInClass(%s, {}, %s); %s'.format(
|
|
self.target.entry.scope.namespace_cname)
|
|
code.putln(lookup_func % (
|
|
target_node.result(),
|
|
interned_cname,
|
|
code.error_goto_if_null(target_node.result(), self.target.pos)))
|
|
code.put_gotref(target_node.result())
|
|
else:
|
|
target_node = self.target
|
|
from_py_node = ExprNodes.CoerceFromPyTypeNode(
|
|
self.loopvar_node.type, target_node, self.target.entry.scope)
|
|
from_py_node.temp_code = loopvar_name
|
|
from_py_node.generate_result_code(code)
|
|
if self.target.entry.is_pyglobal:
|
|
code.put_decref(target_node.result(), target_node.type)
|
|
target_node.release(code)
|
|
|
|
code.putln("}")
|
|
|
|
if not from_range and self.py_loopvar_node:
|
|
# This is potentially wasteful, but we don't want the semantics to
|
|
# depend on whether or not the loop is a python type.
|
|
self.py_loopvar_node.generate_evaluation_code(code)
|
|
self.target.generate_assignment_code(self.py_loopvar_node, code)
|
|
if from_range and not self.is_py_target:
|
|
code.funcstate.release_temp(loopvar_name)
|
|
|
|
break_label = code.break_label
|
|
code.set_loop_labels(old_loop_labels)
|
|
if self.else_clause:
|
|
code.putln("/*else*/ {")
|
|
self.else_clause.generate_execution_code(code)
|
|
code.putln("}")
|
|
code.put_label(break_label)
|
|
self.bound1.generate_disposal_code(code)
|
|
self.bound1.free_temps(code)
|
|
self.bound2.generate_disposal_code(code)
|
|
self.bound2.free_temps(code)
|
|
if isinstance(self.loopvar_node, ExprNodes.TempNode):
|
|
self.loopvar_node.release(code)
|
|
if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
|
|
self.py_loopvar_node.release(code)
|
|
if self.step is not None:
|
|
self.step.generate_disposal_code(code)
|
|
self.step.free_temps(code)
|
|
|
|
relation_table = {
|
|
# {relop : (initial offset, increment op)}
|
|
'<=': ("", "++"),
|
|
'<' : ("+1", "++"),
|
|
'>=': ("", "--"),
|
|
'>' : ("-1", "--"),
|
|
}
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.target.generate_function_definitions(env, code)
|
|
self.bound1.generate_function_definitions(env, code)
|
|
self.bound2.generate_function_definitions(env, code)
|
|
if self.step is not None:
|
|
self.step.generate_function_definitions(env, code)
|
|
self.body.generate_function_definitions(env, code)
|
|
if self.else_clause is not None:
|
|
self.else_clause.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.target.annotate(code)
|
|
self.bound1.annotate(code)
|
|
self.bound2.annotate(code)
|
|
if self.step:
|
|
self.step.annotate(code)
|
|
self.body.annotate(code)
|
|
if self.else_clause:
|
|
self.else_clause.annotate(code)
|
|
|
|
|
|
class WithStatNode(StatNode):
|
|
"""
|
|
Represents a Python with statement.
|
|
|
|
Implemented by the WithTransform as follows:
|
|
|
|
MGR = EXPR
|
|
EXIT = MGR.__exit__
|
|
VALUE = MGR.__enter__()
|
|
EXC = True
|
|
try:
|
|
try:
|
|
TARGET = VALUE # optional
|
|
BODY
|
|
except:
|
|
EXC = False
|
|
if not EXIT(*EXCINFO):
|
|
raise
|
|
finally:
|
|
if EXC:
|
|
EXIT(None, None, None)
|
|
MGR = EXIT = VALUE = None
|
|
"""
|
|
# manager The with statement manager object
|
|
# target ExprNode the target lhs of the __enter__() call
|
|
# body StatNode
|
|
# enter_call ExprNode the call to the __enter__() method
|
|
# exit_var String the cname of the __exit__() method reference
|
|
|
|
child_attrs = ["manager", "enter_call", "target", "body"]
|
|
|
|
enter_call = None
|
|
target_temp = None
|
|
|
|
def analyse_declarations(self, env):
|
|
self.manager.analyse_declarations(env)
|
|
self.enter_call.analyse_declarations(env)
|
|
self.body.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.manager = self.manager.analyse_types(env)
|
|
self.enter_call = self.enter_call.analyse_types(env)
|
|
if self.target:
|
|
# set up target_temp before descending into body (which uses it)
|
|
from .ExprNodes import TempNode
|
|
self.target_temp = TempNode(self.enter_call.pos, self.enter_call.type)
|
|
self.body = self.body.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.manager.generate_function_definitions(env, code)
|
|
self.enter_call.generate_function_definitions(env, code)
|
|
self.body.generate_function_definitions(env, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
code.putln("/*with:*/ {")
|
|
self.manager.generate_evaluation_code(code)
|
|
self.exit_var = code.funcstate.allocate_temp(py_object_type, manage_ref=False)
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("PyObjectLookupSpecial", "ObjectHandling.c"))
|
|
code.putln("%s = __Pyx_PyObject_LookupSpecial(%s, %s); %s" % (
|
|
self.exit_var,
|
|
self.manager.py_result(),
|
|
code.intern_identifier(EncodedString('__aexit__' if self.is_async else '__exit__')),
|
|
code.error_goto_if_null(self.exit_var, self.pos),
|
|
))
|
|
code.put_gotref(self.exit_var)
|
|
|
|
# need to free exit_var in the face of exceptions during setup
|
|
old_error_label = code.new_error_label()
|
|
intermediate_error_label = code.error_label
|
|
|
|
self.enter_call.generate_evaluation_code(code)
|
|
if self.target:
|
|
# The temp result will be cleaned up by the WithTargetAssignmentStatNode
|
|
# after assigning its result to the target of the 'with' statement.
|
|
self.target_temp.allocate(code)
|
|
self.enter_call.make_owned_reference(code)
|
|
code.putln("%s = %s;" % (self.target_temp.result(), self.enter_call.result()))
|
|
self.enter_call.generate_post_assignment_code(code)
|
|
else:
|
|
self.enter_call.generate_disposal_code(code)
|
|
self.enter_call.free_temps(code)
|
|
|
|
self.manager.generate_disposal_code(code)
|
|
self.manager.free_temps(code)
|
|
|
|
code.error_label = old_error_label
|
|
self.body.generate_execution_code(code)
|
|
|
|
if code.label_used(intermediate_error_label):
|
|
step_over_label = code.new_label()
|
|
code.put_goto(step_over_label)
|
|
code.put_label(intermediate_error_label)
|
|
code.put_decref_clear(self.exit_var, py_object_type)
|
|
code.put_goto(old_error_label)
|
|
code.put_label(step_over_label)
|
|
|
|
code.funcstate.release_temp(self.exit_var)
|
|
code.putln('}')
|
|
|
|
|
|
class WithTargetAssignmentStatNode(AssignmentNode):
|
|
# The target assignment of the 'with' statement value (return
|
|
# value of the __enter__() call).
|
|
#
|
|
# This is a special cased assignment that properly cleans up the RHS.
|
|
#
|
|
# lhs ExprNode the assignment target
|
|
# rhs ExprNode a (coerced) TempNode for the rhs (from WithStatNode)
|
|
# with_node WithStatNode the surrounding with-statement
|
|
|
|
child_attrs = ["rhs", "lhs"]
|
|
with_node = None
|
|
rhs = None
|
|
|
|
def analyse_declarations(self, env):
|
|
self.lhs.analyse_target_declaration(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.lhs = self.lhs.analyse_target_types(env)
|
|
self.lhs.gil_assignment_check(env)
|
|
self.rhs = self.with_node.target_temp.coerce_to(self.lhs.type, env)
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
self.rhs.generate_evaluation_code(code)
|
|
self.lhs.generate_assignment_code(self.rhs, code)
|
|
self.with_node.target_temp.release(code)
|
|
|
|
def annotate(self, code):
|
|
self.lhs.annotate(code)
|
|
self.rhs.annotate(code)
|
|
|
|
|
|
class TryExceptStatNode(StatNode):
|
|
# try .. except statement
|
|
#
|
|
# body StatNode
|
|
# except_clauses [ExceptClauseNode]
|
|
# else_clause StatNode or None
|
|
|
|
child_attrs = ["body", "except_clauses", "else_clause"]
|
|
in_generator = False
|
|
|
|
def analyse_declarations(self, env):
|
|
self.body.analyse_declarations(env)
|
|
for except_clause in self.except_clauses:
|
|
except_clause.analyse_declarations(env)
|
|
if self.else_clause:
|
|
self.else_clause.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.body = self.body.analyse_expressions(env)
|
|
default_clause_seen = 0
|
|
for i, except_clause in enumerate(self.except_clauses):
|
|
except_clause = self.except_clauses[i] = except_clause.analyse_expressions(env)
|
|
if default_clause_seen:
|
|
error(except_clause.pos, "default 'except:' must be last")
|
|
if not except_clause.pattern:
|
|
default_clause_seen = 1
|
|
self.has_default_clause = default_clause_seen
|
|
if self.else_clause:
|
|
self.else_clause = self.else_clause.analyse_expressions(env)
|
|
return self
|
|
|
|
nogil_check = Node.gil_error
|
|
gil_message = "Try-except statement"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos) # before changing the error label, in case of tracing errors
|
|
code.putln("{")
|
|
|
|
old_return_label = code.return_label
|
|
old_break_label = code.break_label
|
|
old_continue_label = code.continue_label
|
|
old_error_label = code.new_error_label()
|
|
our_error_label = code.error_label
|
|
except_end_label = code.new_label('exception_handled')
|
|
except_error_label = code.new_label('except_error')
|
|
except_return_label = code.new_label('except_return')
|
|
try_return_label = code.new_label('try_return')
|
|
try_break_label = code.new_label('try_break') if old_break_label else None
|
|
try_continue_label = code.new_label('try_continue') if old_continue_label else None
|
|
try_end_label = code.new_label('try_end')
|
|
|
|
exc_save_vars = [code.funcstate.allocate_temp(py_object_type, False)
|
|
for _ in range(3)]
|
|
save_exc = code.insertion_point()
|
|
code.putln(
|
|
"/*try:*/ {")
|
|
code.return_label = try_return_label
|
|
code.break_label = try_break_label
|
|
code.continue_label = try_continue_label
|
|
self.body.generate_execution_code(code)
|
|
code.mark_pos(self.pos, trace=False)
|
|
code.putln(
|
|
"}")
|
|
temps_to_clean_up = code.funcstate.all_free_managed_temps()
|
|
can_raise = code.label_used(our_error_label)
|
|
|
|
if can_raise:
|
|
# inject code before the try block to save away the exception state
|
|
code.globalstate.use_utility_code(reset_exception_utility_code)
|
|
if not self.in_generator:
|
|
save_exc.putln("__Pyx_PyThreadState_declare")
|
|
save_exc.putln("__Pyx_PyThreadState_assign")
|
|
save_exc.putln("__Pyx_ExceptionSave(%s);" % (
|
|
', '.join(['&%s' % var for var in exc_save_vars])))
|
|
for var in exc_save_vars:
|
|
save_exc.put_xgotref(var)
|
|
|
|
def restore_saved_exception():
|
|
for name in exc_save_vars:
|
|
code.put_xgiveref(name)
|
|
code.putln("__Pyx_ExceptionReset(%s);" %
|
|
', '.join(exc_save_vars))
|
|
else:
|
|
# try block cannot raise exceptions, but we had to allocate the temps above,
|
|
# so just keep the C compiler from complaining about them being unused
|
|
mark_vars_used = ["(void)%s;" % var for var in exc_save_vars]
|
|
save_exc.putln("%s /* mark used */" % ' '.join(mark_vars_used))
|
|
|
|
def restore_saved_exception():
|
|
pass
|
|
|
|
code.error_label = except_error_label
|
|
code.return_label = except_return_label
|
|
normal_case_terminates = self.body.is_terminator
|
|
if self.else_clause:
|
|
code.mark_pos(self.else_clause.pos)
|
|
code.putln(
|
|
"/*else:*/ {")
|
|
self.else_clause.generate_execution_code(code)
|
|
code.putln(
|
|
"}")
|
|
if not normal_case_terminates:
|
|
normal_case_terminates = self.else_clause.is_terminator
|
|
|
|
if can_raise:
|
|
if not normal_case_terminates:
|
|
for var in exc_save_vars:
|
|
code.put_xdecref_clear(var, py_object_type)
|
|
code.put_goto(try_end_label)
|
|
code.put_label(our_error_label)
|
|
for temp_name, temp_type in temps_to_clean_up:
|
|
code.put_xdecref_clear(temp_name, temp_type)
|
|
|
|
outer_except = code.funcstate.current_except
|
|
# Currently points to self, but the ExceptClauseNode would also be ok. Change if needed.
|
|
code.funcstate.current_except = self
|
|
for except_clause in self.except_clauses:
|
|
except_clause.generate_handling_code(code, except_end_label)
|
|
code.funcstate.current_except = outer_except
|
|
|
|
if not self.has_default_clause:
|
|
code.put_goto(except_error_label)
|
|
|
|
for exit_label, old_label in [(except_error_label, old_error_label),
|
|
(try_break_label, old_break_label),
|
|
(try_continue_label, old_continue_label),
|
|
(try_return_label, old_return_label),
|
|
(except_return_label, old_return_label)]:
|
|
if code.label_used(exit_label):
|
|
if not normal_case_terminates and not code.label_used(try_end_label):
|
|
code.put_goto(try_end_label)
|
|
code.put_label(exit_label)
|
|
code.mark_pos(self.pos, trace=False)
|
|
if can_raise:
|
|
restore_saved_exception()
|
|
code.put_goto(old_label)
|
|
|
|
if code.label_used(except_end_label):
|
|
if not normal_case_terminates and not code.label_used(try_end_label):
|
|
code.put_goto(try_end_label)
|
|
code.put_label(except_end_label)
|
|
if can_raise:
|
|
restore_saved_exception()
|
|
if code.label_used(try_end_label):
|
|
code.put_label(try_end_label)
|
|
code.putln("}")
|
|
|
|
for cname in exc_save_vars:
|
|
code.funcstate.release_temp(cname)
|
|
|
|
code.return_label = old_return_label
|
|
code.break_label = old_break_label
|
|
code.continue_label = old_continue_label
|
|
code.error_label = old_error_label
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.body.generate_function_definitions(env, code)
|
|
for except_clause in self.except_clauses:
|
|
except_clause.generate_function_definitions(env, code)
|
|
if self.else_clause is not None:
|
|
self.else_clause.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
self.body.annotate(code)
|
|
for except_node in self.except_clauses:
|
|
except_node.annotate(code)
|
|
if self.else_clause:
|
|
self.else_clause.annotate(code)
|
|
|
|
|
|
class ExceptClauseNode(Node):
|
|
# Part of try ... except statement.
|
|
#
|
|
# pattern [ExprNode]
|
|
# target ExprNode or None
|
|
# body StatNode
|
|
# excinfo_target TupleNode(3*ResultRefNode) or None optional target for exception info (not owned here!)
|
|
# match_flag string result of exception match
|
|
# exc_value ExcValueNode used internally
|
|
# function_name string qualified name of enclosing function
|
|
# exc_vars (string * 3) local exception variables
|
|
# is_except_as bool Py3-style "except ... as xyz"
|
|
|
|
# excinfo_target is never set by the parser, but can be set by a transform
|
|
# in order to extract more extensive information about the exception as a
|
|
# sys.exc_info()-style tuple into a target variable
|
|
|
|
child_attrs = ["pattern", "target", "body", "exc_value"]
|
|
|
|
exc_value = None
|
|
excinfo_target = None
|
|
is_except_as = False
|
|
|
|
def analyse_declarations(self, env):
|
|
if self.target:
|
|
self.target.analyse_target_declaration(env)
|
|
self.body.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.function_name = env.qualified_name
|
|
if self.pattern:
|
|
# normalise/unpack self.pattern into a list
|
|
for i, pattern in enumerate(self.pattern):
|
|
pattern = pattern.analyse_expressions(env)
|
|
self.pattern[i] = pattern.coerce_to_pyobject(env)
|
|
|
|
if self.target:
|
|
from . import ExprNodes
|
|
self.exc_value = ExprNodes.ExcValueNode(self.pos)
|
|
self.target = self.target.analyse_target_expression(env, self.exc_value)
|
|
|
|
self.body = self.body.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_handling_code(self, code, end_label):
|
|
code.mark_pos(self.pos)
|
|
|
|
if self.pattern:
|
|
has_non_literals = not all(
|
|
pattern.is_literal or pattern.is_simple() and not pattern.is_temp
|
|
for pattern in self.pattern)
|
|
|
|
if has_non_literals:
|
|
# For non-trivial exception check expressions, hide the live exception from C-API calls.
|
|
exc_vars = [code.funcstate.allocate_temp(py_object_type, manage_ref=True)
|
|
for _ in range(3)]
|
|
code.globalstate.use_utility_code(UtilityCode.load_cached("PyErrFetchRestore", "Exceptions.c"))
|
|
code.putln("__Pyx_ErrFetch(&%s, &%s, &%s);" % tuple(exc_vars))
|
|
code.globalstate.use_utility_code(UtilityCode.load_cached("FastTypeChecks", "ModuleSetupCode.c"))
|
|
exc_test_func = "__Pyx_PyErr_GivenExceptionMatches(%s, %%s)" % exc_vars[0]
|
|
else:
|
|
exc_vars = ()
|
|
code.globalstate.use_utility_code(UtilityCode.load_cached("PyErrExceptionMatches", "Exceptions.c"))
|
|
exc_test_func = "__Pyx_PyErr_ExceptionMatches(%s)"
|
|
|
|
exc_tests = []
|
|
for pattern in self.pattern:
|
|
pattern.generate_evaluation_code(code)
|
|
exc_tests.append(exc_test_func % pattern.py_result())
|
|
|
|
match_flag = code.funcstate.allocate_temp(PyrexTypes.c_int_type, manage_ref=False)
|
|
code.putln("%s = %s;" % (match_flag, ' || '.join(exc_tests)))
|
|
for pattern in self.pattern:
|
|
pattern.generate_disposal_code(code)
|
|
pattern.free_temps(code)
|
|
|
|
if has_non_literals:
|
|
code.putln("__Pyx_ErrRestore(%s, %s, %s);" % tuple(exc_vars))
|
|
code.putln(' '.join(["%s = 0;" % var for var in exc_vars]))
|
|
for temp in exc_vars:
|
|
code.funcstate.release_temp(temp)
|
|
|
|
code.putln(
|
|
"if (%s) {" %
|
|
match_flag)
|
|
code.funcstate.release_temp(match_flag)
|
|
else:
|
|
code.putln("/*except:*/ {")
|
|
|
|
if (not getattr(self.body, 'stats', True)
|
|
and self.excinfo_target is None
|
|
and self.target is None):
|
|
# most simple case: no exception variable, empty body (pass)
|
|
# => reset the exception state, done
|
|
code.globalstate.use_utility_code(UtilityCode.load_cached("PyErrFetchRestore", "Exceptions.c"))
|
|
code.putln("__Pyx_ErrRestore(0,0,0);")
|
|
code.put_goto(end_label)
|
|
code.putln("}")
|
|
return
|
|
|
|
exc_vars = [code.funcstate.allocate_temp(py_object_type, manage_ref=True)
|
|
for _ in range(3)]
|
|
code.put_add_traceback(self.function_name)
|
|
# We always have to fetch the exception value even if
|
|
# there is no target, because this also normalises the
|
|
# exception and stores it in the thread state.
|
|
code.globalstate.use_utility_code(get_exception_utility_code)
|
|
exc_args = "&%s, &%s, &%s" % tuple(exc_vars)
|
|
code.putln("if (__Pyx_GetException(%s) < 0) %s" % (
|
|
exc_args, code.error_goto(self.pos)))
|
|
for var in exc_vars:
|
|
code.put_gotref(var)
|
|
if self.target:
|
|
self.exc_value.set_var(exc_vars[1])
|
|
self.exc_value.generate_evaluation_code(code)
|
|
self.target.generate_assignment_code(self.exc_value, code)
|
|
if self.excinfo_target is not None:
|
|
for tempvar, node in zip(exc_vars, self.excinfo_target.args):
|
|
node.set_var(tempvar)
|
|
|
|
old_break_label, old_continue_label = code.break_label, code.continue_label
|
|
code.break_label = code.new_label('except_break')
|
|
code.continue_label = code.new_label('except_continue')
|
|
|
|
old_exc_vars = code.funcstate.exc_vars
|
|
code.funcstate.exc_vars = exc_vars
|
|
self.body.generate_execution_code(code)
|
|
code.funcstate.exc_vars = old_exc_vars
|
|
|
|
if not self.body.is_terminator:
|
|
for var in exc_vars:
|
|
# FIXME: XDECREF() is needed to allow re-raising (which clears the exc_vars),
|
|
# but I don't think it's the right solution.
|
|
code.put_xdecref_clear(var, py_object_type)
|
|
code.put_goto(end_label)
|
|
|
|
for new_label, old_label in [(code.break_label, old_break_label),
|
|
(code.continue_label, old_continue_label)]:
|
|
if code.label_used(new_label):
|
|
code.put_label(new_label)
|
|
for var in exc_vars:
|
|
code.put_decref_clear(var, py_object_type)
|
|
code.put_goto(old_label)
|
|
code.break_label = old_break_label
|
|
code.continue_label = old_continue_label
|
|
|
|
for temp in exc_vars:
|
|
code.funcstate.release_temp(temp)
|
|
|
|
code.putln(
|
|
"}")
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
if self.target is not None:
|
|
self.target.generate_function_definitions(env, code)
|
|
self.body.generate_function_definitions(env, code)
|
|
|
|
def annotate(self, code):
|
|
if self.pattern:
|
|
for pattern in self.pattern:
|
|
pattern.annotate(code)
|
|
if self.target:
|
|
self.target.annotate(code)
|
|
self.body.annotate(code)
|
|
|
|
|
|
class TryFinallyStatNode(StatNode):
|
|
# try ... finally statement
|
|
#
|
|
# body StatNode
|
|
# finally_clause StatNode
|
|
# finally_except_clause deep-copy of finally_clause for exception case
|
|
# in_generator inside of generator => must store away current exception also in return case
|
|
#
|
|
# Each of the continue, break, return and error gotos runs
|
|
# into its own deep-copy of the finally block code.
|
|
# In addition, if we're doing an error, we save the
|
|
# exception on entry to the finally block and restore
|
|
# it on exit.
|
|
|
|
child_attrs = ["body", "finally_clause", "finally_except_clause"]
|
|
|
|
preserve_exception = 1
|
|
|
|
# handle exception case, in addition to return/break/continue
|
|
handle_error_case = True
|
|
func_return_type = None
|
|
finally_except_clause = None
|
|
|
|
is_try_finally_in_nogil = False
|
|
in_generator = False
|
|
|
|
@staticmethod
|
|
def create_analysed(pos, env, body, finally_clause):
|
|
node = TryFinallyStatNode(pos, body=body, finally_clause=finally_clause)
|
|
return node
|
|
|
|
def analyse_declarations(self, env):
|
|
self.body.analyse_declarations(env)
|
|
self.finally_except_clause = copy.deepcopy(self.finally_clause)
|
|
self.finally_except_clause.analyse_declarations(env)
|
|
self.finally_clause.analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.body = self.body.analyse_expressions(env)
|
|
self.finally_clause = self.finally_clause.analyse_expressions(env)
|
|
self.finally_except_clause = self.finally_except_clause.analyse_expressions(env)
|
|
if env.return_type and not env.return_type.is_void:
|
|
self.func_return_type = env.return_type
|
|
return self
|
|
|
|
nogil_check = Node.gil_error
|
|
gil_message = "Try-finally statement"
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos) # before changing the error label, in case of tracing errors
|
|
code.putln("/*try:*/ {")
|
|
|
|
old_error_label = code.error_label
|
|
old_labels = code.all_new_labels()
|
|
new_labels = code.get_all_labels()
|
|
new_error_label = code.error_label
|
|
if not self.handle_error_case:
|
|
code.error_label = old_error_label
|
|
catch_label = code.new_label()
|
|
|
|
was_in_try_finally = code.funcstate.in_try_finally
|
|
code.funcstate.in_try_finally = 1
|
|
|
|
self.body.generate_execution_code(code)
|
|
|
|
code.funcstate.in_try_finally = was_in_try_finally
|
|
code.putln("}")
|
|
|
|
temps_to_clean_up = code.funcstate.all_free_managed_temps()
|
|
code.mark_pos(self.finally_clause.pos)
|
|
code.putln("/*finally:*/ {")
|
|
|
|
# Reset labels only after writing out a potential line trace call for correct nogil error handling.
|
|
code.set_all_labels(old_labels)
|
|
|
|
def fresh_finally_clause(_next=[self.finally_clause]):
|
|
# generate the original subtree once and always keep a fresh copy
|
|
node = _next[0]
|
|
node_copy = copy.deepcopy(node)
|
|
if node is self.finally_clause:
|
|
_next[0] = node_copy
|
|
else:
|
|
node = node_copy
|
|
return node
|
|
|
|
preserve_error = self.preserve_exception and code.label_used(new_error_label)
|
|
needs_success_cleanup = not self.finally_clause.is_terminator
|
|
|
|
if not self.body.is_terminator:
|
|
code.putln('/*normal exit:*/{')
|
|
fresh_finally_clause().generate_execution_code(code)
|
|
if not self.finally_clause.is_terminator:
|
|
code.put_goto(catch_label)
|
|
code.putln('}')
|
|
|
|
if preserve_error:
|
|
code.put_label(new_error_label)
|
|
code.putln('/*exception exit:*/{')
|
|
if not self.in_generator:
|
|
code.putln("__Pyx_PyThreadState_declare")
|
|
if self.is_try_finally_in_nogil:
|
|
code.declare_gilstate()
|
|
if needs_success_cleanup:
|
|
exc_lineno_cnames = tuple([
|
|
code.funcstate.allocate_temp(PyrexTypes.c_int_type, manage_ref=False)
|
|
for _ in range(2)])
|
|
exc_filename_cname = code.funcstate.allocate_temp(
|
|
PyrexTypes.CPtrType(PyrexTypes.c_const_type(PyrexTypes.c_char_type)),
|
|
manage_ref=False)
|
|
else:
|
|
exc_lineno_cnames = exc_filename_cname = None
|
|
exc_vars = tuple([
|
|
code.funcstate.allocate_temp(py_object_type, manage_ref=False)
|
|
for _ in range(6)])
|
|
self.put_error_catcher(
|
|
code, temps_to_clean_up, exc_vars, exc_lineno_cnames, exc_filename_cname)
|
|
finally_old_labels = code.all_new_labels()
|
|
|
|
code.putln('{')
|
|
old_exc_vars = code.funcstate.exc_vars
|
|
code.funcstate.exc_vars = exc_vars[:3]
|
|
self.finally_except_clause.generate_execution_code(code)
|
|
code.funcstate.exc_vars = old_exc_vars
|
|
code.putln('}')
|
|
|
|
if needs_success_cleanup:
|
|
self.put_error_uncatcher(code, exc_vars, exc_lineno_cnames, exc_filename_cname)
|
|
if exc_lineno_cnames:
|
|
for cname in exc_lineno_cnames:
|
|
code.funcstate.release_temp(cname)
|
|
if exc_filename_cname:
|
|
code.funcstate.release_temp(exc_filename_cname)
|
|
code.put_goto(old_error_label)
|
|
|
|
for new_label, old_label in zip(code.get_all_labels(), finally_old_labels):
|
|
if not code.label_used(new_label):
|
|
continue
|
|
code.put_label(new_label)
|
|
self.put_error_cleaner(code, exc_vars)
|
|
code.put_goto(old_label)
|
|
|
|
for cname in exc_vars:
|
|
code.funcstate.release_temp(cname)
|
|
code.putln('}')
|
|
|
|
code.set_all_labels(old_labels)
|
|
return_label = code.return_label
|
|
exc_vars = ()
|
|
|
|
for i, (new_label, old_label) in enumerate(zip(new_labels, old_labels)):
|
|
if not code.label_used(new_label):
|
|
continue
|
|
if new_label == new_error_label and preserve_error:
|
|
continue # handled above
|
|
|
|
code.putln('%s: {' % new_label)
|
|
ret_temp = None
|
|
if old_label == return_label:
|
|
# return actually raises an (uncatchable) exception in generators that we must preserve
|
|
if self.in_generator:
|
|
exc_vars = tuple([
|
|
code.funcstate.allocate_temp(py_object_type, manage_ref=False)
|
|
for _ in range(6)])
|
|
self.put_error_catcher(code, [], exc_vars)
|
|
if not self.finally_clause.is_terminator:
|
|
# store away return value for later reuse
|
|
if (self.func_return_type and
|
|
not self.is_try_finally_in_nogil and
|
|
not isinstance(self.finally_clause, GILExitNode)):
|
|
ret_temp = code.funcstate.allocate_temp(
|
|
self.func_return_type, manage_ref=False)
|
|
code.putln("%s = %s;" % (ret_temp, Naming.retval_cname))
|
|
if self.func_return_type.is_pyobject:
|
|
code.putln("%s = 0;" % Naming.retval_cname)
|
|
|
|
fresh_finally_clause().generate_execution_code(code)
|
|
|
|
if old_label == return_label:
|
|
if ret_temp:
|
|
code.putln("%s = %s;" % (Naming.retval_cname, ret_temp))
|
|
if self.func_return_type.is_pyobject:
|
|
code.putln("%s = 0;" % ret_temp)
|
|
code.funcstate.release_temp(ret_temp)
|
|
if self.in_generator:
|
|
self.put_error_uncatcher(code, exc_vars)
|
|
for cname in exc_vars:
|
|
code.funcstate.release_temp(cname)
|
|
|
|
if not self.finally_clause.is_terminator:
|
|
code.put_goto(old_label)
|
|
code.putln('}')
|
|
|
|
# End finally
|
|
code.put_label(catch_label)
|
|
code.putln(
|
|
"}")
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
self.body.generate_function_definitions(env, code)
|
|
self.finally_clause.generate_function_definitions(env, code)
|
|
if self.finally_except_clause:
|
|
self.finally_except_clause.generate_function_definitions(env, code)
|
|
|
|
def put_error_catcher(self, code, temps_to_clean_up, exc_vars,
|
|
exc_lineno_cnames=None, exc_filename_cname=None):
|
|
code.globalstate.use_utility_code(restore_exception_utility_code)
|
|
code.globalstate.use_utility_code(get_exception_utility_code)
|
|
code.globalstate.use_utility_code(swap_exception_utility_code)
|
|
|
|
if self.is_try_finally_in_nogil:
|
|
code.put_ensure_gil(declare_gilstate=False)
|
|
code.putln("__Pyx_PyThreadState_assign")
|
|
|
|
code.putln(' '.join(["%s = 0;" % var for var in exc_vars]))
|
|
for temp_name, type in temps_to_clean_up:
|
|
code.put_xdecref_clear(temp_name, type)
|
|
|
|
# not using preprocessor here to avoid warnings about
|
|
# unused utility functions and/or temps
|
|
code.putln("if (PY_MAJOR_VERSION >= 3)"
|
|
" __Pyx_ExceptionSwap(&%s, &%s, &%s);" % exc_vars[3:])
|
|
code.putln("if ((PY_MAJOR_VERSION < 3) ||"
|
|
# if __Pyx_GetException() fails in Py3,
|
|
# store the newly raised exception instead
|
|
" unlikely(__Pyx_GetException(&%s, &%s, &%s) < 0)) "
|
|
"__Pyx_ErrFetch(&%s, &%s, &%s);" % (exc_vars[:3] * 2))
|
|
for var in exc_vars:
|
|
code.put_xgotref(var)
|
|
if exc_lineno_cnames:
|
|
code.putln("%s = %s; %s = %s; %s = %s;" % (
|
|
exc_lineno_cnames[0], Naming.lineno_cname,
|
|
exc_lineno_cnames[1], Naming.clineno_cname,
|
|
exc_filename_cname, Naming.filename_cname))
|
|
|
|
if self.is_try_finally_in_nogil:
|
|
code.put_release_ensured_gil()
|
|
|
|
def put_error_uncatcher(self, code, exc_vars, exc_lineno_cnames=None, exc_filename_cname=None):
|
|
code.globalstate.use_utility_code(restore_exception_utility_code)
|
|
code.globalstate.use_utility_code(reset_exception_utility_code)
|
|
|
|
if self.is_try_finally_in_nogil:
|
|
code.put_ensure_gil(declare_gilstate=False)
|
|
|
|
# not using preprocessor here to avoid warnings about
|
|
# unused utility functions and/or temps
|
|
code.putln("if (PY_MAJOR_VERSION >= 3) {")
|
|
for var in exc_vars[3:]:
|
|
code.put_xgiveref(var)
|
|
code.putln("__Pyx_ExceptionReset(%s, %s, %s);" % exc_vars[3:])
|
|
code.putln("}")
|
|
for var in exc_vars[:3]:
|
|
code.put_xgiveref(var)
|
|
code.putln("__Pyx_ErrRestore(%s, %s, %s);" % exc_vars[:3])
|
|
|
|
if self.is_try_finally_in_nogil:
|
|
code.put_release_ensured_gil()
|
|
|
|
code.putln(' '.join(["%s = 0;" % var for var in exc_vars]))
|
|
if exc_lineno_cnames:
|
|
code.putln("%s = %s; %s = %s; %s = %s;" % (
|
|
Naming.lineno_cname, exc_lineno_cnames[0],
|
|
Naming.clineno_cname, exc_lineno_cnames[1],
|
|
Naming.filename_cname, exc_filename_cname))
|
|
|
|
def put_error_cleaner(self, code, exc_vars):
|
|
code.globalstate.use_utility_code(reset_exception_utility_code)
|
|
if self.is_try_finally_in_nogil:
|
|
code.put_ensure_gil(declare_gilstate=False)
|
|
|
|
# not using preprocessor here to avoid warnings about
|
|
# unused utility functions and/or temps
|
|
code.putln("if (PY_MAJOR_VERSION >= 3) {")
|
|
for var in exc_vars[3:]:
|
|
code.put_xgiveref(var)
|
|
code.putln("__Pyx_ExceptionReset(%s, %s, %s);" % exc_vars[3:])
|
|
code.putln("}")
|
|
for var in exc_vars[:3]:
|
|
code.put_xdecref_clear(var, py_object_type)
|
|
if self.is_try_finally_in_nogil:
|
|
code.put_release_ensured_gil()
|
|
code.putln(' '.join(["%s = 0;"]*3) % exc_vars[3:])
|
|
|
|
def annotate(self, code):
|
|
self.body.annotate(code)
|
|
self.finally_clause.annotate(code)
|
|
|
|
|
|
class NogilTryFinallyStatNode(TryFinallyStatNode):
|
|
"""
|
|
A try/finally statement that may be used in nogil code sections.
|
|
"""
|
|
|
|
preserve_exception = False
|
|
nogil_check = None
|
|
|
|
|
|
class GILStatNode(NogilTryFinallyStatNode):
|
|
# 'with gil' or 'with nogil' statement
|
|
#
|
|
# state string 'gil' or 'nogil'
|
|
|
|
state_temp = None
|
|
|
|
def __init__(self, pos, state, body):
|
|
self.state = state
|
|
self.create_state_temp_if_needed(pos, state, body)
|
|
TryFinallyStatNode.__init__(
|
|
self, pos,
|
|
body=body,
|
|
finally_clause=GILExitNode(
|
|
pos, state=state, state_temp=self.state_temp))
|
|
|
|
def create_state_temp_if_needed(self, pos, state, body):
|
|
from .ParseTreeTransforms import YieldNodeCollector
|
|
collector = YieldNodeCollector()
|
|
collector.visitchildren(body)
|
|
if not collector.yields:
|
|
return
|
|
|
|
if state == 'gil':
|
|
temp_type = PyrexTypes.c_gilstate_type
|
|
else:
|
|
temp_type = PyrexTypes.c_threadstate_ptr_type
|
|
from . import ExprNodes
|
|
self.state_temp = ExprNodes.TempNode(pos, temp_type)
|
|
|
|
def analyse_declarations(self, env):
|
|
env._in_with_gil_block = (self.state == 'gil')
|
|
if self.state == 'gil':
|
|
env.has_with_gil_block = True
|
|
|
|
return super(GILStatNode, self).analyse_declarations(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
env.use_utility_code(
|
|
UtilityCode.load_cached("ForceInitThreads", "ModuleSetupCode.c"))
|
|
was_nogil = env.nogil
|
|
env.nogil = self.state == 'nogil'
|
|
node = TryFinallyStatNode.analyse_expressions(self, env)
|
|
env.nogil = was_nogil
|
|
return node
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
code.begin_block()
|
|
if self.state_temp:
|
|
self.state_temp.allocate(code)
|
|
variable = self.state_temp.result()
|
|
else:
|
|
variable = None
|
|
|
|
old_gil_config = code.funcstate.gil_owned
|
|
if self.state == 'gil':
|
|
code.put_ensure_gil(variable=variable)
|
|
code.funcstate.gil_owned = True
|
|
else:
|
|
code.put_release_gil(variable=variable)
|
|
code.funcstate.gil_owned = False
|
|
|
|
TryFinallyStatNode.generate_execution_code(self, code)
|
|
|
|
if self.state_temp:
|
|
self.state_temp.release(code)
|
|
|
|
code.funcstate.gil_owned = old_gil_config
|
|
code.end_block()
|
|
|
|
|
|
class GILExitNode(StatNode):
|
|
"""
|
|
Used as the 'finally' block in a GILStatNode
|
|
|
|
state string 'gil' or 'nogil'
|
|
"""
|
|
|
|
child_attrs = []
|
|
state_temp = None
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
if self.state_temp:
|
|
variable = self.state_temp.result()
|
|
else:
|
|
variable = None
|
|
|
|
if self.state == 'gil':
|
|
code.put_release_ensured_gil(variable)
|
|
else:
|
|
code.put_acquire_gil(variable)
|
|
|
|
|
|
class EnsureGILNode(GILExitNode):
|
|
"""
|
|
Ensure the GIL in nogil functions for cleanup before returning.
|
|
"""
|
|
|
|
def generate_execution_code(self, code):
|
|
code.put_ensure_gil(declare_gilstate=False)
|
|
|
|
|
|
def cython_view_utility_code():
|
|
from . import MemoryView
|
|
return MemoryView.view_utility_code
|
|
|
|
|
|
utility_code_for_cimports = {
|
|
# utility code (or inlining c) in a pxd (or pyx) file.
|
|
# TODO: Consider a generic user-level mechanism for importing
|
|
'cpython.array' : lambda : UtilityCode.load_cached("ArrayAPI", "arrayarray.h"),
|
|
'cpython.array.array' : lambda : UtilityCode.load_cached("ArrayAPI", "arrayarray.h"),
|
|
'cython.view' : cython_view_utility_code,
|
|
}
|
|
|
|
utility_code_for_imports = {
|
|
# utility code used when special modules are imported.
|
|
# TODO: Consider a generic user-level mechanism for importing
|
|
'asyncio': ("__Pyx_patch_asyncio", "PatchAsyncIO", "Coroutine.c"),
|
|
'inspect': ("__Pyx_patch_inspect", "PatchInspect", "Coroutine.c"),
|
|
}
|
|
|
|
|
|
class CImportStatNode(StatNode):
|
|
# cimport statement
|
|
#
|
|
# module_name string Qualified name of module being imported
|
|
# as_name string or None Name specified in "as" clause, if any
|
|
# is_absolute bool True for absolute imports, False otherwise
|
|
|
|
child_attrs = []
|
|
is_absolute = False
|
|
|
|
def analyse_declarations(self, env):
|
|
if not env.is_module_scope:
|
|
error(self.pos, "cimport only allowed at module level")
|
|
return
|
|
module_scope = env.find_module(
|
|
self.module_name, self.pos, relative_level=0 if self.is_absolute else -1)
|
|
if "." in self.module_name:
|
|
names = [EncodedString(name) for name in self.module_name.split(".")]
|
|
top_name = names[0]
|
|
top_module_scope = env.context.find_submodule(top_name)
|
|
module_scope = top_module_scope
|
|
for name in names[1:]:
|
|
submodule_scope = module_scope.find_submodule(name)
|
|
module_scope.declare_module(name, submodule_scope, self.pos)
|
|
module_scope = submodule_scope
|
|
if self.as_name:
|
|
env.declare_module(self.as_name, module_scope, self.pos)
|
|
else:
|
|
env.add_imported_module(module_scope)
|
|
env.declare_module(top_name, top_module_scope, self.pos)
|
|
else:
|
|
name = self.as_name or self.module_name
|
|
env.declare_module(name, module_scope, self.pos)
|
|
if self.module_name in utility_code_for_cimports:
|
|
env.use_utility_code(utility_code_for_cimports[self.module_name]())
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
pass
|
|
|
|
|
|
class FromCImportStatNode(StatNode):
|
|
# from ... cimport statement
|
|
#
|
|
# module_name string Qualified name of module
|
|
# relative_level int or None Relative import: number of dots before module_name
|
|
# imported_names [(pos, name, as_name, kind)] Names to be imported
|
|
|
|
child_attrs = []
|
|
module_name = None
|
|
relative_level = None
|
|
imported_names = None
|
|
|
|
def analyse_declarations(self, env):
|
|
if not env.is_module_scope:
|
|
error(self.pos, "cimport only allowed at module level")
|
|
return
|
|
if self.relative_level and self.relative_level > env.qualified_name.count('.'):
|
|
error(self.pos, "relative cimport beyond main package is not allowed")
|
|
return
|
|
module_scope = env.find_module(self.module_name, self.pos, relative_level=self.relative_level)
|
|
module_name = module_scope.qualified_name
|
|
env.add_imported_module(module_scope)
|
|
for pos, name, as_name, kind in self.imported_names:
|
|
if name == "*":
|
|
for local_name, entry in list(module_scope.entries.items()):
|
|
env.add_imported_entry(local_name, entry, pos)
|
|
else:
|
|
entry = module_scope.lookup(name)
|
|
if entry:
|
|
if kind and not self.declaration_matches(entry, kind):
|
|
entry.redeclared(pos)
|
|
entry.used = 1
|
|
else:
|
|
if kind == 'struct' or kind == 'union':
|
|
entry = module_scope.declare_struct_or_union(
|
|
name, kind=kind, scope=None, typedef_flag=0, pos=pos)
|
|
elif kind == 'class':
|
|
entry = module_scope.declare_c_class(name, pos=pos, module_name=module_name)
|
|
else:
|
|
submodule_scope = env.context.find_module(
|
|
name, relative_to=module_scope, pos=self.pos, absolute_fallback=False)
|
|
if submodule_scope.parent_module is module_scope:
|
|
env.declare_module(as_name or name, submodule_scope, self.pos)
|
|
else:
|
|
error(pos, "Name '%s' not declared in module '%s'" % (name, module_name))
|
|
|
|
if entry:
|
|
local_name = as_name or name
|
|
env.add_imported_entry(local_name, entry, pos)
|
|
|
|
if module_name.startswith('cpython') or module_name.startswith('cython'): # enough for now
|
|
if module_name in utility_code_for_cimports:
|
|
env.use_utility_code(utility_code_for_cimports[module_name]())
|
|
for _, name, _, _ in self.imported_names:
|
|
fqname = '%s.%s' % (module_name, name)
|
|
if fqname in utility_code_for_cimports:
|
|
env.use_utility_code(utility_code_for_cimports[fqname]())
|
|
|
|
def declaration_matches(self, entry, kind):
|
|
if not entry.is_type:
|
|
return 0
|
|
type = entry.type
|
|
if kind == 'class':
|
|
if not type.is_extension_type:
|
|
return 0
|
|
else:
|
|
if not type.is_struct_or_union:
|
|
return 0
|
|
if kind != type.kind:
|
|
return 0
|
|
return 1
|
|
|
|
def analyse_expressions(self, env):
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
pass
|
|
|
|
|
|
class FromImportStatNode(StatNode):
|
|
# from ... import statement
|
|
#
|
|
# module ImportNode
|
|
# items [(string, NameNode)]
|
|
# interned_items [(string, NameNode, ExprNode)]
|
|
# item PyTempNode used internally
|
|
# import_star boolean used internally
|
|
|
|
child_attrs = ["module"]
|
|
import_star = 0
|
|
|
|
def analyse_declarations(self, env):
|
|
for name, target in self.items:
|
|
if name == "*":
|
|
if not env.is_module_scope:
|
|
error(self.pos, "import * only allowed at module level")
|
|
return
|
|
env.has_import_star = 1
|
|
self.import_star = 1
|
|
else:
|
|
target.analyse_target_declaration(env)
|
|
|
|
def analyse_expressions(self, env):
|
|
from . import ExprNodes
|
|
self.module = self.module.analyse_expressions(env)
|
|
self.item = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
|
|
self.interned_items = []
|
|
for name, target in self.items:
|
|
if name == '*':
|
|
for _, entry in env.entries.items():
|
|
if not entry.is_type and entry.type.is_extension_type:
|
|
env.use_utility_code(UtilityCode.load_cached("ExtTypeTest", "ObjectHandling.c"))
|
|
break
|
|
else:
|
|
entry = env.lookup(target.name)
|
|
# check whether or not entry is already cimported
|
|
if (entry.is_type and entry.type.name == name
|
|
and hasattr(entry.type, 'module_name')):
|
|
if entry.type.module_name == self.module.module_name.value:
|
|
# cimported with absolute name
|
|
continue
|
|
try:
|
|
# cimported with relative name
|
|
module = env.find_module(self.module.module_name.value, pos=self.pos,
|
|
relative_level=self.module.level)
|
|
if entry.type.module_name == module.qualified_name:
|
|
continue
|
|
except AttributeError:
|
|
pass
|
|
target = target.analyse_target_expression(env, None) # FIXME?
|
|
if target.type is py_object_type:
|
|
coerced_item = None
|
|
else:
|
|
coerced_item = self.item.coerce_to(target.type, env)
|
|
self.interned_items.append((name, target, coerced_item))
|
|
return self
|
|
|
|
def generate_execution_code(self, code):
|
|
code.mark_pos(self.pos)
|
|
self.module.generate_evaluation_code(code)
|
|
if self.import_star:
|
|
code.putln(
|
|
'if (%s(%s) < 0) %s;' % (
|
|
Naming.import_star,
|
|
self.module.py_result(),
|
|
code.error_goto(self.pos)))
|
|
item_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
|
|
self.item.set_cname(item_temp)
|
|
if self.interned_items:
|
|
code.globalstate.use_utility_code(
|
|
UtilityCode.load_cached("ImportFrom", "ImportExport.c"))
|
|
for name, target, coerced_item in self.interned_items:
|
|
code.putln(
|
|
'%s = __Pyx_ImportFrom(%s, %s); %s' % (
|
|
item_temp,
|
|
self.module.py_result(),
|
|
code.intern_identifier(name),
|
|
code.error_goto_if_null(item_temp, self.pos)))
|
|
code.put_gotref(item_temp)
|
|
if coerced_item is None:
|
|
target.generate_assignment_code(self.item, code)
|
|
else:
|
|
coerced_item.allocate_temp_result(code)
|
|
coerced_item.generate_result_code(code)
|
|
target.generate_assignment_code(coerced_item, code)
|
|
code.put_decref_clear(item_temp, py_object_type)
|
|
code.funcstate.release_temp(item_temp)
|
|
self.module.generate_disposal_code(code)
|
|
self.module.free_temps(code)
|
|
|
|
|
|
class ParallelNode(Node):
|
|
"""
|
|
Base class for cython.parallel constructs.
|
|
"""
|
|
|
|
nogil_check = None
|
|
|
|
|
|
class ParallelStatNode(StatNode, ParallelNode):
|
|
"""
|
|
Base class for 'with cython.parallel.parallel():' and 'for i in prange():'.
|
|
|
|
assignments { Entry(var) : (var.pos, inplace_operator_or_None) }
|
|
assignments to variables in this parallel section
|
|
|
|
parent parent ParallelStatNode or None
|
|
is_parallel indicates whether this node is OpenMP parallel
|
|
(true for #pragma omp parallel for and
|
|
#pragma omp parallel)
|
|
|
|
is_parallel is true for:
|
|
|
|
#pragma omp parallel
|
|
#pragma omp parallel for
|
|
|
|
sections, but NOT for
|
|
|
|
#pragma omp for
|
|
|
|
We need this to determine the sharing attributes.
|
|
|
|
privatization_insertion_point a code insertion point used to make temps
|
|
private (esp. the "nsteps" temp)
|
|
|
|
args tuple the arguments passed to the parallel construct
|
|
kwargs DictNode the keyword arguments passed to the parallel
|
|
construct (replaced by its compile time value)
|
|
"""
|
|
|
|
child_attrs = ['body', 'num_threads']
|
|
|
|
body = None
|
|
|
|
is_prange = False
|
|
is_nested_prange = False
|
|
|
|
error_label_used = False
|
|
|
|
num_threads = None
|
|
chunksize = None
|
|
|
|
parallel_exc = (
|
|
Naming.parallel_exc_type,
|
|
Naming.parallel_exc_value,
|
|
Naming.parallel_exc_tb,
|
|
)
|
|
|
|
parallel_pos_info = (
|
|
Naming.parallel_filename,
|
|
Naming.parallel_lineno,
|
|
Naming.parallel_clineno,
|
|
)
|
|
|
|
pos_info = (
|
|
Naming.filename_cname,
|
|
Naming.lineno_cname,
|
|
Naming.clineno_cname,
|
|
)
|
|
|
|
critical_section_counter = 0
|
|
|
|
def __init__(self, pos, **kwargs):
|
|
super(ParallelStatNode, self).__init__(pos, **kwargs)
|
|
|
|
# All assignments in this scope
|
|
self.assignments = kwargs.get('assignments') or {}
|
|
|
|
# All seen closure cnames and their temporary cnames
|
|
self.seen_closure_vars = set()
|
|
|
|
# Dict of variables that should be declared (first|last|)private or
|
|
# reduction { Entry: (op, lastprivate) }.
|
|
# If op is not None, it's a reduction.
|
|
self.privates = {}
|
|
|
|
# [NameNode]
|
|
self.assigned_nodes = []
|
|
|
|
def analyse_declarations(self, env):
|
|
self.body.analyse_declarations(env)
|
|
|
|
self.num_threads = None
|
|
|
|
if self.kwargs:
|
|
# Try to find num_threads and chunksize keyword arguments
|
|
pairs = []
|
|
seen = set()
|
|
for dictitem in self.kwargs.key_value_pairs:
|
|
if dictitem.key.value in seen:
|
|
error(self.pos, "Duplicate keyword argument found: %s" % dictitem.key.value)
|
|
seen.add(dictitem.key.value)
|
|
if dictitem.key.value == 'num_threads':
|
|
if not dictitem.value.is_none:
|
|
self.num_threads = dictitem.value
|
|
elif self.is_prange and dictitem.key.value == 'chunksize':
|
|
if not dictitem.value.is_none:
|
|
self.chunksize = dictitem.value
|
|
else:
|
|
pairs.append(dictitem)
|
|
|
|
self.kwargs.key_value_pairs = pairs
|
|
|
|
try:
|
|
self.kwargs = self.kwargs.compile_time_value(env)
|
|
except Exception as e:
|
|
error(self.kwargs.pos, "Only compile-time values may be "
|
|
"supplied as keyword arguments")
|
|
else:
|
|
self.kwargs = {}
|
|
|
|
for kw, val in self.kwargs.items():
|
|
if kw not in self.valid_keyword_arguments:
|
|
error(self.pos, "Invalid keyword argument: %s" % kw)
|
|
else:
|
|
setattr(self, kw, val)
|
|
|
|
def analyse_expressions(self, env):
|
|
if self.num_threads:
|
|
self.num_threads = self.num_threads.analyse_expressions(env)
|
|
|
|
if self.chunksize:
|
|
self.chunksize = self.chunksize.analyse_expressions(env)
|
|
|
|
self.body = self.body.analyse_expressions(env)
|
|
self.analyse_sharing_attributes(env)
|
|
|
|
if self.num_threads is not None:
|
|
if self.parent and self.parent.num_threads is not None and not self.parent.is_prange:
|
|
error(self.pos, "num_threads already declared in outer section")
|
|
elif self.parent and not self.parent.is_prange:
|
|
error(self.pos, "num_threads must be declared in the parent parallel section")
|
|
elif (self.num_threads.type.is_int and
|
|
self.num_threads.is_literal and
|
|
self.num_threads.compile_time_value(env) <= 0):
|
|
error(self.pos, "argument to num_threads must be greater than 0")
|
|
|
|
if not self.num_threads.is_simple() or self.num_threads.type.is_pyobject:
|
|
self.num_threads = self.num_threads.coerce_to(
|
|
PyrexTypes.c_int_type, env).coerce_to_temp(env)
|
|
return self
|
|
|
|
def analyse_sharing_attributes(self, env):
|
|
"""
|
|
Analyse the privates for this block and set them in self.privates.
|
|
This should be called in a post-order fashion during the
|
|
analyse_expressions phase
|
|
"""
|
|
for entry, (pos, op) in self.assignments.items():
|
|
|
|
if self.is_prange and not self.is_parallel:
|
|
# closely nested prange in a with parallel block, disallow
|
|
# assigning to privates in the with parallel block (we
|
|
# consider it too implicit and magicky for users)
|
|
if entry in self.parent.assignments:
|
|
error(pos, "Cannot assign to private of outer parallel block")
|
|
continue
|
|
|
|
if not self.is_prange and op:
|
|
# Again possible, but considered to magicky
|
|
error(pos, "Reductions not allowed for parallel blocks")
|
|
continue
|
|
|
|
# By default all variables should have the same values as if
|
|
# executed sequentially
|
|
lastprivate = True
|
|
self.propagate_var_privatization(entry, pos, op, lastprivate)
|
|
|
|
def propagate_var_privatization(self, entry, pos, op, lastprivate):
|
|
"""
|
|
Propagate the sharing attributes of a variable. If the privatization is
|
|
determined by a parent scope, done propagate further.
|
|
|
|
If we are a prange, we propagate our sharing attributes outwards to
|
|
other pranges. If we are a prange in parallel block and the parallel
|
|
block does not determine the variable private, we propagate to the
|
|
parent of the parent. Recursion stops at parallel blocks, as they have
|
|
no concept of lastprivate or reduction.
|
|
|
|
So the following cases propagate:
|
|
|
|
sum is a reduction for all loops:
|
|
|
|
for i in prange(n):
|
|
for j in prange(n):
|
|
for k in prange(n):
|
|
sum += i * j * k
|
|
|
|
sum is a reduction for both loops, local_var is private to the
|
|
parallel with block:
|
|
|
|
for i in prange(n):
|
|
with parallel:
|
|
local_var = ... # private to the parallel
|
|
for j in prange(n):
|
|
sum += i * j
|
|
|
|
Nested with parallel blocks are disallowed, because they wouldn't
|
|
allow you to propagate lastprivates or reductions:
|
|
|
|
#pragma omp parallel for lastprivate(i)
|
|
for i in prange(n):
|
|
|
|
sum = 0
|
|
|
|
#pragma omp parallel private(j, sum)
|
|
with parallel:
|
|
|
|
#pragma omp parallel
|
|
with parallel:
|
|
|
|
#pragma omp for lastprivate(j) reduction(+:sum)
|
|
for j in prange(n):
|
|
sum += i
|
|
|
|
# sum and j are well-defined here
|
|
|
|
# sum and j are undefined here
|
|
|
|
# sum and j are undefined here
|
|
"""
|
|
self.privates[entry] = (op, lastprivate)
|
|
|
|
if entry.type.is_memoryviewslice:
|
|
error(pos, "Memoryview slices can only be shared in parallel sections")
|
|
return
|
|
|
|
if self.is_prange:
|
|
if not self.is_parallel and entry not in self.parent.assignments:
|
|
# Parent is a parallel with block
|
|
parent = self.parent.parent
|
|
else:
|
|
parent = self.parent
|
|
|
|
# We don't need to propagate privates, only reductions and
|
|
# lastprivates
|
|
if parent and (op or lastprivate):
|
|
parent.propagate_var_privatization(entry, pos, op, lastprivate)
|
|
|
|
def _allocate_closure_temp(self, code, entry):
|
|
"""
|
|
Helper function that allocate a temporary for a closure variable that
|
|
is assigned to.
|
|
"""
|
|
if self.parent:
|
|
return self.parent._allocate_closure_temp(code, entry)
|
|
|
|
if entry.cname in self.seen_closure_vars:
|
|
return entry.cname
|
|
|
|
cname = code.funcstate.allocate_temp(entry.type, True)
|
|
|
|
# Add both the actual cname and the temp cname, as the actual cname
|
|
# will be replaced with the temp cname on the entry
|
|
self.seen_closure_vars.add(entry.cname)
|
|
self.seen_closure_vars.add(cname)
|
|
|
|
self.modified_entries.append((entry, entry.cname))
|
|
code.putln("%s = %s;" % (cname, entry.cname))
|
|
entry.cname = cname
|
|
|
|
def initialize_privates_to_nan(self, code, exclude=None):
|
|
first = True
|
|
|
|
for entry, (op, lastprivate) in sorted(self.privates.items()):
|
|
if not op and (not exclude or entry != exclude):
|
|
invalid_value = entry.type.invalid_value()
|
|
|
|
if invalid_value:
|
|
if first:
|
|
code.putln("/* Initialize private variables to "
|
|
"invalid values */")
|
|
first = False
|
|
code.putln("%s = %s;" % (entry.cname,
|
|
entry.type.cast_code(invalid_value)))
|
|
|
|
def evaluate_before_block(self, code, expr):
|
|
c = self.begin_of_parallel_control_block_point_after_decls
|
|
# we need to set the owner to ourselves temporarily, as
|
|
# allocate_temp may generate a comment in the middle of our pragma
|
|
# otherwise when DebugFlags.debug_temp_code_comments is in effect
|
|
owner = c.funcstate.owner
|
|
c.funcstate.owner = c
|
|
expr.generate_evaluation_code(c)
|
|
c.funcstate.owner = owner
|
|
|
|
return expr.result()
|
|
|
|
def put_num_threads(self, code):
|
|
"""
|
|
Write self.num_threads if set as the num_threads OpenMP directive
|
|
"""
|
|
if self.num_threads is not None:
|
|
code.put(" num_threads(%s)" % self.evaluate_before_block(code, self.num_threads))
|
|
|
|
|
|
def declare_closure_privates(self, code):
|
|
"""
|
|
If a variable is in a scope object, we need to allocate a temp and
|
|
assign the value from the temp to the variable in the scope object
|
|
after the parallel section. This kind of copying should be done only
|
|
in the outermost parallel section.
|
|
"""
|
|
self.modified_entries = []
|
|
|
|
for entry in sorted(self.assignments):
|
|
if entry.from_closure or entry.in_closure:
|
|
self._allocate_closure_temp(code, entry)
|
|
|
|
def release_closure_privates(self, code):
|
|
"""
|
|
Release any temps used for variables in scope objects. As this is the
|
|
outermost parallel block, we don't need to delete the cnames from
|
|
self.seen_closure_vars.
|
|
"""
|
|
for entry, original_cname in self.modified_entries:
|
|
code.putln("%s = %s;" % (original_cname, entry.cname))
|
|
code.funcstate.release_temp(entry.cname)
|
|
entry.cname = original_cname
|
|
|
|
def privatize_temps(self, code, exclude_temps=()):
|
|
"""
|
|
Make any used temporaries private. Before the relevant code block
|
|
code.start_collecting_temps() should have been called.
|
|
"""
|
|
c = self.privatization_insertion_point
|
|
self.privatization_insertion_point = None
|
|
|
|
if self.is_parallel:
|
|
self.temps = temps = code.funcstate.stop_collecting_temps()
|
|
privates, firstprivates = [], []
|
|
for temp, type in sorted(temps):
|
|
if type.is_pyobject or type.is_memoryviewslice:
|
|
firstprivates.append(temp)
|
|
else:
|
|
privates.append(temp)
|
|
|
|
if privates:
|
|
c.put(" private(%s)" % ", ".join(privates))
|
|
if firstprivates:
|
|
c.put(" firstprivate(%s)" % ", ".join(firstprivates))
|
|
|
|
if self.breaking_label_used:
|
|
shared_vars = [Naming.parallel_why]
|
|
if self.error_label_used:
|
|
shared_vars.extend(self.parallel_exc)
|
|
c.put(" private(%s, %s, %s)" % self.pos_info)
|
|
|
|
c.put(" shared(%s)" % ', '.join(shared_vars))
|
|
|
|
def cleanup_temps(self, code):
|
|
# Now clean up any memoryview slice and object temporaries
|
|
if self.is_parallel and not self.is_nested_prange:
|
|
code.putln("/* Clean up any temporaries */")
|
|
for temp, type in sorted(self.temps):
|
|
if type.is_memoryviewslice:
|
|
code.put_xdecref_memoryviewslice(temp, have_gil=False)
|
|
elif type.is_pyobject:
|
|
code.put_xdecref(temp, type)
|
|
code.putln("%s = NULL;" % temp)
|
|
|
|
def setup_parallel_control_flow_block(self, code):
|
|
"""
|
|
Sets up a block that surrounds the parallel block to determine
|
|
how the parallel section was exited. Any kind of return is
|
|
trapped (break, continue, return, exceptions). This is the idea:
|
|
|
|
{
|
|
int why = 0;
|
|
|
|
#pragma omp parallel
|
|
{
|
|
return # -> goto new_return_label;
|
|
goto end_parallel;
|
|
|
|
new_return_label:
|
|
why = 3;
|
|
goto end_parallel;
|
|
|
|
end_parallel:;
|
|
#pragma omp flush(why) # we need to flush for every iteration
|
|
}
|
|
|
|
if (why == 3)
|
|
goto old_return_label;
|
|
}
|
|
"""
|
|
self.old_loop_labels = code.new_loop_labels()
|
|
self.old_error_label = code.new_error_label()
|
|
self.old_return_label = code.return_label
|
|
code.return_label = code.new_label(name="return")
|
|
|
|
code.begin_block() # parallel control flow block
|
|
self.begin_of_parallel_control_block_point = code.insertion_point()
|
|
self.begin_of_parallel_control_block_point_after_decls = code.insertion_point()
|
|
|
|
self.undef_builtin_expect_apple_gcc_bug(code)
|
|
|
|
def begin_parallel_block(self, code):
|
|
"""
|
|
Each OpenMP thread in a parallel section that contains a with gil block
|
|
must have the thread-state initialized. The call to
|
|
PyGILState_Release() then deallocates our threadstate. If we wouldn't
|
|
do this, each with gil block would allocate and deallocate one, thereby
|
|
losing exception information before it can be saved before leaving the
|
|
parallel section.
|
|
"""
|
|
self.begin_of_parallel_block = code.insertion_point()
|
|
|
|
def end_parallel_block(self, code):
|
|
"""
|
|
To ensure all OpenMP threads have thread states, we ensure the GIL
|
|
in each thread (which creates a thread state if it doesn't exist),
|
|
after which we release the GIL.
|
|
On exit, reacquire the GIL and release the thread state.
|
|
|
|
If compiled without OpenMP support (at the C level), then we still have
|
|
to acquire the GIL to decref any object temporaries.
|
|
"""
|
|
begin_code = self.begin_of_parallel_block
|
|
self.begin_of_parallel_block = None
|
|
|
|
if self.error_label_used:
|
|
end_code = code
|
|
|
|
begin_code.putln("#ifdef _OPENMP")
|
|
begin_code.put_ensure_gil(declare_gilstate=True)
|
|
begin_code.putln("Py_BEGIN_ALLOW_THREADS")
|
|
begin_code.putln("#endif /* _OPENMP */")
|
|
|
|
end_code.putln("#ifdef _OPENMP")
|
|
end_code.putln("Py_END_ALLOW_THREADS")
|
|
end_code.putln("#else")
|
|
end_code.put_safe("{\n")
|
|
end_code.put_ensure_gil()
|
|
end_code.putln("#endif /* _OPENMP */")
|
|
self.cleanup_temps(end_code)
|
|
end_code.put_release_ensured_gil()
|
|
end_code.putln("#ifndef _OPENMP")
|
|
end_code.put_safe("}\n")
|
|
end_code.putln("#endif /* _OPENMP */")
|
|
|
|
def trap_parallel_exit(self, code, should_flush=False):
|
|
"""
|
|
Trap any kind of return inside a parallel construct. 'should_flush'
|
|
indicates whether the variable should be flushed, which is needed by
|
|
prange to skip the loop. It also indicates whether we need to register
|
|
a continue (we need this for parallel blocks, but not for prange
|
|
loops, as it is a direct jump there).
|
|
|
|
It uses the same mechanism as try/finally:
|
|
1 continue
|
|
2 break
|
|
3 return
|
|
4 error
|
|
"""
|
|
save_lastprivates_label = code.new_label()
|
|
dont_return_label = code.new_label()
|
|
|
|
self.any_label_used = False
|
|
self.breaking_label_used = False
|
|
self.error_label_used = False
|
|
|
|
self.parallel_private_temps = []
|
|
|
|
all_labels = code.get_all_labels()
|
|
|
|
# Figure this out before starting to generate any code
|
|
for label in all_labels:
|
|
if code.label_used(label):
|
|
self.breaking_label_used = (self.breaking_label_used or
|
|
label != code.continue_label)
|
|
self.any_label_used = True
|
|
|
|
if self.any_label_used:
|
|
code.put_goto(dont_return_label)
|
|
|
|
for i, label in enumerate(all_labels):
|
|
if not code.label_used(label):
|
|
continue
|
|
|
|
is_continue_label = label == code.continue_label
|
|
|
|
code.put_label(label)
|
|
|
|
if not (should_flush and is_continue_label):
|
|
if label == code.error_label:
|
|
self.error_label_used = True
|
|
self.fetch_parallel_exception(code)
|
|
|
|
code.putln("%s = %d;" % (Naming.parallel_why, i + 1))
|
|
|
|
if (self.breaking_label_used and self.is_prange and not
|
|
is_continue_label):
|
|
code.put_goto(save_lastprivates_label)
|
|
else:
|
|
code.put_goto(dont_return_label)
|
|
|
|
if self.any_label_used:
|
|
if self.is_prange and self.breaking_label_used:
|
|
# Don't rely on lastprivate, save our lastprivates
|
|
code.put_label(save_lastprivates_label)
|
|
self.save_parallel_vars(code)
|
|
|
|
code.put_label(dont_return_label)
|
|
|
|
if should_flush and self.breaking_label_used:
|
|
code.putln_openmp("#pragma omp flush(%s)" % Naming.parallel_why)
|
|
|
|
def save_parallel_vars(self, code):
|
|
"""
|
|
The following shenanigans are instated when we break, return or
|
|
propagate errors from a prange. In this case we cannot rely on
|
|
lastprivate() to do its job, as no iterations may have executed yet
|
|
in the last thread, leaving the values undefined. It is most likely
|
|
that the breaking thread has well-defined values of the lastprivate
|
|
variables, so we keep those values.
|
|
"""
|
|
section_name = "__pyx_parallel_lastprivates%d" % self.critical_section_counter
|
|
code.putln_openmp("#pragma omp critical(%s)" % section_name)
|
|
ParallelStatNode.critical_section_counter += 1
|
|
|
|
code.begin_block() # begin critical section
|
|
|
|
c = self.begin_of_parallel_control_block_point
|
|
|
|
temp_count = 0
|
|
for entry, (op, lastprivate) in sorted(self.privates.items()):
|
|
if not lastprivate or entry.type.is_pyobject:
|
|
continue
|
|
|
|
type_decl = entry.type.empty_declaration_code()
|
|
temp_cname = "__pyx_parallel_temp%d" % temp_count
|
|
private_cname = entry.cname
|
|
|
|
temp_count += 1
|
|
|
|
invalid_value = entry.type.invalid_value()
|
|
if invalid_value:
|
|
init = ' = ' + entry.type.cast_code(invalid_value)
|
|
else:
|
|
init = ''
|
|
# Declare the parallel private in the outer block
|
|
c.putln("%s %s%s;" % (type_decl, temp_cname, init))
|
|
|
|
# Initialize before escaping
|
|
code.putln("%s = %s;" % (temp_cname, private_cname))
|
|
|
|
self.parallel_private_temps.append((temp_cname, private_cname))
|
|
|
|
code.end_block() # end critical section
|
|
|
|
def fetch_parallel_exception(self, code):
|
|
"""
|
|
As each OpenMP thread may raise an exception, we need to fetch that
|
|
exception from the threadstate and save it for after the parallel
|
|
section where it can be re-raised in the master thread.
|
|
|
|
Although it would seem that __pyx_filename, __pyx_lineno and
|
|
__pyx_clineno are only assigned to under exception conditions (i.e.,
|
|
when we have the GIL), and thus should be allowed to be shared without
|
|
any race condition, they are in fact subject to the same race
|
|
conditions that they were previously when they were global variables
|
|
and functions were allowed to release the GIL:
|
|
|
|
thread A thread B
|
|
acquire
|
|
set lineno
|
|
release
|
|
acquire
|
|
set lineno
|
|
release
|
|
acquire
|
|
fetch exception
|
|
release
|
|
skip the fetch
|
|
|
|
deallocate threadstate deallocate threadstate
|
|
"""
|
|
code.begin_block()
|
|
code.put_ensure_gil(declare_gilstate=True)
|
|
|
|
code.putln_openmp("#pragma omp flush(%s)" % Naming.parallel_exc_type)
|
|
code.putln(
|
|
"if (!%s) {" % Naming.parallel_exc_type)
|
|
|
|
code.putln("__Pyx_ErrFetchWithState(&%s, &%s, &%s);" % self.parallel_exc)
|
|
pos_info = chain(*zip(self.parallel_pos_info, self.pos_info))
|
|
code.funcstate.uses_error_indicator = True
|
|
code.putln("%s = %s; %s = %s; %s = %s;" % tuple(pos_info))
|
|
code.put_gotref(Naming.parallel_exc_type)
|
|
|
|
code.putln(
|
|
"}")
|
|
|
|
code.put_release_ensured_gil()
|
|
code.end_block()
|
|
|
|
def restore_parallel_exception(self, code):
|
|
"Re-raise a parallel exception"
|
|
code.begin_block()
|
|
code.put_ensure_gil(declare_gilstate=True)
|
|
|
|
code.put_giveref(Naming.parallel_exc_type)
|
|
code.putln("__Pyx_ErrRestoreWithState(%s, %s, %s);" % self.parallel_exc)
|
|
pos_info = chain(*zip(self.pos_info, self.parallel_pos_info))
|
|
code.putln("%s = %s; %s = %s; %s = %s;" % tuple(pos_info))
|
|
|
|
code.put_release_ensured_gil()
|
|
code.end_block()
|
|
|
|
def restore_labels(self, code):
|
|
"""
|
|
Restore all old labels. Call this before the 'else' clause to for
|
|
loops and always before ending the parallel control flow block.
|
|
"""
|
|
code.set_all_labels(self.old_loop_labels + (self.old_return_label,
|
|
self.old_error_label))
|
|
|
|
def end_parallel_control_flow_block(
|
|
self, code, break_=False, continue_=False, return_=False):
|
|
"""
|
|
This ends the parallel control flow block and based on how the parallel
|
|
section was exited, takes the corresponding action. The break_ and
|
|
continue_ parameters indicate whether these should be propagated
|
|
outwards:
|
|
|
|
for i in prange(...):
|
|
with cython.parallel.parallel():
|
|
continue
|
|
|
|
Here break should be trapped in the parallel block, and propagated to
|
|
the for loop.
|
|
"""
|
|
c = self.begin_of_parallel_control_block_point
|
|
self.begin_of_parallel_control_block_point = None
|
|
self.begin_of_parallel_control_block_point_after_decls = None
|
|
|
|
if self.num_threads is not None:
|
|
# FIXME: is it the right place? should not normally produce code.
|
|
self.num_threads.generate_disposal_code(code)
|
|
self.num_threads.free_temps(code)
|
|
|
|
# Firstly, always prefer errors over returning, continue or break
|
|
if self.error_label_used:
|
|
c.putln("const char *%s = NULL; int %s = 0, %s = 0;" % self.parallel_pos_info)
|
|
c.putln("PyObject *%s = NULL, *%s = NULL, *%s = NULL;" % self.parallel_exc)
|
|
|
|
code.putln(
|
|
"if (%s) {" % Naming.parallel_exc_type)
|
|
code.putln("/* This may have been overridden by a continue, "
|
|
"break or return in another thread. Prefer the error. */")
|
|
code.putln("%s = 4;" % Naming.parallel_why)
|
|
code.putln(
|
|
"}")
|
|
|
|
if continue_:
|
|
any_label_used = self.any_label_used
|
|
else:
|
|
any_label_used = self.breaking_label_used
|
|
|
|
if any_label_used:
|
|
# __pyx_parallel_why is used, declare and initialize
|
|
c.putln("int %s;" % Naming.parallel_why)
|
|
c.putln("%s = 0;" % Naming.parallel_why)
|
|
|
|
code.putln(
|
|
"if (%s) {" % Naming.parallel_why)
|
|
|
|
for temp_cname, private_cname in self.parallel_private_temps:
|
|
code.putln("%s = %s;" % (private_cname, temp_cname))
|
|
|
|
code.putln("switch (%s) {" % Naming.parallel_why)
|
|
if continue_:
|
|
code.put(" case 1: ")
|
|
code.put_goto(code.continue_label)
|
|
|
|
if break_:
|
|
code.put(" case 2: ")
|
|
code.put_goto(code.break_label)
|
|
|
|
if return_:
|
|
code.put(" case 3: ")
|
|
code.put_goto(code.return_label)
|
|
|
|
if self.error_label_used:
|
|
code.globalstate.use_utility_code(restore_exception_utility_code)
|
|
code.putln(" case 4:")
|
|
self.restore_parallel_exception(code)
|
|
code.put_goto(code.error_label)
|
|
|
|
code.putln("}") # end switch
|
|
code.putln(
|
|
"}") # end if
|
|
|
|
code.end_block() # end parallel control flow block
|
|
self.redef_builtin_expect_apple_gcc_bug(code)
|
|
|
|
# FIXME: improve with version number for OS X Lion
|
|
buggy_platform_macro_condition = "(defined(__APPLE__) || defined(__OSX__))"
|
|
have_expect_condition = "(defined(__GNUC__) && " \
|
|
"(__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))"
|
|
redef_condition = "(%s && %s)" % (buggy_platform_macro_condition, have_expect_condition)
|
|
|
|
def undef_builtin_expect_apple_gcc_bug(self, code):
|
|
"""
|
|
A bug on OS X Lion disallows __builtin_expect macros. This code avoids them
|
|
"""
|
|
if not self.parent:
|
|
code.undef_builtin_expect(self.redef_condition)
|
|
|
|
def redef_builtin_expect_apple_gcc_bug(self, code):
|
|
if not self.parent:
|
|
code.redef_builtin_expect(self.redef_condition)
|
|
|
|
|
|
class ParallelWithBlockNode(ParallelStatNode):
|
|
"""
|
|
This node represents a 'with cython.parallel.parallel():' block
|
|
"""
|
|
|
|
valid_keyword_arguments = ['num_threads']
|
|
|
|
num_threads = None
|
|
|
|
def analyse_declarations(self, env):
|
|
super(ParallelWithBlockNode, self).analyse_declarations(env)
|
|
if self.args:
|
|
error(self.pos, "cython.parallel.parallel() does not take "
|
|
"positional arguments")
|
|
|
|
def generate_execution_code(self, code):
|
|
self.declare_closure_privates(code)
|
|
self.setup_parallel_control_flow_block(code)
|
|
|
|
code.putln("#ifdef _OPENMP")
|
|
code.put("#pragma omp parallel ")
|
|
|
|
if self.privates:
|
|
privates = [e.cname for e in self.privates
|
|
if not e.type.is_pyobject]
|
|
code.put('private(%s)' % ', '.join(sorted(privates)))
|
|
|
|
self.privatization_insertion_point = code.insertion_point()
|
|
self.put_num_threads(code)
|
|
code.putln("")
|
|
|
|
code.putln("#endif /* _OPENMP */")
|
|
|
|
code.begin_block() # parallel block
|
|
self.begin_parallel_block(code)
|
|
self.initialize_privates_to_nan(code)
|
|
code.funcstate.start_collecting_temps()
|
|
self.body.generate_execution_code(code)
|
|
self.trap_parallel_exit(code)
|
|
self.privatize_temps(code)
|
|
self.end_parallel_block(code)
|
|
code.end_block() # end parallel block
|
|
|
|
continue_ = code.label_used(code.continue_label)
|
|
break_ = code.label_used(code.break_label)
|
|
return_ = code.label_used(code.return_label)
|
|
|
|
self.restore_labels(code)
|
|
self.end_parallel_control_flow_block(code, break_=break_,
|
|
continue_=continue_,
|
|
return_=return_)
|
|
self.release_closure_privates(code)
|
|
|
|
|
|
class ParallelRangeNode(ParallelStatNode):
|
|
"""
|
|
This node represents a 'for i in cython.parallel.prange():' construct.
|
|
|
|
target NameNode the target iteration variable
|
|
else_clause Node or None the else clause of this loop
|
|
"""
|
|
|
|
child_attrs = ['body', 'target', 'else_clause', 'args', 'num_threads',
|
|
'chunksize']
|
|
|
|
body = target = else_clause = args = None
|
|
|
|
start = stop = step = None
|
|
|
|
is_prange = True
|
|
|
|
nogil = None
|
|
schedule = None
|
|
|
|
valid_keyword_arguments = ['schedule', 'nogil', 'num_threads', 'chunksize']
|
|
|
|
def __init__(self, pos, **kwds):
|
|
super(ParallelRangeNode, self).__init__(pos, **kwds)
|
|
# Pretend to be a ForInStatNode for control flow analysis
|
|
self.iterator = PassStatNode(pos)
|
|
|
|
def analyse_declarations(self, env):
|
|
super(ParallelRangeNode, self).analyse_declarations(env)
|
|
self.target.analyse_target_declaration(env)
|
|
if self.else_clause is not None:
|
|
self.else_clause.analyse_declarations(env)
|
|
|
|
if not self.args or len(self.args) > 3:
|
|
error(self.pos, "Invalid number of positional arguments to prange")
|
|
return
|
|
|
|
if len(self.args) == 1:
|
|
self.stop, = self.args
|
|
elif len(self.args) == 2:
|
|
self.start, self.stop = self.args
|
|
else:
|
|
self.start, self.stop, self.step = self.args
|
|
|
|
if hasattr(self.schedule, 'decode'):
|
|
self.schedule = self.schedule.decode('ascii')
|
|
|
|
if self.schedule not in (None, 'static', 'dynamic', 'guided', 'runtime'):
|
|
error(self.pos, "Invalid schedule argument to prange: %s" % (self.schedule,))
|
|
|
|
def analyse_expressions(self, env):
|
|
was_nogil = env.nogil
|
|
if self.nogil:
|
|
env.nogil = True
|
|
|
|
if self.target is None:
|
|
error(self.pos, "prange() can only be used as part of a for loop")
|
|
return self
|
|
|
|
self.target = self.target.analyse_target_types(env)
|
|
|
|
if not self.target.type.is_numeric:
|
|
# Not a valid type, assume one for now anyway
|
|
|
|
if not self.target.type.is_pyobject:
|
|
# nogil_check will catch the is_pyobject case
|
|
error(self.target.pos,
|
|
"Must be of numeric type, not %s" % self.target.type)
|
|
|
|
self.index_type = PyrexTypes.c_py_ssize_t_type
|
|
else:
|
|
self.index_type = self.target.type
|
|
|
|
# Setup start, stop and step, allocating temps if needed
|
|
self.names = 'start', 'stop', 'step'
|
|
start_stop_step = self.start, self.stop, self.step
|
|
|
|
for node, name in zip(start_stop_step, self.names):
|
|
if node is not None:
|
|
node.analyse_types(env)
|
|
if not node.type.is_numeric:
|
|
error(node.pos, "%s argument must be numeric" % name)
|
|
continue
|
|
|
|
if not node.is_literal:
|
|
node = node.coerce_to_temp(env)
|
|
setattr(self, name, node)
|
|
|
|
# As we range from 0 to nsteps, computing the index along the
|
|
# way, we need a fitting type for 'i' and 'nsteps'
|
|
self.index_type = PyrexTypes.widest_numeric_type(
|
|
self.index_type, node.type)
|
|
|
|
if self.else_clause is not None:
|
|
self.else_clause = self.else_clause.analyse_expressions(env)
|
|
|
|
# Although not actually an assignment in this scope, it should be
|
|
# treated as such to ensure it is unpacked if a closure temp, and to
|
|
# ensure lastprivate behaviour and propagation. If the target index is
|
|
# not a NameNode, it won't have an entry, and an error was issued by
|
|
# ParallelRangeTransform
|
|
if hasattr(self.target, 'entry'):
|
|
self.assignments[self.target.entry] = self.target.pos, None
|
|
|
|
node = super(ParallelRangeNode, self).analyse_expressions(env)
|
|
|
|
if node.chunksize:
|
|
if not node.schedule:
|
|
error(node.chunksize.pos,
|
|
"Must provide schedule with chunksize")
|
|
elif node.schedule == 'runtime':
|
|
error(node.chunksize.pos,
|
|
"Chunksize not valid for the schedule runtime")
|
|
elif (node.chunksize.type.is_int and
|
|
node.chunksize.is_literal and
|
|
node.chunksize.compile_time_value(env) <= 0):
|
|
error(node.chunksize.pos, "Chunksize must not be negative")
|
|
|
|
node.chunksize = node.chunksize.coerce_to(
|
|
PyrexTypes.c_int_type, env).coerce_to_temp(env)
|
|
|
|
if node.nogil:
|
|
env.nogil = was_nogil
|
|
|
|
node.is_nested_prange = node.parent and node.parent.is_prange
|
|
if node.is_nested_prange:
|
|
parent = node
|
|
while parent.parent and parent.parent.is_prange:
|
|
parent = parent.parent
|
|
|
|
parent.assignments.update(node.assignments)
|
|
parent.privates.update(node.privates)
|
|
parent.assigned_nodes.extend(node.assigned_nodes)
|
|
return node
|
|
|
|
def nogil_check(self, env):
|
|
names = 'start', 'stop', 'step', 'target'
|
|
nodes = self.start, self.stop, self.step, self.target
|
|
for name, node in zip(names, nodes):
|
|
if node is not None and node.type.is_pyobject:
|
|
error(node.pos, "%s may not be a Python object "
|
|
"as we don't have the GIL" % name)
|
|
|
|
def generate_execution_code(self, code):
|
|
"""
|
|
Generate code in the following steps
|
|
|
|
1) copy any closure variables determined thread-private
|
|
into temporaries
|
|
|
|
2) allocate temps for start, stop and step
|
|
|
|
3) generate a loop that calculates the total number of steps,
|
|
which then computes the target iteration variable for every step:
|
|
|
|
for i in prange(start, stop, step):
|
|
...
|
|
|
|
becomes
|
|
|
|
nsteps = (stop - start) / step;
|
|
i = start;
|
|
|
|
#pragma omp parallel for lastprivate(i)
|
|
for (temp = 0; temp < nsteps; temp++) {
|
|
i = start + step * temp;
|
|
...
|
|
}
|
|
|
|
Note that accumulation of 'i' would have a data dependency
|
|
between iterations.
|
|
|
|
Also, you can't do this
|
|
|
|
for (i = start; i < stop; i += step)
|
|
...
|
|
|
|
as the '<' operator should become '>' for descending loops.
|
|
'for i from x < i < y:' does not suffer from this problem
|
|
as the relational operator is known at compile time!
|
|
|
|
4) release our temps and write back any private closure variables
|
|
"""
|
|
self.declare_closure_privates(code)
|
|
|
|
# This can only be a NameNode
|
|
target_index_cname = self.target.entry.cname
|
|
|
|
# This will be used as the dict to format our code strings, holding
|
|
# the start, stop , step, temps and target cnames
|
|
fmt_dict = {
|
|
'target': target_index_cname,
|
|
'target_type': self.target.type.empty_declaration_code()
|
|
}
|
|
|
|
# Setup start, stop and step, allocating temps if needed
|
|
start_stop_step = self.start, self.stop, self.step
|
|
defaults = '0', '0', '1'
|
|
for node, name, default in zip(start_stop_step, self.names, defaults):
|
|
if node is None:
|
|
result = default
|
|
elif node.is_literal:
|
|
result = node.get_constant_c_result_code()
|
|
else:
|
|
node.generate_evaluation_code(code)
|
|
result = node.result()
|
|
|
|
fmt_dict[name] = result
|
|
|
|
fmt_dict['i'] = code.funcstate.allocate_temp(self.index_type, False)
|
|
fmt_dict['nsteps'] = code.funcstate.allocate_temp(self.index_type, False)
|
|
|
|
# TODO: check if the step is 0 and if so, raise an exception in a
|
|
# 'with gil' block. For now, just abort
|
|
code.putln("if ((%(step)s == 0)) abort();" % fmt_dict)
|
|
|
|
self.setup_parallel_control_flow_block(code) # parallel control flow block
|
|
|
|
# Note: nsteps is private in an outer scope if present
|
|
code.putln("%(nsteps)s = (%(stop)s - %(start)s + %(step)s - %(step)s/abs(%(step)s)) / %(step)s;" % fmt_dict)
|
|
|
|
# The target iteration variable might not be initialized, do it only if
|
|
# we are executing at least 1 iteration, otherwise we should leave the
|
|
# target unaffected. The target iteration variable is firstprivate to
|
|
# shut up compiler warnings caused by lastprivate, as the compiler
|
|
# erroneously believes that nsteps may be <= 0, leaving the private
|
|
# target index uninitialized
|
|
code.putln("if (%(nsteps)s > 0)" % fmt_dict)
|
|
code.begin_block() # if block
|
|
self.generate_loop(code, fmt_dict)
|
|
code.end_block() # end if block
|
|
|
|
self.restore_labels(code)
|
|
|
|
if self.else_clause:
|
|
if self.breaking_label_used:
|
|
code.put("if (%s < 2)" % Naming.parallel_why)
|
|
|
|
code.begin_block() # else block
|
|
code.putln("/* else */")
|
|
self.else_clause.generate_execution_code(code)
|
|
code.end_block() # end else block
|
|
|
|
# ------ cleanup ------
|
|
self.end_parallel_control_flow_block(code) # end parallel control flow block
|
|
|
|
# And finally, release our privates and write back any closure
|
|
# variables
|
|
for temp in start_stop_step + (self.chunksize,):
|
|
if temp is not None:
|
|
temp.generate_disposal_code(code)
|
|
temp.free_temps(code)
|
|
|
|
code.funcstate.release_temp(fmt_dict['i'])
|
|
code.funcstate.release_temp(fmt_dict['nsteps'])
|
|
|
|
self.release_closure_privates(code)
|
|
|
|
def generate_loop(self, code, fmt_dict):
|
|
if self.is_nested_prange:
|
|
code.putln("#if 0")
|
|
else:
|
|
code.putln("#ifdef _OPENMP")
|
|
|
|
if not self.is_parallel:
|
|
code.put("#pragma omp for")
|
|
self.privatization_insertion_point = code.insertion_point()
|
|
reduction_codepoint = self.parent.privatization_insertion_point
|
|
else:
|
|
code.put("#pragma omp parallel")
|
|
self.privatization_insertion_point = code.insertion_point()
|
|
reduction_codepoint = self.privatization_insertion_point
|
|
code.putln("")
|
|
code.putln("#endif /* _OPENMP */")
|
|
|
|
code.begin_block() # pragma omp parallel begin block
|
|
|
|
# Initialize the GIL if needed for this thread
|
|
self.begin_parallel_block(code)
|
|
|
|
if self.is_nested_prange:
|
|
code.putln("#if 0")
|
|
else:
|
|
code.putln("#ifdef _OPENMP")
|
|
code.put("#pragma omp for")
|
|
|
|
for entry, (op, lastprivate) in sorted(self.privates.items()):
|
|
# Don't declare the index variable as a reduction
|
|
if op and op in "+*-&^|" and entry != self.target.entry:
|
|
if entry.type.is_pyobject:
|
|
error(self.pos, "Python objects cannot be reductions")
|
|
else:
|
|
#code.put(" reduction(%s:%s)" % (op, entry.cname))
|
|
# This is the only way reductions + nesting works in gcc4.5
|
|
reduction_codepoint.put(
|
|
" reduction(%s:%s)" % (op, entry.cname))
|
|
else:
|
|
if entry == self.target.entry:
|
|
code.put(" firstprivate(%s)" % entry.cname)
|
|
code.put(" lastprivate(%s)" % entry.cname)
|
|
continue
|
|
|
|
if not entry.type.is_pyobject:
|
|
if lastprivate:
|
|
private = 'lastprivate'
|
|
else:
|
|
private = 'private'
|
|
|
|
code.put(" %s(%s)" % (private, entry.cname))
|
|
|
|
if self.schedule:
|
|
if self.chunksize:
|
|
chunksize = ", %s" % self.evaluate_before_block(code, self.chunksize)
|
|
else:
|
|
chunksize = ""
|
|
|
|
code.put(" schedule(%s%s)" % (self.schedule, chunksize))
|
|
|
|
self.put_num_threads(reduction_codepoint)
|
|
|
|
code.putln("")
|
|
code.putln("#endif /* _OPENMP */")
|
|
|
|
code.put("for (%(i)s = 0; %(i)s < %(nsteps)s; %(i)s++)" % fmt_dict)
|
|
code.begin_block() # for loop block
|
|
|
|
guard_around_body_codepoint = code.insertion_point()
|
|
|
|
# Start if guard block around the body. This may be unnecessary, but
|
|
# at least it doesn't spoil indentation
|
|
code.begin_block()
|
|
|
|
code.putln("%(target)s = (%(target_type)s)(%(start)s + %(step)s * %(i)s);" % fmt_dict)
|
|
self.initialize_privates_to_nan(code, exclude=self.target.entry)
|
|
|
|
if self.is_parallel and not self.is_nested_prange:
|
|
# nested pranges are not omp'ified, temps go to outer loops
|
|
code.funcstate.start_collecting_temps()
|
|
|
|
self.body.generate_execution_code(code)
|
|
self.trap_parallel_exit(code, should_flush=True)
|
|
if self.is_parallel and not self.is_nested_prange:
|
|
# nested pranges are not omp'ified, temps go to outer loops
|
|
self.privatize_temps(code)
|
|
|
|
if self.breaking_label_used:
|
|
# Put a guard around the loop body in case return, break or
|
|
# exceptions might be used
|
|
guard_around_body_codepoint.putln("if (%s < 2)" % Naming.parallel_why)
|
|
|
|
code.end_block() # end guard around loop body
|
|
code.end_block() # end for loop block
|
|
|
|
if self.is_parallel:
|
|
# Release the GIL and deallocate the thread state
|
|
self.end_parallel_block(code)
|
|
code.end_block() # pragma omp parallel end block
|
|
|
|
|
|
class CnameDecoratorNode(StatNode):
|
|
"""
|
|
This node is for the cname decorator in CythonUtilityCode:
|
|
|
|
@cname('the_cname')
|
|
cdef func(...):
|
|
...
|
|
|
|
In case of a cdef class the cname specifies the objstruct_cname.
|
|
|
|
node the node to which the cname decorator is applied
|
|
cname the cname the node should get
|
|
"""
|
|
|
|
child_attrs = ['node']
|
|
|
|
def analyse_declarations(self, env):
|
|
self.node.analyse_declarations(env)
|
|
|
|
node = self.node
|
|
if isinstance(node, CompilerDirectivesNode):
|
|
node = node.body.stats[0]
|
|
|
|
self.is_function = isinstance(node, FuncDefNode)
|
|
is_struct_or_enum = isinstance(node, (CStructOrUnionDefNode, CEnumDefNode))
|
|
e = node.entry
|
|
|
|
if self.is_function:
|
|
e.cname = self.cname
|
|
e.func_cname = self.cname
|
|
e.used = True
|
|
if e.pyfunc_cname and '.' in e.pyfunc_cname:
|
|
e.pyfunc_cname = self.mangle(e.pyfunc_cname)
|
|
elif is_struct_or_enum:
|
|
e.cname = e.type.cname = self.cname
|
|
else:
|
|
scope = node.scope
|
|
|
|
e.cname = self.cname
|
|
e.type.objstruct_cname = self.cname + '_obj'
|
|
e.type.typeobj_cname = Naming.typeobj_prefix + self.cname
|
|
e.type.typeptr_cname = self.cname + '_type'
|
|
e.type.scope.namespace_cname = e.type.typeptr_cname
|
|
|
|
e.as_variable.cname = e.type.typeptr_cname
|
|
|
|
scope.scope_prefix = self.cname + "_"
|
|
|
|
for name, entry in scope.entries.items():
|
|
if entry.func_cname:
|
|
entry.func_cname = self.mangle(entry.cname)
|
|
if entry.pyfunc_cname:
|
|
entry.pyfunc_cname = self.mangle(entry.pyfunc_cname)
|
|
|
|
def mangle(self, cname):
|
|
if '.' in cname:
|
|
# remove __pyx_base from func_cname
|
|
cname = cname.split('.')[-1]
|
|
return '%s_%s' % (self.cname, cname)
|
|
|
|
def analyse_expressions(self, env):
|
|
self.node = self.node.analyse_expressions(env)
|
|
return self
|
|
|
|
def generate_function_definitions(self, env, code):
|
|
"Ensure a prototype for every @cname method in the right place"
|
|
if self.is_function and env.is_c_class_scope:
|
|
# method in cdef class, generate a prototype in the header
|
|
h_code = code.globalstate['utility_code_proto']
|
|
|
|
if isinstance(self.node, DefNode):
|
|
self.node.generate_function_header(
|
|
h_code, with_pymethdef=False, proto_only=True)
|
|
else:
|
|
from . import ModuleNode
|
|
entry = self.node.entry
|
|
cname = entry.cname
|
|
entry.cname = entry.func_cname
|
|
|
|
ModuleNode.generate_cfunction_declaration(
|
|
entry,
|
|
env.global_scope(),
|
|
h_code,
|
|
definition=True)
|
|
|
|
entry.cname = cname
|
|
|
|
self.node.generate_function_definitions(env, code)
|
|
|
|
def generate_execution_code(self, code):
|
|
self.node.generate_execution_code(code)
|
|
|
|
|
|
#------------------------------------------------------------------------------------
|
|
#
|
|
# Runtime support code
|
|
#
|
|
#------------------------------------------------------------------------------------
|
|
|
|
if Options.gcc_branch_hints:
|
|
branch_prediction_macros = """
|
|
/* Test for GCC > 2.95 */
|
|
#if defined(__GNUC__) \
|
|
&& (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
|
|
#define likely(x) __builtin_expect(!!(x), 1)
|
|
#define unlikely(x) __builtin_expect(!!(x), 0)
|
|
#else /* !__GNUC__ or GCC < 2.95 */
|
|
#define likely(x) (x)
|
|
#define unlikely(x) (x)
|
|
#endif /* __GNUC__ */
|
|
"""
|
|
else:
|
|
branch_prediction_macros = """
|
|
#define likely(x) (x)
|
|
#define unlikely(x) (x)
|
|
"""
|
|
|
|
#------------------------------------------------------------------------------------
|
|
|
|
printing_utility_code = UtilityCode.load_cached("Print", "Printing.c")
|
|
printing_one_utility_code = UtilityCode.load_cached("PrintOne", "Printing.c")
|
|
|
|
#------------------------------------------------------------------------------------
|
|
|
|
# Exception raising code
|
|
#
|
|
# Exceptions are raised by __Pyx_Raise() and stored as plain
|
|
# type/value/tb in PyThreadState->curexc_*. When being caught by an
|
|
# 'except' statement, curexc_* is moved over to exc_* by
|
|
# __Pyx_GetException()
|
|
|
|
restore_exception_utility_code = UtilityCode.load_cached("PyErrFetchRestore", "Exceptions.c")
|
|
raise_utility_code = UtilityCode.load_cached("RaiseException", "Exceptions.c")
|
|
get_exception_utility_code = UtilityCode.load_cached("GetException", "Exceptions.c")
|
|
swap_exception_utility_code = UtilityCode.load_cached("SwapException", "Exceptions.c")
|
|
reset_exception_utility_code = UtilityCode.load_cached("SaveResetException", "Exceptions.c")
|
|
traceback_utility_code = UtilityCode.load_cached("AddTraceback", "Exceptions.c")
|
|
|
|
#------------------------------------------------------------------------------------
|
|
|
|
get_exception_tuple_utility_code = UtilityCode(
|
|
proto="""
|
|
static PyObject *__Pyx_GetExceptionTuple(PyThreadState *__pyx_tstate); /*proto*/
|
|
""",
|
|
# I doubt that calling __Pyx_GetException() here is correct as it moves
|
|
# the exception from tstate->curexc_* to tstate->exc_*, which prevents
|
|
# exception handlers later on from receiving it.
|
|
# NOTE: "__pyx_tstate" may be used by __Pyx_GetException() macro
|
|
impl = """
|
|
static PyObject *__Pyx_GetExceptionTuple(CYTHON_UNUSED PyThreadState *__pyx_tstate) {
|
|
PyObject *type = NULL, *value = NULL, *tb = NULL;
|
|
if (__Pyx_GetException(&type, &value, &tb) == 0) {
|
|
PyObject* exc_info = PyTuple_New(3);
|
|
if (exc_info) {
|
|
Py_INCREF(type);
|
|
Py_INCREF(value);
|
|
Py_INCREF(tb);
|
|
PyTuple_SET_ITEM(exc_info, 0, type);
|
|
PyTuple_SET_ITEM(exc_info, 1, value);
|
|
PyTuple_SET_ITEM(exc_info, 2, tb);
|
|
return exc_info;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
""",
|
|
requires=[get_exception_utility_code])
|