# cython: language_level = 2

#

# Code output module

#

import cython

cython.declare(os=object, re=object, operator=object,

Naming=object, Options=object, StringEncoding=object,

Utils=object, SourceDescriptor=object, StringIOTree=object,

DebugFlags=object, basestring=object)

import os

import re

import sys

from string import Template

import operator

import textwrap

try:

import hashlib

except ImportError:

import md5 as hashlib

import Naming

import Options

import StringEncoding

from Cython import Utils

from Scanning import SourceDescriptor

from Cython.StringIOTree import StringIOTree

import DebugFlags

try:

from __builtin__ import basestring

except ImportError:

from builtins import str as basestring

KEYWORDS_MUST_BE_BYTES = sys.version_info < (2,7)

non_portable_builtins_map = {

# builtins that have different names in different Python versions

'bytes' : ('PY_MAJOR_VERSION < 3', 'str'),

'unicode' : ('PY_MAJOR_VERSION >= 3', 'str'),

'basestring' : ('PY_MAJOR_VERSION >= 3', 'str'),

'xrange' : ('PY_MAJOR_VERSION >= 3', 'range'),

'raw_input' : ('PY_MAJOR_VERSION >= 3', 'input'),

'BaseException' : ('PY_VERSION_HEX < 0x02050000', 'Exception'),

}

basicsize_builtins_map = {

# builtins whose type has a different tp_basicsize than sizeof(...)

'PyTypeObject' : 'PyHeapTypeObject',

}

uncachable_builtins = [

# builtin names that cannot be cached because they may or may not

# be available at import time

'WindowsError',

]

modifier_output_mapper = {

'inline': 'CYTHON_INLINE'

}.get

is_self_assignment = re.compile(r" *(\w+) = (\1);\s*$").match

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")

class UtilityCodeBase(object):

"""

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]

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

requires = None

_utility_cache = {}

@classmethod

def _add_utility(cls, utility, type, lines, begin_lineno, tags=None):

if utility is None:

return

code = '\n'.join(lines)

if tags and 'substitute' in tags and tags['substitute'] == set(['naming']):

del tags['substitute']

try:

code = Template(code).substitute(vars(Naming))

except (KeyError, ValueError), e:

raise RuntimeError("Error parsing templated utility code of type '%s' at line %d: %s" % (

type, begin_lineno, e))

# 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]

if KEYWORDS_MUST_BE_BYTES:

type = type.encode('ASCII')

all_tags[type] = code

if tags:

all_tags = utility[2]

for name, values in tags.items():

if KEYWORDS_MUST_BE_BYTES:

name = name.encode('ASCII')

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

filename = os.path.join(get_utility_dir(), path)

_, ext = os.path.splitext(path)

if ext in ('.pyx', '.py', '.pxd', '.pxi'):

comment = '#'

replace_comments = re.compile(r'^\s*#.*').sub

else:

comment = '/'

replace_comments = re.compile(r'^\s*//.*|^\s*/\*[^*]*\*/').sub

match_special = re.compile(

(r'^%(C)s{5,30}\s*(?P<name>(?:\w|\.)+)\s*%(C)s{5,30}|'

r'^%(C)s+@(?P<tag>\w+)\s*:\s*(?P<value>(?:\w|[.:])+)'

) % {'C':comment}).match

match_type = re.compile('(.+)[.](proto|impl|init|cleanup)$').match

f = Utils.open_source_file(filename, encoding='UTF-8')

try:

all_lines = f.readlines()

finally:

f.close()

utilities = {}

lines = []

tags = {}

utility = 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, 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.setdefault(name, [None, None, {}])

else:

tags.setdefault(m.group('tag'), set()).add(m.group('value'))

lines.append('') # keep line number correct

else:

lines.append(replace_comments('', line).rstrip())

if utility is None:

raise ValueError("Empty utility code file")

# Don't forget to add the last utility code

cls._add_utility(utility, type, lines, begin_lineno, tags)

cls._utility_cache[path] = utilities

return utilities

@classmethod

def load(cls, util_code_name, from_file=None, **kwargs):

"""

