Создание интерфейса FORTRAN для функции C, которая возвращает символ *

Строки динамической длины всегда немного сложны с взаимодействием C. Возможное решение - использовать указатели.

Сначала простой случай, когда вам нужно передать строку с завершающим нулевым символом в C-функцию. Если вы действительно передаете строку только внутрь, вы должны убедиться, что завершили ее с помощью c_null_char, поэтому это направление довольно прямолинейно. Вот примеры из интерфейса 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

А интерфейс lua_getfield выглядит так:

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

А интерфейс C-Code:

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

Теперь немного более сложный случай, когда нам нужно иметь дело с возвращаемой строкой из C с динамической длиной. Самым портативным решением, которое я нашел до сих пор, является использование указателей. Вот пример с указателем, где строка задается программой C (также из упомянутой выше библиотеки Aotus):

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

где lua_tolstring имеет следующий интерфейс:

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

Наконец, вот попытка пояснить, как c_ptr можно интерпретировать как строку символов Фортрана: Предположим, у вас есть c_ptr, указывающий на строку:

type(c_ptr) :: a_c_string

Его длина задается переменной len следующего типа:

integer(kind=c_size_t) :: stringlen

Вы хотите получить эту строку в виде указателя на символьную строку в Фортране:

character,pointer,dimension(:) :: string

Итак, вы делаете отображение:

call c_f_pointer(a_c_string, string, [ stringlen ])

Благодарю heraldkl за решение этой очень неприятной проблемы. Я публикую то, что в конечном итоге реализовал, какие роли выполняет преобразование указателя в интерфейс, что означает, что конечное приложение может вызывать функцию C, не зная о преобразовании указателя:

Функция C:

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

Модуль интерфейса 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

И чтобы вызвать эту функцию из программы FORTRAN:

USE MINTERFACES

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

Еще раз благодарю heraldkl за предоставление этого решения - я бы и понятия не имел, как это сделать без его участия.

Эта ветка немного устарела, но, поскольку у меня была аналогичная проблема (и, вероятно, у других будет), я все равно отправляю ответ.

Приведенные выше коды вызовут ошибку сегментации, если по какой-то причине строка C равна нулю. Кроме того, нет необходимости возвращать строку из 255 символов (которую, вероятно, нужно будет обрезать перед использованием), поскольку Fortran 2003/2008 поддерживает функции, возвращающие размещаемые объекты. Используя всю информацию, опубликованную выше, я получил следующую функцию, которая получает строку C (указатель) и возвращает соответствующую строку Fortran; Если строка C имеет значение NULL, она возвращает «NULL», аналогично C «(null)», напечатанному в аналогичных случаях:

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

Я всегда борюсь с этими функциями совместимости. Я думаю, что ваш интерфейс должен объявлять

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

и что, когда вы вызываете функцию, вы передаете соответствующую символьную переменную Fortran с длиной, равной или большей, чем длина массива символов C, который вы ожидаете вернуть.

Поскольку у вас, похоже, есть Intel Fortran, просмотрите предоставленные образцы кода, они дают полный пример для этого.

Я думаю, вы знаете, что то, что вы опубликовали, не является синтаксически правильным Фортраном?

Я также боролся с вызовом процедуры C, которая возвращает строку, и приведенные выше ответы были очень полезны, но, поскольку я почти ничего не знаю о C, и ответы немного сбивают с толку, я просто хотел внести свое решение, которое использует указатель C, я сделал не удалось использовать ни одно из других предложений выше. Программа C, которую я вызываю, открывает отдельное окно для поиска имени файла.

program test
  use iso_c_binding
  implicit none
! A C function that returns a string need a pointer to the array of single char 
  type (c_ptr) :: C_String_ptr
! This is the Fortran equivalent to a string of single char
  character (len=1, kind=c_char), dimension(:), pointer :: filchar=>null()
! Interface to a C routine which opens a window to browse for a file to open
  interface
    function tinyopen(typ) bind(c, name="tinyopen")
       use iso_c_binding
       implicit none
       integer(c_int), value :: typ
       type (C_Ptr) :: tinyopen
    end function tinyopen
  end interface
  character (len=256) :: filename
  integer typ,jj
  typ=1
C_String_ptr = tinyopen(typ)
! convert C pointer to Fortran pointer
  call c_f_pointer(C_String_ptr,filchar,[256])
  filename=' '
  if(.not.associated(filchar)) then
! if no characters give error message
    write(*,*)'No file name'
  else
! convert the array of single characters to a Fortran character
    jj=1
    do while(filchar(jj).ne.c_null_char)
      filename(jj:jj)=filchar(jj)
      jj=jj+1
    enddo
  endif
  write(*,*)'Text is: ',trim(filename)
end program test

Надеюсь, этот пример упростит следующий пример с той же проблемой.

В Фортране элемент должен быть объявлен как «символ (kind = c_char, len = 1), Dimension (255)», а не len = 255. Это создаст массив символов длиной один, что вам нужно на стороне C. Что может сбивать с толку, так это то, что существует исключение, которое позволяет Фортрану сопоставлять строки с одномерными массивами.

Вы имеете в виду, что хотите вызвать процедуру Fortran из C? См. Этот пример: Вызов подпрограммы FORTRAN из C.

РЕДАКТИРОВАТЬ: И ifort, и gfortran говорят, что массивы не разрешены, поскольку функция возвращается в этом контексте. Это делает возвращение строк в качестве аргументов функции из C в Fortran сложнее, чем использование строки в качестве аргумента (пример в ссылке выше) ... вам нужно использовать указатель, а затем встроенную функцию c_f_pointer Fortran для преобразования из строки C в строку Fortran , как пояснил haraldkl. Вот еще один пример кода:

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

Если вам известна длина строки, то приведенный выше ответ Папа можно значительно упростить:

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

Вышеупомянутая функция принимает указатель C со строкой и длиной строки и возвращает копию в виде строки Fortran.