Richiamare funzioni esterne di librerie scritte in C++
Caso in cui è possibile richiamare direttamente le funzioni esterne in Gambas
Nei casi di librerie, scritte in C++, più semplici, è possibile richiamare direttamente le funzioni in esse presenti.
Il sorgente della libreria sarà compilato con il comando "g++", ma avendo accortezza di dare alla futura libreria esterna l'estensione ".so", proprio come se fosse una libreria scritta in C.
Esempio pratico. Poniamo il caso di avere il seguente file sorgente scritto in C++:
#include <cstdlib>
#include <sstream>
#include <string.h>
int Funzione_1() {
int a;
a = 100;
return a;
}
char s[32];
char * Funzione_2() {
strcpy(s, "testo da Funzione_2");
return s;
}
Salviamo questo codice nel file sorgente ad esempio nel seguente percorso: /tmp/prova.cpp
Successivamente il file sorgente sarà così compilato:
g++ -o /tmp/prova.so /tmp/prova.cpp -shared -fPIC
Per utilizzare le funzioni nel codice Gambas, dobbiamo cercare il loro esatto nome, lanciando in terminale il comando
:~$ nm -D '/tmp/prova.so'
oppure
:~$ objdump -T '/tmp/prova.so'
Troveremo le due funzioni che riportato il proprio nome un po' modificato, similmente ai seguenti:
_Z10Funzione_1v _Z10Funzione_2v
Pertanto nel codice Gambas saranno utilizzati questi identificatori per richiamare le due funzioni presenti nel codice sorgente scritto in C++.
Il codice Gambas sarà ad esempio il seguente:
Library "/tmp/prova" Private Extern _Z10Funzione_1v() As Integer Private Extern _Z10Funzione_2v() As String Public Sub Main() Print _Z10Funzione_1v() Print _Z10Funzione_2v() End
Altro esempio.
Sorgente scritto in C++:
#include <cstdlib>
#include <sstream>
#include <string.h>
int Funzione_1() {
int a;
a = 100;
return a;
}
char * Funzione_2(char *s[]) {
std::string t, r;
/* Vengono unite le stringhe di tipo base */
r = t + " " + std::string(s[0]) + " della libreria esterna in C++";
/* La variabile base stringa "r" viene convertita nel tipo 'char*', affinché possa essere restituita al codice Gambas */
char* rit = strcpy((char*)malloc(r.length()+1), r.c_str());
return rit;
}
Il semplice codice Gambas potrà essere il seguente:
Public Sub Main()
Dim p As Pointer
' Compila la libreria esterna ".so":
Shell "g++ -o /tmp/prova.so /tmp/prova.cpp -shared -fPIC" Wait
Print _Z10Funzione_1v()
p = Alloc("Testo del codice Gambas e")
Print _Z10Funzione_2PPc(VarPtr(p))
Free(p)
End
Caso in cui non sia possibile richiamare direttamente le funzioni esterne in Gambas
Con librerie esterne, scritte in C++, più complesse il richiamo con Extern delle funzioni esterne potrebbe non essere esperibile.
In tali casi risulta possibile soltanto richiamare la funzione principale, quella avente nome identificatore: "main()".
Così, se la libreria dinamica .so contiene più funzioni, queste dovranno essere chiamate comunque attraverso la funzione principale "main()", non essendo direttamente disponibili all'utente come quelle delle librerie condivise .so scritte in C.
Ciò comporta che con Extern non è possibile utilizzare direttamente l'API di librerie esterne condivise .so, ma si dovrà creare un'apposita libreria condivisa .so contenente la parte di programma, scritto in C++, che comprende la routine principale "main()", nella quale sono poste e vengono chiamate le funzioni esterne che si intendono realmente utilizzare.
Insomma, non verrà direttamente dichiarata ed invocata la funzione esterna, che ci interessa, della libreria C++, ma lo sarà una funzione principale "main()" di un'apposita libreria condivisa esterna .so, da noi scritta in C++. All'interno di tale funzione "main()" principale si porrà e si chiamerà la funzione esterna che realmente ci interessa chiamare.
La routine di "main()" - contenuta nella nostra libreria esterna di appoggio, scritta anch'essa ovviamente in C++ - fa dunque da tramite necessario, come già detto, per invocare le funzioni esterne di librerie scritte in C++ .
Ricapitolando si profila un rapporto secondo questo schema:
Gambas <--> Nostra libreria condivisa esterna di appoggio <--> libreria condivisa esterna scritta in C++
Caso in cui si debbano utilizzare più funzioni esterne
Nel caso in cui sia necessario utilizzare più funzioni esterne di una libreria scritta in C++, si possono adottare almeno un paio di soluzioni.
1 - Creare per ciascuna funzione un'apposita libreria condivisa .so esterna d'appoggio, ovviamente scritta in C++, nella quale è appunto contenuta la funzione esterna che a noi interessa invocare. In tal caso, quindi, ogni qual volta si debba utilizzare la funzione esterna, si provvederà ad invocare la funzione della libreria condivisa da noi scritta. La libreria esterna, da noi creata, farà nuovamente da veicolo per utilizzare la funzione esterna che ci interessa realmente.
Questa soluzione ha lo svantaggio, però, di dover realizzare - come ovvio - per ciascuna funzione un'apposita libreria esterna
2 - Creare, comunque, un'apposita libreria condivisa .so esterna, scritta in C++, nella quale porre tutte le funzioni che ci interessano e che dovremo richiamare ed utilizzare.
Si provvederà, poi, all'interno di detta unica libreria condivisa .so a distinguere l'uso di una o di altra funzione mediante l'invio di valori stringa o numerici univoci che saranno valutati da istruzioni condizionali, le quali consentiranno o meno di accedere ad una determinata funzione tra quelle contenute.
Di questa seconda modalità mostriamo un esempio pratico, nel quale abbiamo una certa libreria esterna condivisa .so, scritta in C++, contenente un paio di funzioni:
#include <cstdlib>
#include <sstream>
#include <string.h>
int Funzione_1() {
int a;
a = 100;
return a;
}
std::string Funzione_2() {
std::string s = "testo dalla";
return s;
}
int main(int c, char *s[]) {
int ritorno;
std::string t, r;
/* Se abbiamo passato "funzione_1", verrà invocata la "Funzione_1" */
if (strcmp((char *)s[0], "funzione_1") == 0) {
/* In questo caso viene ritornato un Intero */
ritorno = Funzione_1();
return ritorno;
}
/* Se abbiamo passato "funzione_2", verrà invocata la "Funzione_2". In questo caso viene ritornata per 'riferimento' una Stringa */
if (strcmp((char *)s[0], "funzione_2") == 0) {
t = Funzione_2();
/* Vengono unite le stringhe di tipo base */
r = t + " " + std::string(s[0]) + " della libreria esterna in C++";
/* La variabile base stringa "r" viene convertita nel tipo 'char*', affinché possa essere restituita al codice Gambas attraverso il parametro "char** s" della routine "main()" */
char* rit = strcpy((char*)malloc(r.length()+1), r.c_str());
*s = rit;
return -1;
}
}
Il semplice codice Gambas potrà essere il seguente:
' int main(int c, char *s[])
' E' la routine principale della libreria dinamica condivisa .so da noi creata.
Private Extern main(rit As Integer, po As Pointer) As Integer In "/tmp/libadhoc"
Public Sub Main()
Dim p As Pointer
Dim i As Integer = -1
' Qui va il nome di una delle due funzioni della libreria esterna in C++ che a noi interessa realmente utilizzare:
p = Alloc("funzione_2")
i = main(0, VarPtr(p))
Print "Dato ritornato:"
If i > -1 Then
Print i
Else
Print String@(p)
Endif
Free(p)
End