Load utility code from a file specified by from_file (relative to

Cython/Utility) and name util_code_name. If from_file is not given,

load it from the file util_code_name.*. There should be only one

file matched by this pattern.

"""

if '::' in util_code_name:

from_file, util_code_name = util_code_name.rsplit('::', 1)

if not from_file:

utility_dir = get_utility_dir()

prefix = util_code_name + '.'

try:

listing = os.listdir(utility_dir)

except OSError:

# XXX the code below assumes as 'zipimport.zipimporter' instance

# XXX should be easy to generalize, but too lazy right now to write it

import zipfile

global __loader__

loader = __loader__

archive = loader.archive

fileobj = zipfile.ZipFile(archive)

listing = [ os.path.basename(name)

for name in fileobj.namelist()

if os.path.join(archive, name).startswith(utility_dir)]

fileobj.close()

files = [ os.path.join(utility_dir, filename)

for filename in listing

if filename.startswith(prefix) ]

if not files:

raise ValueError("No match found for utility code " + util_code_name)

if len(files) > 1:

raise ValueError("More than one filename match found for utility code " + util_code_name)

from_file = files[0]

utilities = cls.load_utilities_from_file(from_file)

proto, impl, tags = utilities[util_code_name]

if tags:

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 not values:

values = None

elif len(values) == 1:

values = 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=None, __cache={}):

"""

Calls .load(), but using a per-type cache based on utility name and file name.

"""

key = (cls, from_file, utility_code_name)

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=None, **kwargs):

"""

Load a utility code as a string. Returns (proto, implementation)

"""

util = cls.load(util_code_name, from_file, **kwargs)

proto, impl = util.proto, util.impl

return util.format_code(proto), util.format_code(impl)

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 __str__(self):

return "<%s(%s)" % (type(self).__name__, self.name)

def get_tree(self):

pass

class UtilityCode(UtilityCodeBase):

"""

Stores utility code to add during code generation.

See GlobalState.put_utility_code.

hashes/equals by instance

proto C prototypes

impl implemenation 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)

"""

def __init__(self, proto=None, impl=None, init=None, cleanup=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.requires = requires

self._cache = {}

self.specialize_list = []

self.proto_block = proto_block

self.name = name

self.file = file

def __hash__(self):

return hash((self.proto, self.impl))

def __eq__(self, other):

if self is other:

return True

if not isinstance(other, type(self)):

return False

self_proto = getattr(self, 'proto', None)

other_proto = getattr(other, 'proto', None)

return (self_proto, self.impl) == (other_proto, other.impl)

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):

# Dicts aren't hashable...

if pyrex_type is not None:

data['type'] = pyrex_type.declaration_code('')

data['type_name'] = pyrex_type.specialization_name()

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),

requires,

self.proto_block)

self.specialize_list.append(s)

return s

def inject_string_constants(self, impl, output):

"""Replace 'PYIDENT("xyz")' by a constant Python identifier cname.

