From: Dag Sverre Seljebotn Date: Thu, 21 May 2009 19:39:47 +0000 (+0200) Subject: UtilityCode put_code protocol X-Git-Tag: 0.12.alpha0~289 X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=e6fe63d9371079fa25415263a1178cf2bbc81f5c;p=cython.git UtilityCode put_code protocol --- diff --git a/Cython/Compiler/Code.py b/Cython/Compiler/Code.py index deb49548..8ac93610 100644 --- a/Cython/Compiler/Code.py +++ b/Cython/Compiler/Code.py @@ -68,6 +68,18 @@ class UtilityCode(object): self.specialize_list.append(s) return s + def put_code(self, output): + if self.requires: + for dependency in self.requires: + output.use_utility_code(dependency) + if self.proto: + output['utility_code_proto'].put(self.proto) + if self.impl: + output['utility_code_def'].put(self.impl) + self.write_init_code(output.initwriter, output.module_pos) + self.write_cleanup_code(output.cleanupwriter, output.module_pos) + + class FunctionState(object): # return_label string function return point label # error_label string error catch point label @@ -691,28 +703,18 @@ class GlobalState(object): # Utility code state # - def use_utility_code(self, utility_code, name=None): + def use_utility_code(self, utility_code): """ - Adds the given utility code to the C file if needed. - - codetup should unpack into one prototype code part and one - definition code part, both strings inserted directly in C. + 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 - If name is provided, it is used as an identifier to avoid inserting - code twice. Otherwise, id(codetup) is used as such an identifier. + See UtilityCode. """ - if name is None: name = id(utility_code) - if name not in self.utility_codes: - self.utility_codes.add(name) - if utility_code.requires: - for dependency in utility_code.requires: - self.use_utility_code(dependency) - if utility_code.proto: - self.parts['utility_code_proto'].put(utility_code.proto) - if utility_code.impl: - self.parts['utility_code_def'].put(utility_code.impl) - utility_code.write_init_code(self.initwriter, self.module_pos) - utility_code.write_cleanup_code(self.cleanupwriter, self.module_pos) + if utility_code not in self.utility_codes: + self.utility_codes.add(utility_code) + utility_code.put_code(self) def funccontext_property(name): diff --git a/Cython/Compiler/DebugFlags.py b/Cython/Compiler/DebugFlags.py index d6d52189..f7f5a0eb 100644 --- a/Cython/Compiler/DebugFlags.py +++ b/Cython/Compiler/DebugFlags.py @@ -10,7 +10,7 @@ debug_temp_code_comments = 0 debug_trace_code_generation = 0 # Do not replace exceptions with user-friendly error messages -debug_no_exception_intercept = 0 +debug_no_exception_intercept = 1 # Print a message each time a new stage in the pipeline is entered debug_verbose_pipeline = 0 diff --git a/Cython/Compiler/ModuleNode.py b/Cython/Compiler/ModuleNode.py index 2bb0c0a4..5985af08 100644 --- a/Cython/Compiler/ModuleNode.py +++ b/Cython/Compiler/ModuleNode.py @@ -285,8 +285,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): self.generate_declarations_for_modules(env, modules, globalstate) h_code.write('\n') - for codetup, name in env.utility_code_list: - globalstate.use_utility_code(codetup, name) + for utilcode in env.utility_code_list: + globalstate.use_utility_code(utilcode) globalstate.finalize_main_c_code() f = open_new_file(result.c_file) diff --git a/Cython/Compiler/Symtab.py b/Cython/Compiler/Symtab.py index 87a696d1..e0f584af 100644 --- a/Cython/Compiler/Symtab.py +++ b/Cython/Compiler/Symtab.py @@ -527,8 +527,8 @@ class Scope(object): if entry and entry.is_type: return entry.type - def use_utility_code(self, new_code, name=None): - self.global_scope().use_utility_code(new_code, name) + def use_utility_code(self, new_code): + self.global_scope().use_utility_code(new_code) def generate_library_function_declarations(self, code): # Generate extern decls for C library funcs used. @@ -654,7 +654,7 @@ class ModuleScope(Scope): # method_table_cname string C name of method table # doc string Module doc string # doc_cname string C name of module doc string - # utility_code_list [(UtilityCode, string)] Queuing utility codes for forwarding to Code.py + # utility_code_list [UtilityCode] Queuing utility codes for forwarding to Code.py # 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 @@ -829,9 +829,9 @@ class ModuleScope(Scope): if not entry: self.declare_var(name, py_object_type, pos) - def use_utility_code(self, new_code, name=None): + def use_utility_code(self, new_code): if new_code is not None: - self.utility_code_list.append((new_code, name)) + self.utility_code_list.append(new_code) def declare_c_class(self, name, pos, defining = 0, implementing = 0, module_name = None, base_type = None, objstruct_cname = None,