def test_builder_module1(): integer = make_type_integer() unit = make_translation_unit() m = translation_unit_make_module(unit, "mod1") f = scope_add_function(unit.global_scope, "f", args=["a", "b"], return_var="c") a, b = f.args a.intent = "in" a.type = integer b.intent = "in" b.type = integer c = f.return_var c.type = integer d = function_make_var(f, name="d", type=integer) f.body.extend([ asr.Assignment(d, asr.Num(n=5, type=integer)), asr.Assignment( c, asr.BinOp(d, asr.Mul(), asr.BinOp(a, asr.Add(), b, integer), integer)) ]) a = asr.Variable(name="a", intent="in", type=integer) b = asr.Variable(name="b", intent="in", type=integer) c = asr.Variable(name="c", type=integer) f = scope_add_function(m.symtab, name="g", args=[a, b], return_var=c) verify_asr(unit) a = asr_to_ast.asr_to_ast(unit) s = ast_to_src(a) # Check that the generated source code contains a few "key" parts, which # are reasonably robust against changes in the way the source code is # generated from ASR. def has(s, a): assert s.find(a) > 0 has(s, "function f(a, b)") has(s, "d = 5\n") has(s, "(a + b)") has(s, "interface\n") has(s, "function g(a, b)")
def visit_Variable(self, node): if self._lookup == 1: return self._scope.resolve(node.name) elif self._lookup == 2: v = self._scope.resolve(node.name, raise_exception=False) if v: return v name = self.visit_object(node.name) intent = self.visit_object(node.intent) dummy = self.visit_object(node.dummy) type = self.visit(node.type) return asr.Variable(name=name, intent=intent, dummy=dummy, type=type)
def process_function(scope, node): types = process_type(node.type) arg_names = [] for arg in node.get_arguments(): arg_names.append(arg.spelling) type = make_type_integer() return_var = asr.Variable(name=node.spelling, type=type) f = scope_add_function(scope, node.spelling, args=arg_names, return_var=return_var) for a in f.args: a.intent = "in" f.bind = asr.Bind(lang="c", name=node.spelling)
def convert_function(symtab, table, f): assert isinstance(f, Procedure) assert isinstance(f.name, str) assert isinstance(f.type, str) return_var = asr.Variable(name=f.name, type=string_to_type(f.type)) lf = scope_add_function(symtab, f.name, return_var=return_var) args = [] for arg in f.args: assert isinstance(arg, VarIdx) larg = convert_arg(table, lf.symtab, arg.idx) scope_add_symbol(lf.symtab, larg) args.append(larg) lf.args = args
def convert_arg(table, lscope, idx): arg = table[idx] assert isinstance(arg.name, str) assert isinstance(arg.type, str) a = asr.Variable(name=arg.name, type=string_to_type(arg.type), dummy=True) assert isinstance(arg.intent, str) a.intent = arg.intent if arg.bounds: dims = [] for bound in arg.bounds: lb, ub = bound if lb: lb = tofortran_bound(table, lscope, lb) if ub: ub = tofortran_bound(table, lscope, ub) dims.append(asr.dimension(lb, ub)) a.type.dims = dims return a
def visit_Function(self, node): name = self.visit_object(node.name) symtab = self.visit_object(node.symtab) self._lookup = 1 self._scope = symtab args = self.visit_sequence(node.args) body = self.visit_sequence(node.body) self._lookup = 0 if node.bind: bind = self.visit(node.bind) else: bind = None tmp = asr.Variable(name="a", type=make_type_integer()) f = asr.Function(name=name, args=args, body=body, bind=bind, symtab=symtab, return_var=tmp) return_var = function_make_var(f, name="r", type=self.visit(node.return_var.type)) return_var.dummy = True f.return_var = return_var cname = node.name + "_c_wrapper" mangled_name = '__' + self._modname + '_MOD_' + node.name.lower() bind = asr.Bind(lang="c", name=mangled_name) cargs = [] args2 = [] type1 = make_type_integer() type1.dims = [asr.dimension(asr.Num(n=1, type=make_type_integer()))] type2 = make_type_integer() type2.dims = [ asr.dimension(asr.Num(n=1, type=make_type_integer())), asr.dimension(asr.Num(n=1, type=make_type_integer())) ] c_desc1 = scope_add_function( symtab, "c_desc1_int32", args=[asr.Variable(name="A", intent="in", type=type1)], return_var=asr.Variable(name="c_desc1_int32", type=asr.Derived(name="c_desc1_t")), module="gfort_interop") c_desc2 = scope_add_function( symtab, "c_desc2_int32", args=[asr.Variable(name="A", intent="in", type=type2)], return_var=asr.Variable(name="c_desc2_int32", type=asr.Derived(name="c_desc2_t")), module="gfort_interop") for arg in node.args: type = self.visit(arg.type) if array_is_assumed_shape(type): if len(type.dims) == 1: dname = "c_desc1_t" fname = c_desc1 elif len(type.dims) == 2: dname = "c_desc2_t" fname = c_desc2 else: raise NotImplementedError("Too many dimensions") type = asr.Derived(name=dname, module="gfort_interop") args2.append( asr.FuncCall(func=fname, args=[arg], keywords=[], type=type)) else: args2.append(arg) cargs.append( asr.Variable( name=arg.name, intent=arg.intent, type=type, )) fw = scope_add_function(symtab, cname, args=cargs, return_var=cname) fw.bind = bind body = [ asr.Assignment( return_var, asr.FuncCall(func=fw, args=args2, keywords=[], type=fw.return_var.type)) ] f.body = body return f