So here is the fortran90 with C problem

This is the example I concocted to help demonstrate the problem and help me learn how to solve it. The problem is, I solved this … without any fancy interface blocks or anything strange like that. Go figure.

The makefile

`<code>
CC	= icc
FC	= ifort
LD	= ifort
CFLAGS	= -g
FFLAGS	= -g
LFLAGS	= -g
all:	test.exe
test.exe:	test_f.o test_c.o
    $(LD) $(LFLAGS) test_f.o test_c.o -o test.exe
test_f.o:	test.f90
    $(FC) $(FFLAGS) -c $< -o test_f.o
test_c.o:	test.c
    $(CC) $(FFLAGS) -c $< -o test_c.o
clean:
    rm -f *.o *.exe
</code>
`

the test.f90 code:

`<code>
    program test
    integer, allocatable, dimension(:,:)	:: a
    integer			  		:: b
    integer			  		:: n,m,i,j
    real, allocatable, dimension(:,:)	:: c
    ! -- allocate a and c as 10x10 arrays, and fill with sequential integers
    allocate(a(10,10))
    allocate(c(10,10))
    do i=1,10
     do j=1,10
      a(i,j)=10*(i-1)+j
      c(i,j)=dble(10*(i-1)+j)
     enddo
    enddo
    n=10
    m=10
    print *,'In test.f90: printing out 1 column of a and then c'
    print *,'a:'
    do j=1,10
     print *,'a(1,',j,') = ',a(1,j)
    enddo
    print *, ' '
    print *,'c:'
    do j=1,10
     print *,'c(1,',j,') = ',c(1,j)
    enddo
    call test_c(n,m,a,c)
    end program
</code>
`

the test.c code:

`<code>
#include <stdio.h>
void test_c_(
          int *n,
          int *m,
          int *a,
          float *c
        )
{
  int i,j;
  printf("in test.c: n=%i, m=%i, a=%x, c=%x\n",*n,*m,a,c);
  for(i=0;i<*m;i++)
   {
    printf("a(%i,0)=%i\n",i,*(a+ (*m)*i+0));
   }
  for(i=0;i<*m;i++)
   {
    printf("c(%i,0)=%f\n",i,*(c+ (*m)*i+0));
   }
  return;
}
</code>
`

What is of interest is that Fortran includes metadata in its internal symbol tables that C doesn’t have access to. So you can’t write the C arrays as a[i][j], as this symbol metadata never traversed the language barrier. You have to do pointer arithmetic. Notice how it is done.

`<code>
     a[i][j] -> *(a + j * DIMENSION_ALONG_J + i)
</code>
`

which is equivalent to a(j-1,i-1) in Fortran90. Nice little Rosetta stone we have here :) When you run the code, this is what you get

`~/testcase$ ./test.exe
 In test.f90: printing out 1 column of a and then c
 a:
 a(1,           1 ) =            1
 a(1,           2 ) =            2
 a(1,           3 ) =            3
 a(1,           4 ) =            4
 a(1,           5 ) =            5
 a(1,           6 ) =            6
 a(1,           7 ) =            7
 a(1,           8 ) =            8
 a(1,           9 ) =            9
 a(1,          10 ) =           10
 c:
 c(1,           1 ) =    1.000000
 c(1,           2 ) =    2.000000
 c(1,           3 ) =    3.000000
 c(1,           4 ) =    4.000000
 c(1,           5 ) =    5.000000
 c(1,           6 ) =    6.000000
 c(1,           7 ) =    7.000000
 c(1,           8 ) =    8.000000
 c(1,           9 ) =    9.000000
 c(1,          10 ) =    10.00000
in test.c: n=10, m=10, a=129a030, c=129a1d0
a(0,0)=1
a(1,0)=2
a(2,0)=3
a(3,0)=4
a(4,0)=5
a(5,0)=6
a(6,0)=7
a(7,0)=8
a(8,0)=9
a(9,0)=10
c(0,0)=1.000000
c(1,0)=2.000000
c(2,0)=3.000000
c(3,0)=4.000000
c(4,0)=5.000000
c(5,0)=6.000000
c(6,0)=7.000000
c(7,0)=8.000000
c(8,0)=9.000000
c(9,0)=10.000000
`

So it works. Without an interface block. And indexing is basically correct. The hex address pointers appear to be valid. Now how to translate this to the code we are having trouble with … [updated … fixed my indexing errors…]