ruby - ¿Es posible usar Fiddle para pasar o devolver una estructura a código nativo?

ffi

Question

Me gustaría usar Fiddle para acceder a una biblioteca nativa compilada desde el código Rust. La representación en C de la estructura es muy simple, es solo un puntero y una longitud:

typedef struct {
char *data;
size_t len;
} my_thing_t;
// Example function that somehow accepts a struct
void accepts_a_struct(my_thing_t thing);
// Example function that somehow returns a struct
my_thing_t returns_a_struct(void);

Sin embargo, todos los ejemplos que puedo encontrar aceptan o devuelven punteros a estructuras, y no las estructuras en sí. Me gustaría evitar la doble indirección si es posible.

He tomado prestado un ejemplo de la documentación de Fiddle::Importer . Sin embargo, no veo cómo llamar correctamente al método extern con una estructura en lugar de un puntero a una estructura:

require ''fiddle''
require ''fiddle/import''
module LibSum
extend Fiddle::Importer
dlload ''./libsum.so''
extern ''double sum(double*, int)''
extern ''double split(double)''
end

Nota

El violín no es lo mismo que la gema FFI . Fiddle es un componente de la biblioteca estándar de Ruby y no se proporciona como una gema separada. Estas preguntas relacionadas se refieren a la gema de FFI, y no a Fiddle:

• ¿Cómo envolver la función en el método Ruby FFI que toma struct como argumento?
• ¿Cómo especifico una estructura como el valor de retorno de una función en RubyFFI?

Answer 1

He revisado la documentación de Fiddle y, como puedo ver, no es posible, ya que incluso en la definición de la función central Fiddle::Function.new requiere Fiddle::CParser pueda manejar Fiddle::CParser . He hecho varias pruebas y, para hacer que funcione, tuve que transformar tu código en algo como esto:

prueba2.c

#include <stdio.h>
#include <stdlib.h>
typedef struct {
char *data;
char *more_data;
size_t len;
} my_thing_t;
my_thing_t *returns_a_struct(void){
my_thing_t *structure = malloc(sizeof(my_thing_t));
structure->data = "test2";
structure->more_data = "I am more data";
structure->len = 5;
return structure;
};

irb

require ''fiddle''
require ''fiddle/import''
module Testmd
extend Fiddle::Importer
dlload ''./test2.dll''
RetStruct = struct [''char *data'',''char *more_data'',''size_t len'']
extern ''RetStruct* returns_a_struct(void)''
end
include Testmd
2.2.1 :013 > res = Testmd::returns_a_struct(nil)
=> #<Fiddle::Pointer:0x00000000b12a10 ptr=0x00000000e066b0 size=0 free=0x00000000000000>
2.2.1 :014 > s = RetStruct.new(res)
=> #<Testmd::RetStruct:0x00000000c3e9e8 @entity=#<Fiddle::CStructEntity:0x000000007f0ad0 ptr=0x00000000e066b0 size=24 free=0x00000000000000>>
2.2.1 :015 > s.data.to_s
=> "test2"
2.2.1 :016 > s.more_data.to_s
=> "I am more data"
2.2.1 :017 > s.len
=> 5

Lo que descubrí es que Fiddle puede operar con tipos simples pero necesita que se pasen tipos de struct y de union usando referencias. Todavía tiene envoltorios para estas clases. Además, estos envoltorios se heredan de Fiddle::Pointer lo que nos lleva a la conclusión de que quieren que usemos punteros para estos tipos de datos.

Si desea más detalles sobre esto o desea agregar esta funcionalidad, puede ir a través de su repositorio git .