def visit_FunctionDef(self, node): self.fname = node.name tmp = self.prepare_functiondef_context(node) operator_body, formal_types, formal_args = tmp tmp = self.prepare_types(node) dflt_argv, dflt_argt, result_type, callable_type, pure_type = tmp # a function has a call operator to be called # and a default constructor to create instances fscope = "type{0}::".format( "<{0}>".format(", ".join(formal_types)) if formal_types else "") ffscope = "{0}::{1}".format(node.name, fscope) operator_declaration = [ templatize( make_const_function_declaration( self, node, "typename {0}result_type".format(fscope), "operator()", formal_types, formal_args, dflt_argv), formal_types, dflt_argt), EmptyStatement() ] operator_signature = make_const_function_declaration( self, node, "typename {0}result_type".format(ffscope), "{0}::operator()".format(node.name), formal_types, formal_args) ctx = CachedTypeVisitor(self.lctx) operator_local_declarations = ([ Statement("{0} {1}".format( self.types[self.local_names[k]].generate(ctx), k)) for k in self.ldecls ]) dependent_typedefs = ctx.typedefs() operator_definition = FunctionBody( templatize(operator_signature, formal_types), Block(dependent_typedefs + operator_local_declarations + operator_body)) ctx = CachedTypeVisitor() extra_typedefs = ([ Typedef(Value(t.generate(ctx), t.name)) for t in self.types[node][1] ] + [Typedef(Value(result_type.generate(ctx), "result_type"))]) extra_typedefs = ctx.typedefs() + extra_typedefs return_declaration = [ templatize(Struct("type", extra_typedefs), formal_types, dflt_argt) ] topstruct = Struct(node.name, [callable_type, pure_type] + return_declaration + operator_declaration) return [topstruct], [operator_definition]
def generate_cxx(module_name, code, specs=None, optimizations=None, module_dir=None): '''python + pythran spec -> c++ code returns a PythonModule object and an error checker the error checker can be used to print more detailed info on the origin of a compile error (e.g. due to bad typing) ''' pm, ir, renamings, docstrings = front_middle_end(module_name, code, optimizations, module_dir) # back-end content = pm.dump(Cxx, ir) # instantiate the meta program if specs is None: class Generable(object): def __init__(self, content): self.content = content def __str__(self): return str(self.content) generate = __str__ mod = Generable(content) def error_checker(): tog.typecheck(ir) else: # uniform typing if isinstance(specs, dict): specs = Spec(specs, {}) def error_checker(): types = tog.typecheck(ir) check_specs(ir, specs, renamings, types) specs.to_docstrings(docstrings) if isinstance(code, bytes): code_bytes = code else: code_bytes = code.encode('ascii', 'ignore') metainfo = {'hash': hashlib.sha256(code_bytes).hexdigest(), 'version': __version__, 'date': datetime.now()} mod = PythonModule(module_name, docstrings, metainfo) mod.add_to_preamble(Define("BOOST_SIMD_NO_STRICT_ALIASING", "1")) mod.add_to_includes( Include("pythonic/core.hpp"), Include("pythonic/python/core.hpp"), # FIXME: only include these when needed Include("pythonic/types/bool.hpp"), Include("pythonic/types/int.hpp"), Line("#ifdef _OPENMP\n#include <omp.h>\n#endif") ) mod.add_to_includes(*[Include(inc) for inc in _extract_specs_dependencies(specs)]) mod.add_to_includes(*content.body) mod.add_to_includes( Include("pythonic/python/exception_handler.hpp"), ) def warded(module_name, internal_name): return pythran_ward + '{0}::{1}'.format(module_name, internal_name) for function_name, signatures in specs.functions.items(): internal_func_name = renamings.get(function_name, function_name) # global variables are functions with no signatures :-) if not signatures: mod.add_global_var(function_name, "{}()()".format(warded(module_name, internal_func_name))) for sigid, signature in enumerate(signatures): numbered_function_name = "{0}{1}".format(internal_func_name, sigid) arguments_types = [pytype_to_ctype(t) for t in signature] arguments_names = HasArgument(internal_func_name).visit(ir) arguments = [n for n, _ in zip(arguments_names, arguments_types)] name_fmt = pythran_ward + "{0}::{1}::type{2}" args_list = ", ".join(arguments_types) specialized_fname = name_fmt.format(module_name, internal_func_name, "<{0}>".format(args_list) if arguments_names else "") result_type = "typename %s::result_type" % specialized_fname mod.add_pyfunction( FunctionBody( FunctionDeclaration( Value( result_type, numbered_function_name), [Value(t + '&&', a) for t, a in zip(arguments_types, arguments)]), Block([Statement(""" PyThreadState *_save = PyEval_SaveThread(); try {{ auto res = {0}()({1}); PyEval_RestoreThread(_save); return res; }} catch(...) {{ PyEval_RestoreThread(_save); throw; }} """.format(warded(module_name, internal_func_name), ', '.join(arguments)))]) ), function_name, arguments_types, signature ) for function_name, signature in specs.capsules.items(): internal_func_name = renamings.get(function_name, function_name) arguments_types = [pytype_to_ctype(t) for t in signature] arguments_names = HasArgument(internal_func_name).visit(ir) arguments = [n for n, _ in zip(arguments_names, arguments_types)] name_fmt = pythran_ward + "{0}::{1}::type{2}" args_list = ", ".join(arguments_types) specialized_fname = name_fmt.format(module_name, internal_func_name, "<{0}>".format(args_list) if arguments_names else "") result_type = "typename %s::result_type" % specialized_fname docstring = spec_to_string(function_name, signature) mod.add_capsule( FunctionBody( FunctionDeclaration( Value(result_type, function_name), [Value(t, a) for t, a in zip(arguments_types, arguments)]), Block([ReturnStatement("{0}()({1})".format( warded(module_name, internal_func_name), ', '.join(arguments)))]) ), function_name, docstring ) return mod, error_checker
def visit_FunctionDef(self, node): tmp = self.prepare_functiondef_context(node) operator_body, formal_types, formal_args = tmp tmp = self.prepare_types(node) dflt_argv, dflt_argt, result_type, callable_type, pure_type = tmp # a generator has a call operator that returns the iterator next_name = "__generator__{0}".format(node.name) instanciated_next_name = "{0}{1}".format( next_name, "<{0}>".format(", ".join(formal_types)) if formal_types else "") operator_body.append( Statement("{}: return result_type()".format( CxxGenerator.FinalStatement))) next_declaration = [ FunctionDeclaration(Value("result_type", "next"), []), EmptyStatement() ] # empty statement to force a comma ... # the constructors next_constructors = [ FunctionBody(FunctionDeclaration(Value("", next_name), []), Line(': pythonic::yielder() {}')) ] if formal_types: # If all parameters have a default value, we don't need default # constructor if dflt_argv and all(dflt_argv): next_constructors = list() next_constructors.append( FunctionBody( make_function_declaration(self, node, "", next_name, formal_types, formal_args, dflt_argv), Line(": {0} {{ }}".format(", ".join( ["pythonic::yielder()"] + ["{0}({0})".format(arg) for arg in formal_args]))))) next_iterator = [ FunctionBody(FunctionDeclaration(Value("void", "operator++"), []), Block([Statement("next()")])), FunctionBody( FunctionDeclaration( Value( "typename {0}::result_type".format( instanciated_next_name), "operator*"), [], "const"), Block([ReturnStatement(CxxGenerator.StateValue)])), FunctionBody( FunctionDeclaration( Value( "pythonic::types::generator_iterator<{0}>".format( next_name), "begin"), []), Block([ Statement("next()"), ReturnStatement("pythonic::types::generator_iterator<{0}>" "(*this)".format(next_name)) ])), FunctionBody( FunctionDeclaration( Value( "pythonic::types::generator_iterator<{0}>".format( next_name), "end"), []), Block([ ReturnStatement( "pythonic::types::generator_iterator<{0}>()".format( next_name)) ])) ] next_signature = templatize( FunctionDeclaration( Value( "typename {0}::result_type".format(instanciated_next_name), "{0}::next".format(instanciated_next_name)), []), formal_types) next_body = operator_body # the dispatch table at the entry point next_body.insert( 0, Statement("switch({0}) {{ {1} }}".format( CxxGenerator.StateHolder, " ".join("case {0}: goto {1};".format(num, where) for (num, where) in sorted(self.yields.values(), key=lambda x: x[0]))))) ctx = CachedTypeVisitor(self.lctx) next_members = ([ Statement("{0} {1}".format(ft, fa)) for (ft, fa) in zip(formal_types, formal_args) ] + [ Statement("{0} {1}".format( self.types[self.local_names[k]].generate(ctx), k)) for k in self.ldecls ] + [ Statement("{0} {1}".format(v, k)) for k, v in self.extra_declarations ] + [ Statement("typename {0}::result_type {1}".format( instanciated_next_name, CxxGenerator.StateValue)) ]) extern_typedefs = [ Typedef(Value(t.generate(ctx), t.name)) for t in self.types[node][1] ] iterator_typedef = [ Typedef( Value( "pythonic::types::generator_iterator<{0}>".format( "{0}<{1}>".format(next_name, ", ".join(formal_types) ) if formal_types else next_name), "iterator")), Typedef(Value(result_type.generate(ctx), "value_type")) ] result_typedef = [ Typedef(Value(result_type.generate(ctx), "result_type")) ] extra_typedefs = (ctx.typedefs() + extern_typedefs + iterator_typedef + result_typedef) next_struct = templatize( Struct( next_name, extra_typedefs + next_members + next_constructors + next_iterator + next_declaration, "pythonic::yielder"), formal_types) next_definition = FunctionBody(next_signature, Block(next_body)) operator_declaration = [ templatize( make_const_function_declaration(self, node, instanciated_next_name, "operator()", formal_types, formal_args, dflt_argv), formal_types, dflt_argt), EmptyStatement() ] operator_signature = make_const_function_declaration( self, node, instanciated_next_name, "{0}::operator()".format(node.name), formal_types, formal_args) operator_definition = FunctionBody( templatize(operator_signature, formal_types), Block([ ReturnStatement("{0}({1})".format(instanciated_next_name, ", ".join(formal_args))) ])) topstruct_type = templatize(Struct("type", extra_typedefs), formal_types) topstruct = Struct(node.name, [topstruct_type, callable_type, pure_type] + operator_declaration) return [next_struct, topstruct], [next_definition, operator_definition]
def generate_cxx(module_name, code, specs=None, optimizations=None): '''python + pythran spec -> c++ code returns a PythonModule object ''' if sys.version_info[0] == 3: raise ValueError( "Pythran does not fully support Python3, " "it can only be used to compile C++ code " "generated with the -E flag with a Python2 version of Pythran. " "Sorry about this :-/") pm = PassManager(module_name) # front end ir, renamings, docstrings = frontend.parse(pm, code) # middle-end optimizations = (optimizations or cfg.get('pythran', 'optimizations').split()) optimizations = [_parse_optimization(opt) for opt in optimizations] refine(pm, ir, optimizations) # back-end content = pm.dump(Cxx, ir) # instanciate the meta program if specs is None: class Generable(object): def __init__(self, content): self.content = content def __str__(self): return str(self.content) generate = __str__ mod = Generable(content) else: # uniform typing for fname, signatures in specs.items(): if not isinstance(signatures, tuple): specs[fname] = (signatures, ) # verify the pythran export are compatible with the code specs = expand_specs(specs) check_specs(ir, specs, renamings) specs_to_docstrings(specs, docstrings) metainfo = { 'hash': hashlib.sha256(code).hexdigest(), 'version': __version__, 'date': datetime.now() } mod = PythonModule(module_name, docstrings, metainfo) mod.add_to_preamble(Define("BOOST_SIMD_NO_STRICT_ALIASING", "1")) mod.add_to_includes( Include("pythonic/core.hpp"), Include("pythonic/python/core.hpp"), # FIXME: only include these when needed Include("pythonic/types/bool.hpp"), Include("pythonic/types/int.hpp"), Line("#ifdef _OPENMP\n#include <omp.h>\n#endif")) mod.add_to_includes( *[Include(inc) for inc in _extract_specs_dependencies(specs)]) mod.add_to_includes(*content.body) for function_name, signatures in specs.iteritems(): internal_func_name = renamings.get(function_name, function_name) # global variables are functions with no signatures :-) if not signatures: mod.add_global_var( function_name, "{}()()".format( pythran_ward + '{0}::{1}'.format(module_name, internal_func_name))) for sigid, signature in enumerate(signatures): numbered_function_name = "{0}{1}".format( internal_func_name, sigid) arguments_types = [pytype_to_ctype(t) for t in signature] has_arguments = HasArgument(internal_func_name).visit(ir) arguments = [ "a{0}".format(i) for i in xrange(len(arguments_types)) ] name_fmt = pythran_ward + "{0}::{1}::type{2}" args_list = ", ".join(arguments_types) specialized_fname = name_fmt.format( module_name, internal_func_name, "<{0}>".format(args_list) if has_arguments else "") result_type = "typename %s::result_type" % specialized_fname mod.add_function( FunctionBody( FunctionDeclaration( Value(result_type, numbered_function_name), [ Value(t, a) for t, a in zip(arguments_types, arguments) ]), Block([ Statement("return {0}()({1})".format( pythran_ward + '{0}::{1}'.format( module_name, internal_func_name), ', '.join(arguments))) ])), function_name, arguments_types) return mod
def generate_cxx(module_name, code, specs=None, optimizations=None): '''python + pythran spec -> c++ code returns a PythonModule object ''' pm = PassManager(module_name) # front end ir, renamings, docstrings = frontend.parse(pm, code) # middle-end optimizations = (optimizations or cfg.get('pythran', 'optimizations').split()) optimizations = [_parse_optimization(opt) for opt in optimizations] refine(pm, ir, optimizations) # type check types = tog.typecheck(ir) # back-end content = pm.dump(Cxx, ir) # instantiate the meta program if specs is None: class Generable(object): def __init__(self, content): self.content = content def __str__(self): return str(self.content) generate = __str__ mod = Generable(content) else: # uniform typing for fname, signatures in list(specs.items()): if not isinstance(signatures, tuple): specs[fname] = (signatures,) # verify the pythran export are compatible with the code specs = expand_specs(specs) check_specs(ir, specs, renamings, types) specs_to_docstrings(specs, docstrings) if isinstance(code, bytes): code_bytes = code else: code_bytes = code.encode('ascii', 'ignore') metainfo = {'hash': hashlib.sha256(code_bytes).hexdigest(), 'version': __version__, 'date': datetime.now()} mod = PythonModule(module_name, docstrings, metainfo) mod.add_to_preamble(Define("BOOST_SIMD_NO_STRICT_ALIASING", "1")) mod.add_to_includes( Include("pythonic/core.hpp"), Include("pythonic/python/core.hpp"), # FIXME: only include these when needed Include("pythonic/types/bool.hpp"), Include("pythonic/types/int.hpp"), Line("#ifdef _OPENMP\n#include <omp.h>\n#endif") ) mod.add_to_includes(*[Include(inc) for inc in _extract_specs_dependencies(specs)]) mod.add_to_includes(*content.body) mod.add_to_includes( Include("pythonic/python/exception_handler.hpp"), ) for function_name, signatures in specs.items(): internal_func_name = renamings.get(function_name, function_name) # global variables are functions with no signatures :-) if not signatures: mod.add_global_var(function_name, "{}()()".format( pythran_ward + '{0}::{1}'.format( module_name, internal_func_name))) for sigid, signature in enumerate(signatures): numbered_function_name = "{0}{1}".format(internal_func_name, sigid) arguments_types = [pytype_to_ctype(t) for t in signature] has_arguments = HasArgument(internal_func_name).visit(ir) arguments = ["a{0}".format(i) for i in range(len(arguments_types))] name_fmt = pythran_ward + "{0}::{1}::type{2}" args_list = ", ".join(arguments_types) specialized_fname = name_fmt.format(module_name, internal_func_name, "<{0}>".format(args_list) if has_arguments else "") result_type = "typename %s::result_type" % specialized_fname mod.add_function( FunctionBody( FunctionDeclaration( Value( result_type, numbered_function_name), [Value(t, a) for t, a in zip(arguments_types, arguments)]), Block([Statement(""" PyThreadState *_save = PyEval_SaveThread(); try {{ auto res = {0}()({1}); PyEval_RestoreThread(_save); return res; }} catch(...) {{ PyEval_RestoreThread(_save); throw; }} """.format( pythran_ward + '{0}::{1}'.format( module_name, internal_func_name), ', '.join(arguments)))]) ), function_name, arguments_types ) return mod
def visit_FunctionDef(self, node): class CachedTypeVisitor: class CachedType: def __init__(self, s): self.s = s def generate(self, _): return self.s def __init__(self, other=None): if other: self.cache = other.cache.copy() self.rcache = other.rcache.copy() self.mapping = other.mapping.copy() else: self.cache = dict() self.rcache = dict() self.mapping = dict() def __call__(self, node): if node not in self.mapping: t = node.generate(self) if t in self.rcache: self.mapping[node] = self.mapping[self.rcache[t]] self.cache[node] = self.cache[self.rcache[t]] else: self.rcache[t] = node self.mapping[node] = len(self.mapping) self.cache[node] = t return CachedTypeVisitor.CachedType("__type{0}".format( self.mapping[node])) def typedefs(self): l = sorted(self.mapping.items(), key=lambda x: x[1]) L = list() visited = set() # the same value must not be typedefed twice for k, v in l: if v not in visited: typename = "__type" + str(v) L.append(Typedef(Value(self.cache[k], typename))) visited.add(v) return L self.fname = node.name # prepare context and visit function body fargs = node.args.args formal_args = [arg.id for arg in fargs] formal_types = ["argument_type" + str(i) for i in range(len(fargs))] self.ldecls = set(self.passmanager.gather(LocalNodeDeclarations, node)) self.local_names = {sym.id: sym for sym in self.ldecls} self.local_names.update({arg.id: arg for arg in fargs}) self.extra_declarations = [] self.lctx = CachedTypeVisitor() # choose one node among all the ones with the same name for each name self.ldecls = set({n.id: n for n in self.ldecls}.values()) # 0 is used as initial_state, thus the +1 self.yields = { k: (1 + v, "yield_point{0}".format(1 + v)) for (v, k) in enumerate(self.passmanager.gather(YieldPoints, node)) } # gather body dump operator_body = [self.visit(stmt) for stmt in node.body] # compute arg dump default_arg_values = ([None] * (len(node.args.args) - len(node.args.defaults)) + [self.visit(n) for n in node.args.defaults]) default_arg_types = ([None] * (len(node.args.args) - len(node.args.defaults)) + [self.types[n] for n in node.args.defaults]) # compute type dump result_type = self.types[node][0] callable_type = Typedef(Value("void", "callable")) pure_type = (Typedef(Value("void", "pure")) if node in self.pure_expressions else EmptyStatement()) def make_function_declaration(rtype, name, ftypes, fargs, defaults=None, attributes=None): if defaults is None: defaults = [None] * len(ftypes) if attributes is None: attributes = [] arguments = list() for i, (t, a, d) in enumerate(zip(ftypes, fargs, defaults)): if self.yields: rvalue_ref = "" elif self.argument_effects[node][i]: rvalue_ref = "&&" else: rvalue_ref = " const &" argument = Value( t + rvalue_ref, "{0}{1}".format(a, "= {0}".format(d) if d else "")) arguments.append(argument) return FunctionDeclaration(Value(rtype, name), arguments, *attributes) def make_const_function_declaration(rtype, name, ftypes, fargs, defaults=None): return make_function_declaration(rtype, name, ftypes, fargs, defaults, ["const"]) if self.yields: # generator case # a generator has a call operator that returns the iterator next_name = "__generator__{0}".format(node.name) instanciated_next_name = "{0}{1}".format( next_name, "<{0}>".format(", ".join(formal_types)) if formal_types else "") operator_body.append( Statement("{0}: return result_type();".format( Cxx.final_statement))) next_declaration = [ FunctionDeclaration(Value("result_type", "next"), []), EmptyStatement() ] # empty statement to force a comma ... # the constructors next_constructors = [ FunctionBody(FunctionDeclaration(Value("", next_name), []), Line(': pythonic::yielder() {}')) ] if formal_types: # If all parameters have a default value, we don't need default # constructor if default_arg_values and all(default_arg_values): next_constructors = list() next_constructors.append( FunctionBody( make_function_declaration("", next_name, formal_types, formal_args, default_arg_values), Line(": {0} {{ }}".format(", ".join( ["pythonic::yielder()"] + ["{0}({0})".format(arg) for arg in formal_args]))))) next_iterator = [ FunctionBody( FunctionDeclaration(Value("void", "operator++"), []), Block([Statement("next()")])), FunctionBody( FunctionDeclaration( Value( "typename {0}::result_type".format( instanciated_next_name), "operator*"), [], "const"), Block([ReturnStatement(Cxx.generator_state_value)])), FunctionBody( FunctionDeclaration( Value( "pythonic::types::generator_iterator<{0}>".format( next_name), "begin"), []), Block([ Statement("next()"), ReturnStatement( "pythonic::types::generator_iterator<{0}>" "(*this)".format(next_name)) ])), FunctionBody( FunctionDeclaration( Value( "pythonic::types::generator_iterator<{0}>".format( next_name), "end"), []), Block([ ReturnStatement( "pythonic::types::generator_iterator<{0}>()". format(next_name)) ])) ] next_signature = templatize( FunctionDeclaration( Value( "typename {0}::result_type".format( instanciated_next_name), "{0}::next".format(instanciated_next_name)), []), formal_types) next_body = operator_body # the dispatch table at the entry point next_body.insert( 0, Statement("switch({0}) {{ {1} }}".format( Cxx.generator_state_holder, " ".join("case {0}: goto {1};".format(num, where) for (num, where) in sorted(self.yields.values(), key=lambda x: x[0]))))) ctx = CachedTypeVisitor(self.lctx) next_members = ([ Statement("{0} {1}".format(ft, fa)) for (ft, fa) in zip(formal_types, formal_args) ] + [ Statement("{0} {1}".format(self.types[k].generate(ctx), k.id)) for k in self.ldecls ] + [ Statement("{0} {1}".format(v, k)) for k, v in self.extra_declarations ] + [ Statement("typename {0}::result_type {1}".format( instanciated_next_name, Cxx.generator_state_value)) ]) extern_typedefs = [ Typedef(Value(t.generate(ctx), t.name)) for t in self.types[node][1] if not t.isweak() ] iterator_typedef = [ Typedef( Value( "pythonic::types::generator_iterator<{0}>".format( "{0}<{1}>".format(next_name, ", ".join( formal_types)) if formal_types else next_name), "iterator")), Typedef(Value(result_type.generate(ctx), "value_type")) ] result_typedef = [ Typedef(Value(result_type.generate(ctx), "result_type")) ] extra_typedefs = (ctx.typedefs() + extern_typedefs + iterator_typedef + result_typedef) next_struct = templatize( Struct( next_name, extra_typedefs + next_members + next_constructors + next_iterator + next_declaration, "pythonic::yielder"), formal_types) next_definition = FunctionBody(next_signature, Block(next_body)) operator_declaration = [ templatize( make_const_function_declaration(instanciated_next_name, "operator()", formal_types, formal_args, default_arg_values), formal_types, default_arg_types), EmptyStatement() ] operator_signature = make_const_function_declaration( instanciated_next_name, "{0}::operator()".format(node.name), formal_types, formal_args) operator_definition = FunctionBody( templatize(operator_signature, formal_types), Block([ ReturnStatement("{0}({1})".format(instanciated_next_name, ", ".join(formal_args))) ])) topstruct_type = templatize(Struct("type", extra_typedefs), formal_types) topstruct = Struct(node.name, [topstruct_type, callable_type, pure_type] + operator_declaration) self.declarations.append(next_struct) self.definitions.append(next_definition) else: # regular function case # a function has a call operator to be called # and a default constructor to create instances fscope = "type{0}::".format("<{0}>".format(", ".join(formal_types)) if formal_types else "") ffscope = "{0}::{1}".format(node.name, fscope) operator_declaration = [ templatize( make_const_function_declaration( "typename {0}result_type".format(fscope), "operator()", formal_types, formal_args, default_arg_values), formal_types, default_arg_types), EmptyStatement() ] operator_signature = make_const_function_declaration( "typename {0}result_type".format(ffscope), "{0}::operator()".format(node.name), formal_types, formal_args) ctx = CachedTypeVisitor(self.lctx) operator_local_declarations = ([ Statement("{0} {1}".format(self.types[k].generate(ctx), k.id)) for k in self.ldecls ] + [ Statement("{0} {1}".format(v, k)) for k, v in self.extra_declarations ]) dependent_typedefs = ctx.typedefs() operator_definition = FunctionBody( templatize(operator_signature, formal_types), Block(dependent_typedefs + operator_local_declarations + operator_body)) ctx = CachedTypeVisitor() extra_typedefs = ([ Typedef(Value(t.generate(ctx), t.name)) for t in self.types[node][1] if not t.isweak() ] + [Typedef(Value(result_type.generate(ctx), "result_type"))]) extra_typedefs = ctx.typedefs() + extra_typedefs return_declaration = [ templatize(Struct("type", extra_typedefs), formal_types, default_arg_types) ] topstruct = Struct(node.name, [callable_type, pure_type] + return_declaration + operator_declaration) self.declarations.append(topstruct) self.definitions.append(operator_definition) return EmptyStatement()
def generate_cxx(module_name, code, specs=None, optimizations=None): '''python + pythran spec -> c++ code returns a BoostPythonModule object ''' pm = PassManager(module_name) # front end ir, renamings = frontend.parse(pm, code) # middle-end optimizations = (optimizations or cfg.get('pythran', 'optimizations').split()) optimizations = map(_parse_optimization, optimizations) refine(pm, ir, optimizations) # back-end content = pm.dump(Cxx, ir) # instanciate the meta program if specs is None: class Generable: def __init__(self, content): self.content = content def __str__(self): return str(self.content) generate = __str__ mod = Generable(content) else: # uniform typing for fname, signatures in specs.items(): if not isinstance(signatures, tuple): specs[fname] = (signatures,) # verify the pythran export are compatible with the code specs = expand_specs(specs) check_specs(ir, specs, renamings) mod = BoostPythonModule(module_name) mod.use_private_namespace = False # very low value for max_arity leads to various bugs min_val = 2 specs_max = [max(map(len, s)) for s in specs.itervalues()] max_arity = max([min_val] + specs_max) mod.add_to_preamble([Define("BOOST_PYTHON_MAX_ARITY", max_arity)]) mod.add_to_preamble([Define("BOOST_SIMD_NO_STRICT_ALIASING", "1")]) mod.add_to_preamble([Include("pythonic/core.hpp")]) mod.add_to_preamble([Include("pythonic/python/core.hpp")]) mod.add_to_preamble([Line("#ifdef _OPENMP\n#include <omp.h>\n#endif")]) mod.add_to_preamble(map(Include, _extract_specs_dependencies(specs))) mod.add_to_preamble(content.body) mod.add_to_init([ Line('#ifdef PYTHONIC_TYPES_NDARRAY_HPP\nimport_array()\n#endif')]) # topologically sorted exceptions based on the inheritance hierarchy. # needed because otherwise boost python register_exception handlers # do not catch exception type in the right way # (first valid exception is selected) # Inheritance has to be taken into account in the registration order. exceptions = nx.DiGraph() for function_name, v in functions.iteritems(): for mname, symbol in v: if isinstance(symbol, ConstExceptionIntr): exceptions.add_node( getattr(sys.modules[".".join(mname)], function_name)) # add edges based on class relationships for n in exceptions: if n.__base__ in exceptions: exceptions.add_edge(n.__base__, n) sorted_exceptions = nx.topological_sort(exceptions) mod.add_to_init([ # register exception only if they can be raise from C++ world to # Python world. Preprocessors variables are set only if deps # analysis detect that this exception can be raised Line('#ifdef PYTHONIC_BUILTIN_%s_HPP\n' 'boost::python::register_exception_translator<' 'pythonic::types::%s>(&pythonic::translate_%s);\n' '#endif' % (n.__name__.upper(), n.__name__, n.__name__) ) for n in sorted_exceptions]) mod.add_to_init([ # make sure we get no nested parallelism that wreaks havoc in perf Line('#ifdef _OPENMP\n' 'omp_set_max_active_levels(1);\n' '#endif')]) for function_name, signatures in specs.iteritems(): internal_func_name = renamings.get(function_name, function_name) for sigid, signature in enumerate(signatures): numbered_function_name = "{0}{1}".format(internal_func_name, sigid) arguments_types = [pytype_to_ctype(t) for t in signature] has_arguments = HasArgument(internal_func_name).visit(ir) arguments = ["a{0}".format(i) for i in xrange(len(arguments_types))] name_fmt = pythran_ward + "{0}::{1}::type{2}" args_list = ", ".join(arguments_types) specialized_fname = name_fmt.format(module_name, internal_func_name, "<{0}>".format(args_list) if has_arguments else "") result_type = ("typename std::remove_cv<" "typename std::remove_reference" "<typename {0}::result_type>::type" ">::type").format(specialized_fname) mod.add_to_init( [Statement("pythonic::python_to_pythran<{0}>()".format(t)) for t in _extract_all_constructed_types(signature)]) mod.add_to_init([Statement( "pythonic::pythran_to_python<{0}>()".format(result_type))]) mod.add_function( FunctionBody( FunctionDeclaration( Value( result_type, numbered_function_name), [Value(t, a) for t, a in zip(arguments_types, arguments)]), Block([Statement("return {0}()({1})".format( pythran_ward + '{0}::{1}'.format( module_name, internal_func_name), ', '.join(arguments)))]) ), function_name ) # call __init__() to execute top-level statements init_call = '::'.join([pythran_ward + module_name, '__init__()()']) mod.add_to_init([Statement(init_call)]) return mod