diff --git "a/venv/lib/python3.10/site-packages/Cython/Compiler/Code.py" "b/venv/lib/python3.10/site-packages/Cython/Compiler/Code.py" new file mode 100644--- /dev/null +++ "b/venv/lib/python3.10/site-packages/Cython/Compiler/Code.py" @@ -0,0 +1,3375 @@ +# +# Code output module +# + + +import cython +cython.declare(os=object, re=object, operator=object, textwrap=object, + Template=object, Naming=object, Options=object, StringEncoding=object, + Utils=object, SourceDescriptor=object, StringIOTree=object, + DebugFlags=object, defaultdict=object, + closing=object, partial=object, wraps=object) + +import hashlib +import operator +import os +import re +import shutil +import textwrap +from string import Template +from functools import partial, wraps +from contextlib import closing, contextmanager +from collections import defaultdict + +from . import Naming +from . import Options +from . import DebugFlags +from . import StringEncoding +from .. import Utils +from .Scanning import SourceDescriptor +from ..StringIOTree import StringIOTree + + +renamed_py2_builtins_map = { + # builtins that had different names in Py2 code + 'unicode' : 'str', + 'basestring' : 'str', + 'xrange' : 'range', + 'raw_input' : 'input', +} + +ctypedef_builtins_map = { + # types of builtins in "ctypedef class" statements which we don't + # import either because the names conflict with C types or because + # the type simply is not exposed. + 'py_int' : '&PyLong_Type', + 'py_long' : '&PyLong_Type', + 'py_float' : '&PyFloat_Type', + 'wrapper_descriptor' : '&PyWrapperDescr_Type', +} + +basicsize_builtins_map = { + # builtins whose type has a different tp_basicsize than sizeof(...) + 'PyTypeObject': 'PyHeapTypeObject', +} + +# Builtins as of Python version ... +KNOWN_PYTHON_BUILTINS_VERSION = (3, 13, 0, 'alpha', 5) +KNOWN_PYTHON_BUILTINS = frozenset([ + 'ArithmeticError', + 'AssertionError', + 'AttributeError', + 'BaseException', + 'BaseExceptionGroup', + 'BlockingIOError', + 'BrokenPipeError', + 'BufferError', + 'BytesWarning', + 'ChildProcessError', + 'ConnectionAbortedError', + 'ConnectionError', + 'ConnectionRefusedError', + 'ConnectionResetError', + 'DeprecationWarning', + 'EOFError', + 'Ellipsis', + 'EncodingWarning', + 'EnvironmentError', + 'Exception', + 'ExceptionGroup', + 'False', + 'FileExistsError', + 'FileNotFoundError', + 'FloatingPointError', + 'FutureWarning', + 'GeneratorExit', + 'IOError', + 'ImportError', + 'ImportWarning', + '_IncompleteInputError', + 'IndentationError', + 'IndexError', + 'InterruptedError', + 'IsADirectoryError', + 'KeyError', + 'KeyboardInterrupt', + 'LookupError', + 'MemoryError', + 'ModuleNotFoundError', + 'NameError', + 'None', + 'NotADirectoryError', + 'NotImplemented', + 'NotImplementedError', + 'OSError', + 'OverflowError', + 'PendingDeprecationWarning', + 'PermissionError', + 'ProcessLookupError', + 'PythonFinalizationError', + 'RecursionError', + 'ReferenceError', + 'ResourceWarning', + 'RuntimeError', + 'RuntimeWarning', + 'StopAsyncIteration', + 'StopIteration', + 'SyntaxError', + 'SyntaxWarning', + 'SystemError', + 'SystemExit', + 'TabError', + 'TimeoutError', + 'True', + 'TypeError', + 'UnboundLocalError', + 'UnicodeDecodeError', + 'UnicodeEncodeError', + 'UnicodeError', + 'UnicodeTranslateError', + 'UnicodeWarning', + 'UserWarning', + 'ValueError', + 'Warning', + 'WindowsError', + 'ZeroDivisionError', + '__build_class__', + '__debug__', + '__import__', + 'abs', + 'aiter', + 'all', + 'anext', + 'any', + 'ascii', + 'bin', + 'bool', + 'breakpoint', + 'bytearray', + 'bytes', + 'callable', + 'chr', + 'classmethod', + 'compile', + 'complex', + 'copyright', + 'credits', + 'delattr', + 'dict', + 'dir', + 'divmod', + 'enumerate', + 'eval', + 'exec', + 'exit', + 'filter', + 'float', + 'format', + 'frozenset', + 'getattr', + 'globals', + 'hasattr', + 'hash', + 'help', + 'hex', + 'id', + 'input', + 'int', + 'isinstance', + 'issubclass', + 'iter', + 'len', + 'license', + 'list', + 'locals', + 'map', + 'max', + 'memoryview', + 'min', + 'next', + 'object', + 'oct', + 'open', + 'ord', + 'pow', + 'print', + 'property', + 'quit', + 'range', + 'repr', + 'reversed', + 'round', + 'set', + 'setattr', + 'slice', + 'sorted', + 'staticmethod', + 'str', + 'sum', + 'super', + 'tuple', + 'type', + 'vars', + 'zip', +]) + +uncachable_builtins = [ + # Global/builtin names that cannot be cached because they may or may not + # be available at import time, for various reasons: + ## Python 3.13+ + '_IncompleteInputError', + 'PythonFinalizationError', + ## Python 3.11+ + 'BaseExceptionGroup', + 'ExceptionGroup', + ## - Py3.10+ + 'aiter', + 'anext', + 'EncodingWarning', + ## - Py3.7+ + 'breakpoint', # might deserve an implementation in Cython + ## - platform specific + 'WindowsError', + ## - others + '_', # e.g. used by gettext +] + +special_py_methods = cython.declare(frozenset, frozenset(( + '__cinit__', '__dealloc__', '__richcmp__', '__next__', + '__await__', '__aiter__', '__anext__', + '__getbuffer__', '__releasebuffer__', +))) + +modifier_output_mapper = { + 'inline': 'CYTHON_INLINE' +}.get + +cleanup_level_for_type_prefix = cython.declare(object, { + 'ustring': None, + 'tuple': 2, + 'slice': 2, +}.get) + + +class IncludeCode: + """ + An include file and/or verbatim C code to be included in the + generated sources. + """ + # attributes: + # + # pieces {order: unicode}: pieces of C code to be generated. + # For the included file, the key "order" is zero. + # For verbatim include code, the "order" is the "order" + # attribute of the original IncludeCode where this piece + # of C code was first added. This is needed to prevent + # duplication if the same include code is found through + # multiple cimports. + # location int: where to put this include in the C sources, one + # of the constants INITIAL, EARLY, LATE + # order int: sorting order (automatically set by increasing counter) + + # Constants for location. If the same include occurs with different + # locations, the earliest one takes precedence. + INITIAL = 0 + EARLY = 1 + LATE = 2 + + counter = 1 # Counter for "order" + + def __init__(self, include=None, verbatim=None, late=True, initial=False): + self.order = self.counter + type(self).counter += 1 + self.pieces = {} + + if include: + if include[0] == '<' and include[-1] == '>': + self.pieces[0] = '#include {}'.format(include) + late = False # system include is never late + else: + self.pieces[0] = '#include "{}"'.format(include) + + if verbatim: + self.pieces[self.order] = verbatim + + if initial: + self.location = self.INITIAL + elif late: + self.location = self.LATE + else: + self.location = self.EARLY + + def dict_update(self, d, key): + """ + Insert `self` in dict `d` with key `key`. If that key already + exists, update the attributes of the existing value with `self`. + """ + if key in d: + other = d[key] + other.location = min(self.location, other.location) + other.pieces.update(self.pieces) + else: + d[key] = self + + def sortkey(self): + return self.order + + def mainpiece(self): + """ + Return the main piece of C code, corresponding to the include + file. If there was no include file, return None. + """ + return self.pieces.get(0) + + def write(self, code): + # Write values of self.pieces dict, sorted by the keys + for k in sorted(self.pieces): + code.putln(self.pieces[k]) + + +def get_utility_dir(): + # make this a function and not global variables: + # http://trac.cython.org/cython_trac/ticket/475 + Cython_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + return os.path.join(Cython_dir, "Utility") + +read_utilities_hook = None +""" +Override the hook for reading a utilities file that contains code fragments used +by the codegen. + +The hook functions takes the path of the utilities file, and returns a list +of strings, one per line. + +The default behavior is to open a file relative to get_utility_dir(). +""" + +def read_utilities_from_utility_dir(path): + """ + Read all lines of the file at the provided path from a path relative + to get_utility_dir(). + """ + filename = os.path.join(get_utility_dir(), path) + with closing(Utils.open_source_file(filename, encoding='UTF-8')) as f: + return f.readlines() + +# by default, read utilities from the utility directory. +read_utilities_hook = read_utilities_from_utility_dir + + +class AbstractUtilityCode: + + requires = None + + def put_code(self, output): + pass + + def get_tree(self, **kwargs): + return None + + def get_shared_library_scope(self, **kwargs): + return None + + +class UtilityCodeBase(AbstractUtilityCode): + """ + Support for loading utility code from a file. + + Code sections in the file can be specified as follows: + + ##### MyUtility.proto ##### + + [proto declarations] + + ##### MyUtility.init ##### + + [code run at module initialization] + + ##### MyUtility ##### + #@requires: MyOtherUtility + #@substitute: naming + + [definitions] + + ##### MyUtility ##### + #@substitute: tempita + + [requires tempita substitution + - context can't be specified here though so only + tempita utility that requires no external context + will benefit from this tag + - only necessary when @required from non-tempita code] + + for prototypes and implementation respectively. For non-python or + -cython files backslashes should be used instead. 5 to 30 comment + characters may be used on either side. + + If the @cname decorator is not used and this is a CythonUtilityCode, + one should pass in the 'name' keyword argument to be used for name + mangling of such entries. + """ + + is_cython_utility = False + _utility_cache = {} + + @classmethod + def _add_utility(cls, utility, name, type, lines, begin_lineno, tags=None): + if utility is None: + return + + code = '\n'.join(lines) + if tags and 'substitute' in tags and 'naming' in tags['substitute']: + try: + new_code = Template(code).substitute(vars(Naming)) + except (KeyError, ValueError) as e: + raise RuntimeError( + f"Error parsing templated utility code '{name}.{type}' at line {begin_lineno:d}: {e}") + if new_code == code: + raise RuntimeError( + f"Found useless 'substitute: naming' declaration without replacements. ({name}.{type}:{begin_lineno:d})") + code = new_code + + # remember correct line numbers at least until after templating + code = '\n' * begin_lineno + code + + if type == 'proto': + utility[0] = code + elif type == 'impl': + utility[1] = code + else: + all_tags = utility[2] + all_tags[type] = code + + if tags: + all_tags = utility[2] + for name, values in tags.items(): + all_tags.setdefault(name, set()).update(values) + + @classmethod + def load_utilities_from_file(cls, path): + utilities = cls._utility_cache.get(path) + if utilities: + return utilities + + _, ext = os.path.splitext(path) + if ext in ('.pyx', '.py', '.pxd', '.pxi'): + comment = '#' + strip_comments = partial(re.compile(r'^\s*#(?!\s*cython\s*:).*').sub, '') + rstrip = str.rstrip + else: + comment = '/' + strip_comments = partial(re.compile(r'^\s*//.*|/\*[^*]*\*/').sub, '') + rstrip = partial(re.compile(r'\s+(\\?)$').sub, r'\1') + match_special = re.compile( + (r'^%(C)s{5,30}\s*(?P(?:\w|\.)+)\s*%(C)s{5,30}|' + r'^%(C)s+@(?P\w+)\s*:\s*(?P(?:\w|[.:])+)') % + {'C': comment}).match + match_type = re.compile(r'(.+)[.](proto(?:[.]\S+)?|impl|init|cleanup|module_state_decls)$').match + + all_lines = read_utilities_hook(path) + + utilities = defaultdict(lambda: [None, None, {}]) + lines = [] + tags = defaultdict(set) + utility = name = type = None + begin_lineno = 0 + + for lineno, line in enumerate(all_lines): + m = match_special(line) + if m: + if m.group('name'): + cls._add_utility(utility, name, type, lines, begin_lineno, tags) + + begin_lineno = lineno + 1 + del lines[:] + tags.clear() + + name = m.group('name') + mtype = match_type(name) + if mtype: + name, type = mtype.groups() + else: + type = 'impl' + utility = utilities[name] + else: + tags[m.group('tag')].add(m.group('value')) + lines.append('') # keep line number correct + else: + lines.append(rstrip(strip_comments(line))) + + if utility is None: + raise ValueError("Empty utility code file") + + # Don't forget to add the last utility code + cls._add_utility(utility, name, type, lines, begin_lineno, tags) + + utilities = dict(utilities) # un-defaultdict-ify + cls._utility_cache[path] = utilities + return utilities + + @classmethod + def load(cls, util_code_name, from_file, **kwargs): + """ + Load utility code from a file specified by from_file (relative to + Cython/Utility) and name util_code_name. + """ + + if '::' in util_code_name: + from_file, util_code_name = util_code_name.rsplit('::', 1) + assert from_file + utilities = cls.load_utilities_from_file(from_file) + proto, impl, tags = utilities[util_code_name] + + if tags: + if "substitute" in tags and "tempita" in tags["substitute"]: + if not issubclass(cls, TempitaUtilityCode): + return TempitaUtilityCode.load(util_code_name, from_file, **kwargs) + orig_kwargs = kwargs.copy() + for name, values in tags.items(): + if name in kwargs: + continue + # only pass lists when we have to: most argument expect one value or None + if name == 'requires': + if orig_kwargs: + values = [cls.load(dep, from_file, **orig_kwargs) + for dep in sorted(values)] + else: + # dependencies are rarely unique, so use load_cached() when we can + values = [cls.load_cached(dep, from_file) + for dep in sorted(values)] + elif name == 'substitute': + # don't want to pass "naming" or "tempita" to the constructor + # since these will have been handled + values = values - {'naming', 'tempita'} + if not values: + continue + elif not values: + values = None + elif len(values) == 1: + values = list(values)[0] + kwargs[name] = values + + if proto is not None: + kwargs['proto'] = proto + if impl is not None: + kwargs['impl'] = impl + + if 'name' not in kwargs: + kwargs['name'] = util_code_name + + if 'file' not in kwargs and from_file: + kwargs['file'] = from_file + return cls(**kwargs) + + @classmethod + def load_cached(cls, utility_code_name, from_file, __cache={}): + """ + Calls .load(), but using a per-type cache based on utility name and file name. + """ + key = (utility_code_name, from_file, cls) + try: + return __cache[key] + except KeyError: + pass + code = __cache[key] = cls.load(utility_code_name, from_file) + return code + + @classmethod + def load_as_string(cls, util_code_name, from_file, include_requires=False, **kwargs): + """ + Load a utility code as a string. Returns (proto, implementation). + + If 'include_requires=True', concatenates all requirements before the actually + requested utility code, separately for proto and impl part. + + In a lot of cases it may be better to use regular "load" and "CCodeWriter.put_code_here" + since that is able to apply the code transformations to the code too. + """ + util = cls.load(util_code_name, from_file, **kwargs) + + if not include_requires: + return (util.format_code(util.proto), + util.format_code(util.impl)) + + protos, impls = [], [] + def prepend(util_code): + if util_code.requires: + for dep in util_code.requires: + prepend(dep) + if util_code.proto: + protos.append(util_code.format_code(util_code.proto)) + if util_code.impl: + impls.append(util_code.format_code(util_code.impl)) + + prepend(util) + return "".join(protos), "".join(impls) + + def format_code(self, code_string, replace_empty_lines=re.compile(r'\n\n+').sub): + """ + Format a code section for output. + """ + if code_string: + code_string = replace_empty_lines('\n', code_string.strip()) + '\n\n' + return code_string + + def __repr__(self): + return "<%s(%s)>" % (type(self).__name__, self.name) + + def get_tree(self, **kwargs): + return None + + def get_shared_library_scope(self, **kwargs): + return None + + def __deepcopy__(self, memodict=None): + # No need to deep-copy utility code since it's essentially immutable. + return self + + +class UtilityCode(UtilityCodeBase): + """ + Stores utility code to add during code generation. + + See GlobalState.put_utility_code. + + hashes/equals by instance + + proto C prototypes + impl implementation code + init code to call on module initialization + requires utility code dependencies + proto_block the place in the resulting file where the prototype should + end up + name name of the utility code (or None) + file filename of the utility code file this utility was loaded + from (or None) + """ + code_parts = ["proto", "impl", "init", "cleanup", "module_state_decls"] + + def __init__(self, proto=None, impl=None, init=None, cleanup=None, + module_state_decls=None, requires=None, + proto_block='utility_code_proto', name=None, file=None): + # proto_block: Which code block to dump prototype in. See GlobalState. + self.proto = proto + self.impl = impl + self.init = init + self.cleanup = cleanup + self.module_state_decls = module_state_decls + self.requires = requires + self._cache = {} + self.specialize_list = [] + self.proto_block = proto_block + self.name = name + self.file = file + + # cached for use in hash and eq + self._parts_tuple = tuple(getattr(self, part, None) for part in self.code_parts) + + def __hash__(self): + return hash(self._parts_tuple) + + def __eq__(self, other): + if self is other: + return True + self_type, other_type = type(self), type(other) + if self_type is not other_type and not (isinstance(other, self_type) or isinstance(self, other_type)): + return False + + return self._parts_tuple == other._parts_tuple + + def none_or_sub(self, s, context): + """ + Format a string in this utility code with context. If None, do nothing. + """ + if s is None: + return None + return s % context + + def specialize(self, pyrex_type=None, **data): + name = self.name + if pyrex_type is not None: + data['type'] = pyrex_type.empty_declaration_code() + data['type_name'] = pyrex_type.specialization_name() + name = "%s[%s]" % (name, data['type_name']) + # Dicts aren't hashable... + key = tuple(sorted(data.items())) + try: + return self._cache[key] + except KeyError: + if self.requires is None: + requires = None + else: + requires = [r.specialize(data) for r in self.requires] + + s = self._cache[key] = UtilityCode( + self.none_or_sub(self.proto, data), + self.none_or_sub(self.impl, data), + self.none_or_sub(self.init, data), + self.none_or_sub(self.cleanup, data), + self.none_or_sub(self.module_state_decls, data), + requires, + self.proto_block, + name, + ) + + self.specialize_list.append(s) + return s + + def _put_code_section(self, writer: "CCodeWriter", output: "GlobalState", code_type: str): + code_string = getattr(self, code_type) + if not code_string: + return + + can_be_reused = code_type in ('proto', 'impl') + + code_string, result_is_module_specific = process_utility_ccode(self, output, code_string) + + code_type_name = code_type if code_type != 'impl' else '' + writer.putln(f"/* {self.name}{'.' if code_type_name else ''}{code_type_name} */") + + if can_be_reused and not result_is_module_specific: + # can be reused across modules + writer.put_or_include(code_string, f'{self.name}_{code_type}') + else: + writer.put(code_string) + + def _put_init_code_section(self, output): + if not self.init: + return + writer = output['init_globals'] + self._put_code_section(writer, output, 'init') + # 'init' code can end with an 'if' statement for an error condition like: + # if (check_ok()) ; else + writer.putln(writer.error_goto_if_PyErr(output.module_pos)) + writer.putln() + + def put_code(self, output): + if self.requires: + for dependency in self.requires: + output.use_utility_code(dependency) + + if self.proto: + self._put_code_section(output[self.proto_block], output, 'proto') + if self.impl: + self._put_code_section(output['utility_code_def'], output, 'impl') + if self.cleanup and Options.generate_cleanup_code: + self._put_code_section(output['cleanup_globals'], output, 'cleanup') + if self.module_state_decls: + self._put_code_section(output['module_state_contents'], output, 'module_state_decls') + + if self.init: + self._put_init_code_section(output) + + +def add_macro_processor(*macro_names, regex=None, is_module_specific=False, _last_macro_processor = [None]): + """Decorator to chain the code macro processors below. + """ + last_processor = _last_macro_processor[0] + + def build_processor(func): + @wraps(func) + def process(utility_code: UtilityCode, output, code_string: str): + # First, call the processing chain in FIFO function definition order. + result_is_module_specific = False + if last_processor is not None: + code_string, result_is_module_specific = last_processor(utility_code, output, code_string) + + # Detect if we need to do something. + if macro_names: + for macro in macro_names: + if macro in code_string: + break + else: + return code_string, result_is_module_specific + + # Process the code. + if regex is None: + code_string = func(utility_code, output, code_string) + else: + code_string = re.sub(regex, partial(func, output), code_string) + + # Make sure we found and replaced all macro occurrences. + for macro in macro_names: + if macro in code_string: + raise RuntimeError(f"Left-over utility code macro '{macro}()' found in '{utility_code.name}'") + + result_is_module_specific |= is_module_specific + return code_string, result_is_module_specific + + _last_macro_processor[0] = process + return process + + return build_processor + + +@add_macro_processor( + 'CSTRING', + regex=r'CSTRING\(\s*"""([^"]*(?:"[^"]+)*)"""\s*\)', +) +def _wrap_c_string(_, matchobj): + """Replace CSTRING('''xyz''') by a C compatible string, taking care of line breaks. + """ + content = matchobj.group(1).replace('"', r'\042') + return ''.join( + f'"{line}\\n"\n' if not line.endswith('\\') or line.endswith('\\\\') else f'"{line[:-1]}"\n' + for line in content.splitlines()) + + +@add_macro_processor() +def _format_impl_code(utility_code: UtilityCode, _, impl): + return utility_code.format_code(impl) + + +@add_macro_processor( + 'CALL_UNBOUND_METHOD', + is_module_specific=True, + regex=( + r'CALL_UNBOUND_METHOD\(' + r'([a-zA-Z_]+),\s*' # type cname + r'"([^"]+)",\s*' # method name + r'([^),\s]+)' # object cname + r'((?:,[^),]+)*)' # args* + r'\)' + ), +) +def _inject_unbound_method(output, matchobj): + """Replace 'UNBOUND_METHOD(type, "name")' by a constant Python identifier cname. + """ + type_cname, method_name, obj_cname, args = matchobj.groups() + type_cname = '&%s' % type_cname + args = [arg.strip() for arg in args[1:].split(',')] if args else [] + assert len(args) < 3, f"CALL_UNBOUND_METHOD() does not support {len(args):d} call arguments" + return output.cached_unbound_method_call_code( + f"{Naming.modulestateglobal_cname}->", + obj_cname, type_cname, method_name, args) + + +@add_macro_processor( + 'PYIDENT', 'PYUNICODE', + is_module_specific=True, + regex=r'PY(IDENT|UNICODE)\("([^"]+)"\)', +) +def _inject_string_constant(output, matchobj): + """Replace 'PYIDENT("xyz")' by a constant Python identifier cname. + """ + str_type, name = matchobj.groups() + return "%s->%s" % ( + Naming.modulestateglobal_cname, + output.get_py_string_const( + StringEncoding.EncodedString(name), identifier=str_type == 'IDENT').cname) + + +@add_macro_processor( + 'EMPTY', + # As long as we use the same C access macros for these names, they are not module specific. + # is_module_specific=True, + regex=r'EMPTY\((bytes|unicode|tuple)\)', +) +def _inject_empty_collection_constant(output, matchobj): + """Replace 'EMPTY(bytes|tuple|...)' by a constant Python identifier cname. + """ + type_name = matchobj.group(1) + return "%s->%s" % ( + Naming.modulestateglobal_cname, + getattr(Naming, f'empty_{type_name}')) + + +@add_macro_processor( + 'CGLOBAL', # 'NAMED_CGLOBAL', # first is part of second and thus not needed + is_module_specific=False, + regex=r'(NAMED_)?CGLOBAL\(([^)]+)\)', +) +def _inject_cglobal(output, matchobj): + is_named, name = matchobj.groups() + if is_named: + name = getattr(Naming, name) + return f"{Naming.modulestateglobal_cname}->{name}" + + +@add_macro_processor() +def process_utility_ccode(utility_code, _, code_string): + """Entry point for code processors, must be defined last. + """ + return code_string + + +def sub_tempita(s, context, file=None, name=None, __cache={}): + "Run tempita on string s with given context." + if not s: + return None + + if file: + name = f"{file}:{name}" + if name: + context['__name'] = name + + try: + template = __cache[s] + except KeyError: + from ..Tempita import Template + template = __cache[s] = Template(s, name=name) + + return template.substitute(context) + + +class TempitaUtilityCode(UtilityCode): + def __init__(self, name=None, proto=None, impl=None, init=None, file=None, context=None, **kwargs): + if context is None: + context = {} + else: + # prevent changes propagating back if context is shared between multiple utility codes. + context = context.copy() + proto = sub_tempita(proto, context, file, name) + impl = sub_tempita(impl, context, file, name) + init = sub_tempita(init, context, file, name) + super().__init__( + proto, impl, init=init, name=name, file=file, **kwargs) + + @classmethod + def load_cached(cls, utility_code_name, from_file=None, context=None, __cache={}): + context_key = tuple(sorted(context.items())) if context else None + assert hash(context_key) is not None # raise TypeError if not hashable + key = (cls, from_file, utility_code_name, context_key) + try: + return __cache[key] + except KeyError: + pass + code = __cache[key] = cls.load(utility_code_name, from_file, context=context) + return code + + def none_or_sub(self, s, context): + """ + Format a string in this utility code with context. If None, do nothing. + """ + if s is None: + return None + return sub_tempita(s, context, self.file, self.name) + + +class LazyUtilityCode(UtilityCodeBase): + """ + Utility code that calls a callback with the root code writer when + available. Useful when you only have 'env' but not 'code'. + """ + __name__ = '' + requires = None + + def __init__(self, callback): + self.callback = callback + + def put_code(self, globalstate): + utility = self.callback(globalstate.rootwriter) + globalstate.use_utility_code(utility) + + +class FunctionState: + # return_label string function return point label + # error_label string error catch point label + # error_without_exception boolean Can go to the error label without an exception (e.g. __next__ can return NULL) + # continue_label string loop continue point label + # break_label string loop break point label + # return_from_error_cleanup_label string + # label_counter integer counter for naming labels + # exc_vars (string * 3) exception variables for reraise, or None + # can_trace boolean line tracing is supported in the current context + # scope Scope the scope object of the current function + + # Not used for now, perhaps later + def __init__(self, owner, names_taken=set(), scope=None): + self.names_taken = names_taken + self.owner = owner + self.scope = scope + + self.error_label = None + self.label_counter = 0 + self.labels_used = set() + self.return_label = self.new_label() + self.new_error_label() + self.continue_label = None + self.break_label = None + self.yield_labels = [] + + self.exc_vars = None + self.current_except = None + self.can_trace = False + self.gil_owned = True + + self.temps_allocated = [] # of (name, type, manage_ref, static) + self.temps_free = {} # (type, manage_ref) -> list of free vars with same type/managed status + self.temps_used_type = {} # name -> (type, manage_ref) + self.zombie_temps = set() # temps that must not be reused after release + self.temp_counter = 0 + self.closure_temps = None + + # This is used to collect temporaries, useful to find out which temps + # need to be privatized in parallel sections + self.collect_temps_stack = [] + + # This is used for the error indicator, which needs to be local to the + # function. It used to be global, which relies on the GIL being held. + # However, exceptions may need to be propagated through 'nogil' + # sections, in which case we introduce a race condition. + self.should_declare_error_indicator = False + self.uses_error_indicator = False + + self.error_without_exception = False + + self.needs_refnanny = False + + # safety checks + + def validate_exit(self): + # validate that all allocated temps have been freed + if self.temps_allocated: + leftovers = self.temps_in_use() + if leftovers: + msg = "TEMPGUARD: Temps left over at end of '%s': %s" % (self.scope.name, ', '.join([ + '%s [%s]' % (name, ctype) + for name, ctype, is_pytemp in sorted(leftovers)]), + ) + #print(msg) + raise RuntimeError(msg) + + # labels + + def new_label(self, name=None): + n: cython.size_t = self.label_counter + self.label_counter = n + 1 + label = "%s%d" % (Naming.label_prefix, n) + if name is not None: + label += '_' + name + return label + + def new_yield_label(self, expr_type='yield'): + label = self.new_label('resume_from_%s' % expr_type) + num_and_label = (len(self.yield_labels) + 1, label) + self.yield_labels.append(num_and_label) + return num_and_label + + def new_error_label(self, prefix=""): + old_err_lbl = self.error_label + self.error_label = self.new_label(prefix + 'error') + return old_err_lbl + + def get_loop_labels(self): + return ( + self.continue_label, + self.break_label) + + def set_loop_labels(self, labels): + (self.continue_label, + self.break_label) = labels + + def new_loop_labels(self, prefix=""): + old_labels = self.get_loop_labels() + self.set_loop_labels( + (self.new_label(prefix + "continue"), + self.new_label(prefix + "break"))) + return old_labels + + def get_all_labels(self): + return ( + self.continue_label, + self.break_label, + self.return_label, + self.error_label) + + def set_all_labels(self, labels): + (self.continue_label, + self.break_label, + self.return_label, + self.error_label) = labels + + def all_new_labels(self): + old_labels = self.get_all_labels() + new_labels = [] + for old_label, name in zip(old_labels, ['continue', 'break', 'return', 'error']): + if old_label: + new_labels.append(self.new_label(name)) + else: + new_labels.append(old_label) + self.set_all_labels(new_labels) + return old_labels + + def use_label(self, lbl): + self.labels_used.add(lbl) + + def label_used(self, lbl): + return lbl in self.labels_used + + # temp handling + + def allocate_temp(self, type, manage_ref, static=False, reusable=True): + """ + Allocates a temporary (which may create a new one or get a previously + allocated and released one of the same type). Type is simply registered + and handed back, but will usually be a PyrexType. + + If type.needs_refcounting, manage_ref comes into play. If manage_ref is set to + True, the temp will be decref-ed on return statements and in exception + handling clauses. Otherwise the caller has to deal with any reference + counting of the variable. + + If not type.needs_refcounting, then manage_ref will be ignored, but it + still has to be passed. It is recommended to pass False by convention + if it is known that type will never be a reference counted type. + + static=True marks the temporary declaration with "static". + This is only used when allocating backing store for a module-level + C array literals. + + if reusable=False, the temp will not be reused after release. + + A C string referring to the variable is returned. + """ + if type.is_cv_qualified and not type.is_reference: + type = type.cv_base_type + elif type.is_reference and not type.is_fake_reference: + type = type.ref_base_type + elif type.is_cfunction: + from . import PyrexTypes + type = PyrexTypes.c_ptr_type(type) # A function itself isn't an l-value + elif type.is_cpp_class and not type.is_fake_reference and self.scope.directives['cpp_locals']: + self.scope.use_utility_code(UtilityCode.load_cached("OptionalLocals", "CppSupport.cpp")) + if not type.needs_refcounting: + # Make manage_ref canonical, so that manage_ref will always mean + # a decref is needed. + manage_ref = False + + freelist = self.temps_free.get((type, manage_ref)) + if reusable and freelist is not None and freelist[0]: + result = freelist[0].pop() + freelist[1].remove(result) + else: + while True: + self.temp_counter += 1 + result = "%s%d" % (Naming.codewriter_temp_prefix, self.temp_counter) + if result not in self.names_taken: break + self.temps_allocated.append((result, type, manage_ref, static)) + if not reusable: + self.zombie_temps.add(result) + self.temps_used_type[result] = (type, manage_ref) + if DebugFlags.debug_temp_code_comments: + self.owner.putln("/* %s allocated (%s)%s */" % (result, type, "" if reusable else " - zombie")) + + if self.collect_temps_stack: + self.collect_temps_stack[-1].add((result, type)) + + return result + + def release_temp(self, name): + """ + Releases a temporary so that it can be reused by other code needing + a temp of the same type. + """ + type, manage_ref = self.temps_used_type[name] + freelist = self.temps_free.get((type, manage_ref)) + if freelist is None: + freelist = ([], set()) # keep order in list and make lookups in set fast + self.temps_free[(type, manage_ref)] = freelist + if name in freelist[1]: + raise RuntimeError("Temp %s freed twice!" % name) + if name not in self.zombie_temps: + freelist[0].append(name) + freelist[1].add(name) + if DebugFlags.debug_temp_code_comments: + self.owner.putln("/* %s released %s*/" % ( + name, " - zombie" if name in self.zombie_temps else "")) + + def temps_in_use(self): + """Return a list of (cname,type,manage_ref) tuples of temp names and their type + that are currently in use. + """ + used = [] + for name, type, manage_ref, static in self.temps_allocated: + freelist = self.temps_free.get((type, manage_ref)) + if freelist is None or name not in freelist[1]: + used.append((name, type, manage_ref and type.needs_refcounting)) + return used + + def temps_holding_reference(self): + """Return a list of (cname,type) tuples of temp names and their type + that are currently in use. This includes only temps + with a reference counted type which owns its reference. + """ + return [(name, type) + for name, type, manage_ref in self.temps_in_use() + if manage_ref and type.needs_refcounting] + + def all_managed_temps(self): + """Return a list of (cname, type) tuples of refcount-managed Python objects. + """ + return [(cname, type) + for cname, type, manage_ref, static in self.temps_allocated + if manage_ref] + + def all_free_managed_temps(self): + """Return a list of (cname, type) tuples of refcount-managed Python + objects that are not currently in use. This is used by + try-except and try-finally blocks to clean up temps in the + error case. + """ + return sorted([ # Enforce deterministic order. + (cname, type) + for (type, manage_ref), freelist in self.temps_free.items() if manage_ref + for cname in freelist[0] + ]) + + def start_collecting_temps(self): + """ + Useful to find out which temps were used in a code block + """ + self.collect_temps_stack.append(set()) + + def stop_collecting_temps(self): + return self.collect_temps_stack.pop() + + def init_closure_temps(self, scope): + self.closure_temps = ClosureTempAllocator(scope) + + +class NumConst: + """Global info about a Python number constant held by GlobalState. + + cname string + value string + py_type string int, long, float + value_code string evaluation code if different from value + """ + + def __init__(self, cname, value, py_type, value_code=None): + self.cname = cname + self.value = value + self.py_type = py_type + self.value_code = value_code or value + + +class PyObjectConst: + """Global info about a generic constant held by GlobalState. + """ + # cname string + # type PyrexType + + def __init__(self, cname, type): + self.cname = cname + self.type = type + + +cython.declare(possible_unicode_identifier=object, possible_bytes_identifier=object, + replace_identifier=object, find_alphanums=object) +possible_unicode_identifier = re.compile(r"(?![0-9])\w+$", re.U).match +possible_bytes_identifier = re.compile(br"(?![0-9])\w+$").match +replace_identifier = re.compile(r'[^a-zA-Z0-9_]+').sub +find_alphanums = re.compile('([a-zA-Z0-9]+)').findall + +class StringConst: + """Global info about a C string constant held by GlobalState. + """ + # cname string + # text EncodedString or BytesLiteral + # py_strings {(identifier, encoding) : PyStringConst} + + def __init__(self, cname, text, byte_string): + self.cname = cname + self.text = text + self.escaped_value = StringEncoding.escape_byte_string(byte_string) + self.py_strings = None + + def get_py_string_const(self, encoding, identifier=None): + text = self.text + intern: cython.bint + is_unicode: cython.bint + + if identifier or encoding is None: + # unicode string + encoding = encoding_key = None + is_unicode = True + else: + # bytes + is_unicode = False + encoding = encoding.lower() + if encoding in ('utf8', 'utf-8', 'ascii', 'usascii', 'us-ascii'): + encoding = None + encoding_key = None + else: + encoding_key = ''.join(find_alphanums(encoding)) + + if identifier: + intern = True + elif identifier is None: + if isinstance(text, bytes): + intern = bool(possible_bytes_identifier(text)) + else: + intern = bool(possible_unicode_identifier(text)) + else: + intern = False + + key = (intern, is_unicode, encoding_key) + if self.py_strings is None: + self.py_strings = {} + else: + try: + return self.py_strings[key] + except KeyError: + pass + + pystring_cname = ( + f"{Naming.interned_prefixes['str'] if intern else Naming.py_const_prefix}" + f"{'u' if is_unicode else 'b'}" + f"{'_' + encoding_key if encoding_key else ''}" + f"_{self.cname[len(Naming.const_prefix):]}" + ) + + py_string = PyStringConst(pystring_cname, encoding, intern, is_unicode) + self.py_strings[key] = py_string + return py_string + + +class PyStringConst: + """Global info about a Python string constant held by GlobalState. + """ + # cname string + # encoding string + # intern boolean + # is_unicode boolean + + def __init__(self, cname, encoding, intern=False, is_unicode=False): + self.cname = cname + self.encoding = encoding + self.is_unicode = is_unicode + self.intern = intern + + def __lt__(self, other): + return self.cname < other.cname + + +class GlobalState: + # filename_table {string : int} for finding filename table indexes + # filename_list [string] filenames in filename table order + # input_file_contents dict contents (=list of lines) of any file that was used as input + # to create this output C code. This is + # used to annotate the comments. + # + # utility_codes set IDs of used utility code (to avoid reinsertion) + # + # declared_cnames {string:Entry} used in a transition phase to merge pxd-declared + # constants etc. into the pyx-declared ones (i.e, + # check if constants are already added). + # In time, hopefully the literals etc. will be + # supplied directly instead. + # + # const_cnames_used dict global counter for unique constant identifiers + # + + # parts {string:CCodeWriter} + + + # interned_strings + # consts + # interned_nums + + # directives set Temporary variable used to track + # the current set of directives in the code generation + # process. + + directives = {} + + code_layout = [ + 'h_code', + 'filename_table', + 'utility_code_proto_before_types', + 'numeric_typedefs', # Let these detailed individual parts stay!, + 'complex_type_declarations', # as the proper solution is to make a full DAG... + 'type_declarations', # More coarse-grained blocks would simply hide + 'utility_code_proto', # the ugliness, not fix it + 'module_declarations', + 'typeinfo', + 'before_global_var', + 'global_var', + 'string_decls', + 'decls', + 'late_includes', + 'module_state', + 'module_state_contents', # can be used to inject declarations into the modulestate struct + 'module_state_end', + 'constant_name_defines', + 'module_state_clear', + 'module_state_traverse', + 'module_code', # user code goes here + 'module_exttypes', + 'initfunc_declarations', + 'init_module', + 'pystring_table', + 'cached_builtins', + 'cached_constants', + 'init_constants', + 'init_codeobjects', + 'init_globals', # (utility code called at init-time) + 'cleanup_globals', + 'cleanup_module', + 'main_method', + 'utility_code_pragmas', # silence some irrelevant warnings in utility code + 'utility_code_def', + 'utility_code_pragmas_end', # clean-up the utility_code_pragmas + 'end' + ] + + # h files can only have a much smaller list of sections + h_code_layout = [ + 'h_code', + 'utility_code_proto_before_types', + 'type_declarations', + 'utility_code_proto', + 'end' + ] + + def __init__(self, writer, module_node, code_config, common_utility_include_dir=None): + self.filename_table = {} + self.filename_list = [] + self.input_file_contents = {} + self.utility_codes = set() + self.declared_cnames = {} + self.in_utility_code_generation = False + self.code_config = code_config + self.common_utility_include_dir = common_utility_include_dir + self.parts = {} + self.module_node = module_node # because some utility code generation needs it + # (generating backwards-compatible Get/ReleaseBuffer + + self.const_cnames_used = {} + self.string_const_index = {} + self.dedup_const_index = {} + self.pyunicode_ptr_const_index = {} + self.codeobject_constants = [] + self.num_const_index = {} + self.arg_default_constants = [] + self.const_array_counters = {} # counts of differently prefixed arrays of constants + self.cached_cmethods = {} + self.initialised_constants = set() + + writer.set_global_state(self) + self.rootwriter = writer + + def initialize_main_c_code(self): + rootwriter = self.rootwriter + for i, part in enumerate(self.code_layout): + w = self.parts[part] = rootwriter.insertion_point() + if i > 0: + w.putln("/* #### Code section: %s ### */" % part) + + if not Options.cache_builtins: + del self.parts['cached_builtins'] + else: + w = self.parts['cached_builtins'] + w.start_initcfunc( + "int __Pyx_InitCachedBuiltins(" + f"{Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})") + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + + w = self.parts['cached_constants'] + w.start_initcfunc( + "int __Pyx_InitCachedConstants(" + f"{Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})", + refnanny=True) + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + w.put_setup_refcount_context(StringEncoding.EncodedString("__Pyx_InitCachedConstants")) + + w = self.parts['init_globals'] + w.start_initcfunc("int __Pyx_InitGlobals(void)") + + w = self.parts['init_constants'] + w.start_initcfunc( + "int __Pyx_InitConstants(" + f"{Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})") + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + + if not Options.generate_cleanup_code: + del self.parts['cleanup_globals'] + else: + w = self.parts['cleanup_globals'] + w.start_initcfunc( + "void __Pyx_CleanupGlobals(" + f"{Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})") + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + + code = self.parts['utility_code_proto'] + code.putln("") + code.putln("/* --- Runtime support code (head) --- */") + + code = self.parts['utility_code_def'] + if self.code_config.emit_linenums: + code.write('\n#line 1 "cython_utility"\n') + code.putln("") + code.putln("/* --- Runtime support code --- */") + + def initialize_main_h_code(self): + rootwriter = self.rootwriter + for part in self.h_code_layout: + self.parts[part] = rootwriter.insertion_point() + + def finalize_main_c_code(self): + self.close_global_decls() + + # + # utility_code_def + # + code = self.parts['utility_code_def'] + util = TempitaUtilityCode.load_cached("TypeConversions", "TypeConversion.c") + code.put(util.format_code(util.impl)) + code.putln("") + + # + # utility code pragmas + # + code = self.parts['utility_code_pragmas'] + util = UtilityCode.load_cached("UtilityCodePragmas", "ModuleSetupCode.c") + code.putln(util.format_code(util.impl)) + code.putln("") + code = self.parts['utility_code_pragmas_end'] + util = UtilityCode.load_cached("UtilityCodePragmasEnd", "ModuleSetupCode.c") + code.putln(util.format_code(util.impl)) + code.putln("") + + def __getitem__(self, key): + return self.parts[key] + + # + # Global constants, interned objects, etc. + # + def close_global_decls(self): + # This is called when it is known that no more global declarations will + # declared. + self.generate_const_declarations() + if Options.cache_builtins: + w = self.parts['cached_builtins'] + w.putln("return 0;") + if w.label_used(w.error_label): + w.put_label(w.error_label) + w.putln("return -1;") + w.putln("}") + w.exit_cfunc_scope() + + w = self.parts['cached_constants'] + w.put_finish_refcount_context() + w.putln("return 0;") + if w.label_used(w.error_label): + w.put_label(w.error_label) + w.put_finish_refcount_context() + w.putln("return -1;") + w.putln("}") + w.exit_cfunc_scope() + + for part in ['init_globals', 'init_constants']: + w = self.parts[part] + w.putln("return 0;") + if w.label_used(w.error_label): + w.put_label(w.error_label) + w.putln("return -1;") + w.putln("}") + w.exit_cfunc_scope() + + if Options.generate_cleanup_code: + w = self.parts['cleanup_globals'] + w.putln("}") + w.exit_cfunc_scope() + + if Options.generate_cleanup_code: + w = self.parts['cleanup_module'] + w.putln("}") + w.exit_cfunc_scope() + + def put_pyobject_decl(self, entry): + self['global_var'].putln("static PyObject *%s;" % entry.cname) + + # constant handling at code generation time + + def get_cached_constants_writer(self, target=None): + if target is not None: + if target in self.initialised_constants: + # Return None on second/later calls to prevent duplicate creation code. + return None + self.initialised_constants.add(target) + return self.parts['cached_constants'] + + def get_int_const(self, str_value, longness=False): + py_type = longness and 'long' or 'int' + try: + c = self.num_const_index[(str_value, py_type)] + except KeyError: + c = self.new_num_const(str_value, py_type) + return c + + def get_float_const(self, str_value, value_code): + try: + c = self.num_const_index[(str_value, 'float')] + except KeyError: + c = self.new_num_const(str_value, 'float', value_code) + return c + + def get_py_const(self, prefix, dedup_key=None): + if dedup_key is not None: + const = self.dedup_const_index.get(dedup_key) + if const is not None: + return const + const = self.new_array_const_cname(prefix) + if dedup_key is not None: + self.dedup_const_index[dedup_key] = const + return const + + def get_argument_default_const(self, type): + cname = self.new_const_cname('') + c = PyObjectConst(cname, type) + self.arg_default_constants.append(c) + # Argument default constants aren't currently cleaned up. + # If that changes, it needs to account for the fact that they + # aren't just Python objects + return c + + def get_string_const(self, text): + # return a C string constant, creating a new one if necessary + if text.is_unicode: + byte_string = text.utf8encode() + else: + byte_string = text.byteencode() + try: + c = self.string_const_index[byte_string] + except KeyError: + c = self.new_string_const(text, byte_string) + return c + + def get_pyunicode_ptr_const(self, text): + # return a Py_UNICODE[] constant, creating a new one if necessary + assert text.is_unicode + try: + c = self.pyunicode_ptr_const_index[text] + except KeyError: + c = self.pyunicode_ptr_const_index[text] = self.new_const_cname() + return c + + def get_py_string_const(self, text, identifier=None): + # return a Python string constant, creating a new one if necessary + c_string = self.get_string_const(text) + py_string = c_string.get_py_string_const(text.encoding, identifier) + return py_string + + def get_py_codeobj_const(self, node): + idx = len(self.codeobject_constants) + name = f"{Naming.codeobjtab_cname}[{idx}]" + self.codeobject_constants.append(node) + return name + + def get_interned_identifier(self, text): + return self.get_py_string_const(text, identifier=True) + + def new_string_const(self, text, byte_string): + cname = self.new_string_const_cname(byte_string) + c = StringConst(cname, text, byte_string) + self.string_const_index[byte_string] = c + return c + + def new_num_const(self, value, py_type, value_code=None): + cname = self.new_num_const_cname(value, py_type) + c = NumConst(cname, value, py_type, value_code) + self.num_const_index[(value, py_type)] = c + return c + + def new_string_const_cname(self, bytes_value): + # Create a new globally-unique nice name for a C string constant. + value = bytes_value.decode('ASCII', 'ignore') + return self.new_const_cname(value=value) + + def unique_const_cname(self, format_str): # type: (str) -> str + used = self.const_cnames_used + cname = value = format_str.format(sep='', counter='') + while cname in used: + counter = used[value] = used[value] + 1 + cname = format_str.format(sep='_', counter=counter) + used[cname] = 1 + return cname + + def new_num_const_cname(self, value, py_type): # type: (str, str) -> str + if py_type == 'long': + value += 'L' + py_type = 'int' + prefix = Naming.interned_prefixes[py_type] + + value = value.replace('.', '_').replace('+', '_').replace('-', 'neg_') + if len(value) > 42: + # update tests/run/large_integer_T5290.py in case the amount is changed + cname = self.unique_const_cname( + prefix + "large{counter}_" + value[:18] + "_xxx_" + value[-18:]) + else: + cname = "%s%s" % (prefix, value) + return cname + + def new_const_cname(self, prefix='', value=''): + value = replace_identifier('_', value)[:32].strip('_') + name_suffix = self.unique_const_cname(value + "{sep}{counter}") + if prefix: + prefix = Naming.interned_prefixes[prefix] + else: + prefix = Naming.const_prefix + return "%s%s" % (prefix, name_suffix) + + def new_array_const_cname(self, prefix: str): + count = self.const_array_counters.get(prefix, 0) + self.const_array_counters[prefix] = count+1 + return f"{Naming.pyrex_prefix}{prefix}[{count}]" + + def get_cached_unbound_method(self, type_cname, method_name): + key = (type_cname, method_name) + try: + cname = self.cached_cmethods[key] + except KeyError: + cname = self.cached_cmethods[key] = self.new_const_cname( + 'umethod', '%s_%s' % (type_cname, method_name)) + return cname + + def cached_unbound_method_call_code(self, modulestate_cname, obj_cname, type_cname, method_name, arg_cnames): + # admittedly, not the best place to put this method, but it is reused by UtilityCode and ExprNodes ... + utility_code_name = "CallUnboundCMethod%d" % len(arg_cnames) + self.use_utility_code(UtilityCode.load_cached(utility_code_name, "ObjectHandling.c")) + cache_cname = self.get_cached_unbound_method(type_cname, method_name) + args = [obj_cname] + arg_cnames + return "__Pyx_%s(&%s%s, %s)" % ( + utility_code_name, + modulestate_cname, + cache_cname, + ', '.join(args), + ) + + def add_cached_builtin_decl(self, entry): + if entry.is_builtin and entry.is_const: + if self.should_declare(entry.cname, entry): + self.put_pyobject_decl(entry) + name = entry.name + if name in renamed_py2_builtins_map: + name = renamed_py2_builtins_map[name] + self.put_cached_builtin_init( + entry.pos, StringEncoding.EncodedString(name), + entry.cname) + + def put_cached_builtin_init(self, pos, name, cname): + w = self.parts['cached_builtins'] + cname_in_modulestate = w.name_in_main_c_code_module_state( + self.get_interned_identifier(name).cname) + self.use_utility_code( + UtilityCode.load_cached("GetBuiltinName", "ObjectHandling.c")) + w.putln('%s = __Pyx_GetBuiltinName(%s); if (!%s) %s' % ( + cname, + cname_in_modulestate, + cname, + w.error_goto(pos))) + + def generate_const_declarations(self): + self.generate_cached_methods_decls() + self.generate_object_constant_decls() + self.generate_codeobject_constants() + # generate code for string and numeric constants as late as possible + # to allow new constants be to created by the earlier stages. + # (although the constants themselves are written early) + self.generate_string_constants() + self.generate_num_constants() + + def _generate_module_array_traverse_and_clear(self, struct_attr_cname, count, may_have_refcycles=True): + counter_type = 'int' if count < 2**15 else 'Py_ssize_t' + visit_call = "Py_VISIT" if may_have_refcycles else "__Pyx_VISIT_CONST" + + writer = self.parts['module_state_traverse'] + writer.putln(f"for ({counter_type} i=0; i<{count}; ++i) {{ {visit_call}(traverse_module_state->{struct_attr_cname}[i]); }}") + + writer = self.parts['module_state_clear'] + writer.putln(f"for ({counter_type} i=0; i<{count}; ++i) {{ Py_CLEAR(clear_module_state->{struct_attr_cname}[i]); }}") + + def generate_object_constant_decls(self): + consts = [(len(c.cname), c.cname, c) + for c in self.arg_default_constants] + consts.sort() + for _, cname, c in consts: + self.parts['module_state'].putln("%s;" % c.type.declaration_code(cname)) + if not c.type.needs_refcounting: + # Note that py_constants is used for all argument defaults + # which aren't necessarily PyObjects, so aren't appropriate + # to clear. + continue + + self.parts['module_state_clear'].put_xdecref_clear( + f"clear_module_state->{cname}", + c.type, + clear_before_decref=True, + nanny=False, + ) + + if c.type.is_memoryviewslice: + # TODO: Implement specific to type like CodeWriter.put_xdecref_clear() + cname += "->memview" + + self.parts['module_state_traverse'].putln( + f"Py_VISIT(traverse_module_state->{cname});") + + for prefix, count in sorted(self.const_array_counters.items()): + struct_attr_cname = f"{Naming.pyrex_prefix}{prefix}" + self.parts['module_state'].putln(f"PyObject *{struct_attr_cname}[{count}];") + + # The constant tuples/slices that we create can never participate in reference cycles. + self._generate_module_array_traverse_and_clear(struct_attr_cname, count, may_have_refcycles=False) + + cleanup_level = cleanup_level_for_type_prefix(prefix) + if cleanup_level is not None and cleanup_level <= Options.generate_cleanup_code: + part_writer = self.parts['cleanup_globals'] + part_writer.put(f"for (size_t i=0; i<{count}; ++i) ") + part_writer.putln( + "{ Py_CLEAR(%s); }" % + part_writer.name_in_main_c_code_module_state(f"{struct_attr_cname}[i]") + ) + + def generate_cached_methods_decls(self): + if not self.cached_cmethods: + return + + decl = self.parts['module_state'] + init = self.parts['init_constants'] + cnames = [] + for (type_cname, method_name), cname in sorted(self.cached_cmethods.items()): + cnames.append(cname) + method_name_cname = self.get_interned_identifier(StringEncoding.EncodedString(method_name)).cname + decl.putln('__Pyx_CachedCFunction %s;' % ( + cname)) + # split type reference storage as it might not be static + init.putln('%s.type = (PyObject*)%s;' % ( + init.name_in_main_c_code_module_state(cname), type_cname)) + # method name string isn't static in limited api + init.putln( + f'{init.name_in_main_c_code_module_state(cname)}.method_name = ' + f'&{init.name_in_main_c_code_module_state(method_name_cname)};') + + if Options.generate_cleanup_code: + cleanup = self.parts['cleanup_globals'] + for cname in cnames: + cleanup.putln(f"Py_CLEAR({init.name_in_main_c_code_module_state(cname)}.method);") + + def generate_string_constants(self): + c_consts = [(len(c.cname), c.cname, c) for c in self.string_const_index.values()] + c_consts.sort() + py_strings = [] + longest_pystring = 0 + encodings = set() + + def normalise_encoding_name(py_string): + if py_string.encoding and py_string.encoding not in ( + 'ASCII', 'USASCII', 'US-ASCII', 'UTF8', 'UTF-8'): + return f'"{py_string.encoding.lower()}"' + else: + return '0' + + decls_writer = self.parts['string_decls'] + for _, cname, c in c_consts: + cliteral = StringEncoding.split_string_literal(c.escaped_value) + decls_writer.putln( + f'static const char {cname}[] = "{cliteral}";', + safe=True) # Braces in user strings are not for indentation. + if c.py_strings is not None: + if len(c.escaped_value) > longest_pystring: + # This is not an accurate count since it adds up C escape characters, + # but it's probably good enough for an upper bound. + longest_pystring = len(c.escaped_value) + for py_string in c.py_strings.values(): + encodings.add(normalise_encoding_name(py_string)) + py_strings.append((c.cname, len(py_string.cname), py_string)) + + for c, cname in sorted(self.pyunicode_ptr_const_index.items()): + utf16_array, utf32_array = StringEncoding.encode_pyunicode_string(c) + if utf16_array: + # Narrow and wide representations differ + decls_writer.putln("#ifdef Py_UNICODE_WIDE") + decls_writer.putln("static Py_UNICODE %s[] = { %s };" % (cname, utf32_array)) + if utf16_array: + decls_writer.putln("#else") + decls_writer.putln("static Py_UNICODE %s[] = { %s };" % (cname, utf16_array)) + decls_writer.putln("#endif") + + if not py_strings: + return + + py_strings.sort() + + w = self.parts['pystring_table'] + w.putln("") + + # We use only type size macros from "pyport.h" here. + w.put(textwrap.dedent("""\ + typedef struct { + const char *s; + #if %(max_length)d <= 65535 + const unsigned short n; + #elif %(max_length)d / 2 < INT_MAX + const unsigned int n; + #elif %(max_length)d / 2 < LONG_MAX + const unsigned long n; + #else + const Py_ssize_t n; + #endif + #if %(num_encodings)d <= 31 + const unsigned int encoding : 5; + #elif %(num_encodings)d <= 255 + const unsigned char encoding; + #elif %(num_encodings)d <= 65535 + const unsigned short encoding; + #else + const Py_ssize_t encoding; + #endif + const unsigned int is_unicode : 1; + const unsigned int intern : 1; + } __Pyx_StringTabEntry; + """ % dict( + max_length=longest_pystring, + num_encodings=len(encodings), + ))) + + py_string_count = len(py_strings) + self.parts['module_state'].putln(f"PyObject *{Naming.stringtab_cname}[{py_string_count}];") + self._generate_module_array_traverse_and_clear(Naming.stringtab_cname, py_string_count, may_have_refcycles=False) + + encodings = sorted(encodings) + encodings.sort(key=len) # stable sort to make sure '0' comes first, index 0 + assert not encodings or '0' not in encodings or encodings[0] == '0', encodings + encodings_map = {encoding: i for i, encoding in enumerate(encodings)} + w.putln("static const char * const %s[] = { %s };" % ( + Naming.stringtab_encodings_cname, + ', '.join(encodings), + )) + + w.putln("static const __Pyx_StringTabEntry %s[] = {" % Naming.stringtab_cname) + for n, (c_cname, _, py_string) in enumerate(py_strings): + encodings_index = encodings_map[normalise_encoding_name(py_string)] + is_unicode = py_string.is_unicode + + self.parts['constant_name_defines'].putln("#define %s %s[%s]" % ( + py_string.cname, + Naming.stringtab_cname, + n)) + + w.putln("{%s, sizeof(%s), %d, %d, %d}, /* PyObject cname: %s */" % ( + c_cname, + c_cname, + encodings_index, + is_unicode, + py_string.intern, + py_string.cname + )) + w.putln("{0, 0, 0, 0, 0}") + w.putln("};") + + self.use_utility_code(UtilityCode.load_cached("InitStrings", "StringTools.c")) + + init_constants = self.parts['init_constants'] + init_constants.putln( + "if (__Pyx_InitStrings(%s, %s, %s) < 0) %s;" % ( + Naming.stringtab_cname, + init_constants.name_in_main_c_code_module_state(Naming.stringtab_cname), + Naming.stringtab_encodings_cname, + init_constants.error_goto(self.module_pos))) + + def generate_codeobject_constants(self): + w = self.parts['init_codeobjects'] + init_function = ( + f"int __Pyx_CreateCodeObjects({Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})" + ) + + if not self.codeobject_constants: + w.start_initcfunc(init_function) + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + w.putln("return 0;") + w.exit_cfunc_scope() + w.putln("}") + return + + # Create a downsized config struct and build code objects from it. + max_flags = 0x3ff # to be adapted when we start using new flags + max_func_args = 1 + max_kwonly_args = 1 + max_posonly_args = 1 + max_vars = 1 + max_line = 1 + max_positions = 1 + for node in self.codeobject_constants: + def_node = node.def_node + if not def_node.is_generator_expression: + max_func_args = max(max_func_args, len(def_node.args) - def_node.num_kwonly_args) + max_kwonly_args = max(max_kwonly_args, def_node.num_kwonly_args) + max_posonly_args = max(max_posonly_args, def_node.num_posonly_args) + max_vars = max(max_vars, len(node.varnames)) + max_line = max(max_line, def_node.pos[1]) + max_positions = max(max_positions, len(def_node.node_positions)) + + # Even for full 64-bit line/column values, one entry in the line table can never be larger than 45 bytes. + max_linetable_len = max_positions * 47 + + w.put(textwrap.dedent(f"""\ + typedef struct {{ + unsigned int argcount : {max_func_args.bit_length()}; + unsigned int num_posonly_args : {max_posonly_args.bit_length()}; + unsigned int num_kwonly_args : {max_kwonly_args.bit_length()}; + unsigned int nlocals : {max_vars.bit_length()}; + unsigned int flags : {max_flags.bit_length()}; + unsigned int first_line : {max_line.bit_length()}; + unsigned int line_table_length : {max_linetable_len.bit_length()}; + }} __Pyx_PyCode_New_function_description; + """)) + + self.use_utility_code(UtilityCode.load_cached("NewCodeObj", "ModuleSetupCode.c")) + + w.start_initcfunc(init_function) + + w.putln("PyObject* tuple_dedup_map = PyDict_New();") + w.putln("if (unlikely(!tuple_dedup_map)) return -1;") + + for node in self.codeobject_constants: + node.generate_codeobj(w, "bad") + + w.putln("Py_DECREF(tuple_dedup_map);") + w.putln("return 0;") + + w.putln("bad:") + w.putln("Py_DECREF(tuple_dedup_map);") + w.putln("return -1;") + w.exit_cfunc_scope() + w.putln("}") + + code_object_count = len(self.codeobject_constants) + self.parts['module_state'].putln(f"PyObject *{Naming.codeobjtab_cname}[{code_object_count}];") + # The code objects that we generate only contain plain constants and can never participate in reference cycles. + self._generate_module_array_traverse_and_clear(Naming.codeobjtab_cname, code_object_count, may_have_refcycles=False) + + def generate_num_constants(self): + consts = [(c.py_type, c.value[0] == '-', len(c.value), c.value, c.value_code, c) + for c in self.num_const_index.values()] + consts.sort() + init_constants = self.parts['init_constants'] + for py_type, _, _, value, value_code, c in consts: + cname = c.cname + self.parts['module_state'].putln("PyObject *%s;" % cname) + self.parts['module_state_clear'].putln( + "Py_CLEAR(clear_module_state->%s);" % cname) + self.parts['module_state_traverse'].putln( + "__Pyx_VISIT_CONST(traverse_module_state->%s);" % cname) + if py_type == 'float': + function = 'PyFloat_FromDouble(%s)' + elif py_type == 'long': + function = 'PyLong_FromString("%s", 0, 0)' + elif Utils.long_literal(value): + function = 'PyLong_FromString("%s", 0, 0)' + elif len(value.lstrip('-')) > 4: + function = "PyLong_FromLong(%sL)" + else: + function = "PyLong_FromLong(%s)" + init_cname = init_constants.name_in_main_c_code_module_state(cname) + init_constants.putln('%s = %s; %s' % ( + init_cname, function % value_code, + init_constants.error_goto_if_null(init_cname, self.module_pos))) + + # The functions below are there in a transition phase only + # and will be deprecated. They are called from Nodes.BlockNode. + # The copy&paste duplication is intentional in order to be able + # to see quickly how BlockNode worked, until this is replaced. + + def should_declare(self, cname, entry): + if cname in self.declared_cnames: + other = self.declared_cnames[cname] + assert str(entry.type) == str(other.type) + assert entry.init == other.init + return False + else: + self.declared_cnames[cname] = entry + return True + + # + # File name state + # + + def lookup_filename(self, source_desc): + entry = source_desc.get_filenametable_entry() + try: + index = self.filename_table[entry] + except KeyError: + index = len(self.filename_list) + self.filename_list.append(source_desc) + self.filename_table[entry] = index + return index + + def commented_file_contents(self, source_desc): + try: + return self.input_file_contents[source_desc] + except KeyError: + pass + source_file = source_desc.get_lines(encoding='ASCII', + error_handling='ignore') + try: + F = [' * ' + line.rstrip().replace( + '*/', '*[inserted by cython to avoid comment closer]/' + ).replace( + '/*', '/[inserted by cython to avoid comment start]*' + ) + for line in source_file] + finally: + if hasattr(source_file, 'close'): + source_file.close() + if not F: F.append('') + self.input_file_contents[source_desc] = F + return F + + # + # Utility code state + # + + def use_utility_code(self, utility_code): + """ + Adds code to the C file. utility_code should + a) implement __eq__/__hash__ for the purpose of knowing whether the same + code has already been included + b) implement put_code, which takes a globalstate instance + + See UtilityCode. + """ + if utility_code and utility_code not in self.utility_codes: + self.utility_codes.add(utility_code) + utility_code.put_code(self) + + def use_entry_utility_code(self, entry): + if entry is None: + return + if entry.utility_code: + self.use_utility_code(entry.utility_code) + if entry.utility_code_definition: + self.use_utility_code(entry.utility_code_definition) + + +def funccontext_property(func): + name = func.__name__ + attribute_of = operator.attrgetter(name) + def get(self): + return attribute_of(self.funcstate) + def set(self, value): + setattr(self.funcstate, name, value) + return property(get, set) + + +class CCodeConfig: + # emit_linenums boolean write #line pragmas? + # emit_code_comments boolean copy the original code into C comments? + # c_line_in_traceback boolean append the c file and line number to the traceback for exceptions? + + def __init__(self, emit_linenums=True, emit_code_comments=True, c_line_in_traceback=True): + self.emit_code_comments = emit_code_comments + self.emit_linenums = emit_linenums + self.c_line_in_traceback = c_line_in_traceback + + +class CCodeWriter: + """ + Utility class to output C code. + + When creating an insertion point one must care about the state that is + kept: + - formatting state (level, bol) is cloned and used in insertion points + as well + - labels, temps, exc_vars: One must construct a scope in which these can + exist by calling enter_cfunc_scope/exit_cfunc_scope (these are for + sanity checking and forward compatibility). Created insertion points + looses this scope and cannot access it. + - marker: Not copied to insertion point + - filename_table, filename_list, input_file_contents: All codewriters + coming from the same root share the same instances simultaneously. + """ + + # f file output file + # buffer StringIOTree + + # level int indentation level + # bol bool beginning of line? + # marker string comment to emit before next line + # funcstate FunctionState contains state local to a C function used for code + # generation (labels and temps state etc.) + # globalstate GlobalState contains state global for a C file (input file info, + # utility code, declared constants etc.) + # pyclass_stack list used during recursive code generation to pass information + # about the current class one is in + # code_config CCodeConfig configuration options for the C code writer + + @cython.locals(create_from='CCodeWriter') + def __init__(self, create_from=None, buffer=None, copy_formatting=False): + if buffer is None: buffer = StringIOTree() + self.buffer = buffer + self.last_pos = None + self.last_marked_pos = None + self.pyclass_stack = [] + + self.funcstate = None + self.globalstate = None + self.code_config = None + self.level = 0 + self.call_level = 0 + self.bol = 1 + + if create_from is not None: + # Use same global state + self.set_global_state(create_from.globalstate) + self.funcstate = create_from.funcstate + # Clone formatting state + if copy_formatting: + self.level = create_from.level + self.bol = create_from.bol + self.call_level = create_from.call_level + self.last_pos = create_from.last_pos + self.last_marked_pos = create_from.last_marked_pos + + def create_new(self, create_from, buffer, copy_formatting): + # polymorphic constructor -- very slightly more versatile + # than using __class__ + result = CCodeWriter(create_from, buffer, copy_formatting) + return result + + def set_global_state(self, global_state): + assert self.globalstate is None # prevent overwriting once it's set + self.globalstate = global_state + self.code_config = global_state.code_config + + def copyto(self, f): + self.buffer.copyto(f) + + def getvalue(self): + return self.buffer.getvalue() + + def write(self, s): + if '\n' in s: + self._write_lines(s) + else: + self._write_to_buffer(s) + + def _write_lines(self, s): + # Cygdb needs to know which Cython source line corresponds to which C line. + # Therefore, we write this information into "self.buffer.markers" and then write it from there + # into cython_debug/cython_debug_info_* (see ModuleNode._serialize_lineno_map). + filename_line = self.last_marked_pos[:2] if self.last_marked_pos else (None, 0) + self.buffer.markers.extend([filename_line] * s.count('\n')) + + self._write_to_buffer(s) + + def _write_to_buffer(self, s): + self.buffer.write(s) + + def insertion_point(self): + other = self.create_new(create_from=self, buffer=self.buffer.insertion_point(), copy_formatting=True) + return other + + def new_writer(self): + """ + Creates a new CCodeWriter connected to the same global state, which + can later be inserted using insert. + """ + return CCodeWriter(create_from=self) + + def insert(self, writer): + """ + Inserts the contents of another code writer (created with + the same global state) in the current location. + + It is ok to write to the inserted writer also after insertion. + """ + assert writer.globalstate is self.globalstate + self.buffer.insert(writer.buffer) + + # Properties delegated to function scope + @funccontext_property + def label_counter(self): pass + @funccontext_property + def return_label(self): pass + @funccontext_property + def error_label(self): pass + @funccontext_property + def labels_used(self): pass + @funccontext_property + def continue_label(self): pass + @funccontext_property + def break_label(self): pass + @funccontext_property + def return_from_error_cleanup_label(self): pass + @funccontext_property + def yield_labels(self): pass + + def label_interceptor(self, new_labels, orig_labels, skip_to_label=None, pos=None, trace=True): + """ + Helper for generating multiple label interceptor code blocks. + + @param new_labels: the new labels that should be intercepted + @param orig_labels: the original labels that we should dispatch to after the interception + @param skip_to_label: a label to skip to before starting the code blocks + @param pos: the node position to mark for each interceptor block + @param trace: add a trace line for the pos marker or not + """ + for label, orig_label in zip(new_labels, orig_labels): + if not self.label_used(label): + continue + if skip_to_label: + # jump over the whole interception block + self.put_goto(skip_to_label) + skip_to_label = None + + if pos is not None: + self.mark_pos(pos, trace=trace) + self.put_label(label) + yield (label, orig_label) + self.put_goto(orig_label) + + # Functions delegated to function scope + def new_label(self, name=None): return self.funcstate.new_label(name) + def new_error_label(self, *args): return self.funcstate.new_error_label(*args) + def new_yield_label(self, *args): return self.funcstate.new_yield_label(*args) + def get_loop_labels(self): return self.funcstate.get_loop_labels() + def set_loop_labels(self, labels): return self.funcstate.set_loop_labels(labels) + def new_loop_labels(self, *args): return self.funcstate.new_loop_labels(*args) + def get_all_labels(self): return self.funcstate.get_all_labels() + def set_all_labels(self, labels): return self.funcstate.set_all_labels(labels) + def all_new_labels(self): return self.funcstate.all_new_labels() + def use_label(self, lbl): return self.funcstate.use_label(lbl) + def label_used(self, lbl): return self.funcstate.label_used(lbl) + + + def enter_cfunc_scope(self, scope): + self.funcstate = FunctionState(self, scope=scope) + + def exit_cfunc_scope(self): + if self.funcstate is None: + return + self.funcstate.validate_exit() + self.funcstate = None + + def start_initcfunc(self, signature, scope=None, refnanny=False): + """ + Init code helper function to start a cfunc scope and generate + the prototype and function header ("static SIG {") of the function. + """ + proto = self.globalstate.parts['initfunc_declarations'] + proto.putln(f"static CYTHON_SMALL_CODE {signature}; /*proto*/") + self.enter_cfunc_scope(scope) + self.putln("") + self.putln(f"static {signature} {{") + if refnanny: + self.put_declare_refcount_context() + + def start_slotfunc(self, class_scope, return_type, c_slot_name, args_signature, needs_funcstate=True, needs_prototype=False): + # Slot functions currently live in the class scope as they don't have direct access to the module state. + slotfunc_cname = class_scope.mangle_internal(c_slot_name) + declaration = f"static {return_type.declaration_code(slotfunc_cname)}({args_signature})" + + if needs_prototype: + self.globalstate['decls'].putln(declaration.replace("CYTHON_UNUSED ", "") + "; /*proto*/") + if needs_funcstate: + self.enter_cfunc_scope(class_scope) + self.putln("") + self.putln(declaration + " {") + + # constant handling + + def get_py_int(self, str_value, longness): + return self.name_in_module_state( + self.globalstate.get_int_const(str_value, longness).cname + ) + + def get_py_float(self, str_value, value_code): + return self.name_in_module_state( + self.globalstate.get_float_const(str_value, value_code).cname + ) + + def get_py_const(self, prefix, dedup_key=None): + return self.name_in_module_state( + self.globalstate.get_py_const(prefix, dedup_key) + ) + + def get_string_const(self, text): + return self.globalstate.get_string_const(text).cname + + def get_pyunicode_ptr_const(self, text): + return self.globalstate.get_pyunicode_ptr_const(text) + + def get_py_string_const(self, text, identifier=None): + cname = self.globalstate.get_py_string_const( + text, identifier).cname + return self.name_in_module_state(cname) + + def get_py_codeobj_const(self, node): + return self.name_in_module_state(self.globalstate.get_py_codeobj_const(node)) + + def get_argument_default_const(self, type): + return self.name_in_module_state(self.globalstate.get_argument_default_const(type).cname) + + def intern(self, text): + return self.get_py_string_const(text) + + def intern_identifier(self, text): + return self.get_py_string_const(text, identifier=True) + + def get_cached_constants_writer(self, target=None): + return self.globalstate.get_cached_constants_writer(target) + + def name_in_module_state(self, cname): + if self.funcstate.scope is None: + # This is a mess. For example, within the codeobj generation + # funcstate.scope is None while evaluating the strings, but not while + # evaluating the code objects themselves. Right now it doesn't matter + # because it all ends up going to the same place, but to actually turn + # it into something useful this mess will need to be fixed. + return self.name_in_main_c_code_module_state(cname) + return self.funcstate.scope.name_in_module_state(cname) + + @staticmethod + def name_in_main_c_code_module_state(cname): + # The functions where this applies to have the modulestate passed + # as an argument to them and so it's better use that argument than + # to try to get it from a global variable. + return f"{Naming.modulestatevalue_cname}->{cname}" + + @staticmethod + def name_in_slot_module_state(cname): + # TODO - eventually this will go through PyType_GetModuleByDef + # in cases where it's supported. + return f"{Naming.modulestateglobal_cname}->{cname}" + + def namespace_cname_in_module_state(self, scope): + if scope.is_py_class_scope: + return scope.namespace_cname + else: + return self.name_in_module_state(scope.namespace_cname) + + def typeptr_cname_in_module_state(self, type): + if type.is_extension_type: + return self.name_in_module_state(type.typeptr_cname) + else: + return type.typeptr_cname + + # code generation + + def putln(self, code="", safe=False): + if self.last_pos and self.bol: + self.emit_marker() + if self.code_config.emit_linenums and self.last_marked_pos: + source_desc, line, _ = self.last_marked_pos + self._write_lines(f'\n#line {line} "{source_desc.get_escaped_description()}"\n') + if code: + if safe: + self.put_safe(code) + else: + self.put(code) + self._write_lines("\n") + self.bol = 1 + + def mark_pos(self, pos, trace=True): + if pos is None: + return + if self.last_marked_pos and self.last_marked_pos[:2] == pos[:2]: + return + self.last_pos = (pos, trace) + + def emit_marker(self): + pos, trace = self.last_pos + self.last_marked_pos = pos + self.last_pos = None + self._write_lines("\n") + if self.code_config.emit_code_comments: + self.indent() + self._write_lines(self._build_marker(pos)) + if trace: + self.write_trace_line(pos) + + def write_trace_line(self, pos): + if self.funcstate and self.funcstate.can_trace and self.globalstate.directives['linetrace']: + self.indent() + self._write_lines( + f'__Pyx_TraceLine({pos[1]:d},{self.pos_to_offset(pos):d},{not self.funcstate.gil_owned:d},{self.error_goto(pos)})\n') + + def _build_marker(self, pos): + source_desc, line, col = pos + assert isinstance(source_desc, SourceDescriptor) + contents = self.globalstate.commented_file_contents(source_desc) + lines = contents[max(0, line-3):line] # line numbers start at 1 + lines[-1] += ' # <<<<<<<<<<<<<<' + lines += contents[line:line+2] + code = "\n".join(lines) + return f'/* "{source_desc.get_escaped_description()}":{line:d}\n{code}\n*/\n' + + def put_safe(self, code): + # put code, but ignore {} + self.write(code) + self.bol = 0 + + def put_or_include(self, code, name): + include_dir = self.globalstate.common_utility_include_dir + if include_dir and len(code) > 1024: + hash = hashlib.sha256(code.encode('utf8')).hexdigest() + include_file = f"{name}_{hash}.h" + path = os.path.join(include_dir, include_file) + if not os.path.exists(path): + tmp_path = f'{path}.tmp{os.getpid()}' + done = False + try: + with Utils.open_new_file(tmp_path) as f: + f.write(code) + shutil.move(tmp_path, path) + done = True + except (FileExistsError, PermissionError): + # If a different process created the file faster than us, + # renaming can fail on Windows. It's ok if the file is there now. + if not os.path.exists(path): + raise + finally: + if not done and os.path.exists(tmp_path): + os.unlink(tmp_path) + # We use forward slashes in the include path to assure identical code generation + # under Windows and Posix. C/C++ compilers should still understand it. + c_path = path.replace('\\', '/') + code = f'#include "{c_path}"\n' + self.put(code) + + def put(self, code): + fix_indent = False + if "{" in code: + dl = code.count("{") + else: + dl = 0 + if "}" in code: + dl -= code.count("}") + if dl < 0: + self.level += dl + elif dl == 0 and code[0] == "}": + # special cases like "} else {" need a temporary dedent + fix_indent = True + self.level -= 1 + if self.bol: + self.indent() + self.write(code) + self.bol = 0 + if dl > 0: + self.level += dl + elif fix_indent: + self.level += 1 + + def put_code_here(self, utility: UtilityCode): + # Puts the impl section of the utility code directly to the current position. + # Ensure we don't have a proto section (but do allow init and cleanup sections + # because they might be useful in future). + assert not utility.proto, utility.name + utility._put_code_section(self, self.globalstate, "impl") + utility._put_init_code_section(self.globalstate) + if utility.cleanup and Options.generate_cleanup_code: + utility._put_code_section( + self.globalstate['cleanup_globals'], self.globalstate, "cleanup") + + def increase_indent(self): + self.level += 1 + + def decrease_indent(self): + self.level -= 1 + + def begin_block(self): + self.putln("{") + self.increase_indent() + + def end_block(self): + self.decrease_indent() + self.putln("}") + + def indent(self): + self._write_to_buffer(" " * self.level) + + def get_py_version_hex(self, pyversion): + return "0x%02X%02X%02X%02X" % (tuple(pyversion) + (0,0,0,0))[:4] + + def put_label(self, lbl): + if lbl in self.funcstate.labels_used: + self.putln("%s:;" % lbl) + + def put_goto(self, lbl): + self.funcstate.use_label(lbl) + self.putln("goto %s;" % lbl) + + def put_var_declaration(self, entry, storage_class="", + dll_linkage=None, definition=True): + #print "Code.put_var_declaration:", entry.name, "definition =", definition ### + if entry.visibility == 'private' and not (definition or entry.defined_in_pxd): + #print "...private and not definition, skipping", entry.cname ### + return + if entry.visibility == "private" and not entry.used: + #print "...private and not used, skipping", entry.cname ### + return + if not entry.cf_used: + self.put('CYTHON_UNUSED ') + if storage_class: + self.put("%s " % storage_class) + if entry.is_cpp_optional: + self.put(entry.type.cpp_optional_declaration_code( + entry.cname, dll_linkage=dll_linkage)) + else: + self.put(entry.type.declaration_code( + entry.cname, dll_linkage=dll_linkage)) + if entry.init is not None: + self.put_safe(" = %s" % entry.type.literal_code(entry.init)) + elif entry.type.is_pyobject: + self.put(" = NULL") + self.putln(";") + self.funcstate.scope.use_entry_utility_code(entry) + + def put_temp_declarations(self, func_context): + for name, type, manage_ref, static in func_context.temps_allocated: + if type.is_cpp_class and not type.is_fake_reference and func_context.scope.directives['cpp_locals']: + decl = type.cpp_optional_declaration_code(name) + else: + decl = type.declaration_code(name) + if type.is_pyobject: + self.putln("%s = NULL;" % decl) + elif type.is_memoryviewslice: + self.putln("%s = %s;" % (decl, type.literal_code(type.default_value))) + else: + self.putln("%s%s;" % (static and "static " or "", decl)) + + if func_context.should_declare_error_indicator: + if self.funcstate.uses_error_indicator: + unused = '' + else: + unused = 'CYTHON_UNUSED ' + # Initialize these variables to silence compiler warnings + self.putln("%sint %s = 0;" % (unused, Naming.lineno_cname)) + self.putln("%sconst char *%s = NULL;" % (unused, Naming.filename_cname)) + self.putln("%sint %s = 0;" % (unused, Naming.clineno_cname)) + + def put_generated_by(self): + self.putln(Utils.GENERATED_BY_MARKER) + self.putln("") + + def put_h_guard(self, guard): + self.putln("#ifndef %s" % guard) + self.putln("#define %s" % guard) + + def unlikely(self, cond): + if Options.gcc_branch_hints: + return 'unlikely(%s)' % cond + else: + return cond + + def build_function_modifiers(self, modifiers, mapper=modifier_output_mapper): + if not modifiers: + return '' + return '%s ' % ' '.join([mapper(m,m) for m in modifiers]) + + # Python objects and reference counting + + def entry_as_pyobject(self, entry): + type = entry.type + if (not entry.is_self_arg and not entry.type.is_complete() + or entry.type.is_extension_type): + return "(PyObject *)" + entry.cname + else: + return entry.cname + + def as_pyobject(self, cname, type): + from .PyrexTypes import py_object_type, typecast + return typecast(py_object_type, type, cname) + + def put_gotref(self, cname, type): + type.generate_gotref(self, cname) + + def put_giveref(self, cname, type): + type.generate_giveref(self, cname) + + def put_xgiveref(self, cname, type): + type.generate_xgiveref(self, cname) + + def put_xgotref(self, cname, type): + type.generate_xgotref(self, cname) + + def put_incref(self, cname, type, nanny=True): + # Note: original put_Memslice_Incref/Decref also added in some utility code + # this is unnecessary since the relevant utility code is loaded anyway if a memoryview is used + # and so has been removed. However, it's potentially a feature that might be useful here + type.generate_incref(self, cname, nanny=nanny) + + def put_xincref(self, cname, type, nanny=True): + type.generate_xincref(self, cname, nanny=nanny) + + def put_decref(self, cname, type, nanny=True, have_gil=True): + type.generate_decref(self, cname, nanny=nanny, have_gil=have_gil) + + def put_xdecref(self, cname, type, nanny=True, have_gil=True): + type.generate_xdecref(self, cname, nanny=nanny, have_gil=have_gil) + + def put_decref_clear(self, cname, type, clear_before_decref=False, nanny=True, have_gil=True): + type.generate_decref_clear(self, cname, clear_before_decref=clear_before_decref, + nanny=nanny, have_gil=have_gil) + + def put_xdecref_clear(self, cname, type, clear_before_decref=False, nanny=True, have_gil=True): + type.generate_xdecref_clear(self, cname, clear_before_decref=clear_before_decref, + nanny=nanny, have_gil=have_gil) + + def put_decref_set(self, cname, type, rhs_cname): + type.generate_decref_set(self, cname, rhs_cname) + + def put_xdecref_set(self, cname, type, rhs_cname): + type.generate_xdecref_set(self, cname, rhs_cname) + + def put_incref_memoryviewslice(self, slice_cname, type, have_gil): + # TODO ideally this would just be merged into "put_incref" + type.generate_incref_memoryviewslice(self, slice_cname, have_gil=have_gil) + + def put_var_incref_memoryviewslice(self, entry, have_gil): + self.put_incref_memoryviewslice(entry.cname, entry.type, have_gil=have_gil) + + def put_var_gotref(self, entry): + self.put_gotref(entry.cname, entry.type) + + def put_var_giveref(self, entry): + self.put_giveref(entry.cname, entry.type) + + def put_var_xgotref(self, entry): + self.put_xgotref(entry.cname, entry.type) + + def put_var_xgiveref(self, entry): + self.put_xgiveref(entry.cname, entry.type) + + def put_var_incref(self, entry, **kwds): + self.put_incref(entry.cname, entry.type, **kwds) + + def put_var_xincref(self, entry, **kwds): + self.put_xincref(entry.cname, entry.type, **kwds) + + def put_var_decref(self, entry, **kwds): + self.put_decref(entry.cname, entry.type, **kwds) + + def put_var_xdecref(self, entry, **kwds): + self.put_xdecref(entry.cname, entry.type, **kwds) + + def put_var_decref_clear(self, entry, **kwds): + self.put_decref_clear(entry.cname, entry.type, clear_before_decref=entry.in_closure, **kwds) + + def put_var_decref_set(self, entry, rhs_cname, **kwds): + self.put_decref_set(entry.cname, entry.type, rhs_cname, **kwds) + + def put_var_xdecref_set(self, entry, rhs_cname, **kwds): + self.put_xdecref_set(entry.cname, entry.type, rhs_cname, **kwds) + + def put_var_xdecref_clear(self, entry, **kwds): + self.put_xdecref_clear(entry.cname, entry.type, clear_before_decref=entry.in_closure, **kwds) + + def put_var_decrefs(self, entries, used_only = 0): + for entry in entries: + if not used_only or entry.used: + if entry.xdecref_cleanup: + self.put_var_xdecref(entry) + else: + self.put_var_decref(entry) + + def put_var_xdecrefs(self, entries): + for entry in entries: + self.put_var_xdecref(entry) + + def put_var_xdecrefs_clear(self, entries): + for entry in entries: + self.put_var_xdecref_clear(entry) + + def put_init_to_py_none(self, cname, type, nanny=True): + from .PyrexTypes import py_object_type, typecast + py_none = typecast(type, py_object_type, "Py_None") + if nanny: + self.putln("%s = %s; __Pyx_INCREF(Py_None);" % (cname, py_none)) + else: + self.putln("%s = %s; Py_INCREF(Py_None);" % (cname, py_none)) + + def put_init_var_to_py_none(self, entry, template = "%s", nanny=True): + code = template % entry.cname + #if entry.type.is_extension_type: + # code = "((PyObject*)%s)" % code + self.put_init_to_py_none(code, entry.type, nanny) + if entry.in_closure: + self.put_giveref('Py_None') + + def put_pymethoddef(self, entry, term, allow_skip=True, wrapper_code_writer=None): + is_number_slot = False + if entry.is_special or entry.name == '__getattribute__': + from . import TypeSlots + if entry.name not in special_py_methods: + if TypeSlots.is_binop_number_slot(entry.name): + # It's useful if numeric binops are created with meth coexist + # so they can be called directly by looking up the name, skipping the + # dispatch wrapper that enables the reverse slots. This is most useful + # when c_api_binop_methods is False, but there's no reason not to do it + # all the time + is_number_slot = True + elif entry.name == '__getattr__' and not self.globalstate.directives['fast_getattr']: + pass + # Python's typeobject.c will automatically fill in our slot + # in add_operators() (called by PyType_Ready) with a value + # that's better than ours. + elif allow_skip: + return + + method_flags = entry.signature.method_flags() + if not method_flags: + return + if entry.is_special: + method_flags += [TypeSlots.method_coexist] + func_ptr = wrapper_code_writer.put_pymethoddef_wrapper(entry) if wrapper_code_writer else entry.func_cname + # Add required casts, but try not to shadow real warnings. + cast = entry.signature.method_function_type() + if cast != 'PyCFunction': + func_ptr = '(void(*)(void))(%s)%s' % (cast, func_ptr) + entry_name = entry.name.as_c_string_literal() + if is_number_slot: + # Unlike most special functions, binop numeric operator slots are actually generated here + # (to ensure that they can be looked up). However, they're sometimes guarded by the preprocessor + # so a bit of extra logic is needed + slot = TypeSlots.get_slot_table(self.globalstate.directives).get_slot_by_method_name(entry.name) + preproc_guard = slot.preprocessor_guard_code() + if preproc_guard: + self.putln(preproc_guard) + self.putln( + '{%s, (PyCFunction)%s, %s, %s}%s' % ( + entry_name, + func_ptr, + "|".join(method_flags), + entry.doc_cname if entry.doc else '0', + term)) + if is_number_slot and preproc_guard: + self.putln("#endif") + + def put_pymethoddef_wrapper(self, entry): + func_cname = entry.func_cname + if entry.is_special: + method_flags = entry.signature.method_flags() or [] + from .TypeSlots import method_noargs + if method_noargs in method_flags: + # Special NOARGS methods really take no arguments besides 'self', but PyCFunction expects one. + func_cname = Naming.method_wrapper_prefix + func_cname + self.putln("static PyObject *%s(PyObject *self, CYTHON_UNUSED PyObject *arg) {" % func_cname) + func_call = "%s(self)" % entry.func_cname + if entry.name == "__next__": + self.putln("PyObject *res = %s;" % func_call) + # tp_iternext can return NULL without an exception + self.putln("if (!res && !PyErr_Occurred()) { PyErr_SetNone(PyExc_StopIteration); }") + self.putln("return res;") + else: + self.putln("return %s;" % func_call) + self.putln("}") + return func_cname + + # GIL methods + + def use_fast_gil_utility_code(self): + if self.globalstate.directives['fast_gil']: + self.globalstate.use_utility_code(UtilityCode.load_cached("FastGil", "ModuleSetupCode.c")) + else: + self.globalstate.use_utility_code(UtilityCode.load_cached("NoFastGil", "ModuleSetupCode.c")) + + def put_ensure_gil(self, declare_gilstate=True, variable=None): + """ + Acquire the GIL. The generated code is safe even when no PyThreadState + has been allocated for this thread (for threads not initialized by + using the Python API). Additionally, the code generated by this method + may be called recursively. + """ + if self.globalstate.directives['subinterpreters_compatible'] != 'no': + from .Errors import warning + warning( + self.last_marked_pos, + "Acquiring the GIL is currently very unlikely to work correctly with subinterpreters.", + 2 + ) + self.globalstate.use_utility_code( + UtilityCode.load_cached("ForceInitThreads", "ModuleSetupCode.c")) + self.use_fast_gil_utility_code() + if not variable: + variable = '__pyx_gilstate_save' + if declare_gilstate: + self.put("PyGILState_STATE ") + self.putln("%s = __Pyx_PyGILState_Ensure();" % variable) + + def put_release_ensured_gil(self, variable=None): + """ + Releases the GIL, corresponds to `put_ensure_gil`. + """ + self.use_fast_gil_utility_code() + if not variable: + variable = '__pyx_gilstate_save' + self.putln("__Pyx_PyGILState_Release(%s);" % variable) + + def put_acquire_freethreading_lock(self): + self.putln("#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING") + self.putln(f"PyMutex_Lock(&{Naming.parallel_freethreading_mutex});") + self.putln("#endif") + + def put_release_freethreading_lock(self): + self.putln("#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING") + self.putln(f"PyMutex_Unlock(&{Naming.parallel_freethreading_mutex});") + self.putln("#endif") + + def put_acquire_gil(self, variable=None, unknown_gil_state=True): + """ + Acquire the GIL. The thread's thread state must have been initialized + by a previous `put_release_gil` + """ + self.use_fast_gil_utility_code() + self.putln("__Pyx_FastGIL_Forget();") + if variable: + self.putln('_save = %s;' % variable) + if unknown_gil_state: + self.putln("if (_save) {") + self.putln("Py_BLOCK_THREADS") + if unknown_gil_state: + self.putln("}") + self.putln("#if CYTHON_COMPILING_IN_LIMITED_API") + self.put_release_ensured_gil() + self.putln("#endif") + + def put_release_gil(self, variable=None, unknown_gil_state=True): + "Release the GIL, corresponds to `put_acquire_gil`." + self.use_fast_gil_utility_code() + self.putln("PyThreadState *_save;") + self.putln("_save = NULL;") + if unknown_gil_state: + # We don't *know* that we don't have the GIL (since we may be inside a nogil function, + # and Py_UNBLOCK_THREADS is unsafe without the GIL). + self.putln("#if CYTHON_COMPILING_IN_LIMITED_API") + # In the Limited API we can't check whether we have the GIL. + # Therefore the only way to be sure that we can release it is to acquire it first. + self.put_ensure_gil() + self.putln("#else") + self.putln("if (PyGILState_Check())") + self.putln("#endif") + self.putln("{") + self.putln("Py_UNBLOCK_THREADS") + if unknown_gil_state: + self.putln("}") + if variable: + self.putln('%s = _save;' % variable) + self.putln("__Pyx_FastGIL_Remember();") + + def declare_gilstate(self): + self.putln("PyGILState_STATE __pyx_gilstate_save;") + + # error handling + + def put_error_if_neg(self, pos, value): + # TODO this path is almost _never_ taken, yet this macro makes is slower! + # return self.putln("if (unlikely(%s < 0)) %s" % (value, self.error_goto(pos))) + return self.putln("if (%s < (0)) %s" % (value, self.error_goto(pos))) + + def put_error_if_unbound(self, pos, entry, in_nogil_context=False, unbound_check_code=None): + nogil_tag = "Nogil" if in_nogil_context else "" + if entry.from_closure: + func = "RaiseClosureNameError" + elif entry.type.is_cpp_class and entry.is_cglobal: + func = "RaiseCppGlobalNameError" + elif entry.type.is_cpp_class and entry.is_variable and not entry.is_member and entry.scope.is_c_class_scope: + # there doesn't seem to be a good way to detecting an instance-attribute of a C class + # (is_member is only set for class attributes) + func = "RaiseCppAttributeError" + else: + func = "RaiseUnboundLocalError" + + self.globalstate.use_utility_code( + UtilityCode.load_cached(f"{func}{nogil_tag}", "ObjectHandling.c")) + + if not unbound_check_code: + unbound_check_code = entry.type.check_for_null_code(entry.cname) + self.putln('if (unlikely(!%s)) { %s(%s); %s }' % ( + unbound_check_code, + f"__Pyx_{func}{nogil_tag}", + entry.name.as_c_string_literal(), + self.error_goto(pos))) + + def set_error_info(self, pos, used=False): + self.funcstate.should_declare_error_indicator = True + if used: + self.funcstate.uses_error_indicator = True + return "__PYX_MARK_ERR_POS(%s, %s)" % ( + self.lookup_filename(pos[0]), + pos[1]) + + def error_goto(self, pos, used=True): + lbl = self.funcstate.error_label + self.funcstate.use_label(lbl) + if pos is None: + return 'goto %s;' % lbl + self.funcstate.should_declare_error_indicator = True + if used: + self.funcstate.uses_error_indicator = True + return "__PYX_ERR(%s, %s, %s)" % ( + self.lookup_filename(pos[0]), + pos[1], + lbl) + + def error_goto_if(self, cond, pos): + return "if (%s) %s" % (self.unlikely(cond), self.error_goto(pos)) + + def error_goto_if_null(self, cname, pos): + return self.error_goto_if("!%s" % cname, pos) + + def error_goto_if_neg(self, cname, pos): + # Add extra parentheses to silence clang warnings about constant conditions. + return self.error_goto_if("(%s < 0)" % cname, pos) + + def error_goto_if_PyErr(self, pos): + return self.error_goto_if("PyErr_Occurred()", pos) + + def lookup_filename(self, filename): + return self.globalstate.lookup_filename(filename) + + def put_declare_refcount_context(self): + self.putln('__Pyx_RefNannyDeclarations') + + def put_setup_refcount_context(self, name, acquire_gil=False): + name = name.as_c_string_literal() # handle unicode names + if acquire_gil: + self.globalstate.use_utility_code( + UtilityCode.load_cached("ForceInitThreads", "ModuleSetupCode.c")) + self.putln('__Pyx_RefNannySetupContext(%s, %d);' % (name, acquire_gil and 1 or 0)) + + def put_finish_refcount_context(self, nogil=False): + self.putln("__Pyx_RefNannyFinishContextNogil()" if nogil else "__Pyx_RefNannyFinishContext();") + + def put_add_traceback(self, qualified_name, include_cline=True): + """ + Build a Python traceback for propagating exceptions. + + qualified_name should be the qualified name of the function. + """ + qualified_name = qualified_name.as_c_string_literal() # handle unicode names + format_tuple = ( + qualified_name, + Naming.clineno_cname if include_cline else 0, + Naming.lineno_cname, + Naming.filename_cname, + ) + + self.funcstate.uses_error_indicator = True + self.putln('__Pyx_AddTraceback(%s, %s, %s, %s);' % format_tuple) + + def put_unraisable(self, qualified_name, nogil=False): + """ + Generate code to print a Python warning for an unraisable exception. + + qualified_name should be the qualified name of the function. + """ + format_tuple = ( + qualified_name, + Naming.clineno_cname, + Naming.lineno_cname, + Naming.filename_cname, + self.globalstate.directives['unraisable_tracebacks'], + nogil, + ) + self.funcstate.uses_error_indicator = True + self.putln('__Pyx_WriteUnraisable("%s", %s, %s, %s, %d, %d);' % format_tuple) + self.globalstate.use_utility_code( + UtilityCode.load_cached("WriteUnraisableException", "Exceptions.c")) + + def is_tracing(self): + return self.globalstate.directives['profile'] or self.globalstate.directives['linetrace'] + + def pos_to_offset(self, pos): + """ + Calculate a fake 'instruction offset' from a node position as 31 bit int (32 bit signed). + """ + scope = self.funcstate.scope + while scope and pos not in scope.node_positions_to_offset: + scope = scope.parent_scope + return scope.node_positions_to_offset[pos] if scope else 0 + + def put_trace_declarations(self, is_generator=False): + self.putln('__Pyx_TraceDeclarationsGen' if is_generator else '__Pyx_TraceDeclarationsFunc') + + def put_trace_frame_init(self, codeobj=None): + if codeobj: + self.putln('__Pyx_TraceFrameInit(%s)' % codeobj) + + def put_trace_start(self, name, pos, nogil=False, is_generator=False, is_cpdef_func=False): + trace_func = "__Pyx_TraceStartGen" if is_generator else "__Pyx_TraceStartFunc" + self.putln( + f'{trace_func}(' + f'{name.as_c_string_literal()}, ' + f'{Naming.filetable_cname}[{self.lookup_filename(pos[0])}], ' + f'{pos[1]}, ' + f'{self.pos_to_offset(pos):d}, ' + f'{nogil:d}, ' + f'{Naming.skip_dispatch_cname if is_cpdef_func else "0"}, ' + f'{self.error_goto(pos)}' + ');' + ) + + def put_trace_exit(self, nogil=False): + self.putln(f"__Pyx_PyMonitoring_ExitScope({bool(nogil):d});") + + def put_trace_yield(self, retvalue_cname, pos): + error_goto = self.error_goto(pos) + self.putln(f"__Pyx_TraceYield({retvalue_cname}, {self.pos_to_offset(pos)}, {error_goto});") + + def put_trace_resume(self, pos): + scope = self.funcstate.scope + # pos[1] is probably not the first line, so try to find the first line of the generator function. + first_line = scope.scope_class.pos[1] if scope.scope_class else pos[1] + name = scope.name.as_c_string_literal() + filename_index = self.lookup_filename(pos[0]) + error_goto = self.error_goto(pos) + self.putln( + '__Pyx_TraceResumeGen(' + f'{name}, ' + f'{Naming.filetable_cname}[{filename_index}], ' + f'{first_line}, ' + f'{self.pos_to_offset(pos)}, ' + f'{error_goto}' + ');' + ) + + def put_trace_exception(self, pos, reraise=False, fresh=False): + self.putln(f"__Pyx_TraceException({self.pos_to_offset(pos)}, {bool(reraise):d}, {bool(fresh):d});") + + def put_trace_exception_propagating(self): + self.putln(f"__Pyx_TraceException({Naming.lineno_cname}, 0, 0);") + + def put_trace_exception_handled(self, pos): + self.putln(f"__Pyx_TraceExceptionHandled({self.pos_to_offset(pos)});") + + def put_trace_unwind(self, pos, nogil=False): + self.putln(f"__Pyx_TraceExceptionUnwind({self.pos_to_offset(pos)}, {bool(nogil):d});") + + def put_trace_stopiteration(self, pos, value): + error_goto = self.error_goto(pos) + self.putln(f"__Pyx_TraceStopIteration({value}, {self.pos_to_offset(pos)}, {error_goto});") + + def put_trace_return(self, retvalue_cname, pos, return_type=None, nogil=False): + extra_arg = "" + trace_func = "__Pyx_TraceReturnValue" + + if return_type is None: + pass + elif return_type.is_pyobject: + retvalue_cname = return_type.as_pyobject(retvalue_cname) + elif return_type.is_void: + retvalue_cname = 'Py_None' + elif return_type.is_string: + # We don't know if the C string is 0-terminated, but we cannot convert if it's not. + retvalue_cname = 'Py_None' + elif return_type.to_py_function: + trace_func = "__Pyx_TraceReturnCValue" + extra_arg = f", {return_type.to_py_function}" + else: + # We don't have a Python visible return value but we still need to report that we returned. + # 'None' may not be a misleading (it's false, for one), but it's hopefully better than nothing. + retvalue_cname = 'Py_None' + + error_handling = self.error_goto(pos) + self.putln(f"{trace_func}({retvalue_cname}{extra_arg}, {self.pos_to_offset(pos)}, {bool(nogil):d}, {error_handling});") + + def put_cpp_placement_new(self, target, + _utility_code=UtilityCode.load("DefaultPlacementNew", "CppSupport.cpp")): + self.globalstate.use_utility_code(_utility_code) + self.putln(f"__Pyx_default_placement_construct(&({target}));") + + def putln_openmp(self, string): + self.putln("#ifdef _OPENMP") + self.putln(string) + self.putln("#endif /* _OPENMP */") + + def undef_builtin_expect(self, cond): + """ + Redefine the macros likely() and unlikely to no-ops, depending on + condition 'cond' + """ + self.putln("#if %s" % cond) + self.putln(" #undef likely") + self.putln(" #undef unlikely") + self.putln(" #define likely(x) (x)") + self.putln(" #define unlikely(x) (x)") + self.putln("#endif") + + def redef_builtin_expect(self, cond): + self.putln("#if %s" % cond) + self.putln(" #undef likely") + self.putln(" #undef unlikely") + self.putln(" #define likely(x) __builtin_expect(!!(x), 1)") + self.putln(" #define unlikely(x) __builtin_expect(!!(x), 0)") + self.putln("#endif") + + +class PyrexCodeWriter: + # f file output file + # level int indentation level + + def __init__(self, outfile_name): + self.f = Utils.open_new_file(outfile_name) + self.level = 0 + + def putln(self, code): + self.f.write("%s%s\n" % (" " * self.level, code)) + + def indent(self): + self.level += 1 + + def dedent(self): + self.level -= 1 + + +class PyxCodeWriter: + """ + Can be used for writing out some Cython code. + """ + + def __init__(self, buffer=None, indent_level=0, context=None, encoding='ascii'): + self.buffer = buffer or StringIOTree() + self.level = indent_level + self.original_level = indent_level + self.context = context + self.encoding = encoding + self._insertion_points = {} + + def indent(self, levels=1): + self.level += levels + return True + + def dedent(self, levels=1): + self.level -= levels + + @contextmanager + def indenter(self, line): + """ + with pyx_code.indenter("for i in range(10):"): + pyx_code.putln("print i") + """ + self.putln(line) + self.indent() + yield + self.dedent() + + def empty(self): + return self.buffer.empty() + + def getvalue(self): + result = self.buffer.getvalue() + if isinstance(result, bytes): + result = result.decode(self.encoding) + return result + + def putln(self, line, context=None): + if context is None: + if self.context is not None: + context = self.context + if context is not None: + line = sub_tempita(line, context) + # Avoid indenting empty lines. + self.buffer.write(f"{self.level * ' '}{line}\n" if line else "\n") + + def put_chunk(self, chunk, context=None): + if context is None: + if self.context is not None: + context = self.context + if context is not None: + chunk = sub_tempita(chunk, context) + + chunk = _indent_chunk(chunk, self.level * 4) + self.buffer.write(chunk) + + def insertion_point(self): + return type(self)(self.buffer.insertion_point(), self.level, self.context) + + def reset(self): + # resets the buffer so that nothing gets written. Most useful + # for abandoning all work in a specific insertion point + self.buffer.reset() + self.level = self.original_level + + def named_insertion_point(self, name): + self._insertion_points[name] = self.insertion_point() + + def __getitem__(self, name): + return self._insertion_points[name] + + +@cython.final +@cython.ccall +def _indent_chunk(chunk: str, indentation_length: cython.int) -> str: + """Normalise leading space to the intended indentation and strip empty lines. + """ + assert '\t' not in chunk + lines = chunk.splitlines(keepends=True) + if not lines: + return chunk + last_line = lines[-1].rstrip(' ') + if last_line: + lines[-1] = last_line + else: + del lines[-1] + if not lines: + return '\n' + + # Count minimal (non-empty) indentation and strip empty lines. + min_indentation: cython.int = len(chunk) + 1 + line_indentation: cython.int + line: str + i: cython.int + for i, line in enumerate(lines): + line_indentation = _count_indentation(line) + if line_indentation + 1 == len(line): + lines[i] = '\n' + elif line_indentation < min_indentation: + min_indentation = line_indentation + + if min_indentation > len(chunk): + # All empty lines. + min_indentation = 0 + + if min_indentation < indentation_length: + add_indent = ' ' * (indentation_length - min_indentation) + lines = [ + add_indent + line if line != '\n' else '\n' + for line in lines + ] + elif min_indentation > indentation_length: + start: cython.int = min_indentation - indentation_length + lines = [ + line[start:] if line != '\n' else '\n' + for line in lines + ] + + return ''.join(lines) + + +@cython.exceptval(-1) +@cython.cfunc +def _count_indentation(s: str) -> cython.int: + i: cython.int = 0 + ch: cython.Py_UCS4 + for i, ch in enumerate(s): + if ch != ' ': + break + return i + + +class ClosureTempAllocator: + def __init__(self, klass): + self.klass = klass + self.temps_allocated = {} + self.temps_free = {} + self.temps_count = 0 + + def reset(self): + for type, cnames in self.temps_allocated.items(): + self.temps_free[type] = list(cnames) + + def allocate_temp(self, type): + if type not in self.temps_allocated: + self.temps_allocated[type] = [] + self.temps_free[type] = [] + elif self.temps_free[type]: + return self.temps_free[type].pop(0) + cname = '%s%d' % (Naming.codewriter_temp_prefix, self.temps_count) + self.klass.declare_var(pos=None, name=cname, cname=cname, type=type, is_cdef=True) + self.temps_allocated[type].append(cname) + self.temps_count += 1 + return cname