"""

replacements = {}

def externalise(matchobj):

name = matchobj.group(1)

try:

cname = replacements[name]

except KeyError:

cname = replacements[name] = output.get_interned_identifier(

StringEncoding.EncodedString(name)).cname

return cname

impl = re.sub('PYIDENT\("([^"]+)"\)', externalise, impl)

return bool(replacements), impl

def put_code(self, output):

if self.requires:

for dependency in self.requires:

output.use_utility_code(dependency)

if self.proto:

output[self.proto_block].put_or_include(

self.format_code(self.proto),

'%s_proto' % self.name)

if self.impl:

impl = self.format_code(self.impl)

is_specialised, impl = self.inject_string_constants(impl, output)

if not is_specialised:

# no module specific adaptations => can be reused

output['utility_code_def'].put_or_include(

impl, '%s_impl' % self.name)

else:

output['utility_code_def'].put(impl)

if self.init:

writer = output['init_globals']

writer.putln("/* %s.init */" % self.name)

if isinstance(self.init, basestring):

writer.put(self.format_code(self.init))

else:

self.init(writer, output.module_pos)

writer.putln(writer.error_goto_if_PyErr(output.module_pos))

writer.putln()

if self.cleanup and Options.generate_cleanup_code:

writer = output['cleanup_globals']

if isinstance(self.cleanup, basestring):

writer.put_or_include(

self.format_code(self.cleanup),

'%s_cleanup' % self.name)

else:

self.cleanup(writer, output.module_pos)

def sub_tempita(s, context, file=None, name=None):

"Run tempita on string s with given context."

if not s:

return None

if file:

context['__name'] = "%s:%s" % (file, name)

elif name:

context['__name'] = name

from Cython.Tempita import sub

return sub(s, **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 = {}

proto = sub_tempita(proto, context, file, name)

impl = sub_tempita(impl, context, file, name)

init = sub_tempita(init, context, file, name)

super(TempitaUtilityCode, self).__init__(

proto, impl, init=init, name=name, file=file, **kwargs)

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'.

"""

def __init__(self, callback):

self.callback = callback

def put_code(self, globalstate):

utility = self.callback(globalstate.rootwriter)

globalstate.use_utility_code(utility)

class FunctionState(object):

# return_label string function return point label

# error_label string error catch point label

# 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

# in_try_finally boolean inside try of try...finally

# exc_vars (string * 3) exception variables for reraise, or None

# can_trace boolean line tracing is supported in the current context

# Not used for now, perhaps later

def __init__(self, owner, names_taken=set()):

self.names_taken = names_taken

self.owner = owner

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.in_try_finally = 0

self.exc_vars = None

self.can_trace = False

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.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

# labels

def new_label(self, name=None):

n = 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):

label = self.new_label('resume_from_yield')

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):

old_err_lbl = self.error_label

