Julia - C-Schnittstelle mit nicht-fundamentalen Typen

Question

Ich erweitere ein Julia-Paket, das eine C-Bibliothek verwendet. Ich muss einige C-Funktionen von Julia anrufen. Sie sehen etwas wie folgt aus:

struct contained { 
    int x; 
    int y; 
    int z; 
}; 
struct mystruct { 
    int n; 
    contained* arr; 
}; 
mystruct* mk_mystruct(int n, contained* arr); 
void use_mystruct(mystruct* foo); 

Ich habe auch die entsprechenden Typen in Julia erklärt:

type contained 
    x::Int64 
    y::Int64 
    z::Int64 
end 
type mystruct 
    n::Int64 
    arr::Array{contained, 1} 
end 

Um ccall Funktionen, die eine contained* als Argument nehmen, funktioniert alles einwandfrei Behandlung der contained* als Ptr{Int64}:

con = fill(0, 5, 3); 
mys = ccall((:mk_mystruct, "mylib"), Ptr{mystruct}, (Int64, Ptr{Int64}), n, con) 

ich nehme an, dies funktioniert, weil contained den gleichen m hat Emory Layout als ein Array von Int64s. So wird es auch anderswo im Julia-Paket gemacht. Aber der einzige Weg, den ich kenne, um den Wert des zurückgegebenen mystruct zu überprüfen, ist, es mit unsafe_load zu dereferenzieren, an diesem Punkt stürzt Julia von einem segfault ab. Was ist der richtige Weg, um einen Zeiger in Julia zu dereferenzieren?

Die C-Bibliothek enthält auch recht-Druckfunktionen, so dass anstelle von dereferencing den Zeiger in Julia ich den Zeiger als undurchsichtig behandeln könnte und es zurück zu dieser C-Funktion übergeben:

void print_mystruct(mystruct* foo, FILE* outputfile) 

Im C-Code, dies wird mit outputfile=stdout aufgerufen. Wie würde ich dies mit ccall einrichten? Das funktioniert natürlich nicht:

ccall((:print_mystruct, "mylib"), Void, (Ptr{mystruct}, Ptr{Void}), mys, stdout) 

Was sollte ich statt Ptr{Void} und stdout? Wie implementiert Julia I/O in der C-Schnittstelle?

Answer 1

Wenn Sie den Typ in Julia deklarieren, müssen Sie die gleichen Typen wie C erklären:

type contained 
    x::Cint 
    y::Cint 
    z::Cint 
end 
type mystruct 
    n::Cint 
    arr::Ptr{contained} 
end 

Der Typ Julia Array{contained, 1} würde jl_value_t* in C entsprechen und die Julia Typ Int würde intptr_t in C entsprechen

Ich kenne keine Plattform-agnostische Weise, um ein Handle zu stdout zu bekommen, da die meisten Plattformen ein C-Header-Makro erweitern müssen, um den echten Symbolnamen herauszufinden. Zum Beispiel auf macOS, wird es zu __stdoutp umbenannt:

julia> unsafe_load(cglobal(:__stdoutp, Ptr{Void})) 
Ptr{Void} @0x00007fff751f7348 

julia> ccall(:fprintf, Csize_t, (Ptr{Void}, Cstring, Cint...), ans, "hi\n") 
hi 
0x0000000000000003 

Sie interessiert sein, die Clang.jl package bei der Prüfung, die automatisch diese Definitionen aus Parsen der Header-Dateien erzeugen kann.