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