Gestione delle Strutture esterne - Cronologia

Vuott il 23:41, 9 giu 2023

2023-06-09T23:41:49Z

← Versione meno recente		Versione delle 17:41, 9 giu 2023
Riga 453:		Riga 453:
	Public Sub Main()		Public Sub Main()

	<FONT Color=gray>' ''I bit che saranno elevati a 1, partendo dal 2° bit come fosse il primo identificato con il valore 1 (il 3° bit con valore 2 e così via).''		<FONT Color=gray>' ''I bit che saranno elevati a 1, partendo dal 2° bit (dato che il flag del primo bit effettivo è stato posto a zero nell'array "bb" e qui contrassegnato in rosso) come fosse il primo identificato con il valore 1 (il 3° bit con valore 2 e così via).''
	' ''In questo caso, cominciando dal 2° bit da destra), il valore 11 è dato da 3 bit:		' ''In questo caso, cominciando dal 2° bit da destra), il valore 11 è dato da 3 bit:
	' ''1 (che corrisponde al 2° bit da destra avente valore 2) +''		' ''1 (che corrisponde al 2° bit da destra avente valore 2) +''
Riga 464:		Riga 464:
	' ''''' totale: 566''		' ''''' totale: 566''
	''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''</font>		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''</font>
	Dim bb As Byte[] = [0, 11, 1, 0, 0, 0, 1, 0]		<FONT Color=gray>' ''Il 1° bit da destra <B>↙</b></font>
			Dim bb As Byte[] = [<FONT Color=red><B>0</b></font>, 11, 1, 0, 0, 0, 1, 0]

	Dim p As Pointer		Dim p As Pointer

Vuott il 23:30, 9 giu 2023

2023-06-09T23:30:21Z

