| |
| |
| |
|
|
|
|
| import re |
| import copy |
| import operator |
| import math |
|
|
| from ..Utils import try_finally_contextmanager |
| from .Errors import warning, error, InternalError, performance_hint |
| from .StringEncoding import EncodedString |
| from . import Options, Naming |
| from . import PyrexTypes |
| from .PyrexTypes import py_object_type, unspecified_type |
| from .TypeSlots import ( |
| pyfunction_signature, pymethod_signature, richcmp_special_methods, |
| get_slot_table, get_property_accessor_signature) |
| from . import DebugFlags |
|
|
| from . import Code |
|
|
|
|
| def c_safe_identifier(cname): |
| |
| if ((cname[:2] == '__' and not (cname.startswith(Naming.pyrex_prefix) |
| or cname in ('__weakref__', '__dict__'))) |
| or cname in Naming.reserved_cnames): |
| cname = Naming.pyrex_prefix + cname |
| return cname |
|
|
|
|
| def punycodify_name(cname, mangle_with=None): |
| |
| |
| if cname.isascii(): |
| return cname |
|
|
| cname = cname.encode('punycode').replace(b'-', b'_').decode('ascii') |
| if mangle_with: |
| |
| |
| |
| cname = "%s_%s" % (mangle_with, cname) |
| elif cname.startswith(Naming.pyrex_prefix): |
| |
| |
| cname = cname.replace(Naming.pyrex_prefix, |
| Naming.pyunicode_identifier_prefix, 1) |
|
|
| return cname |
|
|
|
|
| class BufferAux: |
| writable_needed = False |
|
|
| def __init__(self, buflocal_nd_var, rcbuf_var): |
| self.buflocal_nd_var = buflocal_nd_var |
| self.rcbuf_var = rcbuf_var |
|
|
| def __repr__(self): |
| return "<BufferAux %r>" % self.__dict__ |
|
|
|
|
| class Entry: |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| |
|
|
| inline_func_in_pxd = False |
| borrowed = 0 |
| init = "" |
| annotation = None |
| visibility = 'private' |
| is_builtin = 0 |
| is_cglobal = 0 |
| is_pyglobal = 0 |
| is_member = 0 |
| is_pyclass_attr = 0 |
| is_variable = 0 |
| is_cfunction = 0 |
| is_cmethod = 0 |
| is_builtin_cmethod = False |
| is_unbound_cmethod = 0 |
| is_final_cmethod = 0 |
| is_inline_cmethod = 0 |
| is_anonymous = 0 |
| is_type = 0 |
| is_cclass = 0 |
| is_cclass_var_entry = False |
| is_cpp_class = 0 |
| is_const = 0 |
| is_property = 0 |
| is_cproperty = 0 |
| doc_cname = None |
| getter_cname = None |
| setter_cname = None |
| is_self_arg = 0 |
| is_arg = 0 |
| is_local = 0 |
| in_closure = 0 |
| from_closure = 0 |
| in_subscope = 0 |
| is_declared_generic = 0 |
| is_readonly = 0 |
| pyfunc_cname = None |
| func_cname = None |
| func_modifiers = [] |
| final_func_cname = None |
| doc = None |
| as_variable = None |
| xdecref_cleanup = 0 |
| in_cinclude = 0 |
| as_module = None |
| is_inherited = 0 |
| pystring_cname = None |
| is_identifier = 0 |
| is_interned = 0 |
| used = 0 |
| is_special = 0 |
| defined_in_pxd = 0 |
| is_implemented = 0 |
| api = 0 |
| utility_code = None |
| specialiser = None |
| is_overridable = 0 |
| buffer_aux = None |
| prev_entry = None |
| might_overflow = 0 |
| fused_cfunction = None |
| is_fused_specialized = False |
| utility_code_definition = None |
| needs_property = False |
| in_with_gil_block = 0 |
| from_cython_utility_code = None |
| error_on_uninitialized = False |
| cf_used = True |
| outer_entry = None |
| is_cgetter = False |
| is_cpp_optional = False |
| known_standard_library_import = None |
| pytyping_modifiers = None |
| enum_int_value = None |
| vtable_type = None |
|
|
| def __init__(self, name, cname, type, pos = None, init = None): |
| self.name = name |
| self.cname = cname |
| self.type = type |
| self.pos = pos |
| self.init = init |
| self.overloaded_alternatives = [] |
| self.cf_assignments = [] |
| self.cf_references = [] |
| self.inner_entries = [] |
| self.defining_entry = self |
|
|
| |
| if DebugFlags.debug_verbose_entry_types: |
| @property |
| def type(self): |
| return self.__dict__['type'] |
|
|
| @type.setter |
| def type(self, new_type): |
| print(f"ENTRY {self.name}[{self.cname}] TYPE: {self.__dict__.get('type')} -> {new_type}") |
| self.__dict__['type'] = new_type |
|
|
| def __repr__(self): |
| return "%s(<%x>, name=%s, type=%s)" % (type(self).__name__, id(self), self.name, self.type) |
|
|
| def already_declared_here(self): |
| error(self.pos, "Previous declaration is here") |
|
|
| def redeclared(self, pos): |
| error(pos, "'%s' does not match previous declaration" % self.name) |
| self.already_declared_here() |
|
|
| def all_alternatives(self): |
| return [self] + self.overloaded_alternatives |
|
|
| def best_function_match(self, scope, arg_types, fail_if_empty=False, arg_is_lvalue_array=None): |
| func_entry = None |
| if self.specialiser is not None: |
| func_entry = self.specialiser(scope, arg_types) |
| if func_entry is None: |
| if self.type.is_fused: |
| functypes = self.type.get_all_specialized_function_types() |
| alternatives = [f.entry for f in functypes] |
| else: |
| alternatives = self.all_alternatives() |
| func_entry = PyrexTypes.best_match( |
| arg_types, alternatives, fail_if_empty=fail_if_empty, arg_is_lvalue_array=arg_is_lvalue_array) |
| return func_entry |
|
|
| def all_entries(self): |
| return [self] + self.inner_entries |
|
|
| def __lt__(left, right): |
| if isinstance(left, Entry) and isinstance(right, Entry): |
| return (left.name, left.cname) < (right.name, right.cname) |
| else: |
| return NotImplemented |
|
|
| @property |
| def cf_is_reassigned(self): |
| return len(self.cf_assignments) > 1 |
|
|
| def make_cpp_optional(self): |
| assert self.type.is_cpp_class |
| self.is_cpp_optional = True |
| assert not self.utility_code |
| self.utility_code_definition = Code.UtilityCode.load_cached("OptionalLocals", "CppSupport.cpp") |
|
|
| def declared_with_pytyping_modifier(self, modifier_name): |
| return modifier_name in self.pytyping_modifiers if self.pytyping_modifiers else False |
|
|
|
|
| class InnerEntry(Entry): |
| """ |
| An entry in a closure scope that represents the real outer Entry. |
| """ |
| from_closure = True |
|
|
| def __init__(self, outer_entry, scope): |
| Entry.__init__(self, outer_entry.name, |
| outer_entry.cname, |
| outer_entry.type, |
| outer_entry.pos) |
| self.outer_entry = outer_entry |
| self.scope = scope |
|
|
| |
| outermost_entry = outer_entry |
| while outermost_entry.outer_entry: |
| outermost_entry = outermost_entry.outer_entry |
| self.defining_entry = outermost_entry |
| self.inner_entries = outermost_entry.inner_entries |
| self.cf_assignments = outermost_entry.cf_assignments |
| self.cf_references = outermost_entry.cf_references |
| self.overloaded_alternatives = outermost_entry.overloaded_alternatives |
| self.is_cpp_optional = outermost_entry.is_cpp_optional |
| self.inner_entries.append(self) |
|
|
| def __getattr__(self, name): |
| if name.startswith('__'): |
| |
| raise AttributeError(name) |
| return getattr(self.defining_entry, name) |
|
|
| def all_entries(self): |
| return self.defining_entry.all_entries() |
|
|
|
|
| class Scope: |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| is_builtin_scope = 0 |
| is_py_class_scope = 0 |
| is_c_class_scope = 0 |
| is_closure_scope = 0 |
| is_local_scope = False |
| is_generator_expression_scope = 0 |
| is_comprehension_scope = 0 |
| is_passthrough = 0 |
| is_cpp_class_scope = 0 |
| is_property_scope = 0 |
| is_module_scope = 0 |
| is_c_dataclass_scope = False |
| is_internal = 0 |
| scope_prefix = "" |
| in_cinclude = 0 |
| nogil = 0 |
| fused_to_specific = None |
| return_type = None |
| scope_predefined_names = [] |
| |
| in_c_type_context = True |
| node_positions_to_offset = {} |
|
|
| def __init__(self, name, outer_scope, parent_scope): |
| |
| |
| self.name = name |
| self.outer_scope = outer_scope |
| self.parent_scope = parent_scope |
| mangled_name = "%d%s_" % (len(name), name.replace('.', '_dot_')) |
| qual_scope = self.qualifying_scope() |
| if qual_scope: |
| self.qualified_name = qual_scope.qualify_name(name) |
| self.scope_prefix = qual_scope.scope_prefix + mangled_name |
| else: |
| self.qualified_name = EncodedString(name) |
| self.scope_prefix = mangled_name |
| self.entries = {} |
| self.subscopes = set() |
| self.const_entries = [] |
| self.type_entries = [] |
| self.sue_entries = [] |
| self.arg_entries = [] |
| self.var_entries = [] |
| self.pyfunc_entries = [] |
| self.cfunc_entries = [] |
| self.c_class_entries = [] |
| self.defined_c_classes = [] |
| self.imported_c_classes = {} |
| self.cname_to_entry = {} |
| self.identifier_to_entry = {} |
| self.num_to_entry = {} |
| self.obj_to_entry = {} |
| self.buffer_entries = [] |
| self.lambda_defs = [] |
| self.id_counters = {} |
| for var_name in self.scope_predefined_names: |
| self.declare_var(EncodedString(var_name), py_object_type, pos=None) |
|
|
| def __deepcopy__(self, memo): |
| return self |
|
|
| def merge_in(self, other, merge_unused=True, allowlist=None): |
| |
| entries = [] |
| for name, entry in other.entries.items(): |
| if not allowlist or name in allowlist: |
| if entry.used or merge_unused: |
| entries.append((name, entry)) |
|
|
| self.entries.update(entries) |
|
|
| for attr in ('const_entries', |
| 'type_entries', |
| 'sue_entries', |
| 'arg_entries', |
| 'var_entries', |
| 'pyfunc_entries', |
| 'cfunc_entries', |
| 'c_class_entries'): |
| self_entries = getattr(self, attr) |
| names = {e.name for e in self_entries} |
| for entry in getattr(other, attr): |
| if (entry.used or merge_unused) and entry.name not in names: |
| self_entries.append(entry) |
|
|
| def __str__(self): |
| return "<%s %s>" % (self.__class__.__name__, self.qualified_name) |
|
|
| def qualifying_scope(self): |
| return self.parent_scope |
|
|
| def mangle(self, prefix, name = None): |
| if name: |
| return punycodify_name("%s%s%s" % (prefix, self.scope_prefix, name)) |
| else: |
| return self.parent_scope.mangle(prefix, self.name) |
|
|
| def mangle_internal(self, name): |
| |
| |
| prefix = "%s%s_" % (Naming.pyrex_prefix, name) |
| return self.mangle(prefix) |
| |
|
|
| def mangle_class_private_name(self, name): |
| if self.parent_scope: |
| return self.parent_scope.mangle_class_private_name(name) |
| return name |
|
|
| def next_id(self, name=None): |
| |
| counters = self.global_scope().id_counters |
| try: |
| count = counters[name] + 1 |
| except KeyError: |
| count = 0 |
| counters[name] = count |
| if name: |
| if not count: |
| |
| return name |
| return '%s%d' % (name, count) |
| else: |
| return '%d' % count |
|
|
| @property |
| def context(self): |
| return self.global_scope().context |
|
|
| def global_scope(self): |
| """ Return the module-level scope containing this scope. """ |
| return self.outer_scope.global_scope() |
|
|
| def builtin_scope(self): |
| """ Return the module-level scope containing this scope. """ |
| return self.outer_scope.builtin_scope() |
|
|
| def iter_local_scopes(self): |
| yield self |
| if self.subscopes: |
| yield from sorted(self.subscopes, key=operator.attrgetter('scope_prefix')) |
|
|
| @try_finally_contextmanager |
| def new_c_type_context(self, in_c_type_context=None): |
| old_c_type_context = self.in_c_type_context |
| if in_c_type_context is not None: |
| self.in_c_type_context = in_c_type_context |
| yield |
| self.in_c_type_context = old_c_type_context |
|
|
| def handle_already_declared_name(self, name, cname, type, pos, visibility, copy_entry=False): |
| """ |
| Returns an entry or None |
| |
| If it returns an entry, it makes sense for "declare" to keep using that |
| entry and not to declare its own. |
| |
| May be overridden (e.g. for builtin scope, |
| which always allows redeclarations) |
| """ |
| entry = None |
| entries = self.entries |
| old_entry = entries[name] |
|
|
| |
| cpp_override_allowed = False |
| if type.is_cfunction and old_entry.type.is_cfunction and self.is_cpp(): |
| |
| |
| |
| for alt_entry in old_entry.all_alternatives(): |
| if type.compatible_signature_with(alt_entry.type): |
| if name == '<init>' and not type.args: |
| |
| cpp_override_allowed = True |
| elif alt_entry.is_inherited: |
| |
| cpp_override_allowed = True |
| if cpp_override_allowed: |
| entry = alt_entry |
| if copy_entry: |
| entry = copy.copy(alt_entry) |
|
|
| |
| |
| entry.type = type |
| entry.is_inherited = False |
| |
| entry.cname = cname |
| entry.pos = pos |
| break |
| else: |
| cpp_override_allowed = True |
|
|
| if cpp_override_allowed: |
| |
| pass |
| elif entries[name].is_inherited: |
| |
| pass |
| else: |
| if visibility == 'extern': |
| |
| |
| warning(pos, "'%s' redeclared " % name, 1 if self.in_cinclude else 0) |
| elif visibility != 'ignore': |
| error(pos, "'%s' redeclared " % name) |
| self.entries[name].already_declared_here() |
| return None |
|
|
| return entry |
|
|
|
|
| def declare(self, name, cname, type, pos, visibility, shadow = 0, is_type = 0, create_wrapper = 0): |
| |
| |
| |
| if type.is_buffer and not isinstance(self, LocalScope): |
| error(pos, 'Buffer types only allowed as function local variables') |
| if not self.in_cinclude and cname and re.match("^_[_A-Z]+$", cname): |
| |
| warning(pos, "'%s' is a reserved name in C." % cname, -1) |
|
|
| entries = self.entries |
| entry = None |
| if name and name in entries and not shadow: |
| entry = self.handle_already_declared_name(name, cname, type, pos, visibility) |
|
|
| if not entry: |
| entry = Entry(name, cname, type, pos = pos) |
| entry.in_cinclude = self.in_cinclude |
| entry.create_wrapper = create_wrapper |
|
|
| if name: |
| entry.qualified_name = self.qualify_name(name) |
| if not shadow: |
| if name in entries and self.is_cpp() and type.is_cfunction and not entries[name].is_cmethod: |
| |
| entries[name].overloaded_alternatives.append(entry) |
| else: |
| entries[name] = entry |
|
|
| if type.is_memoryviewslice: |
| entry.init = type.default_value |
|
|
| entry.scope = self |
| entry.visibility = visibility |
| return entry |
|
|
| def qualify_name(self, name): |
| return EncodedString("%s.%s" % (self.qualified_name, name)) |
|
|
| def declare_const(self, name, type, value, pos, cname = None, visibility = 'private', api = 0, create_wrapper = 0): |
| |
| if not cname: |
| if self.in_cinclude or (visibility == 'public' or api): |
| cname = name |
| else: |
| cname = self.mangle(Naming.enum_prefix, name) |
| entry = self.declare(name, cname, type, pos, visibility, create_wrapper = create_wrapper) |
| entry.is_const = 1 |
| entry.value_node = value |
| return entry |
|
|
| def declare_type(self, name, type, pos, |
| cname = None, visibility = 'private', api = 0, defining = 1, |
| shadow = 0, template = 0): |
| |
| if not cname: |
| cname = name |
| entry = self.declare(name, cname, type, pos, visibility, shadow, |
| is_type=True) |
| entry.is_type = 1 |
| entry.api = api |
| if defining: |
| self.type_entries.append(entry) |
|
|
| |
| if not template and getattr(type, "entry", None) is None: |
| type.entry = entry |
|
|
| |
| return entry |
|
|
| def declare_typedef(self, name, base_type, pos, cname = None, |
| visibility = 'private', api = 0): |
| if not cname: |
| if self.in_cinclude or (visibility != 'private' or api): |
| cname = name |
| else: |
| cname = self.mangle(Naming.type_prefix, name) |
| try: |
| if self.is_cpp_class_scope: |
| namespace = self.outer_scope.lookup(self.name).type |
| else: |
| namespace = None |
| type = PyrexTypes.create_typedef_type(name, base_type, cname, |
| (visibility == 'extern'), |
| namespace) |
| except ValueError as e: |
| error(pos, e.args[0]) |
| type = PyrexTypes.error_type |
| entry = self.declare_type(name, type, pos, cname, |
| visibility = visibility, api = api) |
| type.qualified_name = entry.qualified_name |
| return entry |
|
|
| def declare_struct_or_union(self, name, kind, scope, |
| typedef_flag, pos, cname = None, |
| visibility = 'private', api = 0, |
| packed = False): |
| |
| if not cname: |
| if self.in_cinclude or (visibility == 'public' or api): |
| cname = name |
| else: |
| cname = self.mangle(Naming.type_prefix, name) |
| entry = self.lookup_here(name) |
| if not entry: |
| in_cpp = self.is_cpp() |
| type = PyrexTypes.CStructOrUnionType( |
| name, kind, scope, typedef_flag, cname, packed, |
| in_cpp = in_cpp) |
| entry = self.declare_type(name, type, pos, cname, |
| visibility = visibility, api = api, |
| defining = scope is not None) |
| self.sue_entries.append(entry) |
| type.entry = entry |
| else: |
| if not (entry.is_type and entry.type.is_struct_or_union |
| and entry.type.kind == kind): |
| warning(pos, "'%s' redeclared " % name, 0) |
| elif scope and entry.type.scope: |
| warning(pos, "'%s' already defined (ignoring second definition)" % name, 0) |
| else: |
| self.check_previous_typedef_flag(entry, typedef_flag, pos) |
| self.check_previous_visibility(entry, visibility, pos) |
| if scope: |
| entry.type.scope = scope |
| self.type_entries.append(entry) |
| if self.is_cpp_class_scope: |
| entry.type.namespace = self.outer_scope.lookup(self.name).type |
| return entry |
|
|
| def declare_cpp_class(self, name, scope, |
| pos, cname = None, base_classes = (), |
| visibility = 'extern', templates = None): |
| if cname is None: |
| if self.in_cinclude or (visibility != 'private'): |
| cname = name |
| else: |
| cname = self.mangle(Naming.type_prefix, name) |
| base_classes = list(base_classes) |
| entry = self.lookup_here(name) |
| if not entry: |
| type = PyrexTypes.CppClassType( |
| name, scope, cname, base_classes, templates = templates) |
| entry = self.declare_type(name, type, pos, cname, |
| visibility = visibility, defining = scope is not None) |
| self.sue_entries.append(entry) |
| else: |
| if not (entry.is_type and entry.type.is_cpp_class): |
| error(pos, "'%s' redeclared " % name) |
| entry.already_declared_here() |
| return None |
| elif scope and entry.type.scope: |
| warning(pos, "'%s' already defined (ignoring second definition)" % name, 0) |
| else: |
| if scope: |
| entry.type.scope = scope |
| self.type_entries.append(entry) |
| if base_classes: |
| if entry.type.base_classes and entry.type.base_classes != base_classes: |
| error(pos, "Base type does not match previous declaration") |
| entry.already_declared_here() |
| else: |
| entry.type.base_classes = base_classes |
| if templates or entry.type.templates: |
| if templates != entry.type.templates: |
| error(pos, "Template parameters do not match previous declaration") |
| entry.already_declared_here() |
|
|
| def declare_inherited_attributes(entry, base_classes): |
| for base_class in base_classes: |
| if base_class is PyrexTypes.error_type: |
| continue |
| if base_class.scope is None: |
| error(pos, "Cannot inherit from incomplete type") |
| else: |
| declare_inherited_attributes(entry, base_class.base_classes) |
| entry.type.scope.declare_inherited_cpp_attributes(base_class) |
| if scope: |
| declare_inherited_attributes(entry, base_classes) |
| scope.declare_var(name="this", cname="this", type=PyrexTypes.CPtrType(entry.type), pos=entry.pos) |
| if self.is_cpp_class_scope: |
| entry.type.namespace = self.outer_scope.lookup(self.name).type |
| return entry |
|
|
| def check_previous_typedef_flag(self, entry, typedef_flag, pos): |
| if typedef_flag != entry.type.typedef_flag: |
| error(pos, "'%s' previously declared using '%s'" % ( |
| entry.name, ("cdef", "ctypedef")[entry.type.typedef_flag])) |
|
|
| def check_previous_visibility(self, entry, visibility, pos): |
| if entry.visibility != visibility: |
| error(pos, "'%s' previously declared as '%s'" % ( |
| entry.name, entry.visibility)) |
|
|
| def declare_enum(self, name, pos, cname, scoped, typedef_flag, |
| visibility='private', api=0, create_wrapper=0, doc=None): |
| if name: |
| if not cname: |
| if (self.in_cinclude or visibility == 'public' |
| or visibility == 'extern' or api): |
| cname = name |
| else: |
| cname = self.mangle(Naming.type_prefix, name) |
| if self.is_cpp_class_scope: |
| namespace = self.outer_scope.lookup(self.name).type |
| else: |
| namespace = None |
|
|
| if scoped: |
| type = PyrexTypes.CppScopedEnumType(name, cname, namespace, doc=doc) |
| else: |
| type = PyrexTypes.CEnumType(name, cname, typedef_flag, namespace, doc=doc) |
| else: |
| type = PyrexTypes.c_anon_enum_type |
| entry = self.declare_type(name, type, pos, cname = cname, |
| visibility = visibility, api = api) |
| if scoped: |
| entry.utility_code = Code.UtilityCode.load_cached("EnumClassDecl", "CppSupport.cpp") |
| self.use_entry_utility_code(entry) |
| entry.create_wrapper = create_wrapper |
| entry.enum_values = [] |
|
|
| self.sue_entries.append(entry) |
| return entry |
|
|
| def declare_tuple_type(self, pos, components): |
| return self.outer_scope.declare_tuple_type(pos, components) |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='private', |
| api=False, in_pxd=False, is_cdef=False, pytyping_modifiers=None): |
| |
| if not cname: |
| if visibility != 'private' or api: |
| cname = name |
| else: |
| cname = self.mangle(Naming.var_prefix, name) |
| entry = self.declare(name, cname, type, pos, visibility) |
| entry.is_variable = 1 |
| if type.is_cpp_class and visibility != 'extern': |
| if self.directives['cpp_locals']: |
| entry.make_cpp_optional() |
| else: |
| type.check_nullary_constructor(pos) |
| if in_pxd and visibility != 'extern': |
| entry.defined_in_pxd = 1 |
| entry.used = 1 |
| if api: |
| entry.api = 1 |
| entry.used = 1 |
| if pytyping_modifiers: |
| entry.pytyping_modifiers = pytyping_modifiers |
| return entry |
|
|
| def _reject_pytyping_modifiers(self, pos, modifiers, allowed=()): |
| if not modifiers: |
| return |
| for modifier in modifiers: |
| if modifier not in allowed: |
| error(pos, "Modifier '%s' is not allowed here." % modifier) |
|
|
| def declare_assignment_expression_target(self, name, type, pos): |
| |
| |
| return self.declare_var(name, type, pos) |
|
|
| def declare_builtin(self, name, pos): |
| name = self.mangle_class_private_name(name) |
| return self.outer_scope.declare_builtin(name, pos) |
|
|
| def _declare_pyfunction(self, name, pos, visibility='extern', entry=None): |
| if entry and not entry.type.is_cfunction: |
| error(pos, "'%s' already declared" % name) |
| error(entry.pos, "Previous declaration is here") |
| entry = self.declare_var(name, py_object_type, pos, visibility=visibility) |
| entry.signature = pyfunction_signature |
| self.pyfunc_entries.append(entry) |
| return entry |
|
|
| def declare_pyfunction(self, name, pos, allow_redefine=False, visibility='extern'): |
| |
| entry = self.lookup_here(name) |
| if not allow_redefine: |
| return self._declare_pyfunction(name, pos, visibility=visibility, entry=entry) |
| if entry: |
| if entry.type.is_unspecified: |
| entry.type = py_object_type |
| elif entry.type is not py_object_type: |
| return self._declare_pyfunction(name, pos, visibility=visibility, entry=entry) |
| else: |
| self.declare_var(name, py_object_type, pos, visibility=visibility) |
| entry = self.declare_var(None, py_object_type, pos, |
| cname=name, visibility='private') |
| entry.name = EncodedString(name) |
| entry.qualified_name = self.qualify_name(name) |
| entry.signature = pyfunction_signature |
| entry.is_anonymous = True |
| return entry |
|
|
| def declare_lambda_function(self, lambda_name, pos): |
| |
| func_cname = self.mangle(Naming.lambda_func_prefix + 'funcdef_', lambda_name) |
| pymethdef_cname = self.mangle(Naming.lambda_func_prefix + 'methdef_', lambda_name) |
| qualified_name = self.qualify_name(lambda_name) |
|
|
| entry = self.declare(None, func_cname, py_object_type, pos, 'private') |
| entry.name = EncodedString(lambda_name) |
| entry.qualified_name = qualified_name |
| entry.pymethdef_cname = pymethdef_cname |
| entry.func_cname = func_cname |
| entry.signature = pyfunction_signature |
| entry.is_anonymous = True |
| return entry |
|
|
| def add_lambda_def(self, def_node): |
| self.lambda_defs.append(def_node) |
|
|
| def register_pyfunction(self, entry): |
| self.pyfunc_entries.append(entry) |
|
|
| def declare_cfunction(self, name, type, pos, |
| cname=None, visibility='private', api=0, in_pxd=0, |
| defining=0, modifiers=(), utility_code=None, overridable=False): |
| |
| if not cname: |
| if visibility != 'private' or api: |
| cname = name |
| else: |
| cname = self.mangle(Naming.func_prefix, name) |
| inline_in_pxd = 'inline' in modifiers and in_pxd and defining |
| if inline_in_pxd: |
| |
| in_pxd = False |
| entry = self.lookup_here(name) |
| if entry: |
| if not in_pxd and visibility != entry.visibility and visibility == 'extern': |
| |
| |
| defining = True |
| visibility = entry.visibility |
| entry.cname = cname |
| entry.func_cname = cname |
| if visibility != 'private' and visibility != entry.visibility: |
| warning(pos, "Function '%s' previously declared as '%s', now as '%s'" % ( |
| name, entry.visibility, visibility), 1) |
| if overridable != entry.is_overridable: |
| warning(pos, "Function '%s' previously declared as '%s'" % ( |
| name, 'cpdef' if overridable else 'cdef'), 1) |
| if entry.type.same_as(type): |
| |
| entry.type = entry.type.with_with_gil(type.with_gil) |
| else: |
| if visibility == 'extern' and entry.visibility == 'extern': |
| can_override = self.is_builtin_scope |
| if self.is_cpp(): |
| can_override = True |
| elif cname and not can_override: |
| |
| |
| for alt_entry in entry.all_alternatives(): |
| if not alt_entry.cname or cname == alt_entry.cname: |
| break |
| else: |
| can_override = True |
| if can_override: |
| temp = self.add_cfunction(name, type, pos, cname, visibility, modifiers) |
| temp.overloaded_alternatives = entry.all_alternatives() |
| if entry.specialiser is not None: |
| temp.specialiser = entry.specialiser |
| entry = temp |
| else: |
| warning(pos, "Function signature does not match previous declaration", 1) |
| entry.type = type |
| elif not in_pxd and entry.defined_in_pxd and type.compatible_signature_with(entry.type): |
| |
| |
|
|
| |
| |
| if entry.type.nogil and entry.type.exception_value is None and type.exception_value: |
| performance_hint( |
| entry.pos, |
| f"No exception value declared for '{entry.name}' in pxd file.\n" |
| "Users cimporting this function and calling it without the gil " |
| "will always require an exception check.\n" |
| "Suggest adding an explicit exception value.", |
| self) |
| entry.type = type |
| else: |
| error(pos, "Function signature does not match previous declaration") |
| else: |
| entry = self.add_cfunction(name, type, pos, cname, visibility, modifiers) |
| entry.func_cname = cname |
| entry.is_overridable = overridable |
| if inline_in_pxd: |
| entry.inline_func_in_pxd = True |
| if in_pxd and visibility != 'extern': |
| entry.defined_in_pxd = 1 |
| if api: |
| entry.api = 1 |
| if not defining and not in_pxd and visibility != 'extern': |
| error(pos, "Non-extern C function '%s' declared but not defined" % name) |
| if defining: |
| entry.is_implemented = True |
| if modifiers: |
| entry.func_modifiers = modifiers |
| if utility_code: |
| assert not entry.utility_code, "duplicate utility code definition in entry %s (%s)" % (name, cname) |
| entry.utility_code = utility_code |
| if overridable: |
| |
| var_entry = Entry(name, cname, py_object_type) |
| var_entry.qualified_name = self.qualify_name(name) |
| var_entry.is_variable = 1 |
| var_entry.is_pyglobal = 1 |
| var_entry.scope = entry.scope |
| entry.as_variable = var_entry |
| type.entry = entry |
| if (type.exception_check and type.exception_value is None and type.nogil and |
| not pos[0].in_utility_code and |
| |
| defining and not in_pxd and not inline_in_pxd): |
| PyrexTypes.write_noexcept_performance_hint( |
| pos, self, function_name=name, void_return=type.return_type.is_void) |
| return entry |
|
|
| def declare_cgetter(self, name, return_type, pos=None, cname=None, |
| visibility="private", modifiers=(), defining=False, **cfunc_type_config): |
| assert all( |
| k in ('exception_value', 'exception_check', 'nogil', 'with_gil', 'is_const_method', 'is_static_method') |
| for k in cfunc_type_config |
| ) |
| cfunc_type = PyrexTypes.CFuncType( |
| return_type, |
| [PyrexTypes.CFuncTypeArg("self", self.parent_type, None)], |
| **cfunc_type_config) |
| entry = self.declare_cfunction( |
| name, cfunc_type, pos, cname=None, visibility=visibility, modifiers=modifiers, defining=defining) |
| entry.is_cgetter = True |
| if cname is not None: |
| entry.func_cname = cname |
| return entry |
|
|
| def add_cfunction(self, name, type, pos, cname, visibility, modifiers, inherited=False): |
| |
| entry = self.declare(name, cname, type, pos, visibility) |
| entry.is_cfunction = 1 |
| if modifiers: |
| entry.func_modifiers = modifiers |
| if inherited or type.is_fused: |
| self.cfunc_entries.append(entry) |
| else: |
| |
| |
| i = len(self.cfunc_entries) |
| for cfunc_entry in reversed(self.cfunc_entries): |
| if cfunc_entry.is_inherited or not cfunc_entry.type.is_fused: |
| break |
| i -= 1 |
| self.cfunc_entries.insert(i, entry) |
| return entry |
|
|
| def find(self, name, pos): |
| |
| entry = self.lookup(name) |
| if entry: |
| return entry |
| else: |
| error(pos, "'%s' is not declared" % name) |
|
|
| def find_imported_module(self, path, pos): |
| |
| |
| scope = self |
| for name in path: |
| entry = scope.find(name, pos) |
| if not entry: |
| return None |
| if entry.as_module: |
| scope = entry.as_module |
| else: |
| error(pos, "'%s' is not a cimported module" % '.'.join(path)) |
| return None |
| return scope |
|
|
| def lookup(self, name): |
| |
| |
|
|
| mangled_name = self.mangle_class_private_name(name) |
| entry = (self.lookup_here(name) |
| or (self.outer_scope and self.outer_scope.lookup(mangled_name)) |
| or None) |
| if entry: |
| return entry |
|
|
| |
| |
| entry = (self.outer_scope and self.outer_scope.lookup(name)) or None |
| if entry and entry.is_pyglobal: |
| self._emit_class_private_warning(entry.pos, name) |
| return entry |
|
|
| def lookup_here(self, name): |
| |
|
|
| entry = self.entries.get(self.mangle_class_private_name(name), None) |
| if entry: |
| return entry |
| |
| |
| |
| return self.entries.get(name, None) |
|
|
| def lookup_here_unmangled(self, name): |
| return self.entries.get(name, None) |
|
|
| def lookup_assignment_expression_target(self, name): |
| |
| |
| return self.lookup_here(name) |
|
|
| def lookup_target(self, name): |
| |
| |
| entry = self.lookup_here(name) |
| if not entry: |
| entry = self.lookup_here_unmangled(name) |
| if entry and entry.is_pyglobal: |
| self._emit_class_private_warning(entry.pos, name) |
| if not entry: |
| entry = self.declare_var(name, py_object_type, None) |
| return entry |
|
|
| def _type_or_specialized_type_from_entry(self, entry): |
| if entry and entry.is_type: |
| if entry.type.is_fused and self.fused_to_specific: |
| return entry.type.specialize(self.fused_to_specific) |
| return entry.type |
|
|
| def lookup_type(self, name): |
| entry = self.lookup(name) |
| |
| |
| |
| |
|
|
| tp = self._type_or_specialized_type_from_entry(entry) |
| if tp: |
| return tp |
| |
| if entry and entry.known_standard_library_import: |
| from .Builtin import get_known_standard_library_entry |
| entry = get_known_standard_library_entry(entry.known_standard_library_import) |
| return self._type_or_specialized_type_from_entry(entry) |
|
|
| def lookup_operator(self, operator, operands): |
| if operands[0].type.is_cpp_class: |
| obj_type = operands[0].type |
| method = obj_type.scope.lookup("operator%s" % operator) |
| if method is not None: |
| arg_types = [arg.type for arg in operands[1:]] |
| res = PyrexTypes.best_match(arg_types, method.all_alternatives()) |
| if res is not None: |
| return res |
| function = self.lookup("operator%s" % operator) |
| function_alternatives = [] |
| if function is not None: |
| function_alternatives = function.all_alternatives() |
|
|
| |
| method_alternatives = [] |
| if len(operands) == 2: |
| for n in range(2): |
| if operands[n].type.is_cpp_class: |
| obj_type = operands[n].type |
| method = obj_type.scope.lookup("operator%s" % operator) |
| if method is not None: |
| method_alternatives += method.all_alternatives() |
|
|
| if (not method_alternatives) and (not function_alternatives): |
| return None |
|
|
| |
| all_alternatives = list(set(method_alternatives + function_alternatives)) |
|
|
| return PyrexTypes.best_match([arg.type for arg in operands], |
| all_alternatives) |
|
|
| def lookup_operator_for_types(self, pos, operator, types): |
| from .Nodes import Node |
| class FakeOperand(Node): |
| pass |
| operands = [FakeOperand(pos, type=type) for type in types] |
| return self.lookup_operator(operator, operands) |
|
|
| def _emit_class_private_warning(self, pos, name): |
| warning(pos, "Global name %s matched from within class scope " |
| "in contradiction to Python 'class private name' rules. " |
| "This may change in a future release." % name, 1) |
|
|
| def use_utility_code(self, new_code): |
| self.global_scope().use_utility_code(new_code) |
|
|
| def use_entry_utility_code(self, entry): |
| self.global_scope().use_entry_utility_code(entry) |
|
|
| def defines_any(self, names): |
| |
| for name in names: |
| if name in self.entries: |
| return 1 |
| return 0 |
|
|
| def defines_any_special(self, names): |
| |
| for name in names: |
| if name in self.entries and self.entries[name].is_special: |
| return 1 |
| return 0 |
|
|
| def infer_types(self): |
| from .TypeInference import get_type_inferer |
| get_type_inferer().infer_types(self) |
|
|
| def is_cpp(self): |
| outer = self.outer_scope |
| if outer is None: |
| return False |
| else: |
| return outer.is_cpp() |
|
|
| def add_include_file(self, filename, verbatim_include=None, late=False): |
| self.outer_scope.add_include_file(filename, verbatim_include, late) |
|
|
| def name_in_module_state(self, cname): |
| |
| |
| return f"{Naming.modulestateglobal_cname}->{cname}" |
|
|
| def find_shared_usages_of_type(self, type_check_predicate, _seen_scopes=None): |
| if _seen_scopes is None: |
| _seen_scopes = set() |
| include_all_entries = not self.is_module_scope |
| for entry in self.entries.values(): |
| if not (include_all_entries or entry.defined_in_pxd or entry.visibility == "public" or entry.api): |
| continue |
| entry_subtypes = PyrexTypes.get_all_subtypes(entry.type) |
| if any(type_check_predicate(sub_tp) for sub_tp in entry_subtypes): |
| return True |
| type_scope = getattr(entry.type, "scope", None) |
| if type_scope is None or type_scope in _seen_scopes: |
| continue |
| _seen_scopes.add(type_scope) |
| if type_scope.find_shared_usages_of_type(type_check_predicate, _seen_scopes): |
| return True |
| return False |
|
|
|
|
| class PreImportScope(Scope): |
|
|
| namespace_cname = Naming.preimport_cname |
|
|
| def __init__(self): |
| Scope.__init__(self, Options.pre_import, None, None) |
|
|
| def declare_builtin(self, name, pos): |
| entry = self.declare(name, name, py_object_type, pos, 'private') |
| entry.is_variable = True |
| entry.is_pyglobal = True |
| return entry |
|
|
|
|
| class BuiltinScope(Scope): |
| |
|
|
| is_builtin_scope = True |
|
|
| def __init__(self): |
| if Options.pre_import is None: |
| Scope.__init__(self, "__builtin__", None, None) |
| else: |
| Scope.__init__(self, "__builtin__", PreImportScope(), None) |
| self.type_names = {} |
|
|
| def lookup(self, name, language_level=None): |
| |
| if name == 'unicode' or name == 'basestring': |
| |
| name = 'str' |
| elif name == 'long' and language_level == 2: |
| |
| name = 'int' |
| return Scope.lookup(self, name) |
|
|
| def declare_builtin(self, name, pos): |
| if name not in Code.KNOWN_PYTHON_BUILTINS: |
| if self.outer_scope is not None: |
| return self.outer_scope.declare_builtin(name, pos) |
| else: |
| if Options.error_on_unknown_names: |
| error(pos, "undeclared name not builtin: %s" % name) |
| else: |
| warning(pos, "undeclared name not builtin: %s" % name, 2) |
|
|
| def declare_builtin_cfunction(self, name, type, cname, python_equiv=None, utility_code=None, specialiser=None): |
| |
| |
| name = EncodedString(name) |
| entry = self.declare_cfunction(name, type, None, cname, visibility='extern', utility_code=utility_code) |
| if specialiser is not None: |
| entry.specialiser = specialiser |
| if python_equiv: |
| if python_equiv == "*": |
| python_equiv = name |
| else: |
| python_equiv = EncodedString(python_equiv) |
| var_entry = Entry(python_equiv, python_equiv, py_object_type) |
| var_entry.qualified_name = self.qualify_name(name) |
| var_entry.is_variable = 1 |
| var_entry.is_builtin = 1 |
| var_entry.utility_code = utility_code |
| var_entry.scope = entry.scope |
| entry.as_variable = var_entry |
| return entry |
|
|
| def declare_builtin_type(self, name, cname, |
| objstruct_cname=None, type_class=PyrexTypes.BuiltinObjectType): |
| name = EncodedString(name) |
| type = type_class(name, cname, objstruct_cname) |
| scope = CClassScope(name, outer_scope=None, visibility='extern', parent_type=type) |
| scope.directives = {} |
| type.set_scope(scope) |
| self.type_names[name] = 1 |
| entry = self.declare_type(name, type, None, visibility='extern') |
|
|
| var_entry = Entry( |
| name=entry.name, |
| type=self.lookup('type').type, |
| pos=entry.pos, |
| cname=entry.type.typeptr_cname, |
| ) |
| var_entry.qualified_name = self.qualify_name(name) |
| var_entry.is_variable = 1 |
| var_entry.is_cglobal = 1 |
| var_entry.is_readonly = 1 |
| var_entry.is_builtin = 1 |
| var_entry.scope = self |
| if Options.cache_builtins: |
| var_entry.is_const = True |
| entry.as_variable = var_entry |
|
|
| return type |
|
|
| def builtin_scope(self): |
| return self |
|
|
| def handle_already_declared_name(self, name, cname, type, pos, visibility, copy_entry=False): |
| |
| return None |
|
|
|
|
| const_counter = 1 |
|
|
| class ModuleScope(Scope): |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| is_module_scope = 1 |
| has_import_star = 0 |
| is_cython_builtin = 0 |
| old_style_globals = 0 |
| namespace_cname_is_type = False |
| scope_predefined_names = [ |
| '__builtins__', '__name__', '__file__', '__doc__', '__path__', |
| '__spec__', '__loader__', '__package__', '__cached__', |
| ] |
|
|
| def __init__(self, name, parent_module, context, is_package=False): |
| from . import Builtin |
| self.parent_module = parent_module |
| outer_scope = Builtin.builtin_scope |
| Scope.__init__(self, name, outer_scope, parent_module) |
| self.is_package = is_package |
| self.module_name = name |
| self.module_name = EncodedString(self.module_name) |
| self._context = context |
| self.module_cname = Naming.module_cname |
| self.module_dict_cname = Naming.moddict_cname |
| self.method_table_cname = Naming.methtable_cname |
| self.doc = "" |
| self.doc_cname = Naming.moddoc_cname |
| self.utility_code_list = [] |
| self.module_entries = {} |
| self.c_includes = {} |
| self.type_names = dict(outer_scope.type_names) |
| self.pxd_file_loaded = 0 |
| self.cimported_modules = [] |
| self.types_imported = set() |
| self.included_files = [] |
| self.has_extern_class = 0 |
| self.cached_builtins = [] |
| self.undeclared_cached_builtins = [] |
| self.namespace_cname = self.module_cname |
| self._cached_tuple_types = {} |
| self._cached_defaults_c_class_entries = {} |
| self.process_include(Code.IncludeCode("Python.h", initial=True)) |
|
|
| def qualifying_scope(self): |
| return self.parent_module |
|
|
| @property |
| def context(self): |
| return self._context |
|
|
| def global_scope(self): |
| return self |
|
|
| def lookup(self, name, language_level=None): |
| entry = self.lookup_here(name) |
| if entry is not None: |
| return entry |
|
|
| if language_level is None: |
| language_level = self.context.language_level if self.context is not None else 3 |
| return self.outer_scope.lookup(name, language_level=language_level) |
|
|
| def declare_tuple_type(self, pos, components): |
| components = tuple(components) |
| try: |
| ttype = self._cached_tuple_types[components] |
| except KeyError: |
| ttype = self._cached_tuple_types[components] = PyrexTypes.c_tuple_type(components) |
| cname = ttype.cname |
| entry = self.lookup_here(cname) |
| if not entry: |
| scope = StructOrUnionScope(cname) |
| for ix, component in enumerate(components): |
| scope.declare_var(name="f%s" % ix, type=component, pos=pos) |
| struct_entry = self.declare_struct_or_union( |
| cname + '_struct', 'struct', scope, typedef_flag=True, pos=pos, cname=cname) |
| self.type_entries.remove(struct_entry) |
| ttype.struct_entry = struct_entry |
| entry = self.declare_type(cname, ttype, pos, cname) |
| ttype.entry = entry |
| return entry |
|
|
| def declare_defaults_c_class(self, pos, components): |
| |
| components = tuple(components) |
| try: |
| return self._cached_defaults_c_class_entries[components] |
| except KeyError: |
| pass |
|
|
| cname = self.next_id(Naming.defaults_struct_prefix) |
| cname = EncodedString(cname) |
| entry = self._cached_defaults_c_class_entries[components] = self.declare_c_class( |
| cname, pos, defining=True, implementing=True, |
| objstruct_cname=cname) |
| self.check_c_class(entry) |
| entry.type.is_final_type = True |
| scope = entry.type.scope |
| scope.is_internal = True |
| scope.is_defaults_class_scope = True |
|
|
| |
| num_zeros = len(str(len(components))) |
| build_argname = ("arg{:0>%dd}" % num_zeros).format |
| for n, type_ in enumerate(components): |
| arg_name = EncodedString(build_argname(n)) |
| scope.declare_var(arg_name, type_, pos=None, is_cdef=True) |
| return entry |
|
|
| def declare_builtin(self, name, pos): |
| if name not in Code.KNOWN_PYTHON_BUILTINS \ |
| and name not in Code.renamed_py2_builtins_map \ |
| and name not in Code.uncachable_builtins: |
| if self.has_import_star: |
| entry = self.declare_var(name, py_object_type, pos) |
| return entry |
| else: |
| if Options.error_on_unknown_names: |
| error(pos, "undeclared name not builtin: %s" % name) |
| else: |
| warning(pos, "undeclared name not builtin: %s" % name, 2) |
| |
| entry = self.declare(name, None, py_object_type, pos, 'private') |
| entry.is_builtin = 1 |
| return entry |
| if Options.cache_builtins: |
| for entry in self.cached_builtins: |
| if entry.name == name: |
| return entry |
| if name == 'globals' and not self.old_style_globals: |
| return self.outer_scope.lookup('__Pyx_Globals') |
| else: |
| entry = self.declare(None, None, py_object_type, pos, 'private') |
| if Options.cache_builtins and name not in Code.uncachable_builtins: |
| entry.is_builtin = 1 |
| entry.is_const = 1 |
| entry.name = name |
| entry.cname = Naming.builtin_prefix + name |
| self.cached_builtins.append(entry) |
| self.undeclared_cached_builtins.append(entry) |
| else: |
| entry.is_builtin = 1 |
| entry.name = name |
| entry.qualified_name = self.builtin_scope().qualify_name(name) |
| return entry |
|
|
| def find_module(self, module_name, pos, relative_level=-1): |
| |
| |
| |
| |
| is_relative_import = relative_level is not None and relative_level > 0 |
| from_module = None |
| absolute_fallback = False |
| if relative_level is not None and relative_level > 0: |
| |
| |
| from_module = self |
|
|
| top_level = 1 if self.is_package else 0 |
| |
| |
| |
| |
| while relative_level > top_level and from_module: |
| from_module = from_module.parent_module |
| relative_level -= 1 |
|
|
| elif relative_level != 0: |
| |
| from_module = self.parent_module |
| absolute_fallback = True |
|
|
| module_scope = self.global_scope() |
| return module_scope.context.find_module( |
| module_name, from_module=from_module, pos=pos, absolute_fallback=absolute_fallback, relative_import=is_relative_import) |
|
|
| def find_submodule(self, name, as_package=False): |
| |
| |
| if '.' in name: |
| name, submodule = name.split('.', 1) |
| else: |
| submodule = None |
| scope = self.lookup_submodule(name) |
| if not scope: |
| scope = ModuleScope(name, parent_module=self, context=self.context, is_package=True if submodule else as_package) |
| self.module_entries[name] = scope |
| if submodule: |
| scope = scope.find_submodule(submodule, as_package=as_package) |
| return scope |
|
|
| def lookup_submodule(self, name): |
| |
| if '.' in name: |
| name, submodule = name.split('.', 1) |
| else: |
| submodule = None |
| module = self.module_entries.get(name, None) |
| if submodule and module is not None: |
| module = module.lookup_submodule(submodule) |
| return module |
|
|
| def add_include_file(self, filename, verbatim_include=None, late=False): |
| """ |
| Add `filename` as include file. Add `verbatim_include` as |
| verbatim text in the C file. |
| Both `filename` and `verbatim_include` can be `None` or empty. |
| """ |
| inc = Code.IncludeCode(filename, verbatim_include, late=late) |
| self.process_include(inc) |
|
|
| def process_include(self, inc): |
| """ |
| Add `inc`, which is an instance of `IncludeCode`, to this |
| `ModuleScope`. This either adds a new element to the |
| `c_includes` dict or it updates an existing entry. |
| |
| In detail: the values of the dict `self.c_includes` are |
| instances of `IncludeCode` containing the code to be put in the |
| generated C file. The keys of the dict are needed to ensure |
| uniqueness in two ways: if an include file is specified in |
| multiple "cdef extern" blocks, only one `#include` statement is |
| generated. Second, the same include might occur multiple times |
| if we find it through multiple "cimport" paths. So we use the |
| generated code (of the form `#include "header.h"`) as dict key. |
| |
| If verbatim code does not belong to any include file (i.e. it |
| was put in a `cdef extern from *` block), then we use a unique |
| dict key: namely, the `sortkey()`. |
| |
| One `IncludeCode` object can contain multiple pieces of C code: |
| one optional "main piece" for the include file and several other |
| pieces for the verbatim code. The `IncludeCode.dict_update` |
| method merges the pieces of two different `IncludeCode` objects |
| if needed. |
| """ |
| key = inc.mainpiece() |
| if key is None: |
| key = inc.sortkey() |
| inc.dict_update(self.c_includes, key) |
| inc = self.c_includes[key] |
|
|
| def add_imported_module(self, scope): |
| if scope not in self.cimported_modules: |
| for inc in scope.c_includes.values(): |
| self.process_include(inc) |
| self.cimported_modules.append(scope) |
| for m in scope.cimported_modules: |
| self.add_imported_module(m) |
|
|
| def add_imported_entry(self, name, entry, pos): |
| if entry.is_pyglobal: |
| |
| entry.is_variable = True |
| if entry not in self.entries: |
| self.entries[name] = entry |
| else: |
| warning(pos, "'%s' redeclared " % name, 0) |
|
|
| def declare_module(self, name, scope, pos): |
| |
| |
| |
| |
| entry = self.lookup_here(name) |
| if entry: |
| if entry.is_pyglobal and entry.as_module is scope: |
| return entry |
| if not (entry.is_pyglobal and not entry.as_module): |
| |
| |
| |
| |
| |
| |
| |
| return entry |
| else: |
| entry = self.declare_var(name, py_object_type, pos) |
| entry.is_variable = 0 |
| entry.as_module = scope |
| self.add_imported_module(scope) |
| return entry |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='private', |
| api=False, in_pxd=False, is_cdef=False, pytyping_modifiers=None): |
| |
| |
| |
| |
| if visibility not in ('private', 'public', 'extern'): |
| error(pos, "Module-level variable cannot be declared %s" % visibility) |
| self._reject_pytyping_modifiers(pos, pytyping_modifiers, ('typing.Optional',)) |
| if not is_cdef: |
| if type is unspecified_type: |
| type = py_object_type |
| if not (type.is_pyobject and not type.is_extension_type): |
| raise InternalError( |
| "Non-cdef global variable is not a generic Python object") |
| if (is_cdef and visibility != "extern" |
| and self.directives['subinterpreters_compatible'] != "no"): |
| extra_warning = "" |
| pyobject_warning = "" |
| if type.is_pyobject: |
| extra_warning = "\nPython objects should not be shared between interpreters" |
| pyobject_warning = "Python " |
| warning( |
| pos, |
| f"Global cdef {pyobject_warning}variable used with subinterpreter support enabled.\n" |
| "This variable is not currently in the per-interpreter module state " |
| "but this will likely change in future releases." + |
| extra_warning, |
| 2+(1 if extra_warning else 0)) |
|
|
| if not cname: |
| defining = not in_pxd |
| if visibility == 'extern' or (visibility == 'public' and defining): |
| cname = name |
| else: |
| cname = self.mangle(Naming.var_prefix, name) |
|
|
| entry = self.lookup_here(name) |
| if entry and entry.defined_in_pxd: |
| |
| |
| if not entry.type.same_as(type): |
| if visibility == 'extern' and entry.visibility == 'extern': |
| warning(pos, "Variable '%s' type does not match previous declaration" % name, 1) |
| entry.type = type |
| |
| |
| if entry.visibility != "private": |
| mangled_cname = self.mangle(Naming.var_prefix, name) |
| if entry.cname == mangled_cname: |
| cname = name |
| entry.cname = name |
| if not entry.is_implemented: |
| entry.is_implemented = True |
| return entry |
|
|
| entry = Scope.declare_var(self, name, type, pos, |
| cname=cname, visibility=visibility, |
| api=api, in_pxd=in_pxd, is_cdef=is_cdef, pytyping_modifiers=pytyping_modifiers) |
| if is_cdef: |
| entry.is_cglobal = 1 |
| if entry.type.declaration_value: |
| entry.init = entry.type.declaration_value |
| self.var_entries.append(entry) |
| else: |
| entry.is_pyglobal = 1 |
| if Options.cimport_from_pyx: |
| entry.used = 1 |
| return entry |
|
|
| def declare_cfunction(self, name, type, pos, |
| cname=None, visibility='private', api=0, in_pxd=0, |
| defining=0, modifiers=(), utility_code=None, overridable=False): |
| if not defining and 'inline' in modifiers: |
| |
| warning(pos, "Declarations should not be declared inline.", 1) |
| |
| if not cname: |
| if visibility == 'extern' or (visibility == 'public' and defining): |
| cname = name |
| else: |
| cname = self.mangle(Naming.func_prefix, name) |
| if visibility == 'extern' and type.optional_arg_count: |
| error(pos, "Extern functions cannot have default arguments values.") |
| entry = self.lookup_here(name) |
| if entry and entry.defined_in_pxd: |
| if entry.visibility != "private": |
| mangled_cname = self.mangle(Naming.func_prefix, name) |
| if entry.cname == mangled_cname: |
| cname = name |
| entry.cname = cname |
| entry.func_cname = cname |
| entry = Scope.declare_cfunction( |
| self, name, type, pos, |
| cname=cname, visibility=visibility, api=api, in_pxd=in_pxd, |
| defining=defining, modifiers=modifiers, utility_code=utility_code, |
| overridable=overridable) |
| return entry |
|
|
| def declare_global(self, name, pos): |
| entry = self.lookup_here(name) |
| if not entry: |
| self.declare_var(name, py_object_type, pos) |
|
|
| def use_utility_code(self, new_code): |
| if new_code is not None: |
| self.utility_code_list.append(new_code) |
|
|
| def use_entry_utility_code(self, entry): |
| if entry is None: |
| return |
| if entry.utility_code: |
| self.utility_code_list.append(entry.utility_code) |
| if entry.utility_code_definition: |
| self.utility_code_list.append(entry.utility_code_definition) |
|
|
| def declare_c_class(self, name, pos, defining=0, implementing=0, |
| module_name=None, base_type=None, objstruct_cname=None, |
| typeobj_cname=None, typeptr_cname=None, visibility='private', |
| typedef_flag=0, api=0, check_size=None, |
| buffer_defaults=None, shadow=0): |
| |
| |
| |
| if typedef_flag and visibility != 'extern': |
| if not (visibility == 'public' or api): |
| warning(pos, "ctypedef only valid for 'extern' , 'public', and 'api'", 2) |
| objtypedef_cname = objstruct_cname |
| typedef_flag = 0 |
| else: |
| objtypedef_cname = None |
| |
| |
| |
| entry = self.lookup_here(name) |
| if entry and not shadow: |
| type = entry.type |
| if not (entry.is_type and type.is_extension_type): |
| entry = None |
| else: |
| scope = type.scope |
| if typedef_flag and (not scope or scope.defined): |
| self.check_previous_typedef_flag(entry, typedef_flag, pos) |
| if (scope and scope.defined) or (base_type and type.base_type): |
| if base_type and base_type is not type.base_type: |
| error(pos, "Base type does not match previous declaration") |
| if base_type and not type.base_type: |
| type.base_type = base_type |
| |
| |
| |
| if not entry or shadow: |
| type = PyrexTypes.PyExtensionType( |
| name, typedef_flag, base_type, visibility == 'extern', check_size=check_size) |
| type.pos = pos |
| type.buffer_defaults = buffer_defaults |
| if objtypedef_cname is not None: |
| type.objtypedef_cname = objtypedef_cname |
| if visibility == 'extern': |
| type.module_name = module_name |
| else: |
| type.module_name = self.qualified_name |
| if typeptr_cname: |
| type.typeptr_cname = typeptr_cname |
| else: |
| type.typeptr_cname = self.mangle(Naming.typeptr_prefix, name) |
| entry = self.declare_type(name, type, pos, visibility = visibility, |
| defining = 0, shadow = shadow) |
| entry.is_cclass = True |
| if objstruct_cname: |
| type.objstruct_cname = objstruct_cname |
| elif not entry.in_cinclude: |
| type.objstruct_cname = self.mangle(Naming.objstruct_prefix, name) |
| else: |
| error(entry.pos, |
| "Object name required for 'public' or 'extern' C class") |
| self.attach_var_entry_to_c_class(entry) |
| self.c_class_entries.append(entry) |
| |
| |
| |
| if not type.scope: |
| if defining or implementing: |
| scope = CClassScope(name = name, outer_scope = self, |
| visibility=visibility, |
| parent_type=type) |
| scope.directives = self.directives.copy() |
| if base_type and base_type.scope: |
| scope.declare_inherited_c_attributes(base_type.scope) |
| type.set_scope(scope) |
| self.type_entries.append(entry) |
| else: |
| if defining and type.scope.defined: |
| error(pos, "C class '%s' already defined" % name) |
| elif implementing and type.scope.implemented: |
| error(pos, "C class '%s' already implemented" % name) |
| |
| |
| |
| if defining: |
| entry.defined_in_pxd = 1 |
| if implementing: |
| entry.pos = pos |
| if visibility != 'private' and entry.visibility != visibility: |
| error(pos, "Class '%s' previously declared as '%s'" |
| % (name, entry.visibility)) |
| if api: |
| entry.api = 1 |
| if objstruct_cname: |
| if type.objstruct_cname and type.objstruct_cname != objstruct_cname: |
| error(pos, "Object struct name differs from previous declaration") |
| type.objstruct_cname = objstruct_cname |
| if typeobj_cname: |
| if type.typeobj_cname and type.typeobj_cname != typeobj_cname: |
| error(pos, "Type object name differs from previous declaration") |
| type.typeobj_cname = typeobj_cname |
|
|
| if self.directives.get('final'): |
| entry.type.is_final_type = True |
| collection_type = self.directives.get('collection_type') |
| if collection_type: |
| from .UtilityCode import NonManglingModuleScope |
| if not isinstance(self, NonManglingModuleScope): |
| |
| |
| error(pos, "'collection_type' is not a public cython directive") |
| if collection_type == 'sequence': |
| entry.type.has_sequence_flag = True |
|
|
| |
| |
| entry.used = True |
|
|
| |
| |
| |
| return entry |
|
|
| def allocate_vtable_names(self, entry): |
| |
| |
| type = entry.type |
| if type.base_type and type.base_type.vtabslot_cname: |
| |
| type.vtabslot_cname = "%s.%s" % ( |
| Naming.obj_base_cname, type.base_type.vtabslot_cname) |
| elif type.scope and type.scope.cfunc_entries: |
| |
| |
| |
| entry_count = len(type.scope.cfunc_entries) |
| base_type = type.base_type |
| while base_type: |
| |
| if not base_type.scope or entry_count > len(base_type.scope.cfunc_entries): |
| break |
| if base_type.is_builtin_type: |
| |
| return |
| base_type = base_type.base_type |
| |
| type.vtabslot_cname = Naming.vtabslot_cname |
| if type.vtabslot_cname: |
| |
| type.vtabstruct_cname = self.mangle(Naming.vtabstruct_prefix, entry.name) |
| type.vtabptr_cname = self.mangle(Naming.vtabptr_prefix, entry.name) |
|
|
| def check_c_classes_pxd(self): |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| for entry in self.c_class_entries: |
| |
| if not entry.type.scope: |
| error(entry.pos, "C class '%s' is declared but not defined" % entry.name) |
|
|
| def check_c_class(self, entry): |
| type = entry.type |
| name = entry.name |
| visibility = entry.visibility |
| |
| if not type.scope: |
| error(entry.pos, "C class '%s' is declared but not defined" % name) |
| |
| if visibility != 'extern' and not type.typeobj_cname: |
| type.typeobj_cname = self.mangle(Naming.typeobj_prefix, name) |
| |
| |
| |
| if type.scope: |
| for method_entry in type.scope.cfunc_entries: |
| if not method_entry.is_inherited and not method_entry.func_cname: |
| error(method_entry.pos, "C method '%s' is declared but not defined" % |
| method_entry.name) |
| |
| if type.vtabslot_cname: |
| |
| type.vtable_cname = self.mangle(Naming.vtable_prefix, entry.name) |
|
|
| def check_c_classes(self): |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| debug_check_c_classes = 0 |
| if debug_check_c_classes: |
| print("Scope.check_c_classes: checking scope " + self.qualified_name) |
| for entry in self.c_class_entries: |
| if debug_check_c_classes: |
| print("...entry %s %s" % (entry.name, entry)) |
| print("......type = ", entry.type) |
| print("......visibility = ", entry.visibility) |
| self.check_c_class(entry) |
|
|
| def check_c_functions(self): |
| |
| |
| for name, entry in self.entries.items(): |
| if entry.is_cfunction: |
| if (entry.defined_in_pxd |
| and entry.scope is self |
| and entry.visibility != 'extern' |
| and not entry.in_cinclude |
| and not entry.is_implemented): |
| error(entry.pos, "Non-extern C function '%s' declared but not defined" % name) |
|
|
| def attach_var_entry_to_c_class(self, entry): |
| |
| |
| |
| |
| |
| |
| from . import Builtin |
| var_entry = Entry(name = entry.name, |
| type = Builtin.type_type, |
| pos = entry.pos, |
| cname = entry.type.typeptr_cname) |
| var_entry.qualified_name = entry.qualified_name |
| var_entry.is_variable = 1 |
| var_entry.is_cglobal = 1 |
| var_entry.is_readonly = 1 |
| var_entry.is_cclass_var_entry = True |
| var_entry.scope = entry.scope |
| entry.as_variable = var_entry |
|
|
| def is_cpp(self): |
| return self.cpp |
|
|
| def infer_types(self): |
| from .TypeInference import PyObjectTypeInferer |
| PyObjectTypeInferer().infer_types(self) |
|
|
|
|
| class LocalScope(Scope): |
| is_local_scope = True |
|
|
| |
| has_with_gil_block = False |
|
|
| |
| _in_with_gil_block = False |
|
|
| def __init__(self, name, outer_scope, parent_scope = None): |
| if parent_scope is None: |
| parent_scope = outer_scope |
| Scope.__init__(self, name, outer_scope, parent_scope) |
|
|
| def mangle(self, prefix, name): |
| return punycodify_name(prefix + name) |
|
|
| def declare_arg(self, name, type, pos): |
| |
| name = self.mangle_class_private_name(name) |
| cname = self.mangle(Naming.var_prefix, name) |
| entry = self.declare(name, cname, type, pos, 'private') |
| entry.is_variable = 1 |
| if type.is_pyobject: |
| entry.init = "0" |
| entry.is_arg = 1 |
| |
| self.arg_entries.append(entry) |
| return entry |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='private', |
| api=False, in_pxd=False, is_cdef=False, pytyping_modifiers=None): |
| name = self.mangle_class_private_name(name) |
| |
| if visibility in ('public', 'readonly'): |
| error(pos, "Local variable cannot be declared %s" % visibility) |
| entry = Scope.declare_var(self, name, type, pos, |
| cname=cname, visibility=visibility, |
| api=api, in_pxd=in_pxd, is_cdef=is_cdef, pytyping_modifiers=pytyping_modifiers) |
| if entry.type.declaration_value: |
| entry.init = entry.type.declaration_value |
| entry.is_local = 1 |
|
|
| entry.in_with_gil_block = self._in_with_gil_block |
| self.var_entries.append(entry) |
| return entry |
|
|
| def declare_global(self, name, pos): |
| |
| if self.lookup_here(name): |
| warning(pos, "'%s' redeclared ", 0) |
| else: |
| entry = self.global_scope().lookup_target(name) |
| self.entries[name] = entry |
|
|
| def declare_nonlocal(self, name, pos): |
| |
| orig_entry = self.lookup_here(name) |
| if orig_entry and orig_entry.scope is self and not orig_entry.from_closure: |
| error(pos, "'%s' redeclared as nonlocal" % name) |
| orig_entry.already_declared_here() |
| else: |
| entry = self.lookup(name) |
| if entry is None or not entry.from_closure: |
| error(pos, "no binding for nonlocal '%s' found" % name) |
|
|
| def _create_inner_entry_for_closure(self, name, entry): |
| entry.in_closure = True |
| inner_entry = InnerEntry(entry, self) |
| inner_entry.is_variable = True |
| self.entries[name] = inner_entry |
| return inner_entry |
|
|
| def lookup(self, name): |
| |
| |
|
|
| entry = Scope.lookup(self, name) |
| if entry is not None: |
| entry_scope = entry.scope |
| while entry_scope.is_comprehension_scope: |
| entry_scope = entry_scope.outer_scope |
| if entry_scope is not self and entry_scope.is_closure_scope: |
| if hasattr(entry.scope, "scope_class"): |
| raise InternalError("lookup() after scope class created.") |
| |
| |
| return self._create_inner_entry_for_closure(name, entry) |
| return entry |
|
|
| def mangle_closure_cnames(self, outer_scope_cname): |
| for scope in self.iter_local_scopes(): |
| for entry in scope.entries.values(): |
| if entry.from_closure: |
| cname = entry.outer_entry.cname |
| if self.is_passthrough: |
| entry.cname = cname |
| else: |
| if cname.startswith(Naming.cur_scope_cname): |
| cname = cname[len(Naming.cur_scope_cname)+2:] |
| entry.cname = "%s->%s" % (outer_scope_cname, cname) |
| elif entry.in_closure: |
| entry.original_cname = entry.cname |
| entry.cname = "%s->%s" % (Naming.cur_scope_cname, entry.cname) |
| if entry.type.is_cpp_class and entry.scope.directives['cpp_locals']: |
| entry.make_cpp_optional() |
|
|
|
|
| class ComprehensionScope(Scope): |
| """Scope for comprehensions (but not generator expressions, which use ClosureScope). |
| As opposed to generators, these can be easily inlined in some cases, so all |
| we really need is a scope that holds the loop variable(s). |
| """ |
| is_comprehension_scope = True |
|
|
| def __init__(self, outer_scope): |
| parent_scope = outer_scope |
| |
| while parent_scope.is_comprehension_scope: |
| parent_scope = parent_scope.parent_scope |
| name = parent_scope.global_scope().next_id(Naming.genexpr_id_ref) |
| Scope.__init__(self, name, outer_scope, parent_scope) |
| self.directives = outer_scope.directives |
| self.genexp_prefix = "%s%d%s" % (Naming.pyrex_prefix, len(name), name) |
|
|
| |
| |
| while outer_scope.is_comprehension_scope or outer_scope.is_c_class_scope or outer_scope.is_py_class_scope: |
| outer_scope = outer_scope.outer_scope |
| self.var_entries = outer_scope.var_entries |
| outer_scope.subscopes.add(self) |
|
|
| def mangle(self, prefix, name): |
| return '%s%s' % (self.genexp_prefix, self.parent_scope.mangle(prefix, name)) |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='private', |
| api=False, in_pxd=False, is_cdef=True, pytyping_modifiers=None): |
| if type is unspecified_type: |
| |
| outer_entry = self.outer_scope.lookup(name) |
| if outer_entry and outer_entry.is_variable: |
| type = outer_entry.type |
| self._reject_pytyping_modifiers(pos, pytyping_modifiers) |
| |
| |
| cname = '%s%s' % (self.genexp_prefix, self.parent_scope.mangle(Naming.var_prefix, name or self.next_id())) |
| entry = self.declare(name, cname, type, pos, visibility) |
| entry.is_variable = True |
| if self.parent_scope.is_module_scope: |
| entry.is_cglobal = True |
| else: |
| entry.is_local = True |
| entry.in_subscope = True |
| self.var_entries.append(entry) |
| self.entries[name] = entry |
| return entry |
|
|
| def declare_assignment_expression_target(self, name, type, pos): |
| |
| return self.parent_scope.declare_var(name, type, pos) |
|
|
| def declare_pyfunction(self, name, pos, allow_redefine=False): |
| return self.outer_scope.declare_pyfunction( |
| name, pos, allow_redefine) |
|
|
| def declare_lambda_function(self, func_cname, pos): |
| return self.outer_scope.declare_lambda_function(func_cname, pos) |
|
|
| def add_lambda_def(self, def_node): |
| return self.outer_scope.add_lambda_def(def_node) |
|
|
| def lookup_assignment_expression_target(self, name): |
| entry = self.lookup_here(name) |
| if not entry: |
| entry = self.parent_scope.lookup_assignment_expression_target(name) |
| return entry |
|
|
|
|
| class ClosureScope(LocalScope): |
|
|
| is_closure_scope = True |
|
|
| def __init__(self, name, scope_name, outer_scope, parent_scope=None): |
| LocalScope.__init__(self, name, outer_scope, parent_scope) |
| self.closure_cname = "%s%s" % (Naming.closure_scope_prefix, scope_name) |
|
|
| |
| |
| |
| |
|
|
| |
| |
| |
|
|
| def declare_pyfunction(self, name, pos, allow_redefine=False): |
| return LocalScope.declare_pyfunction(self, name, pos, allow_redefine, visibility='private') |
|
|
| def declare_assignment_expression_target(self, name, type, pos): |
| return self.declare_var(name, type, pos) |
|
|
|
|
| class GeneratorExpressionScope(ClosureScope): |
| is_generator_expression_scope = True |
|
|
| def declare_assignment_expression_target(self, name, type, pos): |
| entry = self.parent_scope.declare_var(name, type, pos) |
| return self._create_inner_entry_for_closure(name, entry) |
|
|
| def lookup_assignment_expression_target(self, name): |
| entry = self.lookup_here(name) |
| if not entry: |
| entry = self.parent_scope.lookup_assignment_expression_target(name) |
| if entry: |
| return self._create_inner_entry_for_closure(name, entry) |
| return entry |
|
|
|
|
| class StructOrUnionScope(Scope): |
| |
|
|
| def __init__(self, name="?"): |
| Scope.__init__(self, name, outer_scope=None, parent_scope=None) |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='private', |
| api=False, in_pxd=False, is_cdef=False, pytyping_modifiers=None, |
| allow_pyobject=False, allow_memoryview=False, allow_refcounted=False): |
| |
| if not cname: |
| cname = name |
| if visibility == 'private': |
| cname = c_safe_identifier(cname) |
| if type.is_cfunction: |
| type = PyrexTypes.CPtrType(type) |
| self._reject_pytyping_modifiers(pos, pytyping_modifiers) |
| entry = self.declare(name, cname, type, pos, visibility) |
| entry.is_variable = 1 |
| self.var_entries.append(entry) |
| if type.is_pyobject: |
| if not allow_pyobject: |
| error(pos, "C struct/union member cannot be a Python object") |
| elif type.is_memoryviewslice: |
| if not allow_memoryview: |
| |
| error(pos, "C struct/union member cannot be a memory view") |
| elif type.needs_refcounting: |
| if not allow_refcounted: |
| error(pos, "C struct/union member cannot be reference-counted type '%s'" % type) |
| return entry |
|
|
| def declare_cfunction(self, name, type, pos, |
| cname=None, visibility='private', api=0, in_pxd=0, |
| defining=0, modifiers=(), overridable=False): |
| if overridable: |
| error(pos, "C struct/union member cannot be declared 'cpdef'") |
| return self.declare_var(name, type, pos, |
| cname=cname, visibility=visibility) |
|
|
|
|
| class ClassScope(Scope): |
| |
| |
| |
| |
| |
| |
| |
|
|
| scope_predefined_names = ['__module__', '__qualname__'] |
|
|
| def mangle_class_private_name(self, name): |
| |
| if name and name.lower().startswith("__pyx_"): |
| return name |
| if name and name.startswith('__') and not name.endswith('__'): |
| name = EncodedString('_%s%s' % (self.class_name.lstrip('_'), name)) |
| return name |
|
|
| def __init__(self, name, outer_scope): |
| Scope.__init__(self, name, outer_scope, outer_scope) |
| self.class_name = name |
| self.doc = None |
|
|
| def lookup(self, name): |
| entry = Scope.lookup(self, name) |
| if entry: |
| return entry |
| if name == "classmethod": |
| |
| |
| |
| |
| entry = Entry( |
| "classmethod", |
| "__Pyx_Method_ClassMethod", |
| PyrexTypes.CFuncType( |
| py_object_type, |
| [PyrexTypes.CFuncTypeArg("", py_object_type, None)], 0, 0)) |
| entry.utility_code_definition = Code.UtilityCode.load_cached("ClassMethod", "CythonFunction.c") |
| self.use_entry_utility_code(entry) |
| entry.is_cfunction = 1 |
| entry.scope = self.builtin_scope() |
| return entry |
|
|
|
|
| class PyClassScope(ClassScope): |
| |
| |
| |
|
|
| is_py_class_scope = 1 |
| namespace_cname_is_type = False |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='private', |
| api=False, in_pxd=False, is_cdef=False, pytyping_modifiers=None): |
| name = self.mangle_class_private_name(name) |
| if type is unspecified_type: |
| type = py_object_type |
| |
| entry = Scope.declare_var(self, name, type, pos, |
| cname=cname, visibility=visibility, |
| api=api, in_pxd=in_pxd, is_cdef=is_cdef, pytyping_modifiers=pytyping_modifiers) |
| entry.is_pyglobal = 1 |
| entry.is_pyclass_attr = 1 |
| return entry |
|
|
| def declare_nonlocal(self, name, pos): |
| |
| orig_entry = self.lookup_here(name) |
| if orig_entry and orig_entry.scope is self and not orig_entry.from_closure: |
| error(pos, "'%s' redeclared as nonlocal" % name) |
| orig_entry.already_declared_here() |
| else: |
| entry = self.lookup(name) |
| if entry is None: |
| error(pos, "no binding for nonlocal '%s' found" % name) |
| else: |
| |
| |
| self.entries[name] = entry |
|
|
| def declare_global(self, name, pos): |
| |
| if self.lookup_here(name): |
| warning(pos, "'%s' redeclared ", 0) |
| else: |
| entry = self.global_scope().lookup_target(name) |
| self.entries[name] = entry |
|
|
| def add_default_value(self, type): |
| return self.outer_scope.add_default_value(type) |
|
|
|
|
| class CClassScope(ClassScope): |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| is_c_class_scope = 1 |
| is_closure_class_scope = False |
| is_defaults_class_scope = False |
|
|
| has_pyobject_attrs = False |
| has_memoryview_attrs = False |
| has_explicitly_constructable_attrs = False |
| has_cyclic_pyobject_attrs = False |
| defined = False |
| implemented = False |
|
|
| def __init__(self, name, outer_scope, visibility, parent_type): |
| ClassScope.__init__(self, name, outer_scope) |
| if visibility != 'extern': |
| self.method_table_cname = outer_scope.mangle(Naming.methtab_prefix, name) |
| self.getset_table_cname = outer_scope.mangle(Naming.gstab_prefix, name) |
| self.property_entries = [] |
| self.inherited_var_entries = [] |
| self.parent_type = parent_type |
| |
| |
| |
| |
| if ((parent_type.is_builtin_type or parent_type.is_extension_type) |
| and parent_type.typeptr_cname): |
| self.namespace_cname = self.parent_type.typeptr_cname |
| self.namespace_cname_is_type = True |
|
|
| def needs_gc(self): |
| |
| |
| if self.has_cyclic_pyobject_attrs and not self.directives.get('no_gc', False): |
| return True |
| if self.parent_type.is_external and not self.parent_type.is_builtin_type: |
| |
| return True |
| base_type = self.parent_type.base_type |
| if base_type and base_type.scope is not None: |
| return base_type.scope.needs_gc() |
| elif self.parent_type.is_builtin_type: |
| return not self.parent_type.is_gc_simple |
| return False |
|
|
| def needs_trashcan(self): |
| |
| |
| directive = self.directives.get('trashcan') |
| if directive is False: |
| return False |
| |
| |
| if directive and self.has_cyclic_pyobject_attrs: |
| return True |
| |
| base_type = self.parent_type.base_type |
| if base_type and base_type.scope is not None: |
| return base_type.scope.needs_trashcan() |
| return self.parent_type.builtin_trashcan |
|
|
| def needs_tp_clear(self): |
| """ |
| Do we need to generate an implementation for the tp_clear slot? Can |
| be disabled to keep references for the __dealloc__ cleanup function. |
| """ |
| return self.needs_gc() and not self.directives.get('no_gc_clear', False) |
|
|
| def may_have_finalize(self): |
| """ |
| This covers cases where we definitely have a __del__ function |
| and also cases where one of the base classes could have a __del__ |
| function but we don't know. |
| """ |
| current_type_scope = self |
| while current_type_scope: |
| del_entry = current_type_scope.lookup_here("__del__") |
| if del_entry and del_entry.is_special: |
| return True |
| if (current_type_scope.parent_type.is_external or not current_type_scope.implemented or |
| current_type_scope.parent_type.multiple_bases): |
| |
| return True |
| current_base_type = current_type_scope.parent_type.base_type |
| current_type_scope = current_base_type.scope if current_base_type else None |
| return False |
|
|
| def get_refcounted_entries(self, include_weakref=False, |
| include_gc_simple=True): |
| py_attrs = [] |
| py_buffers = [] |
| memoryview_slices = [] |
|
|
| for entry in self.var_entries: |
| if entry.type.is_pyobject: |
| if include_weakref or (self.is_closure_class_scope or entry.name != "__weakref__"): |
| if include_gc_simple or not entry.type.is_gc_simple: |
| py_attrs.append(entry) |
| elif entry.type == PyrexTypes.c_py_buffer_type: |
| py_buffers.append(entry) |
| elif entry.type.is_memoryviewslice: |
| memoryview_slices.append(entry) |
|
|
| have_entries = py_attrs or py_buffers or memoryview_slices |
| return have_entries, (py_attrs, py_buffers, memoryview_slices) |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='private', |
| api=False, in_pxd=False, is_cdef=False, pytyping_modifiers=None): |
| name = self.mangle_class_private_name(name) |
|
|
| if pytyping_modifiers: |
| if "typing.ClassVar" in pytyping_modifiers: |
| is_cdef = 0 |
| if not type.is_pyobject: |
| if not type.equivalent_type: |
| warning(pos, "ClassVar[] requires the type to be a Python object type. Found '%s', using object instead." % type) |
| type = py_object_type |
| else: |
| type = type.equivalent_type |
| if "dataclasses.InitVar" in pytyping_modifiers and not self.is_c_dataclass_scope: |
| error(pos, "Use of cython.dataclasses.InitVar does not make sense outside a dataclass") |
|
|
| if is_cdef: |
| |
| if self.defined: |
| error(pos, |
| "C attributes cannot be added in implementation part of" |
| " extension type defined in a pxd") |
| if (not self.is_closure_class_scope and |
| get_slot_table(self.directives).get_special_method_signature(name)): |
| error(pos, |
| "The name '%s' is reserved for a special method." |
| % name) |
| if not cname: |
| cname = name |
| if not (self.parent_type.is_external or self.parent_type.entry.api or |
| self.parent_type.entry.visibility == "public"): |
| cname = c_safe_identifier(cname) |
| cname = punycodify_name(cname, Naming.unicode_structmember_prefix) |
| entry = self.declare(name, cname, type, pos, visibility) |
| entry.is_variable = 1 |
| self.var_entries.append(entry) |
| entry.pytyping_modifiers = pytyping_modifiers |
| if type.is_cpp_class and visibility != 'extern': |
| if self.directives['cpp_locals']: |
| entry.make_cpp_optional() |
| else: |
| type.check_nullary_constructor(pos) |
| if type.is_memoryviewslice: |
| self.has_memoryview_attrs = True |
| elif type.needs_explicit_construction(self): |
| self.has_explicitly_constructable_attrs = True |
| elif type.is_pyobject and (self.is_closure_class_scope or name != '__weakref__'): |
| self.has_pyobject_attrs = True |
| if (not type.is_builtin_type |
| or not type.scope or type.scope.needs_gc()): |
| self.has_cyclic_pyobject_attrs = True |
| if visibility not in ('private', 'public', 'readonly'): |
| error(pos, |
| "Attribute of extension type cannot be declared %s" % visibility) |
| if visibility in ('public', 'readonly'): |
| |
| |
| |
| entry.needs_property = True |
| if not self.is_closure_class_scope and name == "__weakref__": |
| error(pos, "Special attribute __weakref__ cannot be exposed to Python") |
| if not (type.is_pyobject or type.can_coerce_to_pyobject(self)): |
| |
| error(pos, "C attribute of type '%s' cannot be accessed from Python" % type) |
| else: |
| entry.needs_property = False |
| return entry |
| else: |
| if type is unspecified_type: |
| type = py_object_type |
| |
| entry = Scope.declare_var(self, name, type, pos, |
| cname=cname, visibility=visibility, |
| api=api, in_pxd=in_pxd, is_cdef=is_cdef, pytyping_modifiers=pytyping_modifiers) |
| entry.is_member = 1 |
| |
| |
| entry.is_pyglobal = 1 |
|
|
| return entry |
|
|
| def declare_pyfunction(self, name, pos, allow_redefine=False): |
| |
| if name in richcmp_special_methods: |
| if self.lookup_here('__richcmp__'): |
| error(pos, "Cannot define both % and __richcmp__" % name) |
| elif name == '__richcmp__': |
| for n in richcmp_special_methods: |
| if self.lookup_here(n): |
| error(pos, "Cannot define both % and __richcmp__" % n) |
| if name == "__new__": |
| error(pos, "__new__ method of extension type will change semantics " |
| "in a future version of Pyrex and Cython. Use __cinit__ instead.") |
| entry = self.declare_var(name, py_object_type, pos, |
| visibility='extern') |
| special_sig = get_slot_table(self.directives).get_special_method_signature(name) |
| if special_sig: |
| |
| |
| entry.signature = special_sig |
| entry.is_special = 1 |
| else: |
| entry.signature = pymethod_signature |
| entry.is_special = 0 |
|
|
| self.pyfunc_entries.append(entry) |
| return entry |
|
|
| def lookup_here(self, name): |
| if not self.is_closure_class_scope and name == "__new__": |
| name = EncodedString("__cinit__") |
| entry = ClassScope.lookup_here(self, name) |
| if entry and entry.is_builtin_cmethod: |
| if not self.parent_type.is_builtin_type: |
| |
| |
| |
| |
| |
| if not self.parent_type.is_final_type: |
| return None |
| return entry |
|
|
| def declare_cfunction(self, name, type, pos, |
| cname=None, visibility='private', api=0, in_pxd=0, |
| defining=0, modifiers=(), utility_code=None, overridable=False): |
| name = self.mangle_class_private_name(name) |
| if (get_slot_table(self.directives).get_special_method_signature(name) |
| and not self.parent_type.is_builtin_type): |
| error(pos, "Special methods must be declared with 'def', not 'cdef'") |
| args = type.args |
| if not type.is_static_method: |
| if not args: |
| error(pos, "C method has no self argument") |
| elif not self.parent_type.assignable_from(args[0].type): |
| error(pos, "Self argument (%s) of C method '%s' does not match parent type (%s)" % |
| (args[0].type, name, self.parent_type)) |
| entry = self.lookup_here(name) |
| if cname is None: |
| cname = punycodify_name(c_safe_identifier(name), Naming.unicode_vtabentry_prefix) |
| if entry: |
| if not entry.is_cfunction: |
| error(pos, "'%s' redeclared " % name) |
| entry.already_declared_here() |
| else: |
| if defining and entry.func_cname: |
| error(pos, "'%s' already defined" % name) |
| |
| if entry.is_final_cmethod and entry.is_inherited: |
| error(pos, "Overriding final methods is not allowed") |
| elif type.same_c_signature_as(entry.type, as_cmethod = 1) and type.nogil == entry.type.nogil: |
| |
| entry.type = entry.type.with_with_gil(type.with_gil) |
| elif type.compatible_signature_with(entry.type, as_cmethod = 1) and type.nogil == entry.type.nogil: |
| if (self.defined and not in_pxd |
| and not type.same_c_signature_as_resolved_type( |
| entry.type, as_cmethod=1, as_pxd_definition=1)): |
| |
| warning(pos, |
| "Compatible but non-identical C method '%s' not redeclared " |
| "in definition part of extension type '%s'. " |
| "This may cause incorrect vtables to be generated." % ( |
| name, self.class_name), 2) |
| warning(entry.pos, "Previous declaration is here", 2) |
| entry = self.add_cfunction(name, type, pos, cname, visibility='ignore', modifiers=modifiers) |
| else: |
| error(pos, "Signature not compatible with previous declaration") |
| error(entry.pos, "Previous declaration is here") |
| else: |
| if self.defined: |
| error(pos, |
| "C method '%s' not previously declared in definition part of" |
| " extension type '%s'" % (name, self.class_name)) |
| entry = self.add_cfunction(name, type, pos, cname, visibility, modifiers) |
| if defining: |
| entry.func_cname = self.mangle(Naming.func_prefix, name) |
| entry.utility_code = utility_code |
| type.entry = entry |
|
|
| if 'inline' in modifiers: |
| entry.is_inline_cmethod = True |
|
|
| if self.parent_type.is_final_type or entry.is_inline_cmethod or self.directives.get('final'): |
| entry.is_final_cmethod = True |
| entry.final_func_cname = entry.func_cname |
| if not type.is_fused: |
| entry.vtable_type = entry.type |
| entry.type = type |
|
|
| return entry |
|
|
| def add_cfunction(self, name, type, pos, cname, visibility, modifiers, inherited=False): |
| |
| prev_entry = self.lookup_here(name) |
| entry = ClassScope.add_cfunction( |
| self, name, type, pos, cname, visibility, modifiers, inherited=inherited) |
| entry.is_cmethod = 1 |
| entry.prev_entry = prev_entry |
| return entry |
|
|
| def declare_builtin_cfunction(self, name, type, cname, utility_code = None): |
| |
| |
| name = EncodedString(name) |
| entry = self.declare_cfunction( |
| name, type, pos=None, cname=cname, visibility='extern', utility_code=utility_code) |
| var_entry = Entry(name, name, py_object_type) |
| var_entry.qualified_name = name |
| var_entry.is_variable = 1 |
| var_entry.is_builtin = 1 |
| var_entry.utility_code = utility_code |
| var_entry.scope = entry.scope |
| entry.as_variable = var_entry |
| return entry |
|
|
| def declare_property(self, name, doc, pos, ctype=None, property_scope=None): |
| entry = self.lookup_here(name) |
| if entry is None: |
| entry = self.declare(name, name, py_object_type if ctype is None else ctype, pos, 'private') |
| entry.is_property = True |
| if ctype is not None: |
| entry.is_cproperty = True |
| entry.doc = doc |
| if property_scope is None: |
| entry.scope = PropertyScope(name, class_scope=self) |
| else: |
| entry.scope = property_scope |
| self.property_entries.append(entry) |
| return entry |
|
|
| def declare_cproperty(self, name, type, cfunc_name, doc=None, pos=None, visibility='extern', |
| nogil=False, with_gil=False, exception_value=None, exception_check=False, |
| utility_code=None): |
| """Internal convenience method to declare a C property function in one go. |
| """ |
| property_entry = self.declare_property(name, doc=doc, ctype=type, pos=pos) |
| cfunc_entry = property_entry.scope.declare_cfunction( |
| name=name, |
| type=PyrexTypes.CFuncType( |
| type, |
| [PyrexTypes.CFuncTypeArg("self", self.parent_type, pos=None)], |
| nogil=nogil, |
| with_gil=with_gil, |
| exception_value=exception_value, |
| exception_check=exception_check, |
| ), |
| cname=cfunc_name, |
| utility_code=utility_code, |
| visibility=visibility, |
| pos=pos, |
| ) |
| return property_entry, cfunc_entry |
|
|
| def declare_inherited_c_attributes(self, base_scope): |
| |
| |
| |
| def adapt(cname): |
| return "%s.%s" % (Naming.obj_base_cname, base_entry.cname) |
|
|
| entries = base_scope.inherited_var_entries + base_scope.var_entries |
| for base_entry in entries: |
| entry = self.declare( |
| base_entry.name, adapt(base_entry.cname), |
| base_entry.type, None, 'private') |
| entry.is_variable = 1 |
| entry.is_inherited = True |
| entry.annotation = base_entry.annotation |
| self.inherited_var_entries.append(entry) |
|
|
| |
| |
| |
| for base_entry in base_scope.cfunc_entries[:]: |
| if base_entry.type.is_fused: |
| base_entry.type.get_all_specialized_function_types() |
|
|
| for base_entry in base_scope.cfunc_entries: |
| cname = base_entry.cname |
| var_entry = base_entry.as_variable |
| is_builtin = var_entry and var_entry.is_builtin |
| if not is_builtin: |
| cname = adapt(cname) |
| entry = self.add_cfunction( |
| base_entry.name, base_entry.type, base_entry.pos, cname, |
| base_entry.visibility, base_entry.func_modifiers, inherited=True) |
| entry.is_inherited = 1 |
| if base_entry.is_final_cmethod: |
| entry.is_final_cmethod = True |
| entry.is_inline_cmethod = base_entry.is_inline_cmethod |
| if (self.parent_scope == base_scope.parent_scope or |
| entry.is_inline_cmethod): |
| entry.final_func_cname = base_entry.final_func_cname |
| if is_builtin: |
| entry.is_builtin_cmethod = True |
| entry.as_variable = var_entry |
| if base_entry.utility_code: |
| entry.utility_code = base_entry.utility_code |
|
|
|
|
| def handle_already_declared_name(self, name, cname, type, pos, visibility, copy_entry=True): |
| |
| super().handle_already_declared_name(name, cname, type, pos, visibility, copy_entry) |
|
|
| class CppClassScope(Scope): |
| |
|
|
| is_cpp_class_scope = 1 |
|
|
| default_constructor = None |
| type = None |
|
|
| def __init__(self, name, outer_scope, templates=None): |
| Scope.__init__(self, name, outer_scope, None) |
| self.directives = outer_scope.directives |
| self.inherited_var_entries = [] |
| if templates is not None: |
| for T in templates: |
| template_entry = self.declare( |
| T, T, PyrexTypes.TemplatePlaceholderType(T), None, 'extern') |
| template_entry.is_type = 1 |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='extern', |
| api=False, in_pxd=False, is_cdef=False, defining=False, pytyping_modifiers=None): |
| |
| if not cname: |
| cname = name |
| self._reject_pytyping_modifiers(pos, pytyping_modifiers) |
| entry = self.lookup_here(name) |
| if defining and entry is not None: |
| if type.is_cfunction: |
| entry = self.declare(name, cname, type, pos, visibility) |
| elif entry.type.same_as(type): |
| |
| entry.type = entry.type.with_with_gil(type.with_gil) |
| else: |
| error(pos, "Function signature does not match previous declaration") |
| else: |
| entry = self.declare(name, cname, type, pos, visibility) |
| if type.is_cfunction and not defining: |
| entry.is_inherited = 1 |
| entry.is_variable = 1 |
| if type.is_cfunction: |
| entry.is_cfunction = 1 |
| if self.type and not self.type.get_fused_types(): |
| entry.func_cname = "%s::%s" % (self.type.empty_declaration_code(), cname) |
| if name != "this" and (defining or name != "<init>"): |
| self.var_entries.append(entry) |
| return entry |
|
|
| def declare_cfunction(self, name, type, pos, |
| cname=None, visibility='extern', api=0, in_pxd=0, |
| defining=0, modifiers=(), utility_code=None, overridable=False): |
| class_name = self.name.split('::')[-1] |
| if name in (class_name, '__init__') and cname is None: |
| cname = "%s__init__%s" % (Naming.func_prefix, class_name) |
| name = EncodedString('<init>') |
| type.return_type = PyrexTypes.CVoidType() |
| |
| |
| type.original_args = type.args |
| def maybe_ref(arg): |
| if arg.type.is_cpp_class and not arg.type.is_reference: |
| return PyrexTypes.CFuncTypeArg( |
| arg.name, PyrexTypes.c_ref_type(arg.type), arg.pos) |
| else: |
| return arg |
| type.args = [maybe_ref(arg) for arg in type.args] |
| elif name == '__dealloc__' and cname is None: |
| cname = "%s__dealloc__%s" % (Naming.func_prefix, class_name) |
| name = EncodedString('<del>') |
| type.return_type = PyrexTypes.CVoidType() |
| if name in ('<init>', '<del>') and type.nogil: |
| for base in self.type.base_classes: |
| base_entry = base.scope.lookup(name) |
| if base_entry and not base_entry.type.nogil: |
| error(pos, "Constructor cannot be called without GIL unless all base constructors can also be called without GIL") |
| error(base_entry.pos, "Base constructor defined here.") |
| |
| entry = self.declare_var(name, type, pos, |
| defining=defining, |
| cname=cname, visibility=visibility) |
| entry.utility_code = utility_code |
| type.entry = entry |
| return entry |
|
|
| def declare_inherited_cpp_attributes(self, base_class): |
| base_scope = base_class.scope |
| template_type = base_class |
| while getattr(template_type, 'template_type', None): |
| template_type = template_type.template_type |
| if getattr(template_type, 'templates', None): |
| base_templates = [T.name for T in template_type.templates] |
| else: |
| base_templates = () |
| |
| |
| |
| for base_entry in base_scope.inherited_var_entries + base_scope.var_entries: |
| |
| if base_entry.name in ("<init>", "<del>"): |
| continue |
| |
| if base_entry.name in self.entries: |
| base_entry.name |
| entry = self.declare(base_entry.name, base_entry.cname, |
| base_entry.type, None, 'extern') |
| entry.is_variable = 1 |
| entry.is_inherited = 1 |
| if base_entry.is_cfunction: |
| entry.is_cfunction = 1 |
| entry.func_cname = base_entry.func_cname |
| self.inherited_var_entries.append(entry) |
| for base_entry in base_scope.cfunc_entries: |
| entry = self.declare_cfunction(base_entry.name, base_entry.type, |
| base_entry.pos, base_entry.cname, |
| base_entry.visibility, api=0, |
| modifiers=base_entry.func_modifiers, |
| utility_code=base_entry.utility_code) |
| entry.is_inherited = 1 |
| for base_entry in base_scope.type_entries: |
| if base_entry.name not in base_templates: |
| entry = self.declare_type(base_entry.name, base_entry.type, |
| base_entry.pos, base_entry.cname, |
| base_entry.visibility, defining=False) |
| entry.is_inherited = 1 |
|
|
| def specialize(self, values, type_entry): |
| scope = CppClassScope(self.name, self.outer_scope) |
| scope.type = type_entry |
| for entry in self.entries.values(): |
| if entry.is_type: |
| scope.declare_type(entry.name, |
| entry.type.specialize(values), |
| entry.pos, |
| entry.cname, |
| template=1) |
| elif entry.type.is_cfunction: |
| for e in entry.all_alternatives(): |
| scope.declare_cfunction(e.name, |
| e.type.specialize(values), |
| e.pos, |
| e.cname, |
| utility_code=e.utility_code) |
| else: |
| scope.declare_var(entry.name, |
| entry.type.specialize(values), |
| entry.pos, |
| entry.cname, |
| entry.visibility) |
|
|
| return scope |
|
|
| def lookup_here(self, name): |
| if name == "__init__": |
| name = "<init>" |
| elif name == "__dealloc__": |
| name = "<del>" |
| return super(CppClassScope, self).lookup_here(name) |
|
|
| def is_cpp(self): |
| |
| |
| return True |
|
|
|
|
| class CppScopedEnumScope(Scope): |
| |
|
|
| def __init__(self, name, outer_scope): |
| Scope.__init__(self, name, outer_scope, None) |
|
|
| def declare_var(self, name, type, pos, |
| cname=None, visibility='extern', pytyping_modifiers=None): |
| |
| if not cname: |
| cname = name |
| self._reject_pytyping_modifiers(pos, pytyping_modifiers) |
| entry = self.declare(name, cname, type, pos, visibility) |
| entry.is_variable = True |
| return entry |
|
|
|
|
| class PropertyScope(Scope): |
| |
| |
| |
| |
|
|
| is_property_scope = 1 |
|
|
| def __init__(self, name, class_scope): |
| |
| outer_scope = class_scope.global_scope() if class_scope.outer_scope else None |
| Scope.__init__(self, name, outer_scope, parent_scope=class_scope) |
| self.parent_type = class_scope.parent_type |
| self.directives = class_scope.directives |
|
|
| def declare_cfunction(self, name, type, pos, *args, **kwargs): |
| """Declare a C property function. |
| """ |
| if type.return_type.is_void: |
| error(pos, "C property method cannot return 'void'") |
|
|
| if type.args and type.args[0].type is py_object_type: |
| |
| type.args[0].type = self.parent_scope.parent_type |
| elif len(type.args) != 1: |
| error(pos, "C property method must have a single (self) argument") |
| elif not (type.args[0].type.is_pyobject or type.args[0].type is self.parent_scope.parent_type): |
| error(pos, "C property method must have a single (object) argument") |
|
|
| entry = Scope.declare_cfunction(self, name, type, pos, *args, **kwargs) |
| entry.is_cproperty = True |
| return entry |
|
|
| def declare_pyfunction(self, name, pos, allow_redefine=False): |
| |
| signature = get_property_accessor_signature(name) |
| if signature: |
| entry = self.declare(name, name, py_object_type, pos, 'private') |
| entry.is_special = 1 |
| entry.signature = signature |
| return entry |
| else: |
| error(pos, "Only __get__, __set__ and __del__ methods allowed " |
| "in a property declaration") |
| return None |
|
|
|
|
| class CConstOrVolatileScope(Scope): |
|
|
| def __init__(self, base_type_scope, is_const=0, is_volatile=0): |
| Scope.__init__( |
| self, |
| 'cv_' + base_type_scope.name, |
| base_type_scope.outer_scope, |
| base_type_scope.parent_scope) |
| self.base_type_scope = base_type_scope |
| self.is_const = is_const |
| self.is_volatile = is_volatile |
|
|
| def lookup_here(self, name): |
| entry = self.base_type_scope.lookup_here(name) |
| if entry is not None: |
| entry = copy.copy(entry) |
| entry.type = PyrexTypes.c_const_or_volatile_type( |
| entry.type, self.is_const, self.is_volatile) |
| return entry |
|
|
|
|
| class TemplateScope(Scope): |
| def __init__(self, name, outer_scope): |
| Scope.__init__(self, name, outer_scope, None) |
| self.directives = outer_scope.directives |
|
|