self.error_label = self.new_label('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):

old_labels = self.get_loop_labels()

self.set_loop_labels(

(self.new_label("continue"),

self.new_label("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):

"""

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.is_pyobject, 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.is_pyobject, 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 Python object.

static=True marks the temporary declaration with "static".

This is only used when allocating backing store for a module-level

C array literals.

A C string referring to the variable is returned.

"""

if type.is_const:

type = type.const_base_type

if not type.is_pyobject and not type.is_memoryviewslice:

# 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 freelist is not None and len(freelist) > 0:

result = freelist.pop()

else:

while True:

self.temp_counter += 1

result = "%s%d" % (Naming.codewriter_temp_prefix, self.temp_counter)

if not result in self.names_taken: break

self.temps_allocated.append((result, type, manage_ref, static))

self.temps_used_type[result] = (type, manage_ref)

if DebugFlags.debug_temp_code_comments:

self.owner.putln("/* %s allocated */" % result)

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 = []

self.temps_free[(type, manage_ref)] = freelist

if name in freelist:

raise RuntimeError("Temp %s freed twice!" % name)

freelist.append(name)

if DebugFlags.debug_temp_code_comments:

self.owner.putln("/* %s released */" % name)

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:

used.append((name, type, manage_ref and type.is_pyobject))

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 of a

Python object type which owns its reference.

"""

return [(name, type)

for name, type, manage_ref in self.temps_in_use()

if manage_ref and type.is_pyobject]

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 [(cname, type)

for (type, manage_ref), freelist in self.temps_free.items()

if manage_ref

for cname in freelist]

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(object):

"""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(object):

"""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(ur"(?![0-9])\w+$", re.U).match

possible_bytes_identifier = re.compile(r"(?![0-9])\w+$".encode('ASCII')).match

replace_identifier = re.compile(r'[^a-zA-Z0-9_]+').sub

find_alphanums = re.compile('([a-zA-Z0-9]+)').findall

class StringConst(object):

"""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

self.py_versions = []

def add_py_version(self, version):

if not version:

self.py_versions = [2,3]

elif version not in self.py_versions:

self.py_versions.append(version)

def get_py_string_const(self, encoding, identifier=None,

is_str=False, py3str_cstring=None):

py_strings = self.py_strings

text = self.text

is_str = bool(identifier or is_str)

is_unicode = encoding is None and not is_str

if encoding is None:

# unicode string

encoding_key = None

else:

# bytes or str

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))

key = (is_str, is_unicode, encoding_key, py3str_cstring)

if py_strings is not None:

try:

return py_strings[key]

except KeyError:

pass

else:

self.py_strings = {}

if identifier:

intern = True

elif identifier is None:

if isinstance(text, unicode):

intern = bool(possible_unicode_identifier(text))

else:

intern = bool(possible_bytes_identifier(text))

else:

intern = False

if intern:

prefix = Naming.interned_prefixes['str']

else:

prefix = Naming.py_const_prefix

if encoding_key:

encoding_prefix = '_%s' % encoding_key

else:

encoding_prefix = ''

pystring_cname = "%s%s%s_%s" % (

prefix,

(is_str and 's') or (is_unicode and 'u') or 'b',

encoding_prefix,

self.cname[len(Naming.const_prefix):])

py_string = PyStringConst(

pystring_cname, encoding, is_unicode, is_str, py3str_cstring, intern)

self.py_strings[key] = py_string

return py_string

class PyStringConst(object):

"""Global info about a Python string constant held by GlobalState.

"""

# cname string

# py3str_cstring string

# encoding string

# intern boolean

# is_unicode boolean

# is_str boolean

def __init__(self, cname, encoding, is_unicode, is_str=False,

py3str_cstring=None, intern=False):

self.cname = cname

self.py3str_cstring = py3str_cstring

self.encoding = encoding

self.is_str = is_str

self.is_unicode = is_unicode

self.intern = intern

def __lt__(self, other):

return self.cname < other.cname

class GlobalState(object):

# 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',

'decls',

'all_the_rest',

'pystring_table',

'cached_builtins',

'cached_constants',

'init_globals',

'init_module',

'cleanup_globals',

'cleanup_module',

'main_method',

'utility_code_def',

'end'

]

def __init__(self, writer, module_node, emit_linenums=False, 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.emit_linenums = emit_linenums

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.pyunicode_ptr_const_index = {}

self.num_const_index = {}

self.py_constants = []

assert writer.globalstate is None

writer.globalstate = self

self.rootwriter = writer

def initialize_main_c_code(self):

rootwriter = self.rootwriter

for part in self.code_layout:

self.parts[part] = rootwriter.insertion_point()

if not Options.cache_builtins:

del self.parts['cached_builtins']

else:

w = self.parts['cached_builtins']

w.enter_cfunc_scope()

w.putln("static int __Pyx_InitCachedBuiltins(void) {")

w = self.parts['cached_constants']

w.enter_cfunc_scope()

w.putln("")

w.putln("static int __Pyx_InitCachedConstants(void) {")

w.put_declare_refcount_context()

w.put_setup_refcount_context("__Pyx_InitCachedConstants")

w = self.parts['init_globals']

w.enter_cfunc_scope()

w.putln("")

w.putln("static int __Pyx_InitGlobals(void) {")

if not Options.generate_cleanup_code:

del self.parts['cleanup_globals']

else:

w = self.parts['cleanup_globals']

w.enter_cfunc_scope()

w.putln("")

w.putln("static void __Pyx_CleanupGlobals(void) {")

#

# utility_code_def

#

code = self.parts['utility_code_def']

if self.emit_linenums:

code.write('\n#line 1 "cython_utility"\n')

code.putln("")

code.putln("/* Runtime support code */")

def finalize_main_c_code(self):

self.close_global_decls()

#

# utility_code_def

#

code = self.parts['utility_code_def']

code.put(UtilityCode.load_as_string("TypeConversions", "TypeConversion.c")[1])

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):