todas - Crear una interfaz FORTRAN para una función C que devuelve un carácter*

todas las funciones de c++

Question

Me he retrasado en esto durante una semana, y he buscado foro tras foro para obtener una explicación clara de cómo enviar un char * de C a FORTRAN. Para hacer que el asunto sea más frustrante, enviar un argumento de char * de FORTRAN a C fue directo ...

Enviar un argumento char * de FORTRAN a C (esto funciona bien):

// The C header declaration (using __cdecl in a def file):
extern "C" double GetLoggingValue(char* name);

Y de FORTRAN:

! The FORTRAN interface:
INTERFACE
REAL(8) FUNCTION GetLoggingValue [C, ALIAS: ''_GetLoggingValue''] (name)
USE ISO_C_BINDING
CHARACTER(LEN=1, KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: name
END FUNCTION GetLoggingValue
END INTERFACE
! Calling the function:
GetLoggingValue(user_name)

Cuando trato de usar una lógica análoga para devolver un carácter * desde C, aparece un problema tras otro. Un intento que sentí que debería funcionar es:

// The C declaration header (using __cdecl in a def file):
extern "C" const char* GetLastErrorMessage();

Y la interfaz FORTRAN:

INTERFACE
FUNCTION GetLastErrorMessage [C, ALIAS: ''_GetLastErrorMessage''] ()
USE ISO_C_BINDING
CHARACTER(LEN=1, KIND=C_CHAR), DIMENSION(255), :: GetLastErrorMessage
END FUNCTION GetLastErrorMessage
END INTERFACE

(No puedo usar literalmente la DIMENSIÓN (*), así que he pasado de tamaño a 255).

Esto debería devolver un puntero a una matriz de 255 caracteres estilo C, pero si lo hace, no he podido convertir esto en una cadena significativa. En la práctica, devuelve un conjunto aleatorio de caracteres, desde Wingdings hasta el personaje ''campana'' ...

También intenté regresar:

• Un puntero al CARÁCTER (LEN = 255, KIND = C_CHAR).
• Literalmente CARÁCTER (LEN = 255, KIND = C_CHAR).
• Un INTEGER (C_SIZE_T), y trató de convertirlo en un puntero a una matriz de cadenas.
• UN PERSONAJE.
• etc.

Si alguien puede darme un ejemplo de cómo hacer esto, estaría muy agradecido ...

Atentamente,

Micro

Answer 1

Siempre lucho con estas funciones de interoperabilidad. Creo que su interfaz debería declarar

CHARACTER(KIND=C_CHAR),DIMENSION(*) :: getlasterrormessage

y que, cuando llame a la función, pase una variable de caracteres Fortran correspondiente con una longitud igual o mayor que la longitud de la matriz de C caracteres que espera devolver.

Dado que parece tener Intel Fortran, consulte las muestras de código proporcionadas, dan un ejemplo completo de esto.

Supongo que sabes que lo que has publicado no es sintácticamente correcto Fortran.

Answer 2

Las cadenas de longitud dinámica siempre son un poco complicadas con la interacción C. Una posible solución es usar punteros.

Primero, un caso simple, donde debe entregar una cadena terminada de carácter nulo a una función C. Si realmente solo pasa la cuerda, debe asegurarse de finalizarla con el c_null_char, por lo tanto, esta dirección es bastante directa. Aquí hay ejemplos de una interfaz LuaFortran :

subroutine flu_getfield(L, index, k)
type(flu_State) :: L
integer :: index
character(len=*) :: k
integer(kind=c_int) :: c_index
character(len=len_trim(k)+1) :: c_k
c_k = trim(k) // c_null_char
c_index = index
call lua_getfield(L%state, c_index, c_k)
end subroutine flu_getfield

Y la interfaz de lua_getfield se ve así:

subroutine lua_getfield(L, index, k) bind(c, name="lua_getfield")
use, intrinsic :: iso_c_binding
type(c_ptr), value :: L
integer(kind=c_int), value :: index
character(kind=c_char), dimension(*) :: k
end subroutine lua_getfield

Y la interfaz de C-Code es:

void lua_getfield (lua_State *L, int idx, const char *k)

Ahora el caso un poco más complejo, donde tenemos que lidiar con una cadena devuelta de C con una longitud dinámica. La solución más portátil que encontré hasta ahora es el uso de punteros. Aquí hay un ejemplo con un puntero, donde la cadena está dada por la C-Rutina (también de la biblioteca de Aotus mencionada anteriormente):

function flu_tolstring(L, index, len) result(string)
type(flu_State) :: L
integer :: index
integer :: len
character,pointer,dimension(:) :: string
integer :: string_shape(1)
integer(kind=c_int) :: c_index
integer(kind=c_size_t) :: c_len
type(c_ptr) :: c_string
c_index = index
c_string = lua_tolstring(L%state, c_index, c_len)
len = int(c_len,kind=kind(len))
string_shape(1) = len
call c_f_pointer(c_string, string, string_shape)
end function flu_tolstring

donde lua_tolstring tiene la siguiente interfaz :

function lua_tolstring(L, index, len) bind(c, name="lua_tolstring")
use, intrinsic :: iso_c_binding
type(c_ptr), value :: L
integer(kind=c_int), value :: index
integer(kind=c_size_t) :: len
type(c_ptr) :: lua_tolstring
end function lua_tolstring

Finalmente, aquí hay un intento de aclarar cómo un c_ptr puede interpretarse como una cadena de caracteres Fortran: Supongamos que tiene un c_ptr apuntando a la cadena:

type(c_ptr) :: a_c_string

Y la longitud del mismo viene dada por una variable len con el siguiente tipo:

integer(kind=c_size_t) :: stringlen

Desea obtener esta cadena en un puntero a una cadena de caracteres en Fortran:

character,pointer,dimension(:) :: string

Entonces haces el mapeo:

call c_f_pointer(a_c_string, string, [ stringlen ])

Answer 3

Este hilo es un poco viejo, pero como tuve un problema similar (y probablemente otros lo hagan), publico una respuesta de todos modos.

Los códigos publicados anteriormente causarán un error de segmentación si, por alguna razón, la cadena C es nula. Además, no es necesario devolver una cadena de 255 caracteres (que probablemente será necesario recortar antes de su uso), ya que Fortran 2003/2008 es compatible con funciones que devuelven entidades asignables. Utilizando toda la información publicada anteriormente, terminé con la siguiente función, que obtiene una cadena C (puntero) y devuelve la cadena Fortran correspondiente; Si la cadena C es nula, devuelve "NULO", de forma similar a C "(nulo)" impreso en casos similares:

function C_to_F_string(c_string_pointer) result(f_string)
use, intrinsic :: iso_c_binding, only: c_ptr,c_f_pointer,c_char,c_null_char
type(c_ptr), intent(in) :: c_string_pointer
character(len=:), allocatable :: f_string
character(kind=c_char), dimension(:), pointer :: char_array_pointer => null()
character(len=255) :: aux_string
integer :: i,length
call c_f_pointer(c_string_pointer,char_array_pointer,[255])
if (.not.associated(char_array_pointer)) then
allocate(character(len=4)::f_string); f_string="NULL"; return
end if
aux_string=" "
do i=1,255
if (char_array_pointer(i)==c_null_char) then
length=i-1; exit
end if
aux_string(i:i)=char_array_pointer(i)
end do
allocate(character(len=length)::f_string)
f_string=aux_string(1:length)
end function C_to_F_string

Answer 4

En Fortran, el elemento debe declararse como "carácter (tipo = c_char, len = 1), dimensión (255)" en lugar de len = 255. Esto creará una matriz de caracteres de longitud uno, que es lo que necesita en el lado C. Lo que puede ser confuso es que hay una excepción que permite a Fortran hacer coincidir cadenas con matrices unidimensionales.

¿Quiere decir que quiere llamar a un procedimiento de Fortran desde C? Vea este ejemplo: Llamar a una subrutina FORTRAN desde C.

EDITAR: Tanto ifort como gfortran dicen que las matrices no están permitidas ya que la función vuelve en este contexto. Lo que hace que devolver cadenas como argumentos de función de C a Fortran sea más difícil que usar una cadena como argumento (ejemplo en el enlace de arriba) ... tienes que usar un puntero y luego el c_f_pointer Fortran intrínseco para convertir de la secuencia C a una cadena Fortran , según lo explicado por haraldkl. Aquí hay otro ejemplo de código:

program test_c_func
use iso_c_binding
implicit none
type (C_PTR) :: C_String_ptr
character (len=1, kind=c_char), dimension (:), pointer :: ErrChars => null ()
character (len=255) :: ErrString
integer :: i
INTERFACE
FUNCTION GetLastErrorMessage () bind (C, name="GetLastErrorMessage" )
USE ISO_C_BINDING
type (C_PTR) :: GetLastErrorMessage
END FUNCTION GetLastErrorMessage
END INTERFACE
C_String_ptr = GetLastErrorMessage ()
call c_f_pointer ( C_String_ptr, ErrChars, [255] )
ErrString = " "
xfer_string: do i=1, 255
if ( ErrChars (i) == c_null_char) exit xfer_string
ErrString (i:i) = ErrChars (i)
end do xfer_string
write (*, ''( "Fortran: <", A, ">" )'' ) trim (ErrString)
end program test_c_func

Answer 5

Mi agradecimiento a heraldkl por darme la solución a este problema tan frustrante. Estoy publicando lo que finalmente implementé, los roles de la conversión del puntero a la interfaz, lo que significa que la aplicación final puede llamar a la función C sin tener que conocer la conversión del puntero:

La función C:

// The C declaration header (using __cdecl in a def file):
extern "C" const char* GetLastErrorMessage();

El módulo de interfaz FORTRAN:

MODULE mINTERFACES
USE ISO_C_BINDING
INTERFACE
FUNCTION GetLastErrorMessagePtr [C, ALIAS: ''_GetLastErrorMessage''] ()
USE ISO_C_BINDING
TYPE(C_PTR) :: GetLastErrorMessagePtr
END FUNCTION GetLastErrorMessagePtr
END INTERFACE
CONTAINS ! this must be after all INTERFACE definitions
FUNCTION GetLastErrorMessage()
USE ISO_C_BINDING
CHARACTER*255 :: GetLastErrorMessage
CHARACTER, POINTER, DIMENSION(:) :: last_message_array
CHARACTER*255 last_message
INTEGER message_length
CALL C_F_POINTER(GetLastErrorMessagePtr(), last_message_array, [ 255 ])
DO 10 i=1, 255
last_message(i:i+1) = last_message_array(i)
10 CONTINUE
message_length = LEN_TRIM(last_message(1:INDEX(last_message, CHAR(0))))
GetLastErrorMessage = last_message(1:message_length-1)
END FUNCTION GetLastErrorMessage

Y para llamar a esta función desde un programa FORTRAN:

USE MINTERFACES
PRINT *, "--> GetLastErrorMessage: ''", TRIM(GetLastErrorMessage()), "''"

Mi agradecimiento nuevamente a heraldkl por proporcionar esta solución. No tenía ni idea de cómo hacerlo sin su aporte.

Answer 6

Si conoce la longitud de la cadena, entonces la respuesta anterior de Pap se puede simplificar enormemente:

function stringc2f(n, cstr) result(fstr)
integer, intent(in) :: n
type(c_ptr), intent(in) :: cstr
character(:), allocatable :: fstr
character(n, kind=c_char), pointer :: fptr
call c_f_pointer(cstr, fptr)
fstr = fptr
end function

La función anterior acepta un puntero C con la cadena y la longitud de la cadena, y devuelve una copia como una cadena Fortran.