← Versione meno recente		Versione delle 17:30, 9 giu 2023
Riga 446:		Riga 446:
	Gambas non prevede nella gestione delle proprie ''Strutture'' l'uso dei "Campi" che fanno riferimento ai singoli bit.		Gambas non prevede nella gestione delle proprie ''Strutture'' l'uso dei "Campi" che fanno riferimento ai singoli bit.
	<BR>Ad ogni modo, poiché in C ogni insieme di "Campi" occupa una quantità di memoria pari a un "Intero", in Gambas si dovrà provare ad utilizzare un membro di tipo di dato "Integer", assegnandogli un valore tale che i suoi bit siano posti a 1 e/o a 0, come dovuto. Nel fare ciò, bisognerà tenere conto che il primo identificatore di bit di "Campo", all'interno di una ''Struttura'' esterna scritta in C, corrisponde al bit meno significativo del tipo "Integer" (ossia quello più a destra nella rappresentazione binaria di un numero).		<BR>Ad ogni modo, poiché in C ogni insieme di "Campi" occupa una quantità di memoria pari a un "Intero", in Gambas si dovrà provare ad utilizzare un membro di tipo di dato "Integer", assegnandogli un valore tale che i suoi bit siano posti a 1 e/o a 0, come dovuto. Nel fare ciò, bisognerà tenere conto che il primo identificatore di bit di "Campo", all'interno di una ''Struttura'' esterna scritta in C, corrisponde al bit meno significativo del tipo "Integer" (ossia quello più a destra nella rappresentazione binaria di un numero).

			Vediamo di seguito un esempio pratico di utilizzo dei ''Campi'' con Gambas, per il quale sarà necessario creare un'apposita libreria esterna:
			Private Extern campi(cmp As Pointer) As Pointer In "/tmp/libcampi"


			Public Sub Main()

			<FONT Color=gray>' ''I bit che saranno elevati a 1, partendo dal 2° bit come fosse il primo identificato con il valore 1 (il 3° bit con valore 2 e così via).''
			' ''In questo caso, cominciando dal 2° bit da destra), il valore 11 è dato da 3 bit:
			' ''1 (che corrisponde al 2° bit da destra avente valore 2) +''
			' ''2 (che corrisponde al 3° bit da destra avente valore 4) +''
			' ''8 (che corrisponde al 4° bit da destra avente valore 16) =''
			' ''11 22 +''
			' '' 1 (che corrisponde al 6° bit da destra avente valore 32) =''
			' '' 54 +''
			' '' 1 (che corrisponde al 10° bit da destra con valore 512) =''
			' ''''' totale: 566''
			''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''</font>
			Dim bb As Byte[] = [0, 11, 1, 0, 0, 0, 1, 0]

			Dim p As Pointer

			Creaso()

			p = campi(bb.Data)
			If p == 0 Then Error.Raise("Errore !")

			Print CInt(p), "&h"; CStr(p)

			End

			Private Procedure Creaso()

			File.Save("/tmp/libcampi.c", "struct STRUTTURA {\n" &
			"<FONT Color=blue>/* Numero di bit necessari da coinvolgere per ciascun Campo a partire dal meno-significativo:*/</font>\n" &
			" unsigned a: 1;\n" & ' occupa un solo bit a cominciare dal 1° bit da destra
			" unsigned b: 4;\n" & ' occupa 4 bit a cominciare dal 2° bit da destra
			" unsigned c: 1;\n" & ' occupa un bit a cominciare dal 6° bit da destra (valore-byte 32)
			" unsigned d: 1;\n" & ' etc...
			" unsigned e: 1;\n" &
			" unsigned f: 1;\n" &
			" unsigned g: 1;\n};\n\n" &
			"struct STRUTTURA st;\n\n" &
			"struct STRUTTURA campi(char *cc) {\n" &
			" st.a = cc[0];\n" &
			" st.b = cc[1];\n" &
			" st.c = cc[2];\n" &
			" st.d = cc[3];\n" &
			" st.e = cc[4];\n" &
			" st.f = cc[5];\n" &
			" st.g = cc[6];\n" &
			" return st;\n}")

			Shell "gcc -o /tmp/libcampi.so /tmp/libcampi.c -shared -fPIC" Wait

			End

Vuott il 14:39, 9 giu 2023

2023-06-09T14:39:14Z

← Versione meno recente		Versione delle 08:39, 9 giu 2023
Riga 445:		Riga 445:
	=Gestione dei Campi bit di una Struttura=		=Gestione dei Campi bit di una Struttura=
	Gambas non prevede nella gestione delle proprie ''Strutture'' l'uso dei "Campi" che fanno riferimento ai singoli bit.		Gambas non prevede nella gestione delle proprie ''Strutture'' l'uso dei "Campi" che fanno riferimento ai singoli bit.
	<BR>Ad ogni modo, poiché in C ogni insieme di "Campi" occupa una quantità di memoria pari a un "Intero", in Gambas si dovrà provare ad utilizzare ~~una~~ membro di tipo di dato "Integer", assegnandogli un valore tale che i suoi bit siano posti a 1 e/o a 0, come dovuto. Nel fare ciò, bisognerà tenere conto che il primo identificatore di bit di "Campo", all'interno di una ''Struttura'' esterna scritta in C, corrisponde al bit meno significativo del tipo "Integer" (ossia quello più a destra nella rappresentazione binaria di un numero).		<BR>Ad ogni modo, poiché in C ogni insieme di "Campi" occupa una quantità di memoria pari a un "Intero", in Gambas si dovrà provare ad utilizzare un membro di tipo di dato "Integer", assegnandogli un valore tale che i suoi bit siano posti a 1 e/o a 0, come dovuto. Nel fare ciò, bisognerà tenere conto che il primo identificatore di bit di "Campo", all'interno di una ''Struttura'' esterna scritta in C, corrisponde al bit meno significativo del tipo "Integer" (ossia quello più a destra nella rappresentazione binaria di un numero).

Vuott il 23:43, 5 apr 2023

2023-04-05T23:43:02Z

← Versione meno recente		Versione delle 17:43, 5 apr 2023
Riga 95:		Riga 95:
	laddove la ''Struttura'', chiamata "Secondaria", occupa una quantità di memroia pari a 16 byte, mentre la ''Struttura'', chiamata "PRINCIPALE", occupa una quantità di memoria pari a 24 byte, così specificata:		laddove la ''Struttura'', chiamata "Secondaria", occupa una quantità di memroia pari a 16 byte, mentre la ''Struttura'', chiamata "PRINCIPALE", occupa una quantità di memoria pari a 24 byte, così specificata:
	<BR>- 1 byte dal primo membro che è un tipo di dato "char";		<BR>- 1 byte dal primo membro che è un tipo di dato "char";
	<BR>- 16 byte dal membro che fa riferimento all'altra ''Struttura'' (denominata "Secondaria"). Poiché la quantità di memoria occupata da questo secondo membro è superiore a quella occupata dal primo membro, allora per la norma dell'<I>allineamento</i> esso sarà posizionato al byte pari al numero d'indice corrispondente alla quantità di ~~memria~~ occupata, se libero, e comunque non superiore a 8. La ~~memria~~ occupata da questo secondo membro è 16, pertanto sarà adattato al valore d'indice 8 (o multiplo di 8, se il numero d'indice 8 è occupato da altro membro).		<BR>- 16 byte dal membro che fa riferimento all'altra ''Struttura'' (denominata "Secondaria"). Poiché la quantità di memoria occupata da questo secondo membro è superiore a quella occupata dal primo membro, allora per la norma dell'<I>allineamento</i> esso - <SPAN Style="text-decoration:underline">essendo successivo al primo membro della ''Struttura''</span> - sarà posizionato al byte pari al numero d'indice corrispondente alla quantità di memoria occupata, se libero, e comunque quantità non superiore a 8. La memoria occupata da questo secondo membro è 16, pertanto sarà adattato al valore d'indice 8 (o multiplo di 8, se il numero d'indice 8 è occupato da altro membro).
	<BR>Pertanto la quantità di memoria, occupata dalla ''Struttura'', chiamata "PRINCIPALE", è pari a 24 byte, come è agevolmente individuabile dal seguente codice in C:		<BR>Pertanto la quantità di memoria, occupata dalla ''Struttura'', chiamata "PRINCIPALE", è pari a 24 byte, come è agevolmente individuabile dal seguente codice in C:
	#include <stdio.h>		#include <stdio.h>
Riga 228:		Riga 228:

	==Allineamento dei membri nell'area di memoria allocata di una Struttura esterna scritta in C==		==Allineamento dei membri nell'area di memoria allocata di una Struttura esterna scritta in C==
	Quando la quantità di byte, occupati dal tipo di dati di un membro, successivo al primo, di una ''Struttura'', è superiore alla quantità occupata dal tipo di dati del membro precedente, esso è posto al numero d'indice (''offset'' ) uguale alla quantità di byte occupati dal tipo di dati di appartenenza e <SPAN Style="text-decoration:underline">in ogni caso mai superiore a 8 byte</span>. Se il numero d'indice è già occupato, allora la collocazione del membro scorre al numero d'indice uguale al multiplo della predetta quantità di byte, occupati da suo tipo di dati, immediatamente successivo purché libero.		Quando la quantità di byte, occupati dal tipo di dati di un membro, <SPAN Style="text-decoration:underline">successivo al primo/span>, di una ''Struttura'', è superiore alla quantità occupata dal tipo di dati del membro precedente, esso è posto al numero d'indice (''offset'' ) uguale alla quantità di byte occupati dal tipo di dati di appartenenza e <SPAN Style="text-decoration:underline">in ogni caso mai superiore a 8 byte</span>. Se il numero d'indice è già occupato, allora la collocazione del membro scorre al numero d'indice uguale al multiplo della predetta quantità di byte, occupati da suo tipo di dati, immediatamente successivo purché libero.

	Se invece la quantità occupata dal tipo di dati di un membro è inferiore o uguale a quella occupata dal ~~mebro~~ precedente, esso è posto al numero d'indice immediatamente libero dopo il membro che lo precede.		Se invece la quantità occupata dal tipo di dati di un membro è inferiore o uguale a quella occupata dal membro precedente, esso è posto al numero d'indice immediatamente libero dopo il membro che lo precede.

	Così in C, se una ''Struttura'' è composta ad esempio da un membro di tipo "char" e da un membro di tipo "int", la quantità di memoria, occupata dal titpo di dati ("int" = 4 byte) del secondo membro, è superiore alla quantità occupata dal tipo di dati del primo ("char" = 1 byte), l'allineamento dei due membri all'interno dell'area di memoria riservata della ''Struttura'' sarà il seguente:		Così in C, se una ''Struttura'' è composta ad esempio da un membro di tipo "char" e da un membro di tipo "int", la quantità di memoria, occupata dal titpo di dati ("int" = 4 byte) del secondo membro, è superiore alla quantità occupata dal tipo di dati del primo ("char" = 1 byte), l'allineamento dei due membri all'interno dell'area di memoria riservata della ''Struttura'' sarà il seguente:

Vuott il 00:16, 28 ott 2022

2022-10-28T00:16:54Z

@@ Riga 316: / Riga 316: @@
 la quantità di memoria occupata da tale esempio di ''Union'' è uguale a 8, ossia alla quantità di memoria occupata dal membro più grande (in tal caso quello di tipo "long int"). Inoltre, dovendosi potrà contenere <SPAN Style="text-decoration:underline">ogni qual volta</span> deve essere valorizzato un suo membro, il dato di <SPAN Style="text-decoration:underline">uno solo</span> dei suoi tre membri.
 In Gambas una "Union" può essere ricreata attraverso la usuale Classe "Struct", avendo l'accortezza di occupare una quantità di memoria pari alla totale quantità di memoria allocata per la "Union" della libreria esterna scritta in C.
 <BR>Nel caso della "Union" precedente, potremo definire in Gambas:
@@ Riga 321: / Riga 322: @@
     l As Long
   End Struct
 La "Union" altresì può essere gestita mediante una variabile di tipo ''Puntatore''.
 <BR>Poniamo l'esempio di una "Union" restituita per "Valore" da una funzione esterna contenuta in una libreria condivisa da noi creata. Poiché viene valorizzato il membro del tipo "int", che corrisponde in Gambas al tipo di dato "Integer", otterremo il valore usando la funzione propria di Gambas per di dereferenziazione "Int@()".
@@ Riga 354: / Riga 426: @@
   End
+oppure anche:
 =Gestione dei Campi bit di una Struttura=

Vuott il 23:48, 27 ott 2022

2022-10-27T23:48:36Z

← Versione meno recente		Versione delle 17:48, 27 ott 2022
Riga 329:		Riga 329:
	Public Sub Main()		Public Sub Main()

	~~Dim bb As Byte[]'New Byte[SizeOf(gb.Long)]~~
	Dim p As Pointer		Dim p As Pointer
	Dim i As Integer		Dim i As Integer

Vuott il 23:47, 27 ott 2022

2022-10-27T23:47:58Z

← Versione meno recente		Versione delle 17:47, 27 ott 2022
Riga 323:		Riga 323:
	La "Union" altresì può essere gestita mediante una variabile di tipo ''Puntatore''.		La "Union" altresì può essere gestita mediante una variabile di tipo ''Puntatore''.
	<BR>Poniamo l'esempio di una "Union" restituita per "Valore" da una funzione esterna contenuta in una libreria condivisa da noi creata. Poiché viene valorizzato il membro del tipo "int", che corrisponde in Gambas al tipo di dato "Integer", otterremo il valore usando la funzione propria di Gambas per di dereferenziazione "Int@()".		<BR>Poniamo l'esempio di una "Union" restituita per "Valore" da una funzione esterna contenuta in una libreria condivisa da noi creata. Poiché viene valorizzato il membro del tipo "int", che corrisponde in Gambas al tipo di dato "Integer", otterremo il valore usando la funzione propria di Gambas per di dereferenziazione "Int@()".
	<FONT Color=gray>' ''union funzione()''</font>		<FONT Color=gray>' ''union UNIONE * funzione()''</font>
	Private Extern funzione() As Pointer In "/tmp/libadhoc"		Private Extern funzione() As Pointer In "/tmp/libadhoc"

Vuott il 23:47, 27 ott 2022

2022-10-27T23:47:17Z

@@ Riga 321: / Riga 321: @@
     l As Long
   End Struct
-La "Union" altresì può essere ricreata con un Oggetto array di lunghezza pari alla quantità di memoria occupata dal membro può grande della "Union" medesima.
+La "Union" altresì può essere gestita mediante una variabile di tipo ''Puntatore''.
-<BR>Nel caso della "Union" precedente, potremo dichiarare in Gambas:
+<BR>Poniamo l'esempio di una "Union" restituita per "Valore" da una funzione esterna contenuta in una libreria condivisa da noi creata. Poiché viene valorizzato il membro del tipo "int", che corrisponde in Gambas al tipo di dato "Integer", otterremo il valore usando la funzione propria di Gambas per di dereferenziazione "Int@()".
-  Dim vettore As Byte[SizeOf(gb.Long)]
+  <FONT Color=gray>' ''union funzione()''</font>
-oppure ovviamente mediante l'allocazione dinamica mediante la funzione "Alloc()" di un'area riservata puntata da una variabile di tipo ''Puntatore''.
+ Private Extern funzione() As Pointer In "/tmp/libadhoc"
-<BR>Nel caso della "Union" precedente, potremo definire in Gambas:
-  p = Alloc(SizeOf(gb.Long), 1)

Vuott il 22:46, 27 ott 2022

2022-10-27T22:46:26Z

@@ Riga 219: / Riga 219: @@
-==Gestione delle "Union"==
+==Gestione di un membro di una Struttura che fa riferimento a una ''Union''==
-Una "Unione" è un'area di memoria allocata che può contenere - in momenti diversi - dati di diversa dimensione e tipo, comunque <SPAN Style="text-decoration:underline">condividendo sempre il medesimo spazio di memoria</span>. In tal senso <SPAN Style="text-decoration:underline">lo spazio riservato per una "Union" corrisponde soltanto a quello necessario per il suo membro più grande</span>. Pertanto la ''Union'' contiene il dato di <SPAN Style="text-decoration:underline">un solo membro per volta</span>.
+Se uno o più membri della ''Struttura'' fanno riferimento ad una ''Union'', allora si calcola ''solo'' il membro della ''Union'' che occupa la quantità maggiore di memoria rispetto agli altri membri. Insomma nella ''Union'' - con riferimento alla determinazione della sua dimensione - prevale il membro che in assoluto (o per tipo di dati o perché è un array con dimensione superiore ai ''tipi'' di ciascun altro membro della ''Union'') occupa la maggiore quantità di memoria rispetto agli altri membri della ''Union'' medesima.
-<BR>Così se abbiamo questa "Unione":
- union UNIONE {
+Però, riguardo alla posizione d'indice nell'area riservata di memoria si fa riferimento al ''tipo'' di dato più grande presente tra i membri della ''Union''.
-In Gambas una "Union" può essere ricreata attraverso la usuale Classe "Struct", avendo l'accortezza di occupare una quantità di memoria pari alla totale quantità di memoria allocata per la "Union" della libreria esterna scritta in C.
+Se due membri contingui della ''Struttura'' sono due ''Union'', e se l'ultimo membro della prima delle due ''Union'' è di tipo comunque ''diverso'' dal tipo dal tipo del primo membro della seconda ''Union'', va effettuato l'allineamento fra le due ''Union'' secondo i consueti criteri.
@@ Riga 321: / Riga 306: @@
-==Gestione dei Campi bit di una Struttura==
+=Gestione delle "Union"=
 Gambas non prevede nella gestione delle proprie ''Strutture'' l'uso dei "Campi" che fanno riferimento ai singoli bit.
 <BR>Ad ogni modo, poiché in C ogni insieme di "Campi" occupa una quantità di memoria pari a un "Intero", in Gambas si dovrà provare ad utilizzare una membro di tipo di dato "Integer", assegnandogli un valore tale che i suoi bit siano posti a 1 e/o a 0, come dovuto. Nel fare ciò, bisognerà tenere conto che il primo identificatore di bit di "Campo", all'interno di una ''Struttura'' esterna scritta in C, corrisponde al bit meno significativo del tipo "Integer" (ossia quello più a destra nella rappresentazione binaria di un numero).

Vuott il 22:39, 27 ott 2022

2022-10-27T22:39:17Z

← Versione meno recente		Versione delle 16:39, 27 ott 2022
Riga 229:		Riga 229:
	la quantità di memoria occupata da tale esempio di ''Union'' è uguale a 8, ossia alla quantità di memoria occupata dal membro più grande (in tal caso quello di tipo "long int"). Inoltre, dovendosi potrà contenere <SPAN Style="text-decoration:underline">ogni qual volta</span> deve essere valorizzato un suo membro, il dato di <SPAN Style="text-decoration:underline">uno solo</span> dei suoi tre membri.		la quantità di memoria occupata da tale esempio di ''Union'' è uguale a 8, ossia alla quantità di memoria occupata dal membro più grande (in tal caso quello di tipo "long int"). Inoltre, dovendosi potrà contenere <SPAN Style="text-decoration:underline">ogni qual volta</span> deve essere valorizzato un suo membro, il dato di <SPAN Style="text-decoration:underline">uno solo</span> dei suoi tre membri.

	In Gambas una "Union" va ricreata attraverso la usuale Classe "Struct", avendo l'accortezza di occupare una quantità di memoria pari alla totale quantità di memoria allocata per la "Union" della libreria esterna scritta in C.		In Gambas una "Union" può essere ricreata attraverso la usuale Classe "Struct", avendo l'accortezza di occupare una quantità di memoria pari alla totale quantità di memoria allocata per la "Union" della libreria esterna scritta in C.
	<BR>~~Di ciò bisogna avere cura anche qualora si utilizzi, poi, nel codice Gambas esclusivamente un membro~~ della "Union" ~~la cui complessiva dimensione di memoria occupata sia inferiore alla quantità di memoria che deve essere riservata per la~~ "Union"~~. In tal caso si aggiungerà un membro fittizio, ad esempio~~ un array di ~~tipo Byte, con un numero di elementi~~ pari ~~al numero necessario per coprire l'intera~~ quantità di memoria ~~da riservare per la~~ "Union".		<BR>Nel caso della "Union" precedente, potremo definire in Gambas:
	<BR>~~Se ad esempio la~~ "Union" ~~nella libreria esterna~~, ~~formata da un membro di tipo di una~~ "~~Struttura~~" e da ~~un array~~ di tipo ~~Byte, laddove il membro di tipo "Struttura" occupa una quantità di memoria inferiore alla complessiva quantità di memoria occupata dall~~'~~array, ovviamente la quantità di memoria che il sistema riserverà per la "Union" è pari alla quantità di memoria occupata dal predetto array~~. ~~In questo caso, se interessa in Gambas utilizzare solamente la "Struttura" quale~~ <~~SPAN Style="text-decoration:underline"~~>~~membro</span> (in questo esempio)~~ della "Union", ~~porremo nella "Struttura" (che~~ in Gambas ~~deve ricreare la "Union" esterna) anche l'array di tipo Byte~~ (~~che casualmente è già un membro componente della "Union" esterna~~) ~~con un numero di elementi pari alla differenza fra la quantità di byte di memoria, occupata dalla "Union" esterna scritta in C~~, ~~e la quantità di memoria che sarà occupata dal membro di tipo della "Struttura" (anch'esso, come sappiamo, costituente la "Union" esterna~~).		Public Struct UNIONE
			l As Long
			End Struct
			La "Union" altresì può essere ricreata con un Oggetto array di lunghezza pari alla quantità di memoria occupata dal membro può grande della "Union" medesima.
			<BR>Nel caso della "Union" precedente, potremo dichiarare in Gambas:
			Dim vettore As Byte[SizeOf(gb.Long)]
			oppure ovviamente mediante l'allocazione dinamica mediante la funzione "Alloc()" di un'area riservata puntata da una variabile di tipo ''Puntatore''.
			<BR>Nel caso della "Union" precedente, potremo definire in Gambas:
			p = Alloc(SizeOf(gb.Long), 1)