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)