How to pass derived type in C which is NOT interop with C struct?

Question

I am trying to get Fortan API to work with the C code. The Fortran code contains mainly derived types which are NOT interoperable with the C by using iso_c_binding module. I have found this post that contains similar problem https://software.intel.com/en-us/forums/topic/394312. This post c-fortran interoperability - derived types with pointers suggest that there is new standard that could solve this problem, but it is still not implemented by any fortran compiler. I have tried this code with gfortran 4.8.3 and gcc:

module types
    type SomeDerivedType
            integer :: someInteger
            character*24 :: string
            real, dimension(:), allocatable :: array
    end type
end module

! Given the address of a C_PTR this subroutine allocates the memory required
! for a SomeDerivedType derived data type, initializes it with the given  values,
! and stores the C_LOCated address in the C_PTR.
subroutine makeDerivedType_(cdt) bind(c, name='makeDerivedType_')
    use iso_c_binding
    use types
    type (C_PTR) :: cdt
    type (SomeDerivedType), pointer :: fdt
    integer :: i
    allocate(fdt)
    allocate(fdt%array(0:10))
    fdt%someInteger = 4
    fdt%string = 'Hello'
    do i = 0,9
       fdt%array(i) = i*2.0
    end do
    cdt = C_LOC(fdt)
end subroutine makeDerivedType_

! This subroutine converts the given C_PTR value to a fortran pointer making
! it accessible again from fortran
subroutine examineDerivedType_(this) bind(c, name='examineDerivedType_')
    use iso_c_binding
    use types
    type(C_PTR), value :: this
    type(SomeDerivedType), pointer :: that
    integer :: i
    call C_F_POINTER(this,that)
    write(*,*) "that%someInteger", that%someInteger
    do i = 0,9
            print*, "that%array:", that%array(i)
    end do
 end subroutine examineDerivedType_

The corresponding C code is:

#include<stdio.h>
extern void makeDerivedType_(void **m);
extern void examineDerivedType_( void *m );
typedef struct SomeDerivedType {
    int someInteger;
    char string[24];
    double *array;
}SomeDerivedType;
int main(int argc, char **argv)
{
    void *m = 0;
    char *teststring[2] = {"test1", "test2"};
    makeDerivedType_(&m);
    SomeDerivedType* dt = (SomeDerivedType*) m;
    for(int i  = 0; i < 10; i++)
        printf("%f\n",dt->array[i]);
    printf("someInteger: %i\n",dt->someInteger); 
    printf("%s \n", dt->string);
    examineDerivedType_(m);
}

This program returns:

2.000000
8192.001968
524288.126953
8388610.039062
67108880.375000
0.000000
0.000000
0.000000
0.000000
0.000000
someInteger: 4
Hello                   ? 
 that%someInteger           4
 that%array:   0.00000000    
 that%array:   2.00000000    
 that%array:   4.00000000    
 that%array:   6.00000000    
 that%array:   8.00000000    
 that%array:   10.0000000    
 that%array:   12.0000000    
 that%array:   14.0000000    
 that%array:   16.0000000    
 that%array:   18.0000000

It is interesting to see that string and someInteger variables are properly returned from C, while array returns bad values. I assumed that the reason is that array is not contiguously allocated in Fortran code so C returns contiguous memory locations starting from *(array+i). Is it possible to ensure that Fortran allocates array contiguously or exists any other more portable way to access derived type with allocatable components from C.

I have edited the question and tags: it isn't about Fortran 90. — francescalus

Vladimir F Vladimir F · Accepted Answer · 2014-12-27T14:56:26

real, dimension(:), allocatable :: array is NOT equivalent to a C pointer. Your approach cannot work that simply.

There is actually an array descriptor present in the object. The descriptor than contains a address (C style pointer) to the contiguously allocated array.

You can read more about the implementation of the descriptor for one particular compiler in https://software.intel.com/en-us/node/510871.

You may try to find out the offset of the address in the descriptor and use it manually. In any way, your C struct must be more complicated and must include another struct - the descriptor. You should be careful to get the size of the struct right. The Intel's manual suggests it is 36 bytes for 32bit and 72 bytes for 64bit binaries for one-dimensional arrays.

Your link to the other question and my answer there suggests to use TS 29113. Intel's descriptor should be compatible this one and that's why the Intel's manual is useful. gfortran, however, is not yet compatible and uses a different descriptor.

How to pass derived type in C which is NOT interop with C struct?

1 Answers