self.value = value
self.is_long = is_long
+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
+
possible_identifier = re.compile(ur"(?![0-9])\w+$", re.U).match
nice_identifier = re.compile('^[a-zA-Z0-0_]+$').match
self.const_cname_counter = 1
self.string_const_index = {}
self.int_const_index = {}
+ self.py_constants = []
def initwriters(self, rootwriter):
self.utilprotowriter = rootwriter.new_writer()
c = self.new_int_const(str_value, longness)
return c
+ def get_py_const(self, type):
+ # create a new Python object constant
+ return self.new_py_const(type)
+
def get_string_const(self, text):
# return a C string constant, creating a new one if necessary
if text.is_unicode:
self.int_const_index[(value, longness)] = c
return c
+ def new_py_const(self, type):
+ cname = self.new_const_cname()
+ c = PyObjectConst(cname, type)
+ self.py_constants.append(c)
+ return c
+
def new_string_const_cname(self, value, intern=None):
# Create a new globally-unique nice name for a C string constant.
if len(value) < 20 and nice_identifier(value):
def generate_const_declarations(self):
self.generate_string_constants()
self.generate_int_constants()
+ self.generate_object_constant_decls()
+
+ def generate_object_constant_decls(self):
+ consts = [ (len(c.cname), c.cname, c)
+ for c in self.py_constants ]
+ consts.sort()
+ for _, cname, c in consts:
+ self.decls_writer.putln(
+ "static %s;" % c.type.declaration_code(cname))
def generate_string_constants(self):
c_consts = [ (len(c.cname), c.cname, c)
def get_py_string_const(self, text, identifier=None):
return self.globalstate.get_py_string_const(text, identifier).cname
+ def get_argument_default_const(self, type):
+ return self.globalstate.get_py_const(type).cname
+
def intern(self, text):
return self.get_py_string_const(text)
code.putln("")
code.putln("/* Implementation of %s */" % env.qualified_name)
- self.generate_const_definitions(env, code)
- self.generate_interned_num_decls(env, code)
- self.generate_interned_string_decls(env, code)
- self.generate_py_string_decls(env, code)
code.globalstate.insert_global_var_declarations_into(code)
" 'cdef extern from' block")
else:
last_entry = enum_values[-1]
+ # this does not really generate code, just builds the result value
for value_entry in enum_values:
- if value_entry.value == value_entry.name:
+ if value_entry.value_node is not None:
+ value_entry.value_node.generate_evaluation_code(code)
+
+ for value_entry in enum_values:
+ if value_entry.value_node is None:
value_code = value_entry.cname
else:
value_code = ("%s = %s" % (
value_entry.cname,
- value_entry.value))
+ value_entry.value_node.result()))
if value_entry is not last_entry:
value_code += ","
code.putln(value_code)
entry.type.typeptr_cname)
code.put_var_declarations(env.var_entries, static = 1,
dll_linkage = "DL_EXPORT", definition = definition)
- if definition:
- code.put_var_declarations(env.default_entries, static = 1,
- definition = definition)
def generate_cfunction_predeclarations(self, env, code, definition):
for entry in env.cfunc_entries:
code.put_decref_clear(Naming.empty_tuple,
PyrexTypes.py_object_type,
nanny=False)
- for entry in env.pynum_entries:
- code.put_decref_clear(entry.cname,
- PyrexTypes.py_object_type,
- nanny=False)
- for entry in env.all_pystring_entries:
- if entry.is_interned:
- code.put_decref_clear(entry.pystring_cname,
- PyrexTypes.py_object_type,
- nanny=False)
- for entry in env.default_entries:
- if entry.type.is_pyobject and entry.used:
- code.putln("Py_DECREF(%s); %s = 0;" % (
- code.entry_as_pyobject(entry), entry.cname))
+# for entry in env.pynum_entries:
+# code.put_decref_clear(entry.cname,
+# PyrexTypes.py_object_type,
+# nanny=False)
+# for entry in env.all_pystring_entries:
+# if entry.is_interned:
+# code.put_decref_clear(entry.pystring_cname,
+# PyrexTypes.py_object_type,
+# nanny=False)
+# for entry in env.default_entries:
+# if entry.type.is_pyobject and entry.used:
+# code.putln("Py_DECREF(%s); %s = 0;" % (
+# code.entry_as_pyobject(entry), entry.cname))
code.putln("Py_INCREF(Py_None); return Py_None;")
code.putln('}')
class BlockNode(object):
# Mixin class for nodes representing a declaration block.
- def generate_const_definitions(self, env, code):
- if env.const_entries:
- for entry in env.const_entries:
- if not entry.is_interned:
- code.globalstate.add_const_definition(entry)
-
- def generate_interned_string_decls(self, env, code):
- entries = env.global_scope().new_interned_string_entries
- if entries:
- for entry in entries:
- code.globalstate.add_interned_string_decl(entry)
- del entries[:]
-
- def generate_py_string_decls(self, env, code):
- if env is None:
- return # earlier error
- entries = env.pystring_entries
- if entries:
- for entry in entries:
- if not entry.is_interned:
- code.globalstate.add_py_string_decl(entry)
-
- def generate_interned_num_decls(self, env, code):
- # Flush accumulated interned nums from the global scope
- # and generate declarations for them.
- genv = env.global_scope()
- entries = genv.interned_nums
- if entries:
- for entry in entries:
- code.globalstate.add_interned_num_decl(entry)
- del entries[:]
-
def generate_cached_builtins_decls(self, env, code):
entries = env.global_scope().undeclared_cached_builtins
for entry in entries:
# declarator CDeclaratorNode
# not_none boolean Tagged with 'not None'
# default ExprNode or None
- # default_entry Symtab.Entry Entry for the variable holding the default value
- # default_result_code string cname or code fragment for default value
+ # default_value PyObjectConst constant for default value
# is_self_arg boolean Is the "self" arg of an extension type method
# is_kw_only boolean Is a keyword-only argument
is_generic = 1
type = None
name_declarator = None
+ default_value = None
def analyse(self, env, nonempty = 0):
#print "CArgDeclNode.analyse: is_self_arg =", self.is_self_arg ###
else:
return self.name_declarator, self.type
- def prepare_default_result_code(self, code):
- if self.default:
- if self.default.is_literal:
- # FIXME: IS IT OK TO CALL THIS HERE???
- self.default.generate_evaluation_code(code)
- self.default_result_code = self.default.result()
- if self.default.type != self.type and not self.type.is_int:
- self.default_result_code = self.type.cast_code(self.default_result_code)
- else:
- self.default_result_code = self.default_entry.cname
+ def calculate_default_value_code(self, code):
+ if self.default_value is None:
+ if self.default:
+ if self.default.is_literal:
+ # will not output any code, just assign the result_code
+ self.default.generate_evaluation_code(code)
+ return self.type.cast_code(self.default.result())
+ self.default_value = code.get_argument_default_const(self.type)
+ return self.default_value
def annotate(self, code):
if self.default:
if not self.value.type.is_int:
self.value = self.value.coerce_to(PyrexTypes.c_int_type, env)
self.value.analyse_const_expression(env)
- value = self.value.get_constant_result_code()
- else:
- value = self.name
entry = env.declare_const(self.name, enum_entry.type,
- value, self.pos, cname = self.cname, visibility = enum_entry.visibility)
+ self.value, self.pos, cname = self.cname,
+ visibility = enum_entry.visibility)
enum_entry.enum_values.append(entry)
if not hasattr(arg, 'default_entry'):
arg.default.analyse_types(env)
arg.default = arg.default.coerce_to(arg.type, genv)
- if arg.default.is_literal:
- arg.default_entry = arg.default
- else:
- arg.default.allocate_temps(genv)
- arg.default_entry = genv.add_default_value(arg.type)
- if arg.type.is_pyobject:
- arg.default_entry.init = 0
- arg.default_entry.used = 1
+ arg.default.allocate_temps(genv)
else:
error(arg.pos,
"This argument cannot have a default value")
# ----- Top-level constants used by this function
code.mark_pos(self.pos)
- self.generate_interned_num_decls(lenv, code)
- self.generate_interned_string_decls(lenv, code)
- self.generate_py_string_decls(lenv, code)
self.generate_cached_builtins_decls(lenv, code)
- #code.putln("")
- #code.put_var_declarations(lenv.const_entries, static = 1)
- self.generate_const_definitions(lenv, code)
# ----- Function header
code.putln("")
if self.py_func:
if not default.is_literal:
default.generate_evaluation_code(code)
default.make_owned_reference(code)
+ result = default.result_as(arg.type)
code.putln(
"%s = %s;" % (
- arg.default_entry.cname,
- default.result_as(arg.default_entry.type)))
- if default.is_temp and default.type.is_pyobject:
- code.putln("%s = 0;" % default.result())
+ arg.calculate_default_value_code(code),
+ result))
+ if arg.type.is_pyobject:
+ code.put_giveref(default.result())
+ default.generate_post_assignment_code(code)
default.free_temps(code)
- code.put_var_giveref(arg.default_entry)
# For Python class methods, create and store function object
if self.assmt:
self.assmt.generate_execution_code(code)
def generate_argument_declarations(self, env, code):
for arg in self.args:
if arg.default:
- arg.prepare_default_result_code(code)
+ result = arg.calculate_default_value_code(code)
code.putln('%s = %s;' % (
- arg.type.declaration_code(arg.cname), arg.default_result_code))
+ arg.type.declaration_code(arg.cname), result))
def generate_keyword_list(self, code):
pass
code.putln("PyObject *%s = 0;" % arg.hdr_cname)
else:
code.put_var_declaration(arg.entry)
- if arg.default:
- arg.prepare_default_result_code(code)
-
+
def generate_keyword_list(self, code):
if self.signature_has_generic_args() and \
self.signature_has_nongeneric_args():
code.putln(
"%s = %s;" % (
arg.entry.cname,
- arg.default_result_code))
+ arg.calculate_default_value_code(code)))
def generate_stararg_init_code(self, max_positional_args, code):
if self.starstar_arg:
default_args = []
for i, arg in enumerate(all_args):
if arg.default and arg.type.is_pyobject:
- default_value = arg.default_result_code
+ default_value = arg.calculate_default_value_code(code)
if arg.type is not PyrexTypes.py_object_type:
default_value = "(PyObject*)"+default_value
default_args.append((i, default_value))
code.putln(
"%s = %s;" % (
arg.entry.cname,
- arg.default_result_code))
+ arg.calculate_default_value_code(code)))
code.putln('}')
def generate_argument_conversion_code(self, code):
#self.target.release_target_temp(env)
def generate_function_definitions(self, env, code):
- self.generate_py_string_decls(self.scope, code)
self.body.generate_function_definitions(self.scope, code)
def generate_execution_code(self, code):
self.body.analyse_expressions(scope)
def generate_function_definitions(self, env, code):
- self.generate_py_string_decls(self.entry.type.scope, code)
if self.body:
self.body.generate_function_definitions(
self.entry.type.scope, code)
def qualify_name(self, name):
return "%s.%s" % (self.qualified_name, name)
-
+
def declare_const(self, name, type, value, pos, cname = None, visibility = 'private'):
# Add an entry for a named constant.
if not cname:
cname = self.mangle(Naming.enum_prefix, name)
entry = self.declare(name, cname, type, pos, visibility)
entry.is_const = 1
- entry.value = value
+ entry.value_node = value
return entry
def declare_type(self, name, type, pos,
# method_table_cname string C name of method table
# doc string Module doc string
# doc_cname string C name of module doc string
- # const_counter integer Counter for naming constants (PS: MOVED TO GLOBAL)
# utility_code_list [(UtilityCode, string)] Queuing utility codes for forwarding to Code.py
- # default_entries [Entry] Function argument default entries
# python_include_files [string] Standard Python headers to be included
# include_files [string] Other C headers to be included
# string_to_entry {string : Entry} Map string const to entry
# included_files [string] Cython sources included with 'include'
# pxd_file_loaded boolean Corresponding .pxd file has been processed
# cimported_modules [ModuleScope] Modules imported with cimport
- # new_interned_string_entries [Entry] New interned strings waiting to be declared
- # interned_nums [int/long] Interned numeric constants
- # all_pystring_entries [Entry] Python string consts from all scopes
# types_imported {PyrexType : 1} Set of types for which import code generated
# has_import_star boolean Module contains import *
self.doc = ""
self.doc_cname = Naming.moddoc_cname
self.utility_code_list = []
- self.default_entries = []
self.module_entries = {}
self.python_include_files = ["Python.h", "structmember.h"]
self.include_files = []
self.type_names = dict(outer_scope.type_names)
self.pxd_file_loaded = 0
self.cimported_modules = []
- self.new_interned_string_entries = []
- self.interned_nums = []
- self.interned_objs = []
- self.all_pystring_entries = []
self.types_imported = {}
self.included_files = []
- self.pynum_entries = []
self.has_extern_class = 0
self.cached_builtins = []
self.undeclared_cached_builtins = []
if not entry:
self.declare_var(name, py_object_type, pos)
- def add_default_value(self, type):
- # Add an entry for holding a function argument
- # default value.
- cname = self.new_const_cname()
- entry = Entry("", cname, type)
- self.default_entries.append(entry)
- return entry
-
- def new_const_cname(self):
- global const_counter
- # Create a new globally-unique name for a constant.
- prefix=''
- n = const_counter
- const_counter = n + 1
- return "%s%s%d" % (Naming.const_prefix, prefix, n)
-
def use_utility_code(self, new_code, name=None):
if new_code is not None:
self.utility_code_list.append((new_code, name))
projects / cython.git / commitdiff