def setup(self):
self.lit_int = pyf.Parameter("lit_int",
dtype=pyf.default_integer,
expr="30-10")
self.sik = pyf.Parameter("sik_10",
dtype=pyf.default_integer,
expr="selected_int_kind(10)")
self.srk = pyf.Parameter("srk_10_20",
dtype=pyf.default_integer,
expr="selected_real_kind(10, lit_int)")
srk_real = pyf.RealType("srk_10_20", kind="srk_10_20")
self.real_arg = pyf.Argument("real_arg",
dtype=srk_real,
intent='inout')
sik_int = pyf.IntegerType("sik_10", kind="sik_10")
self.int_arg = pyf.Argument("int_arg",
dtype=sik_int,
dimension=[("lit_int", )])
subr = pyf.Subroutine(name="subr",
args=[self.real_arg, self.int_arg],
params=[self.lit_int, self.sik, self.srk])
self.ret_arg = pyf.Argument("func", dtype=srk_real)
func = pyf.Function(name="func",
args=[self.real_arg, self.int_arg],
params=[self.lit_int, self.sik, self.srk],
return_arg=self.ret_arg)
self.args = [self.real_arg, self.int_arg]
self.params = [self.lit_int, self.sik, self.srk]
def test_generate_fc_h():
return_arg = pyf.Argument(name="two_arg", dtype=pyf.default_real)
two_arg_func = pyf.Function(name='two_arg',
args=[
pyf.Argument(name='a',
dtype=pyf.default_integer,
intent='in'),
pyf.Argument(name='b',
dtype=pyf.default_integer,
intent='in'),
pyf.Argument(name='c',
dtype=pyf.default_integer,
intent='in'),
pyf.Argument(name='d',
dtype=pyf.default_integer,
intent='in'),
],
return_arg=return_arg)
ta_wrp = fc_wrap.FunctionWrapper(wrapped=two_arg_func)
ast = [ta_wrp]
buf = CodeBuffer()
header_name = 'foobar'
fc_wrap.generate_fc_h(ast, header_name, buf)
code = '''\
#include "foobar"
void two_arg_c(fwr_real_t *, fwi_integer_t *, fwi_integer_t *, fwi_integer_t *, fwi_integer_t *, fwi_integer_t *, fw_character_t *);
'''
compare(buf.getvalue(), code)
def test_empty_ret(self):
int_args_in = [
pyf.Argument('a1', pyf.default_integer, 'in'),
pyf.Argument('a2', pyf.default_integer, 'in')
]
subr = pyf.Subroutine(name='dummy', args=int_args_in)
fc_wrapper = fc_wrap.SubroutineWrapper(wrapped=subr)
cy_wrapper = cy_wrap.ProcWrapper(wrapped=fc_wrapper)
eq_(cy_wrapper.return_tuple(), '')
def test_func_return_array():
args = [
pyf.Argument(name='a', dtype=pyf.default_integer, intent='in'),
pyf.Argument(name='b', dtype=pyf.default_integer, intent='in')
]
return_arg = pyf.Argument(name="arr_fun",
dtype=pyf.default_real,
dimension=('a', 'b'))
arrfun = pyf.Function(name="arr_fun", args=args, return_arg=return_arg)
def test_array_dstring(self):
real_in = pyf.Argument("real_in",
pyf.default_real,
"in",
dimension=[":", ":"])
complex_out = pyf.Argument("cpx_out",
pyf.default_complex,
'out',
dimension=["n1:n2+n3"])
logical_inout = pyf.Argument("lgcl_inout",
pyf.default_logical,
'inout',
dimension=["n1:n2", "*"])
character_inout = pyf.Argument("char_inout",
pyf.CharacterType("char", len='*'),
'inout',
dimension=[":", ":"])
int_ = pyf.Argument('int_arg',
pyf.default_integer,
dimension=[":"] * 7)
args = [real_in, complex_out, logical_inout, int_, character_inout]
fcargs = [fc_wrap.ArgWrapperFactory(arg) for arg in args]
cyargs = [cy_wrap.CyArrayArgWrapper(arg) for arg in fcargs]
cy_real, cy_cpx, cy_log, cy_int, cy_char = cyargs
real_str = ["real_in : fwr_real, 2D array, dimension(:, :), intent in"]
eq_(cy_real.in_dstring(), real_str)
eq_(cy_real.out_dstring(), [])
cpx_str = [
"cpx_out : fwc_complex, 1D array, dimension(n1:n2+n3), intent out"
]
eq_(cy_cpx.in_dstring(), cpx_str)
eq_(cy_cpx.out_dstring(), cpx_str)
log_str = [
"lgcl_inout : fwl_logical, "
"2D array, dimension(n1:n2, *), intent inout"
]
eq_(cy_log.in_dstring(), log_str)
eq_(cy_log.out_dstring(), log_str)
int_str = [
"int_arg : fwi_integer, "
"7D array, dimension(:, :, :, :, :, :, :)"
]
eq_(cy_int.in_dstring(), int_str)
eq_(cy_int.out_dstring(), int_str)
char_str = [
"char_inout : fw_char, len *, 2D array, dimension(:, :), intent inout"
]
eq_(cy_char.in_dstring(), char_str)
eq_(cy_char.out_dstring(), char_str)
def setup(self):
dlgcl = pyf.default_logical
dint = pyf.IntegerType(fw_ktp='int')
self.lgcl1 = pyf.Argument(name='lgcl1', dtype=dlgcl, intent='inout')
self.lgcl2 = pyf.Argument(name='lgcl2', dtype=dlgcl, intent='inout')
self.intarg = pyf.Argument(name='int', dtype=dint, intent='inout')
self.args = [self.lgcl1, self.lgcl2, self.intarg]
self.l1wrap = fc_wrap.LogicalWrapper(self.lgcl1)
self.l2wrap = fc_wrap.LogicalWrapper(self.lgcl2)
subr = pyf.Subroutine('foo', args=self.args)
self.am = fc_wrap.ArgWrapperManager(subr)
def setup(self):
arg1 = pyf.Argument('array',
dtype=pyf.default_real,
dimension=[':'] * 3,
intent='in')
arg2 = pyf.Argument('int_array',
dtype=pyf.default_integer,
dimension=[':'] * 1,
intent='inout')
fc_arg = fc_wrap.ArrayArgWrapper(arg1)
self.cy_arg = cy_wrap.CyArrayArgWrapper(fc_arg)
self.cy_int_arg = cy_wrap.CyArrayArgWrapper(
fc_wrap.ArrayArgWrapper(arg2))
def _set_extern_args(self):
self._arr_dims = []
self.ndims = len(self.orig_arg.dimension)
for idx in range(self.ndims):
self._arr_dims.append(
pyf.Argument(name='%s_d%d' % (self.name, idx + 1),
dtype=pyf.dim_dtype,
intent='in'))
dim_names = [dim.name for dim in self._arr_dims]
self.extern_arg = pyf.Argument(name=self.name,
dtype=self.dtype,
intent=self.intent,
dimension=dim_names)
self.extern_args = self._arr_dims + [self.extern_arg]
def test_c_proto_args(self):
args = [
pyf.Argument(name='int_arg',
dtype=pyf.default_integer,
intent='in'),
pyf.Argument(name='real_arg', dtype=pyf.default_real, intent='out')
]
return_arg = pyf.Argument(name='fname', dtype=pyf.default_real)
func = pyf.Function('foo', args=args, return_arg=return_arg)
arg_man = fc_wrap.ArgWrapperManager(func)
eq_(arg_man.c_proto_args(), [
'fwr_real_t *', 'fwi_integer_t *', 'fwr_real_t *',
'fwi_integer_t *', 'fw_character_t *'
])
def test_declaration_order(self):
array_arg = pyf.Argument('arr',
pyf.default_integer,
'in',
dimension=('d1', 'd2'))
d1 = pyf.Argument('d1', pyf.default_integer, 'in')
d2 = pyf.Argument('d2', pyf.default_integer, 'in')
am = pyf.ArgManager([array_arg, d2, d1])
decls = '''\
integer(kind=fwi_integer_t), intent(in) :: d2
integer(kind=fwi_integer_t), intent(in) :: d1
integer(kind=fwi_integer_t), dimension(d1, d2), intent(in) :: arr
'''
eq_(am.arg_declarations(), decls.splitlines())
def setup(self):
dint = pyf.IntegerType('fwi_int')
dlgcl = pyf.default_logical
self.int_arg = pyf.Argument(name='int', dtype=dint, intent='inout')
self.int_arg_wrap = fc_wrap.ArgWrapperFactory(self.int_arg)
self.lgcl_arg = pyf.Argument(name='lgcl', dtype=dlgcl, intent='inout')
self.lgcl_arg_wrap = fc_wrap.ArgWrapperFactory(self.lgcl_arg)
self.lgcl_arg_in = pyf.Argument(name='lgcl_in',
dtype=dlgcl,
intent='in')
self.lgcl_arg_in_wrap = fc_wrap.ArgWrapperFactory(self.lgcl_arg_in)
def setup(self):
arg1d = pyf.Argument('charr1',
dtype=pyf.CharacterType(fw_ktp='charr_x8',
len='20'),
dimension=[':'],
intent='inout')
arg2d = pyf.Argument('charr2',
dtype=pyf.CharacterType(fw_ktp='charr_x30',
len='30'),
dimension=[':'] * 2,
intent='inout')
fc_arg1d = fc_wrap.ArrayArgWrapper(arg1d)
fc_arg2d = fc_wrap.ArrayArgWrapper(arg2d)
self.cy_arg1d = cy_wrap.CyCharArrayArgWrapper(fc_arg1d)
self.cy_arg2d = cy_wrap.CyCharArrayArgWrapper(fc_arg2d)
def setup(self):
dlgcl = pyf.default_logical
dint = pyf.IntegerType(fw_ktp='int')
self.lgcl = pyf.Argument(name='ll',
dtype=dlgcl,
intent='out',
is_return_arg=True)
self.int = pyf.Argument(name='int',
dtype=dint,
intent='out',
is_return_arg=True)
subr = pyf.Subroutine('foo', args=[self.lgcl])
self.am_lgcl = fc_wrap.ArgWrapperManager(subr)
subr = pyf.Subroutine('foo', args=[self.int])
self.am_int = fc_wrap.ArgWrapperManager(subr)
def setup(self):
int_arg_inout = pyf.Argument("int_arg_inout", pyf.default_integer,
'inout')
int_arg = pyf.Argument("int_arg", pyf.default_integer)
int_array = pyf.Argument("int_array",
pyf.default_integer,
intent="out",
dimension=[':', ':'])
return_arg = pyf.Argument(name="dstring_func",
dtype=pyf.default_integer)
func = pyf.Function(name="dstring_func",
args=[int_arg_inout, int_arg, int_array],
return_arg=return_arg)
fcw = fc_wrap.FunctionWrapper(wrapped=func)
self.cyw = cy_wrap.ProcWrapper(wrapped=fcw)
def test_gen_fortran_one_arg_func():
one_arg = pyf.Subroutine(
name='one_arg',
args=[pyf.Argument(name='a', dtype=pyf.default_integer, intent="in")])
one_arg_wrapped = fc_wrap.SubroutineWrapper(wrapped=one_arg)
buf = CodeBuffer()
one_arg_wrapped.generate_wrapper(buf)
fort_file = '''\
subroutine one_arg_c(a, fw_iserr__, fw_errstr__) bind(c, name="one_arg_c")
use fwrap_ktp_mod
implicit none
integer(kind=fwi_integer_t), intent(in) :: a
integer(kind=fwi_integer_t), intent(out) :: fw_iserr__
character(kind=fw_character_t, len=1), dimension(fw_errstr_len) :: fw_errstr__
interface
subroutine one_arg(a)
use fwrap_ktp_mod
implicit none
integer(kind=fwi_integer_t), intent(in) :: a
end subroutine one_arg
end interface
fw_iserr__ = FW_INIT_ERR__
call one_arg(a)
fw_iserr__ = FW_NO_ERR__
end subroutine one_arg_c
'''
compare(fort_file, buf.getvalue())
def test_function(self):
return_arg = pyf.Argument('fort_function', dtype=pyf.default_integer)
ffun = pyf.Function(name="fort_function",
args=(),
return_arg=return_arg)
ok_(ffun.name == 'fort_function')
ok_(ffun.return_arg.dtype is pyf.default_integer)
def test_logical_wrapper():
args = [
pyf.Argument(name='lgcl',
dtype=pyf.LogicalType(fw_ktp='lgcl_ktp'),
intent="inout")
]
lgcl_arg = pyf.Subroutine(name='lgcl_arg', args=args)
lgcl_arg_wrapped = fc_wrap.SubroutineWrapper(wrapped=lgcl_arg)
buf = CodeBuffer()
lgcl_arg_wrapped.generate_wrapper(buf)
fort_file = '''\
subroutine lgcl_arg_c(lgcl, fw_iserr__, fw_errstr__) bind(c, name="lgcl_arg_c")
use fwrap_ktp_mod
implicit none
type(c_ptr), value :: lgcl
integer(kind=fwi_integer_t), intent(out) :: fw_iserr__
character(kind=fw_character_t, len=1), dimension(fw_errstr_len) :: fw_errstr__
interface
subroutine lgcl_arg(lgcl)
use fwrap_ktp_mod
implicit none
logical(kind=fwl_lgcl_ktp_t), intent(inout) :: lgcl
end subroutine lgcl_arg
end interface
logical(kind=fwl_lgcl_ktp_t), pointer :: fw_lgcl
fw_iserr__ = FW_INIT_ERR__
call c_f_pointer(lgcl, fw_lgcl)
call lgcl_arg(fw_lgcl)
fw_iserr__ = FW_NO_ERR__
end subroutine lgcl_arg_c
'''
compare(fort_file, buf.getvalue())
def test_gen_empty_func_wrapper():
return_arg = pyf.Argument("empty_func", dtype=pyf.default_integer)
empty_func = pyf.Function(name='empty_func',
args=(),
return_arg=return_arg)
empty_func_wrapper = fc_wrap.FunctionWrapper(wrapped=empty_func)
empty_func_wrapped = '''\
subroutine empty_func_c(fw_ret_arg, fw_iserr__, fw_errstr__) bind(c, name="empty_func_c")
use fwrap_ktp_mod
implicit none
integer(kind=fwi_integer_t), intent(out) :: fw_ret_arg
integer(kind=fwi_integer_t), intent(out) :: fw_iserr__
character(kind=fw_character_t, len=1), dimension(fw_errstr_len) :: fw_errstr__
interface
function empty_func()
use fwrap_ktp_mod
implicit none
integer(kind=fwi_integer_t) :: empty_func
end function empty_func
end interface
fw_iserr__ = FW_INIT_ERR__
fw_ret_arg = empty_func()
fw_iserr__ = FW_NO_ERR__
end subroutine empty_func_c
'''
buf = CodeBuffer()
empty_func_wrapper.generate_wrapper(buf)
compare(empty_func_wrapped, buf.getvalue())
def test_logical_function():
return_arg = pyf.Argument('lgcl_fun', dtype=pyf.LogicalType(fw_ktp='lgcl'))
lgcl_fun = pyf.Function(name='lgcl_fun', args=[], return_arg=return_arg)
lgcl_fun_wrapped = fc_wrap.FunctionWrapper(wrapped=lgcl_fun)
buf = CodeBuffer()
lgcl_fun_wrapped.generate_wrapper(buf)
fort_file = '''\
subroutine lgcl_fun_c(fw_ret_arg, fw_iserr__, fw_errstr__) bind(c, name="lgcl_fun_c")
use fwrap_ktp_mod
implicit none
type(c_ptr), value :: fw_ret_arg
integer(kind=fwi_integer_t), intent(out) :: fw_iserr__
character(kind=fw_character_t, len=1), dimension(fw_errstr_len) :: fw_errstr__
interface
function lgcl_fun()
use fwrap_ktp_mod
implicit none
logical(kind=fwl_lgcl_t) :: lgcl_fun
end function lgcl_fun
end interface
logical(kind=fwl_lgcl_t), pointer :: fw_fw_ret_arg
fw_iserr__ = FW_INIT_ERR__
call c_f_pointer(fw_ret_arg, fw_fw_ret_arg)
fw_fw_ret_arg = lgcl_fun()
fw_iserr__ = FW_NO_ERR__
end subroutine lgcl_fun_c
'''
compare(fort_file, buf.getvalue())
def test_assumed_shape_int_array():
arr_arg = pyf.Subroutine(name='arr_arg',
args=[
pyf.Argument(name='arr',
dtype=pyf.default_integer,
dimension=(':', ':'),
intent="inout")
])
arr_arg_wrapped = fc_wrap.SubroutineWrapper(wrapped=arr_arg)
buf = CodeBuffer()
arr_arg_wrapped.generate_wrapper(buf)
fort_file = '''\
subroutine arr_arg_c(arr_d1, arr_d2, arr, fw_iserr__, fw_errstr__) bind(c, name="arr_arg_c")
use fwrap_ktp_mod
implicit none
integer(kind=fwi_npy_intp_t), intent(in) :: arr_d1
integer(kind=fwi_npy_intp_t), intent(in) :: arr_d2
integer(kind=fwi_integer_t), dimension(arr_d1, arr_d2), intent(inout) :: arr
integer(kind=fwi_integer_t), intent(out) :: fw_iserr__
character(kind=fw_character_t, len=1), dimension(fw_errstr_len) :: fw_errstr__
interface
subroutine arr_arg(arr)
use fwrap_ktp_mod
implicit none
integer(kind=fwi_integer_t), dimension(:, :), intent(inout) :: arr
end subroutine arr_arg
end interface
fw_iserr__ = FW_INIT_ERR__
call arr_arg(arr)
fw_iserr__ = FW_NO_ERR__
end subroutine arr_arg_c
'''
compare(fort_file, buf.getvalue())
def _get_arg(p_arg):
p_typedecl = p_arg.get_typedecl()
dtype = _get_dtype(p_typedecl)
name = p_arg.name
intent = _get_intent(p_arg)
if p_arg.is_scalar():
return pyf.Argument(name=name, dtype=dtype, intent=intent)
elif p_arg.is_array():
p_dims = p_arg.get_array_spec()
dimspec = pyf.Dimension(p_dims)
return pyf.Argument(name=name,
dtype=dtype,
intent=intent,
dimension=dimspec)
else:
raise RuntimeError("argument %s is neither "
"a scalar or an array (derived type?)" % p_arg)
def test_parameter():
param = pyf.Parameter(name='FOO',
dtype=pyf.default_integer,
expr='kind(1.0D0)')
arg = pyf.Argument(name="fooarg",
dtype=pyf.RealType("foo_real", kind="FOO"),
intent="inout")
subr = pyf.Subroutine(name="foosubr", args=[arg], params=[param])
def __init__(self, proc):
self.proc = proc
self.isfunction = (proc.kind == 'function')
self.ret_arg = None
if self.isfunction:
ra = pyf.Argument(name=FunctionWrapper.RETURN_ARG_NAME,
dtype=proc.return_arg.dtype,
intent='out')
self._orig_args = [ra] + list(proc.args)
else:
self._orig_args = list(proc.args)
self.arg_wrappers = None
self.errflag = pyf.Argument(name=constants.ERR_NAME,
dtype=pyf.default_integer,
intent='out')
self.errstr = ErrStrArgWrapper()
self._gen_wrappers()
def test_explicit_shape_int_array():
args = [
pyf.Argument(name='arr',
dtype=pyf.default_integer,
dimension=('d1', 'd2'),
intent="inout"),
pyf.Argument(name='d1', dtype=pyf.default_integer, intent='in'),
pyf.Argument(name='d2', dtype=pyf.default_integer, intent='in')
]
arr_arg = pyf.Subroutine(name='arr_arg', args=args)
arr_arg_wrapped = fc_wrap.SubroutineWrapper(wrapped=arr_arg)
buf = CodeBuffer()
arr_arg_wrapped.generate_wrapper(buf)
fort_file = '''\
subroutine arr_arg_c(arr_d1, arr_d2, arr, d1, d2, fw_iserr__, fw_errstr__) bind(c, name="arr_arg_c")
use fwrap_ktp_mod
implicit none
integer(kind=fwi_npy_intp_t), intent(in) :: arr_d1
integer(kind=fwi_npy_intp_t), intent(in) :: arr_d2
integer(kind=fwi_integer_t), dimension(arr_d1, arr_d2), intent(inout) :: arr
integer(kind=fwi_integer_t), intent(in) :: d1
integer(kind=fwi_integer_t), intent(in) :: d2
integer(kind=fwi_integer_t), intent(out) :: fw_iserr__
character(kind=fw_character_t, len=1), dimension(fw_errstr_len) :: fw_errstr__
interface
subroutine arr_arg(arr, d1, d2)
use fwrap_ktp_mod
implicit none
integer(kind=fwi_integer_t), intent(in) :: d1
integer(kind=fwi_integer_t), intent(in) :: d2
integer(kind=fwi_integer_t), dimension(d1, d2), intent(inout) :: arr
end subroutine arr_arg
end interface
fw_iserr__ = FW_INIT_ERR__
if ((d1) .ne. (arr_d1) .or. (d2) .ne. (arr_d2)) then
fw_iserr__ = FW_ARR_DIM__
fw_errstr__ = transfer("arr ", fw_errstr__)
fw_errstr__(fw_errstr_len) = C_NULL_CHAR
return
endif
call arr_arg(arr, d1, d2)
fw_iserr__ = FW_NO_ERR__
end subroutine arr_arg_c
'''
compare(fort_file, buf.getvalue())
def setup(self):
intents = ('in', 'inout', 'out', None)
self.args = [
fc_wrap.ArgWrapperFactory(
pyf.Argument(name='larg',
dtype=pyf.default_logical,
intent=intent)) for intent in intents
]
self.arg_dict = dict(zip(intents, self.args))
def __init__(self):
self.arg = pyf.Argument(name=constants.ERRSTR_NAME,
dtype=pyf.default_character,
dimension=[constants.ERRSTR_LEN])
self.dtype = self.arg.dtype
self.name = self.arg.name
self.intern_name = self.arg.name
self.ktp = self.arg.ktp
self.intent = None
def setup(self):
self.real_arr_arg = pyf.Argument('real_arr_arg',
pyf.default_real,
dimension=(':', ':', ':'),
intent='out')
self.int_arr_arg = pyf.Argument('arr_arg',
pyf.default_integer,
dimension=(':', ':'),
intent='inout')
self.int_arr_wrapper = fc_wrap.ArrayArgWrapper(self.int_arr_arg)
self.real_arr_wrapper = fc_wrap.ArrayArgWrapper(self.real_arr_arg)
self.real_explicit_arg = pyf.Argument('real_exp_arg',
pyf.default_real,
dimension=('d1', 'd2', 'd3'),
intent='inout')
self.real_explicit_wrapper = fc_wrap.ArrayArgWrapper(
self.real_explicit_arg)
def test_parse(self):
ast = fwrapper.parse(self.source_file_lst)
return_arg = pyf.Argument('empty_func', dtype=pyf.default_integer)
empty_func = pyf.Function(name='empty_func',
args=(),
return_arg=return_arg)
eq_(ast[0].name, empty_func.name)
eq_(ast[0].return_arg.name, empty_func.return_arg.name)
eq_(len(ast[0].args), len(empty_func.args))
def setup(self):
int_arg_in = pyf.Argument("int_arg_in", pyf.default_integer, 'in')
int_arg_inout = pyf.Argument("int_arg_inout", pyf.default_integer,
'inout')
int_arg_out = pyf.Argument("int_arg_out", pyf.default_integer, 'out')
real_arg = pyf.Argument("real_arg", pyf.default_real)
all_args = [int_arg_in, int_arg_inout, int_arg_out, real_arg]
return_arg = pyf.Argument(name="fort_func", dtype=pyf.default_integer)
pyf_func = pyf.Function(name="fort_func",
args=all_args,
return_arg=return_arg)
func_wrapper = fc_wrap.FunctionWrapper(wrapped=pyf_func)
self.cy_func_wrapper = cy_wrap.ProcWrapper(wrapped=func_wrapper)
pyf_subr = pyf.Subroutine(name="fort_subr", args=all_args)
subr_wrapper = fc_wrap.SubroutineWrapper(wrapped=pyf_subr)
self.cy_subr_wrapper = cy_wrap.ProcWrapper(wrapped=subr_wrapper)
def setup(self):
self.dts = ("default_integer", "default_real")
self.cy_args = []
for dt in self.dts:
arg = pyf.Argument('foo_%s' % dt,
dtype=getattr(pyf, dt),
intent='in')
fwarg = fc_wrap.ArgWrapper(arg)
self.cy_args.append(cy_wrap.CyArgWrapper(fwarg))
self.mgr = cy_wrap.CyArgWrapperManager(args=self.cy_args)
