Working with C Pointers (The GNU Fortran Compiler) (original) (raw)

6.1.5 Working with C Pointers ¶

C pointers are represented in Fortran via the special opaque derived type type(c_ptr) (with private components). C pointers are distinct from Fortran objects with the POINTER attribute. Thus one needs to use intrinsic conversion procedures to convert from or to C pointers. For some applications, using an assumed type (TYPE(*)) can be an alternative to a C pointer, and you can also use library routines to access Fortran pointers from C. See Further Interoperability of Fortran with C.

Here is an example of using C pointers in Fortran:

use iso_c_binding type(c_ptr) :: cptr1, cptr2 integer, target :: array(7), scalar integer, pointer :: pa(:), ps cptr1 = c_loc(array(1)) ! The programmer needs to ensure that the ! array is contiguous if required by the C ! procedure cptr2 = c_loc(scalar) call c_f_pointer(cptr2, ps) call c_f_pointer(cptr2, pa, shape=[7])

When converting C to Fortran arrays, the one-dimensional SHAPE argument has to be passed.

If a pointer is a dummy argument of an interoperable procedure, it usually has to be declared using the VALUE attribute. void*matches TYPE(C_PTR), VALUE, while TYPE(C_PTR) alone matches void**.

Procedure pointers are handled analogously to pointers; the C type isTYPE(C_FUNPTR) and the intrinsic conversion procedures areC_F_PROCPOINTER and C_FUNLOC.

Let us consider two examples of actually passing a procedure pointer from C to Fortran and vice versa. Note that these examples are also very similar to passing ordinary pointers between both languages. First, consider this code in C:

/* Procedure implemented in Fortran. / void get_values (void ()(double));

/* Call-back routine we want called from Fortran. */ void print_it (double x) { printf ("Number is %f.\n", x); }

/* Call Fortran routine and pass call-back to it. */ void foobar () { get_values (&print_it); }

A matching implementation for get_values in Fortran that correctly receives the procedure pointer from C and is able to call it, is given in the following MODULE:

MODULE m IMPLICIT NONE

! Define interface of call-back routine. ABSTRACT INTERFACE SUBROUTINE callback (x) USE, INTRINSIC :: ISO_C_BINDING REAL(KIND=C_DOUBLE), INTENT(IN), VALUE :: x END SUBROUTINE callback END INTERFACE

CONTAINS

! Define C-bound procedure. SUBROUTINE get_values (cproc) BIND(C) USE, INTRINSIC :: ISO_C_BINDING TYPE(C_FUNPTR), INTENT(IN), VALUE :: cproc

PROCEDURE(callback), POINTER :: proc

! Convert C to Fortran procedure pointer.
CALL C_F_PROCPOINTER (cproc, proc)

! Call it.
CALL proc (1.0_C_DOUBLE)
CALL proc (-42.0_C_DOUBLE)
CALL proc (18.12_C_DOUBLE)

END SUBROUTINE get_values

END MODULE m

Next, we want to call a C routine that expects a procedure pointer argument and pass it a Fortran procedure (that clearly must be interoperable!). Again, the C function may be:

int call_it (int (*func)(int), int arg) { return func (arg); }

It can be used as in the following Fortran code:

MODULE m USE, INTRINSIC :: ISO_C_BINDING IMPLICIT NONE

! Define interface of C function. INTERFACE INTEGER(KIND=C_INT) FUNCTION call_it (func, arg) BIND(C) USE, INTRINSIC :: ISO_C_BINDING TYPE(C_FUNPTR), INTENT(IN), VALUE :: func INTEGER(KIND=C_INT), INTENT(IN), VALUE :: arg END FUNCTION call_it END INTERFACE

CONTAINS

! Define procedure passed to C function. ! It must be interoperable! INTEGER(KIND=C_INT) FUNCTION double_it (arg) BIND(C) INTEGER(KIND=C_INT), INTENT(IN), VALUE :: arg double_it = arg + arg END FUNCTION double_it

! Call C function. SUBROUTINE foobar () TYPE(C_FUNPTR) :: cproc INTEGER(KIND=C_INT) :: i

! Get C procedure pointer.
cproc = C_FUNLOC (double_it)

! Use it.
DO i = 1_C_INT, 10_C_INT
  PRINT *, call_it (cproc, i)
END DO

END SUBROUTINE foobar

END MODULE m