PKZ%~abstract_interface/foo.f90nu[module ops_module abstract interface subroutine op(x, y, z) integer, intent(in) :: x, y integer, intent(out) :: z end subroutine end interface contains subroutine foo(x, y, r1, r2) integer, intent(in) :: x, y integer, intent(out) :: r1, r2 procedure (op) add1, add2 procedure (op), pointer::p p=>add1 call p(x, y, r1) p=>add2 call p(x, y, r2) end subroutine end module subroutine add1(x, y, z) integer, intent(in) :: x, y integer, intent(out) :: z z = x + y end subroutine subroutine add2(x, y, z) integer, intent(in) :: x, y integer, intent(out) :: z z = x + 2 * y end subroutine PKZ!ii"abstract_interface/gh18403_mod.f90nu[module test abstract interface subroutine foo() end subroutine end interface end module test PKZ L:array_from_pyobj/wrapmodule.cnu[/* * This file was auto-generated with f2py (version:2_1330) and hand edited by * Pearu for testing purposes. Do not edit this file unless you know what you * are doing!!! */ #ifdef __cplusplus extern "C" { #endif /*********************** See f2py2e/cfuncs.py: includes ***********************/ #define PY_SSIZE_T_CLEAN #include #include "fortranobject.h" #include static PyObject *wrap_error; static PyObject *wrap_module; /************************************ call ************************************/ static char doc_f2py_rout_wrap_call[] = "\ Function signature:\n\ arr = call(type_num,dims,intent,obj)\n\ Required arguments:\n" " type_num : input int\n" " dims : input int-sequence\n" " intent : input int\n" " obj : input python object\n" "Return objects:\n" " arr : array"; static PyObject *f2py_rout_wrap_call(PyObject *capi_self, PyObject *capi_args) { PyObject * volatile capi_buildvalue = NULL; int type_num = 0; int elsize = 0; npy_intp *dims = NULL; PyObject *dims_capi = Py_None; int rank = 0; int intent = 0; PyArrayObject *capi_arr_tmp = NULL; PyObject *arr_capi = Py_None; int i; if (!PyArg_ParseTuple(capi_args,"iiOiO|:wrap.call",\ &type_num,&elsize,&dims_capi,&intent,&arr_capi)) return NULL; rank = PySequence_Length(dims_capi); dims = malloc(rank*sizeof(npy_intp)); for (i=0;ikind, PyArray_DESCR(arr)->type, PyArray_TYPE(arr), PyArray_ITEMSIZE(arr), PyArray_DESCR(arr)->alignment, PyArray_FLAGS(arr), PyArray_ITEMSIZE(arr)); } static PyMethodDef f2py_module_methods[] = { {"call",f2py_rout_wrap_call,METH_VARARGS,doc_f2py_rout_wrap_call}, {"array_attrs",f2py_rout_wrap_attrs,METH_VARARGS,doc_f2py_rout_wrap_attrs}, {NULL,NULL} }; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "test_array_from_pyobj_ext", NULL, -1, f2py_module_methods, NULL, NULL, NULL, NULL }; PyMODINIT_FUNC PyInit_test_array_from_pyobj_ext(void) { PyObject *m,*d, *s; m = wrap_module = PyModule_Create(&moduledef); Py_SET_TYPE(&PyFortran_Type, &PyType_Type); import_array(); if (PyErr_Occurred()) Py_FatalError("can't initialize module wrap (failed to import numpy)"); d = PyModule_GetDict(m); s = PyUnicode_FromString("This module 'wrap' is auto-generated with f2py (version:2_1330).\nFunctions:\n" " arr = call(type_num,dims,intent,obj)\n" "."); PyDict_SetItemString(d, "__doc__", s); wrap_error = PyErr_NewException ("wrap.error", NULL, NULL); Py_DECREF(s); #define ADDCONST(NAME, CONST) \ s = PyLong_FromLong(CONST); \ PyDict_SetItemString(d, NAME, s); \ Py_DECREF(s) ADDCONST("F2PY_INTENT_IN", F2PY_INTENT_IN); ADDCONST("F2PY_INTENT_INOUT", F2PY_INTENT_INOUT); ADDCONST("F2PY_INTENT_OUT", F2PY_INTENT_OUT); ADDCONST("F2PY_INTENT_HIDE", F2PY_INTENT_HIDE); ADDCONST("F2PY_INTENT_CACHE", F2PY_INTENT_CACHE); ADDCONST("F2PY_INTENT_COPY", F2PY_INTENT_COPY); ADDCONST("F2PY_INTENT_C", F2PY_INTENT_C); ADDCONST("F2PY_OPTIONAL", F2PY_OPTIONAL); ADDCONST("F2PY_INTENT_INPLACE", F2PY_INTENT_INPLACE); ADDCONST("NPY_BOOL", NPY_BOOL); ADDCONST("NPY_BYTE", NPY_BYTE); ADDCONST("NPY_UBYTE", NPY_UBYTE); ADDCONST("NPY_SHORT", NPY_SHORT); ADDCONST("NPY_USHORT", NPY_USHORT); ADDCONST("NPY_INT", NPY_INT); ADDCONST("NPY_UINT", NPY_UINT); ADDCONST("NPY_INTP", NPY_INTP); ADDCONST("NPY_UINTP", NPY_UINTP); ADDCONST("NPY_LONG", NPY_LONG); ADDCONST("NPY_ULONG", NPY_ULONG); ADDCONST("NPY_LONGLONG", NPY_LONGLONG); ADDCONST("NPY_ULONGLONG", NPY_ULONGLONG); ADDCONST("NPY_FLOAT", NPY_FLOAT); ADDCONST("NPY_DOUBLE", NPY_DOUBLE); ADDCONST("NPY_LONGDOUBLE", NPY_LONGDOUBLE); ADDCONST("NPY_CFLOAT", NPY_CFLOAT); ADDCONST("NPY_CDOUBLE", NPY_CDOUBLE); ADDCONST("NPY_CLONGDOUBLE", NPY_CLONGDOUBLE); ADDCONST("NPY_OBJECT", NPY_OBJECT); ADDCONST("NPY_STRING", NPY_STRING); ADDCONST("NPY_UNICODE", NPY_UNICODE); ADDCONST("NPY_VOID", NPY_VOID); ADDCONST("NPY_NTYPES", NPY_NTYPES); ADDCONST("NPY_NOTYPE", NPY_NOTYPE); ADDCONST("NPY_USERDEF", NPY_USERDEF); ADDCONST("CONTIGUOUS", NPY_ARRAY_C_CONTIGUOUS); ADDCONST("FORTRAN", NPY_ARRAY_F_CONTIGUOUS); ADDCONST("OWNDATA", NPY_ARRAY_OWNDATA); ADDCONST("FORCECAST", NPY_ARRAY_FORCECAST); ADDCONST("ENSURECOPY", NPY_ARRAY_ENSURECOPY); ADDCONST("ENSUREARRAY", NPY_ARRAY_ENSUREARRAY); ADDCONST("ALIGNED", NPY_ARRAY_ALIGNED); ADDCONST("WRITEABLE", NPY_ARRAY_WRITEABLE); ADDCONST("WRITEBACKIFCOPY", NPY_ARRAY_WRITEBACKIFCOPY); ADDCONST("BEHAVED", NPY_ARRAY_BEHAVED); ADDCONST("BEHAVED_NS", NPY_ARRAY_BEHAVED_NS); ADDCONST("CARRAY", NPY_ARRAY_CARRAY); ADDCONST("FARRAY", NPY_ARRAY_FARRAY); ADDCONST("CARRAY_RO", NPY_ARRAY_CARRAY_RO); ADDCONST("FARRAY_RO", NPY_ARRAY_FARRAY_RO); ADDCONST("DEFAULT", NPY_ARRAY_DEFAULT); ADDCONST("UPDATE_ALL", NPY_ARRAY_UPDATE_ALL); #undef ADDCONST( if (PyErr_Occurred()) Py_FatalError("can't initialize module wrap"); #ifdef F2PY_REPORT_ATEXIT on_exit(f2py_report_on_exit,(void*)"array_from_pyobj.wrap.call"); #endif return m; } #ifdef __cplusplus } #endif PKZassumed_shape/.f2py_f2cmapnu[dict(real=dict(rk="double")) PKZ2assumed_shape/foo_free.f90nu[ subroutine sum(x, res) implicit none real, intent(in) :: x(:) real, intent(out) :: res integer :: i !print *, "sum: size(x) = ", size(x) res = 0.0 do i = 1, size(x) res = res + x(i) enddo end subroutine sum function fsum(x) result (res) implicit none real, intent(in) :: x(:) real :: res integer :: i !print *, "fsum: size(x) = ", size(x) res = 0.0 do i = 1, size(x) res = res + x(i) enddo end function fsum PKZassumed_shape/foo_mod.f90nu[ module mod contains subroutine sum(x, res) implicit none real, intent(in) :: x(:) real, intent(out) :: res integer :: i !print *, "sum: size(x) = ", size(x) res = 0.0 do i = 1, size(x) res = res + x(i) enddo end subroutine sum function fsum(x) result (res) implicit none real, intent(in) :: x(:) real :: res integer :: i !print *, "fsum: size(x) = ", size(x) res = 0.0 do i = 1, size(x) res = res + x(i) enddo end function fsum end module mod PKZg  assumed_shape/foo_use.f90nu[subroutine sum_with_use(x, res) use precision implicit none real(kind=rk), intent(in) :: x(:) real(kind=rk), intent(out) :: res integer :: i !print *, "size(x) = ", size(x) res = 0.0 do i = 1, size(x) res = res + x(i) enddo end subroutine PKZ"Hassumed_shape/precision.f90nu[module precision integer, parameter :: rk = selected_real_kind(8) integer, parameter :: ik = selected_real_kind(4) end module PKZ-aablock_docstring/foo.fnu[ SUBROUTINE FOO() INTEGER BAR(2, 3) COMMON /BLOCK/ BAR RETURN END PKZ.callback/foo.fnu[ subroutine t(fun,a) integer a cf2py intent(out) a external fun call fun(a) end subroutine func(a) cf2py intent(in,out) a integer a a = a + 11 end subroutine func0(a) cf2py intent(out) a integer a a = 11 end subroutine t2(a) cf2py intent(callback) fun integer a cf2py intent(out) a external fun call fun(a) end subroutine string_callback(callback, a) external callback double precision callback double precision a character*1 r cf2py intent(out) a r = 'r' a = callback(r) end subroutine string_callback_array(callback, cu, lencu, a) external callback integer callback integer lencu character*8 cu(lencu) integer a cf2py intent(out) a a = callback(cu, lencu) end subroutine hidden_callback(a, r) external global_f cf2py intent(callback, hide) global_f integer a, r, global_f cf2py intent(out) r r = global_f(a) end subroutine hidden_callback2(a, r) external global_f integer a, r, global_f cf2py intent(out) r r = global_f(a) end PKZ8>1callback/gh17797.f90nu[function gh17797(f, y) result(r) external f integer(8) :: r, f integer(8), dimension(:) :: y r = f(0) r = r + sum(y) end function gh17797 PKZcallback/gh18335.f90nu[ ! When gh18335_workaround is defined as an extension, ! the issue cannot be reproduced. !subroutine gh18335_workaround(f, y) ! implicit none ! external f ! integer(kind=1) :: y(1) ! call f(y) !end subroutine gh18335_workaround function gh18335(f) result (r) implicit none external f integer(kind=1) :: y(1), r y(1) = 123 call f(y) r = y(1) end function gh18335 PKZn GG cli/hi77.fnu[ SUBROUTINE HI PRINT*, "HELLO WORLD" END SUBROUTINE PKZ 33cli/hiworld.f90nu[function hi() print*, "Hello World" end function PKZMbcommon/block.fnu[ SUBROUTINE INITCB DOUBLE PRECISION LONG CHARACTER STRING INTEGER OK COMMON /BLOCK/ LONG, STRING, OK LONG = 1.0 STRING = '2' OK = 3 RETURN END PKZ2crackfortran/accesstype.f90nu[module foo public type, private, bind(c) :: a integer :: i end type a type, bind(c) :: b_ integer :: j end type b_ public :: b_ type :: c integer :: k end type c end module foo PKZmOn0crackfortran/foo_deps.f90nu[module foo type bar character(len = 4) :: text end type bar type(bar), parameter :: abar = bar('abar') end module foo PKZ~wwcrackfortran/gh15035.fnu[ subroutine subb(k) real(8), intent(inout) :: k(:) k=k+1 endsubroutine subroutine subc(w,k) real(8), intent(in) :: w(:) real(8), intent(out) :: k(size(w)) k=w+1 endsubroutine function t0(value) character value character t0 t0 = value endfunction PKZm2TTcrackfortran/gh17859.fnu[ integer(8) function external_as_statement(fcn) implicit none external fcn integer(8) :: fcn external_as_statement = fcn(0) end integer(8) function external_as_attribute(fcn) implicit none integer(8), external :: fcn external_as_attribute = fcn(0) end PKZ~~crackfortran/gh23533.fnu[ SUBROUTINE EXAMPLE( ) IF( .TRUE. ) THEN CALL DO_SOMETHING() END IF ! ** .TRUE. ** END PKZ`eecrackfortran/gh23598.f90nu[integer function intproduct(a, b) result(res) integer, intent(in) :: a, b res = a*b end function PKZ+r?crackfortran/gh23598Warn.f90nu[module test_bug implicit none private public :: intproduct contains integer function intproduct(a, b) result(res) integer, intent(in) :: a, b res = a*b end function end module PKZZXLLcrackfortran/gh23879.f90nu[module gh23879 implicit none private public :: foo contains subroutine foo(a, b) integer, intent(in) :: a integer, intent(out) :: b b = a call bar(b) end subroutine subroutine bar(x) integer, intent(inout) :: x x = 2*x end subroutine end module gh23879 PKZәcrackfortran/gh2848.f90nu[ subroutine gh2848( & ! first 2 parameters par1, par2,& ! last 2 parameters par3, par4) integer, intent(in) :: par1, par2 integer, intent(out) :: par3, par4 par3 = par1 par4 = par2 end subroutine gh2848 PKZȑcrackfortran/operators.f90nu[module foo type bar character(len = 32) :: item end type bar interface operator(.item.) module procedure item_int, item_real end interface operator(.item.) interface operator(==) module procedure items_are_equal end interface operator(==) interface assignment(=) module procedure get_int, get_real end interface assignment(=) contains function item_int(val) result(elem) integer, intent(in) :: val type(bar) :: elem write(elem%item, "(I32)") val end function item_int function item_real(val) result(elem) real, intent(in) :: val type(bar) :: elem write(elem%item, "(1PE32.12)") val end function item_real function items_are_equal(val1, val2) result(equal) type(bar), intent(in) :: val1, val2 logical :: equal equal = (val1%item == val2%item) end function items_are_equal subroutine get_real(rval, item) real, intent(out) :: rval type(bar), intent(in) :: item read(item%item, *) rval end subroutine get_real subroutine get_int(rval, item) integer, intent(out) :: rval type(bar), intent(in) :: item read(item%item, *) rval end subroutine get_int end module foo PKZ!RCcrackfortran/privatemod.f90nu[module foo private integer :: a public :: setA integer :: b contains subroutine setA(v) integer, intent(in) :: v a = v end subroutine setA end module foo PKZNcrackfortran/publicmod.f90nu[module foo public integer, private :: a public :: setA contains subroutine setA(v) integer, intent(in) :: v a = v end subroutine setA end module foo PKZư&crackfortran/pubprivmod.f90nu[module foo public integer, private :: a integer :: b contains subroutine setA(v) integer, intent(in) :: v a = v end subroutine setA end module foo PKZRbb crackfortran/unicode_comment.f90nu[subroutine foo(x) real(8), intent(in) :: x ! Écrit à l'écran la valeur de x end subroutine PKZRRf2cmap/.f2py_f2cmapnu[dict(real=dict(real32='float', real64='double'), integer=dict(int64='long_long')) PKZ+**f2cmap/isoFortranEnvMap.f90nu[ subroutine func1(n, x, res) use, intrinsic :: iso_fortran_env, only: int64, real64 implicit none integer(int64), intent(in) :: n real(real64), intent(in) :: x(n) real(real64), intent(out) :: res Cf2py intent(hide) :: n res = sum(x) end PKZ%[[ kind/foo.f90nu[ subroutine selectedrealkind(p, r, res) implicit none integer, intent(in) :: p, r !f2py integer :: r=0 integer, intent(out) :: res res = selected_real_kind(p, r) end subroutine subroutine selectedintkind(p, res) implicit none integer, intent(in) :: p integer, intent(out) :: res res = selected_int_kind(p) end subroutine PKZ_UU mixed/foo.fnu[ subroutine bar11(a) cf2py intent(out) a integer a a = 11 end PKZVmixed/foo_fixed.f90nu[ module foo_fixed contains subroutine bar12(a) !f2py intent(out) a integer a a = 12 end subroutine bar12 end module foo_fixed PKZLmmixed/foo_free.f90nu[module foo_free contains subroutine bar13(a) !f2py intent(out) a integer a a = 13 end subroutine bar13 end module foo_free PKZ module_data/mod.modnu[]o0+]bKѐa1yEb2%Q篔9B{Bߞ@ X{zW@:KY uiM4m~apNIeM(PE,0'.="(gqE؄c8uPx(sJ>⩭F|`8\( Q6:.ԢzP@% jEK+tWLz+o>(%' t<"nc 7LN \J>U2vqELčju\ntq#[} Nctk]ҕa\p F?5X{e|}\cr$h)'VغsVIaЩan1~ZPKZ;!:%module_data/module_data_docstring.f90nu[module mod integer :: i integer :: x(4) real, dimension(2,3) :: a real, allocatable, dimension(:,:) :: b contains subroutine foo integer :: k k = 1 a(1,2) = a(1,2)+3 end subroutine foo end module mod PKZ)"negative_bounds/issue_20853.f90nu[subroutine foo(is_, ie_, arr, tout) implicit none integer :: is_,ie_ real, intent(in) :: arr(is_:ie_) real, intent(out) :: tout(is_:ie_) tout = arr end PKZ梻parameter/constant_both.f90nu[! Check that parameters are correct intercepted. ! Constants with comma separations are commonly ! used, for instance Pi = 3._dp subroutine foo(x) implicit none integer, parameter :: sp = selected_real_kind(6) integer, parameter :: dp = selected_real_kind(15) integer, parameter :: ii = selected_int_kind(9) integer, parameter :: il = selected_int_kind(18) real(dp), intent(inout) :: x dimension x(3) real(sp), parameter :: three_s = 3._sp real(dp), parameter :: three_d = 3._dp integer(ii), parameter :: three_i = 3_ii integer(il), parameter :: three_l = 3_il x(1) = x(1) + x(2) * three_s * three_i + x(3) * three_d * three_l x(2) = x(2) * three_s x(3) = x(3) * three_l return end subroutine subroutine foo_no(x) implicit none integer, parameter :: sp = selected_real_kind(6) integer, parameter :: dp = selected_real_kind(15) integer, parameter :: ii = selected_int_kind(9) integer, parameter :: il = selected_int_kind(18) real(dp), intent(inout) :: x dimension x(3) real(sp), parameter :: three_s = 3. real(dp), parameter :: three_d = 3. integer(ii), parameter :: three_i = 3 integer(il), parameter :: three_l = 3 x(1) = x(1) + x(2) * three_s * three_i + x(3) * three_d * three_l x(2) = x(2) * three_s x(3) = x(3) * three_l return end subroutine subroutine foo_sum(x) implicit none integer, parameter :: sp = selected_real_kind(6) integer, parameter :: dp = selected_real_kind(15) integer, parameter :: ii = selected_int_kind(9) integer, parameter :: il = selected_int_kind(18) real(dp), intent(inout) :: x dimension x(3) real(sp), parameter :: three_s = 2._sp + 1._sp real(dp), parameter :: three_d = 1._dp + 2._dp integer(ii), parameter :: three_i = 2_ii + 1_ii integer(il), parameter :: three_l = 1_il + 2_il x(1) = x(1) + x(2) * three_s * three_i + x(3) * three_d * three_l x(2) = x(2) * three_s x(3) = x(3) * three_l return end subroutine PKZAparameter/constant_compound.f90nu[! Check that parameters are correct intercepted. ! Constants with comma separations are commonly ! used, for instance Pi = 3._dp subroutine foo_compound_int(x) implicit none integer, parameter :: ii = selected_int_kind(9) integer(ii), intent(inout) :: x dimension x(3) integer(ii), parameter :: three = 3_ii integer(ii), parameter :: two = 2_ii integer(ii), parameter :: six = three * 1_ii * two x(1) = x(1) + x(2) + x(3) * six return end subroutine PKZm+ddparameter/constant_integer.f90nu[! Check that parameters are correct intercepted. ! Constants with comma separations are commonly ! used, for instance Pi = 3._dp subroutine foo_int(x) implicit none integer, parameter :: ii = selected_int_kind(9) integer(ii), intent(inout) :: x dimension x(3) integer(ii), parameter :: three = 3_ii x(1) = x(1) + x(2) + x(3) * three return end subroutine subroutine foo_long(x) implicit none integer, parameter :: ii = selected_int_kind(18) integer(ii), intent(inout) :: x dimension x(3) integer(ii), parameter :: three = 3_ii x(1) = x(1) + x(2) + x(3) * three return end subroutine PKZY5Qaa#parameter/constant_non_compound.f90nu[! Check that parameters are correct intercepted. ! Specifically that types of constants without ! compound kind specs are correctly inferred ! adapted Gibbs iteration code from pymc ! for this test case subroutine foo_non_compound_int(x) implicit none integer, parameter :: ii = selected_int_kind(9) integer(ii) maxiterates parameter (maxiterates=2) integer(ii) maxseries parameter (maxseries=2) integer(ii) wasize parameter (wasize=maxiterates*maxseries) integer(ii), intent(inout) :: x dimension x(wasize) x(1) = x(1) + x(2) + x(3) + x(4) * wasize return end subroutine PKZI[bbbparameter/constant_real.f90nu[! Check that parameters are correct intercepted. ! Constants with comma separations are commonly ! used, for instance Pi = 3._dp subroutine foo_single(x) implicit none integer, parameter :: rp = selected_real_kind(6) real(rp), intent(inout) :: x dimension x(3) real(rp), parameter :: three = 3._rp x(1) = x(1) + x(2) + x(3) * three return end subroutine subroutine foo_double(x) implicit none integer, parameter :: rp = selected_real_kind(15) real(rp), intent(inout) :: x dimension x(3) real(rp), parameter :: three = 3._rp x(1) = x(1) + x(2) + x(3) * three return end subroutine PKZ{quoted_character/foo.fnu[ SUBROUTINE FOO(OUT1, OUT2, OUT3, OUT4, OUT5, OUT6) CHARACTER SINGLE, DOUBLE, SEMICOL, EXCLA, OPENPAR, CLOSEPAR PARAMETER (SINGLE="'", DOUBLE='"', SEMICOL=';', EXCLA="!", 1 OPENPAR="(", CLOSEPAR=")") CHARACTER OUT1, OUT2, OUT3, OUT4, OUT5, OUT6 Cf2py intent(out) OUT1, OUT2, OUT3, OUT4, OUT5, OUT6 OUT1 = SINGLE OUT2 = DOUBLE OUT3 = SEMICOL OUT4 = EXCLA OUT5 = OPENPAR OUT6 = CLOSEPAR RETURN END PKZt regression/inout.f90nu[! Check that intent(in out) translates as intent(inout). ! The separation seems to be a common usage. subroutine foo(x) implicit none real(4), intent(in out) :: x dimension x(3) x(1) = x(1) + x(2) + x(3) return end PKZBreturn_character/foo77.fnu[ function t0(value) character value character t0 t0 = value end function t1(value) character*1 value character*1 t1 t1 = value end function t5(value) character*5 value character*5 t5 t5 = value end function ts(value) character*(*) value character*(*) ts ts = value end subroutine s0(t0,value) character value character t0 cf2py intent(out) t0 t0 = value end subroutine s1(t1,value) character*1 value character*1 t1 cf2py intent(out) t1 t1 = value end subroutine s5(t5,value) character*5 value character*5 t5 cf2py intent(out) t5 t5 = value end subroutine ss(ts,value) character*(*) value character*10 ts cf2py intent(out) ts ts = value end PKZqreturn_character/foo90.f90nu[module f90_return_char contains function t0(value) character :: value character :: t0 t0 = value end function t0 function t1(value) character(len=1) :: value character(len=1) :: t1 t1 = value end function t1 function t5(value) character(len=5) :: value character(len=5) :: t5 t5 = value end function t5 function ts(value) character(len=*) :: value character(len=10) :: ts ts = value end function ts subroutine s0(t0,value) character :: value character :: t0 !f2py intent(out) t0 t0 = value end subroutine s0 subroutine s1(t1,value) character(len=1) :: value character(len=1) :: t1 !f2py intent(out) t1 t1 = value end subroutine s1 subroutine s5(t5,value) character(len=5) :: value character(len=5) :: t5 !f2py intent(out) t5 t5 = value end subroutine s5 subroutine ss(ts,value) character(len=*) :: value character(len=10) :: ts !f2py intent(out) ts ts = value end subroutine ss end module f90_return_char PKZb return_complex/foo77.fnu[ function t0(value) complex value complex t0 t0 = value end function t8(value) complex*8 value complex*8 t8 t8 = value end function t16(value) complex*16 value complex*16 t16 t16 = value end function td(value) double complex value double complex td td = value end subroutine s0(t0,value) complex value complex t0 cf2py intent(out) t0 t0 = value end subroutine s8(t8,value) complex*8 value complex*8 t8 cf2py intent(out) t8 t8 = value end subroutine s16(t16,value) complex*16 value complex*16 t16 cf2py intent(out) t16 t16 = value end subroutine sd(td,value) double complex value double complex td cf2py intent(out) td td = value end PKZjreturn_complex/foo90.f90nu[module f90_return_complex contains function t0(value) complex :: value complex :: t0 t0 = value end function t0 function t8(value) complex(kind=4) :: value complex(kind=4) :: t8 t8 = value end function t8 function t16(value) complex(kind=8) :: value complex(kind=8) :: t16 t16 = value end function t16 function td(value) double complex :: value double complex :: td td = value end function td subroutine s0(t0,value) complex :: value complex :: t0 !f2py intent(out) t0 t0 = value end subroutine s0 subroutine s8(t8,value) complex(kind=4) :: value complex(kind=4) :: t8 !f2py intent(out) t8 t8 = value end subroutine s8 subroutine s16(t16,value) complex(kind=8) :: value complex(kind=8) :: t16 !f2py intent(out) t16 t16 = value end subroutine s16 subroutine sd(td,value) double complex :: value double complex :: td !f2py intent(out) td td = value end subroutine sd end module f90_return_complex PKZ Mreturn_integer/foo77.fnu[ function t0(value) integer value integer t0 t0 = value end function t1(value) integer*1 value integer*1 t1 t1 = value end function t2(value) integer*2 value integer*2 t2 t2 = value end function t4(value) integer*4 value integer*4 t4 t4 = value end function t8(value) integer*8 value integer*8 t8 t8 = value end subroutine s0(t0,value) integer value integer t0 cf2py intent(out) t0 t0 = value end subroutine s1(t1,value) integer*1 value integer*1 t1 cf2py intent(out) t1 t1 = value end subroutine s2(t2,value) integer*2 value integer*2 t2 cf2py intent(out) t2 t2 = value end subroutine s4(t4,value) integer*4 value integer*4 t4 cf2py intent(out) t4 t4 = value end subroutine s8(t8,value) integer*8 value integer*8 t8 cf2py intent(out) t8 t8 = value end PKZ?nreturn_integer/foo90.f90nu[module f90_return_integer contains function t0(value) integer :: value integer :: t0 t0 = value end function t0 function t1(value) integer(kind=1) :: value integer(kind=1) :: t1 t1 = value end function t1 function t2(value) integer(kind=2) :: value integer(kind=2) :: t2 t2 = value end function t2 function t4(value) integer(kind=4) :: value integer(kind=4) :: t4 t4 = value end function t4 function t8(value) integer(kind=8) :: value integer(kind=8) :: t8 t8 = value end function t8 subroutine s0(t0,value) integer :: value integer :: t0 !f2py intent(out) t0 t0 = value end subroutine s0 subroutine s1(t1,value) integer(kind=1) :: value integer(kind=1) :: t1 !f2py intent(out) t1 t1 = value end subroutine s1 subroutine s2(t2,value) integer(kind=2) :: value integer(kind=2) :: t2 !f2py intent(out) t2 t2 = value end subroutine s2 subroutine s4(t4,value) integer(kind=4) :: value integer(kind=4) :: t4 !f2py intent(out) t4 t4 = value end subroutine s4 subroutine s8(t8,value) integer(kind=8) :: value integer(kind=8) :: t8 !f2py intent(out) t8 t8 = value end subroutine s8 end module f90_return_integer PKZqVreturn_logical/foo77.fnu[ function t0(value) logical value logical t0 t0 = value end function t1(value) logical*1 value logical*1 t1 t1 = value end function t2(value) logical*2 value logical*2 t2 t2 = value end function t4(value) logical*4 value logical*4 t4 t4 = value end c function t8(value) c logical*8 value c logical*8 t8 c t8 = value c end subroutine s0(t0,value) logical value logical t0 cf2py intent(out) t0 t0 = value end subroutine s1(t1,value) logical*1 value logical*1 t1 cf2py intent(out) t1 t1 = value end subroutine s2(t2,value) logical*2 value logical*2 t2 cf2py intent(out) t2 t2 = value end subroutine s4(t4,value) logical*4 value logical*4 t4 cf2py intent(out) t4 t4 = value end c subroutine s8(t8,value) c logical*8 value c logical*8 t8 cf2py intent(out) t8 c t8 = value c end PKZ܂return_logical/foo90.f90nu[module f90_return_logical contains function t0(value) logical :: value logical :: t0 t0 = value end function t0 function t1(value) logical(kind=1) :: value logical(kind=1) :: t1 t1 = value end function t1 function t2(value) logical(kind=2) :: value logical(kind=2) :: t2 t2 = value end function t2 function t4(value) logical(kind=4) :: value logical(kind=4) :: t4 t4 = value end function t4 function t8(value) logical(kind=8) :: value logical(kind=8) :: t8 t8 = value end function t8 subroutine s0(t0,value) logical :: value logical :: t0 !f2py intent(out) t0 t0 = value end subroutine s0 subroutine s1(t1,value) logical(kind=1) :: value logical(kind=1) :: t1 !f2py intent(out) t1 t1 = value end subroutine s1 subroutine s2(t2,value) logical(kind=2) :: value logical(kind=2) :: t2 !f2py intent(out) t2 t2 = value end subroutine s2 subroutine s4(t4,value) logical(kind=4) :: value logical(kind=4) :: t4 !f2py intent(out) t4 t4 = value end subroutine s4 subroutine s8(t8,value) logical(kind=8) :: value logical(kind=8) :: t8 !f2py intent(out) t8 t8 = value end subroutine s8 end module f90_return_logical PKZ1 -callback/gh17797.f90nu[PKZ-callback/gh18335.f90nu[PKZn GG #0cli/hi77.fnu[PKZ 330cli/hiworld.f90nu[PKZMb1common/block.fnu[PKZ242crackfortran/accesstype.f90nu[PKZmOn0O3crackfortran/foo_deps.f90nu[PKZ~ww4crackfortran/gh15035.fnu[PKZm2TT5crackfortran/gh17859.fnu[PKZ~~o7crackfortran/gh23533.fnu[PKZ`ee38crackfortran/gh23598.f90nu[PKZ+r?8crackfortran/gh23598Warn.f90nu[PKZZXLL9crackfortran/gh23879.f90nu[PKZә;crackfortran/gh2848.f90nu[PKZȑ<crackfortran/operators.f90nu[PKZ!RCAcrackfortran/privatemod.f90nu[PKZNBcrackfortran/publicmod.f90nu[PKZư&Ccrackfortran/pubprivmod.f90nu[PKZRbb Dcrackfortran/unicode_comment.f90nu[PKZRRdEf2cmap/.f2py_f2cmapnu[PKZ+**Ef2cmap/isoFortranEnvMap.f90nu[PKZ%[[ nGkind/foo.f90nu[PKZ_UU Imixed/foo.fnu[PKZVImixed/foo_fixed.f90nu[PKZLmJmixed/foo_free.f90nu[PKZ XKmodule_data/mod.modnu[PKZ;!:%7Mmodule_data/module_data_docstring.f90nu[PKZ)"lNnegative_bounds/issue_20853.f90nu[PKZ梻XOparameter/constant_both.f90nu[PKZA6Wparameter/constant_compound.f90nu[PKZm+ddZYparameter/constant_integer.f90nu[PKZY5Qaa# \parameter/constant_non_compound.f90nu[PKZI[bbb^parameter/constant_real.f90nu[PKZ{maquoted_character/foo.fnu[PKZt cregression/inout.f90nu[PKZBdreturn_character/foo77.fnu[PKZq ireturn_character/foo90.f90nu[PKZb 4nreturn_complex/foo77.fnu[PKZjGrreturn_complex/foo90.f90nu[PKZ Mewreturn_integer/foo77.fnu[PKZ?nE|return_integer/foo90.f90nu[PKZqVreturn_logical/foo77.fnu[PKZ܂rreturn_logical/foo90.f90nu[PKZ