Gestire con un Puntatore le Strutture esterne
Come descritto anche nella pagina dedicata alla gestione in modo sicuro delle Strutture esterne, la lettura e la scrittura effettuate su Strutture esterne di una certa complessità è sempre molto difficile. Tanto è che, nella pagina segnalata nel collegamento, si è proposto nei casi più difficili di creare un'apposita libreria dinamica .so esterna scritta in C, nella quale gestire con le risorse del linguaggio C i membri di tali Strutture molto complesse sia in lettura che in scrittura.
La difficoltà della gestione delle Strutture molto complesse, appartenenti a librerie condivise .so esterne, consiste nel fatto che, tentando di riprodurre nel progetto Gambas tali Strutture, il linguaggio non riesce sempre a gestire la coerenza dei necessari allineamenti tra alcuni particolari membri costituenti la Struttura medesima.
Ad ogni modo alcune Strutture complesse possono essere affrontate tentandone la lettura e la scrittura attraverso un Puntatore. All'interno dell'area puntata da detto Puntatore si scorrerà con i Memory Stream (per la lettura e/o scrittura), oppure semplicemente sommando o sottrando valori alla variabile Puntatore come segue:
p = p + n p = p - n
oppure con le funzioni
Inc p Dec p
e quindi dereferenziando con le apposite funzioni di dereferenziazione di un Puntatore previste da Gambas (solo per la lettura).
L'ostacolo maggiore è rappresentato dagli eventuali necessari allineamenti fra i membri, dei quali si dovrà tenere rigidamente conto durante la lettura e la scrittura nello spostamento lungo l'area puntata dal Puntatore.
In particolare, sorvolando sull'ovvia circostanza che i valori del primo membro della Struttura esterna sono leggibili e scrivibili a cominciare dal primo byte dell'area puntata dal Puntatore, v'è da precisare che per i valori appartenenti ai membri successivi al primo membro, il primo byte del valore di ogni membro (successivo al primo membro della Struttura) si trova al numero di indice (offset) uguale al valore che rappresenta la dimensione (quantità di byte occupati) del tipo di variabile contenente il valore medesimo, oppure uguale - se tale indice è già occupato da altro valore - al multiplo più prossimo al valore della dimensione predetta.
Cerchiamo di spiegare meglio quanto detto con un esempio.
Poniamo il caso che la Struttura presente nella libreria condivisa dinamica esterna sia così composta:
struct STRUTTURA {
char c;
int i;
char * p;
short s;
};
Laddove sostanzialmente abbiamo:
il primo membro di tipo char occupa 1 byte di memoria (come in Gambas il tipo Byte);
il secondo membro di tipo int occupa 4 byte di memoria (come in Gambas il tipo Integer);
il terzo membro di tipo char * (Puntatore) occupa 8 byte (nei sistemi a 64bit) di memoria (come in Gambas il tipo Pointer);
il quarto membro di tipo short occupa 2 byte di memoria (come in Gambas il tipo Short).
Tali membri sono dislocati all'interno dell'area di memoria occupata dalla loro Struttura secondi il seguente ragionamento e calcolo:
- il valore contenuto dal primo membro, ovviamente, ha inizio nell'area di memoria dal byte di indice 0 (il primo membro coincide sempre con l'indice zero).
Il primo membro occupa, come abbiamo visto solo un byte di memoria nell'area riservata, pertanto il prossimo byte da verificare è quello di indice 1.
- Il secondo membro, però, essendo un Intero (int) ha una dimensione di 4 byte (occupa, cioè, 4 byte di memoria per rappresentare il valore assegnatogli). Pertanto, si dovrà verificare se il numero dell'indice (offset) disponibile (abbiamo visto che ora è uguale a 1) coincide con il valore della dimensione del tipo int, oppure con un suo multiplo (8, 12, 16, 20, etc). Notiamo che 1 (l'indice attuale) non coincide con il 4 (dimensione di memoria occupata dal tipo int) né con un suo multiplo. Pertanto, sposteremo in avanti l'indice di un altro byte per la verifica. L'indice 1 resterà con valore zero ed entrando così a far parte dell'allineamento.
Ora verifichiamo il nuovo indice disponibile: 2, che come il precedente non corrisponde al numero 4 (ricordiamo che v'è da piazzare un Intero !) né ad un multiplo di 4. Quindi spostiamo ancora in avanti il puntatore interno dell'indice (offset), come fatto appena prima, e lasceremo a zero anche il terzo byte (ossia quello di indice 2 !), entrando così anch'esso a far parte dell'allineamento.
Ora verifichiamo il nuovo indice disponibile: 3, che come il precedente non corrisponde al numero 4 (ricordiamo che v'è da piazzare un Intero !) né ad un multiplo di 4. Quindi spostiamo ancora in avanti il puntatore interno dell'indice, e lasceremo a zero anche il quarto byte (ossia quello di indice 3), entrando così anch'esso a far parte dell'allineamento.
Ora verifichiamo il nuovo indice disponibile: 4. Questo numero corrisponde esattamente con il valore della dimensione di un Intero (int). Quindi il primo byte del valore assegnato a tale Intero sarà posto al byte di indice 4 (dunque al 5° byte), e occuperà ovviamente ben 4 byte, spostando così il puntatore interno al byte di indice 8 dell'area di memoria della Struttura esterna.
- Possiamo passare ad individuare il terzo membro, che essendo una variabile Puntatore (char *) occupa 8 byte (nei sistemi a 64bit). Esso occuperà (nei sistemi a 64bit) comunque 8 byte di memoria, qualunque sia la dimensione dell'area di memoria riservata, che nel codice sarà stata allocata con la funzione malloc(), alla quale esso punta. Dobbiamo, quindi, verificare se l'attuale numero dell'indice disponibile, al quale ci siamo sin'ora spostati, corrisponde a 8 o ad un multiplo di 8 (8, 16, 24, 32, etc).
Abbiamo che l'indice attuale è 8 (9° byte dell'area di memoria della Struttura esterna) che corrisponde esattamente con il valore della dimensione di un Puntatore. Pertanto il primo byte del valore contenuto dalla variabile Puntatore char * (ossia l'indirizzo di memoria puntata da questa variabile di tipo Puntatore) è posto al byte di indice 8 (9° byte), ed occuperà in totale ben 8 byte, spostando così il puntatore interno al byte di indice 16 dell'area di memoria della Struttura esterna.
- Possiamo passare ad individuare il quarto membro, che essendo una variabile Short (short) occupa 2 byte. Dobbiamo, quindi, verificare se l'attuale numero dell'indice disponibile, al quale ci siamo sin'ora spostati, corrisponde a 2 o ad un multiplo di 8 (4, 6, 8, 10, 12, 14, 16, etc).
Abbiamo che l'indice attuale è 16 (17° byte dell'area di memoria della Struttura esterna) che corrisponde ad un multiplo del valore della dimensione di uno short. Pertanto il primo byte del valore contenuto dalla variabile short è posto al byte di indice 16 (17° byte), ed occuperà in totale ben 2 byte.
La dimensione totale della Struttura raggiungerà il valore più prossimo pari ad un multiplo di 8. In tal caso: 24. Quindi la Struttura "in quanto tale" occuperà complessivamente 24 byte di memoria.
Mostriamo di seguito un esempio di gestione della Struttura in linguaggio C appena descritta sopra. In particolare, per essa scriveremo un'apposita libreria dinamica e condivisa .so esterna, mediante la quale sarà utilizzata con un'applicazione Gambas principale la predetta Struttura in tutti i suoi membri sia scivendovi che leggendovi valori.
Private Extern Valorizza(stP As Pointer) As Pointer In "/tmp/libadhoc"
Public Sub Main()
Dim p, rit, rit2 As Pointer
Dim bb As Byte[] = [1, 2, 3, 4]
Dim st1, st2 As Stream
Dim b As Byte
Dim c As Short
Dim i As Integer
CreaSo()
' Per usare il "Puntatore", è necessario allocare un'area di memoria di dimensione pari alla quantità di memoria occupata dalla "Struttura" esterna in C da gestire:
p = Alloc(24)
' Scriviamo dei valori dell'area di memoria allocata, che sarà passata successivamente alla funzione esterna per assegnare detti valori alla "Struttura" esterna da gestire:
st1 = Memory p For Write
Write #st1, 9 As Byte
Seek #st1, 4
Write #st1, 9999 As Integer
Write #st1, bb.Data As Pointer
Write #st1, 99 As Short
st1.Close
' Viene invocata la funzione esterna per l'assegnazione dei valori scritti nell'area di memoria allocata e puntata dal "Puntatore", e per leggere successivamente i dati dalla "Struttura" medesima:
rit = Valorizza(p)
' La lettura dei dati presenti nell'area di memoria puntata dal "Puntatore" passato dalla funzione esterna, può avvenire con la dereferenziazione mediante i "Memory Stream"...:
st = Memory rit For Read
Read #st1, b
Print "Valore del 1° membro (char): ";; b
Seek #st1, 4
Read #st1, i
Print "Valore del 2° membro (int): ";; i
Read #st1, rit2
st2 = Memory rit2 For Read
Read #st2, b
Print "\nValore indice 0 del 3° membro (char *): ";; b
Read #st2, b
Print "Valore indice 1 del 3° membro (char *): ";; b
Read #st2, b
Print "Valore indice 2 del 3° membro (char *): ";; b
Read #st2, b
Print "Valore indice 3 del 3° membro (char *): ";; b
st2.Close
Read #st1, c
Print "\nValore del 4° membro (short): ";; c
' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' ...oppure scorrendo all'interno del "Puntatore" e dereferenziando con le apposite funzioni di Gambas di dereferenziazione:
rit = Valorizza(p)
Print "Valore del 1° membro (char): ";; Byte@(rit)
rit2 = rit + 4
Print "Valore del 2° membro (int): ";; Int@(rit2)
rit2 = rit + 8
Print "\nValore indice 0 del 3° membro (char *): ";; Byte@(Pointer@(rit2))
Print "Valore indice 1 del 3° membro (char *): ";; Byte@(Pointer@(rit2) + 1)
Print "Valore indice 2 del 3° membro (char *): ";; Byte@(Pointer@(rit2) + 2)
Print "Valore indice 3 del 3° membro (char *): ";; Byte@(Pointer@(rit2) + 3)
rit2 = rit + 16
Print "\nValore del 4° membro (short): ";; Short@(rit2)
Free(p)
End
Private Procedure CreaSo()
Dim s As String
' Impostiamo il codice sorgente C della futura libreria dinamica codivisa .so:
s = "#include <stdlib.h>\n" &
"#include <stdio.h>\n\n" &
"struct STRUTTURA {\n" &
"char c;\n" &
"int i;\n" &
"char * p;\n" &
"short s;\n};\n\n" &
"struct STRUTTURA Ra;\n\n" &
"struct STRUTTURA * Valorizza(struct STRUTTURA *St) {\n" &
"St->c *= 10;\n" &
"St->i *= 10;\n" &
"St->p[0] *= 10;\n" &
"St->p[1] *= 10;\n" &
"St->p[2] *= 10;\n" &
"St->p[3] *= 10;\n" &
"St->s *= 10;\n" &
"Ra = *St; /* Assegna i dati della variabile St alla omogenea variabile Ra */\n" &
"St = (struct STRUTTURA *) 0; /* Pulisce ed azzera i membri della Struttura */\n" &
"return &Ra;\n}"
File.Save("/tmp/libadhoc.c", s)
' Crea la libreria dinamica codivisa .so:
Shell "gcc -o /tmp/libadhoc.so /tmp/libadhoc.c -shared -fPIC" Wait
End
Indice
Altro esempio pratico
Mostriamo di seguito un altro esempio pratico, un po' più complesso del precedente, in cui il codice sorgente in C della libreria dinamica condivisa .so esterna è il seguente:
#include <stdlib.h>
struct AAA {
char c;
short s;
int i;
char * p[5];
char * p1, * p2;
int n;
};
struct AAA a;
struct AAA * Estrae_Valori() {
a.c = 0x0F;
a.s = 0x0400;
a.i = 0x00444444;
a.p[0] = (char *) malloc(4);
a.p[1] = (char *) malloc(4);
a.p[2] = (char *) malloc(4);
a.p[3] = (char *) malloc(4);
a.p[4] = (char *) malloc(4);
a.p[0][0] = 0x01;
a.p[0][1] = 0x02;
a.p[0][2] = 0x03;
a.p[0][3] = 0x04;
a.p[1][0] = 11;
a.p[1][1] = 11;
a.p[1][2] = 11;
a.p[1][3] = 11;
a.p[2][0] = 22;
a.p[2][1] = 22;
a.p[2][2] = 22;
a.p[2][3] = 22;
a.p[3][0] = 33;
a.p[3][1] = 33;
a.p[3][2] = 33;
a.p[3][3] = 33;
a.p[4][0] = 44;
a.p[4][1] = 44;
a.p[4][2] = 44;
a.p[4][3] = 44;
a.p1 = (char *) malloc(4);
a.p1[0] = 99;
a.p1[1] = 99;
a.p1[2] = 99;
a.p1[3] = 99;
a.p2 = "efgh";
a.n = 10000;
return &a;
}
che ritorna alla funzione chiamante di Gambas l'indirizzo di memoria della sua Struttura.
Nel codice Gambas, che segue, si andrà a leggere da un Puntatore, che ha raccolto l'indirizzo di memoria della Struttura esterna ritornata dalla libreria esterna, e con i Memory Stream i valori dei vari membri della predetta Struttura
Si ponga particolare attenzione al calcolo per l'eventuale necessaroi allineamento dei membri.
Private Extern Estrae_Valori() As Pointer In "/tmp/stru"
Public Sub Main()
Dim p, po, p1, p2 As Pointer
Dim st, re, s1, s2 As Stream
Dim b As Byte
Dim j As Short
Dim t As String
' Generiamo la libreria esterna, scritta in C, contenente la "Struttura":
Shell "gcc -o /tmp/stru.so " & Application.Path &/ "stru.c -shared -fPIC" Wait
p = Estrae_Valori()
st = Memory p For Read
Print Read #st As Byte ' Legge il 1° membro (char) che occupa 1 byte
Seek #st, 2 ' Ci spostiamo nel rispetto dell'allineamento dei membri
Print Read #st As Short ' Legge il 2° membro (short) che occupa 2 byte
Print Read #st As Integer ' Legge il 3° membro (int) che occupa 4 byte
Read #st, po ' Legge il 3° membro: il puntatore (che occupa 8 byte) della prima dimensione di char * p[5]
re = Memory po For Read ' Andiamo a dereferenziare il "Puntatore" per leggere nell'area di memoria da esso puntata
For j = 0 To 3
Read #re, b
Print j, b
Next
Seek #re, 32 ' Per ciascuna dimensione si salta di 32 byte avanti
For j = Seek(re) To Seek(re) + 3
Read #re, b
Print j, b
Next
Seek #re, 64 ' Per ciascuna dimensione si salta di 32 byte avanti
For j = Seek(re) To Seek(re) + 3
Read #re, b
Print j, b
Next
Seek #re, 96 ' Per ciascuna dimensione si salta di 32 byte avanti
For j = Seek(re) To Seek(re) + 3
Read #re, b
Print j, b
Next
Seek #re, 128 ' Per ciascuna dimensione si salta di 32 byte avanti
For j = Seek(re) To Seek(re) + 3
Read #re, b
Print j, b
Next
re.Close
Seek #st, Seek(st) + (SizeOf(gb.Pointer) * 4) ' Si moltiplica per l'indice massimo di char * p[n]
Read #st, p1 ' Legge il 5° membro: il puntatore (che occupa 8 byte) della prima dimensione di char * p1
s1 = Memory p1 For Read ' Andiamo a dereferenziare il "Puntatore" per leggere nell'area di memoria da esso puntata
For j = 0 To 3
Read #s1, b
Print j, b
Next
s1.Close
Read #st, p2 ' Legge il 6° membro: il puntatore (che occupa 8 byte) della prima dimensione di char * p2
s2 = Memory p2 For Read ' Andiamo a dereferenziare il "Puntatore" per leggere nell'area di memoria da esso puntata
Read #s2, t
Print t
s2.Close
Print Read #st As Integer ' Legge il 7° membro (int) che occupa 4 byte
st.Close
End
Caso di Struttura contenente altra Struttura
Qualora una Struttura contenga un'altra Struttura, la Struttura innestata occupa, qualora essa venga dichiarata con una ordinaria variabile di tipo Struttura, una quantità di byte pari alla sua stessa dimensione. Se, invece, la Struttura innestata è dichiarata all'interno della Struttura principale con un Puntatore, allora essa occupa la quantità di byte occupati ordinariamente dalla variabile di tipo Puntatore.
Mostriamo due codici esemplificativi.
Primo esempio
Nel seguente codice la Struttura secondaria, innestata in quella principale, è dichiarata con una ordinaria varibile di tipo Struttura:
#include <stdio.h>
struct STRUTTURA {
char c;
short s;
int i;
struct Innesto {
short Is;
long Il;
} In;
} St;
int main() {
printf("%ld\n", sizeof(St));
return (0);
}
In tal caso la dimensione complessiva della Struttura principale (che nell'esempio abbiamo denominato con l'identificativo: STRUTTURA) è pari a 24 byte, così distribuiti:
- 1 byte per il primo membro (essendo di tipo char);
- 1 byte per il necessario allineamento;
- 2 byte per il secondo membro (essendo di tipo short);
- 4 byte per il terzo membro (essendo di tipo int);
- 2 byte per il primo membro della Struttura innestata (essendo di tipo short);
- 2 byte per il necessario allineamento;
- 8 byte per il secondo membro della Struttura innestata (essendo di tipo long).
Secondo esempio
In questo secondo codice, invece, la Struttura secondaria, innestata in quella principale, è dichiarata mediante una varibile di tipo Puntatore:
#include <stdio.h>
struct STRUTTURA {
char c;
short s;
int i;
struct Innesto {
short Is;
long Il;
} *In;
} St;
int main() {
printf("%ld\n", sizeof(St));
return (0);
}
In tal caso la dimensione complessiva della Struttura principale è pari a 16 byte, così distribuiti:
- 1 byte per il primo membro (essendo di tipo char);
- 1 byte per il necessario allineamento;
- 2 byte per il secondo membro (essendo di tipo short);
- 4 byte per il terzo membro (essendo di tipo int);
- 8 byte (nei sistemi a 64bit) per il quarto membro (essendo una variabile di tipo Puntatore).
