Conversione Big-Endian/Little-Endian - Cronologia

Vuott il 23:41, 26 ott 2025

2025-10-26T23:41:37Z

← Versione meno recente		Versione delle 17:41, 26 ott 2025
Riga 23:		Riga 23:
	* esplicite operazioni matematiche;		* esplicite operazioni matematiche;
	* Uso dell'operatore ''OR'' combinato con operazione di scorrimento dei bit a sinistra;		* Uso dell'operatore ''OR'' combinato con operazione di scorrimento dei bit a sinistra;
	* Uso degli operatori AND e OR.		* Uso degli operatori AND e OR, nonché delle funzioni Shr() e Shl();
			* Uso degli operatori AND e OR, nonché della sola funzione Shr().

	==Uso delle funzioni di scorrimento dei bit a destra ed a sinistra==		==Uso delle funzioni di scorrimento dei bit a destra ed a sinistra==

Vuott il 23:38, 26 ott 2025

2025-10-26T23:38:43Z

Vuott il 12:50, 26 ott 2025

2025-10-26T12:50:29Z

← Versione meno recente		Versione delle 06:50, 26 ott 2025
Riga 30:		Riga 30:
	Hex((Shr(''valore'', 8) And &FF) Or (Shl(''valore'', 8) And &FF00&), 4) As String		Hex((Shr(''valore'', 8) And &FF) Or (Shl(''valore'', 8) And &FF00&), 4) As String
	V'è da sottolineare che:		V'è da sottolineare che:
	<BR> - il il valore ''&FF00&'' necessita assolutamente alla fine del carattere '''&''', poiché, se non lo si ponesse, avremmo come risultato un valore in esadecimale di 3 byte ! <SUP>[ [[#Note\|~~Nota~~ 1]] ]</sup>		<BR> - il il valore ''&FF00&'' necessita assolutamente alla fine del carattere '''&''', poiché, se non lo si ponesse, avremmo come risultato un valore in esadecimale di 3 byte ! <SUP>[ [[#Note\|nota 1]] ]</sup>
	<BR> - se il valore convertito assume un valore massimo supportato in Gambas dal tipo "Short" (ossia superiore al valore espresso in esadecimale &7FFF), allora la variabile "valore" dovrà essere dichiarata come tipo <SPAN Style="text-decoration:underline">Integer</span>.		<BR> - se il valore convertito assume un valore massimo supportato in Gambas dal tipo "Short" (ossia superiore al valore espresso in esadecimale &7FFF), allora la variabile "valore" dovrà essere dichiarata come tipo <SPAN Style="text-decoration:underline">Integer</span>.

Vuott il 12:49, 26 ott 2025

2025-10-26T12:49:55Z

← Versione meno recente		Versione delle 06:49, 26 ott 2025
Riga 19:		Riga 19:

	=Conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a '''16-bit'''=		=Conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a '''16-bit'''=
	La formula astratta per ottenere la conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a 16bit (= 2 byte, ossia di tipo ''Short'') può essere la seguente (anche se [http://stackoverflow.com/questions/105252/how-do-i-convert-between-big-endian-and-little-endian-values-in-c le modalità sono molteplici] per ottenere la conversione):		La formula astratta - espressa in linguaggio C - per ottenere la conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a 16bit (= 2 byte, ossia di tipo ''Short'') può essere la seguente (anche se [http://stackoverflow.com/questions/105252/how-do-i-convert-between-big-endian-and-little-endian-values-in-c le modalità sono molteplici] per ottenere la conversione):
	((valore >> 8) & 0x00FF) \| ((valore << 8) & 0xFF00)		((valore >> 8) & 0x00FF) \| ((valore << 8) & 0xFF00)
	che in Gambas potremo tradurre, utilizzando uno dei seguenti metodi:		che in Gambas potremo tradurre, utilizzando uno dei seguenti metodi:
Riga 27:		Riga 27:

	==Uso delle funzioni di scorrimento dei bit a destra ed a sinistra==		==Uso delle funzioni di scorrimento dei bit a destra ed a sinistra==
	Questa modalità è in sintassi così espressa:		Questa modalità è in sintassi così in Gambas espressa:
	Hex((Shr(''valore'', 8) And &FF) Or (Shl(''valore'', 8) And &FF00&), 4) As String		Hex((Shr(''valore'', 8) And &FF) Or (Shl(''valore'', 8) And &FF00&), 4) As String
	V'è da sottolineare che:		V'è da sottolineare che:

Vuott il 12:47, 26 ott 2025

2025-10-26T12:47:30Z

← Versione meno recente		Versione delle 06:47, 26 ott 2025
Riga 14:		Riga 14:


	In taluni casi particolari, pertanto, possiamo riscontrare che alcuni valori vengono scritti per la memorizzazione in modalità ''Little-Endian'', e che~~, pertanto~~, per comprenderne il reale significato/valore, devono essere convertiti in forma ''Big-Endian''. Possiamo, per converso, avere valori che, memorizzati inizialmente nel formato esadecimale della forma ''Big-Endian'', debbano essere convertiti in forma ''Little-Endian'', affinché altri pogrammi possano comprendere il loro reale significato e restituire quindi il vero valore.		In taluni casi particolari, pertanto, possiamo riscontrare che alcuni valori vengono scritti per la memorizzazione in modalità ''Little-Endian'', e che di conseguenza, per comprenderne il reale significato/valore, devono essere convertiti in forma ''Big-Endian''. Possiamo, per converso, avere valori che, memorizzati inizialmente nel formato esadecimale della forma ''Big-Endian'', debbano essere convertiti in forma ''Little-Endian'', affinché altri pogrammi possano comprendere il loro reale significato e restituire quindi il vero valore.

Vuott il 07:37, 26 lug 2025

2025-07-26T07:37:51Z

← Versione meno recente		Versione delle 01:37, 26 lug 2025
Riga 18:		Riga 18:


	=Conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a 16-bit=		=Conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a '''16-bit'''=
	La formula astratta per ottenere la conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a 16bit (= 2 byte, ossia di tipo ''Short'') può essere la seguente (anche se [http://stackoverflow.com/questions/105252/how-do-i-convert-between-big-endian-and-little-endian-values-in-c le modalità sono molteplici] per ottenere la conversione):		La formula astratta per ottenere la conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a 16bit (= 2 byte, ossia di tipo ''Short'') può essere la seguente (anche se [http://stackoverflow.com/questions/105252/how-do-i-convert-between-big-endian-and-little-endian-values-in-c le modalità sono molteplici] per ottenere la conversione):
	((valore >> 8) & 0x00FF) \| ((valore << 8) & 0xFF00)		((valore >> 8) & 0x00FF) \| ((valore << 8) & 0xFF00)

Vuott il 07:37, 26 lug 2025

2025-07-26T07:37:24Z

@@ Riga 58: / Riga 58: @@
 Questo algoritmo è valido anche per la conversione contraria: da ''Big-Endian'' a ''Little-Endian''.
 =Conversione ''Big-Endian''/''Little-Endian'' e viceversa di un valore a 32-bit=
 La formula astratta per ottenere la conversione ''Big-Endian''/''Little-Endian'' di un valore intero a 32-bit (''Integer'') può essere la seguente:
   ((valore >> 24) & 0xff) | ((valore << 8) & 0xff0000) | ((valore >> 8) & 0xff00) | ((valore << 24) & 0xff000000)
@@ Riga 74: / Riga 105: @@
   Hex((Shr(valore, 24)) Or (Shl(i, 8) And &FF0000) Or (Shr(valore, 8) And &FF00&) Or (Shl(valore, 24)), 8) As String
 Va sottolineato che, se dalla conversione, il numero assumerà un valore superiore a quello supportato in Gambas dal tipo "Integer" (ossia superiore al valore espresso in esadecimale &7FFFFF), allora sarà opportuno dichiarare la variabile "valore" come tipo <SPAN Style="text-decoration:underline">Long</span>.
 ==Uso del solo operatore AND e della sola funzione Shr()==
@@ Riga 88: / Riga 155: @@
   End

Vuott il 06:45, 26 lug 2025

2025-07-26T06:45:27Z

← Versione meno recente		Versione delle 00:45, 26 lug 2025
Riga 75:		Riga 75:
	Va sottolineato che, se dalla conversione, il numero assumerà un valore superiore a quello supportato in Gambas dal tipo "Integer" (ossia superiore al valore espresso in esadecimale &7FFFFF), allora sarà opportuno dichiarare la variabile "valore" come tipo <SPAN Style="text-decoration:underline">Long</span>.		Va sottolineato che, se dalla conversione, il numero assumerà un valore superiore a quello supportato in Gambas dal tipo "Integer" (ossia superiore al valore espresso in esadecimale &7FFFFF), allora sarà opportuno dichiarare la variabile "valore" come tipo <SPAN Style="text-decoration:underline">Long</span>.

	===Uso del solo operatore AND e della funzione Shr()===		==Uso del solo operatore AND e della sola funzione Shr()==
	Mostriamo una funzione di supporto che converte un intero a 32 bit in stringa 4 byte ''little endian'':		Mostriamo una funzione di supporto che converte un intero a 32 bit in stringa 4 byte ''little endian'':
	Private Function IntToLittleEndian(value As Integer) As String		Private Function IntToLittleEndian(value As Integer) As String

Vuott il 06:43, 26 lug 2025

2025-07-26T06:43:43Z

← Versione meno recente		Versione delle 00:43, 26 lug 2025
Riga 74:		Riga 74:
	Hex((Shr(valore, 24)) Or (Shl(i, 8) And &FF0000) Or (Shr(valore, 8) And &FF00&) Or (Shl(valore, 24)), 8) As String		Hex((Shr(valore, 24)) Or (Shl(i, 8) And &FF0000) Or (Shr(valore, 8) And &FF00&) Or (Shl(valore, 24)), 8) As String
	Va sottolineato che, se dalla conversione, il numero assumerà un valore superiore a quello supportato in Gambas dal tipo "Integer" (ossia superiore al valore espresso in esadecimale &7FFFFF), allora sarà opportuno dichiarare la variabile "valore" come tipo <SPAN Style="text-decoration:underline">Long</span>.		Va sottolineato che, se dalla conversione, il numero assumerà un valore superiore a quello supportato in Gambas dal tipo "Integer" (ossia superiore al valore espresso in esadecimale &7FFFFF), allora sarà opportuno dichiarare la variabile "valore" come tipo <SPAN Style="text-decoration:underline">Long</span>.

			===Uso del solo operatore AND e della funzione Shr()===
			Mostriamo una funzione di supporto che converte un intero a 32 bit in stringa 4 byte ''little endian'':
			Private Function IntToLittleEndian(value As Integer) As String

			Dim b1 As Byte = value And &HFF
			Dim b2 As Byte = (value Shr 8) And &HFF
			Dim b3 As Byte = (value Shr 16) And &HFF
			Dim b4 As Byte = (value Shr 24) And &HFF

			Return Chr(b1) & Chr(b2) & Chr(b3) & Chr(b4)

			End

	==Uso di esplicite operazioni matematiche==		==Uso di esplicite operazioni matematiche==
	Se si vorranno utilizzare esplicite operazioni matematiche anziché funzioni Gambas, si potrà adoperare la seguente formula:		Se si vorranno utilizzare esplicite operazioni matematiche anziché funzioni Gambas, si potrà adoperare la seguente formula:
Riga 82:		Riga 96:


	=Rotazione dei byte mediante le funzioni ''ntohl( )'' e ''ntohs( )''=		=Rotazione dei byte mediante le funzioni esterne "ntohl()" e "ntohs()"=
	Mediante le funzioni esterne ''ntohl( )'' e ''ntohs( )'', dichiarate nel file header "''/usr/include/netinet/in.h''", è possibile ottenere la rotazione dei byte rispettivamente di un valore di tipo ''Intero'' (32 bit) e di uno valore di tipo ''Intero Corto'' (16 bit).		Mediante le funzioni esterne ''ntohl( )'' e ''ntohs( )'', dichiarate nel file header "''/usr/include/netinet/in.h''", è possibile ottenere la rotazione dei byte rispettivamente di un valore di tipo ''Intero'' (32 bit) e di uno valore di tipo ''Intero Corto'' (16 bit).

Vuott il 04:55, 21 nov 2024

2024-11-21T04:55:08Z

← Versione meno recente		Versione delle 22:55, 20 nov 2024
Riga 127:		Riga 127:
	* https://www.geeksforgeeks.org/little-and-big-endian-mystery/		* https://www.geeksforgeeks.org/little-and-big-endian-mystery/
	* http://people.cs.umass.edu/~verts/cs32/endian.html		* http://people.cs.umass.edu/~verts/cs32/endian.html
			* https://www.youtube.com/watch?v=n6lPuep66aM
			* https://www.youtube.com/watch?v=JrNF0KRAlyo

← Versione meno recente		Versione delle 17:38, 26 ott 2025
Riga 12:		Riga 12:
	87 D6 12		87 D6 12
	è, invece, di tipo ''Little-Endian''.		è, invece, di tipo ''Little-Endian''.


	In taluni casi particolari, pertanto, possiamo riscontrare che alcuni valori vengono scritti per la memorizzazione in modalità ''Little-Endian'', e che di conseguenza, per comprenderne il reale significato/valore, devono essere convertiti in forma ''Big-Endian''. Possiamo, per converso, avere valori che, memorizzati inizialmente nel formato esadecimale della forma ''Big-Endian'', debbano essere convertiti in forma ''Little-Endian'', affinché altri pogrammi possano comprendere il loro reale significato e restituire quindi il vero valore.		In taluni casi particolari, pertanto, possiamo riscontrare che alcuni valori vengono scritti per la memorizzazione in modalità ''Little-Endian'', e che di conseguenza, per comprenderne il reale significato/valore, devono essere convertiti in forma ''Big-Endian''. Possiamo, per converso, avere valori che, memorizzati inizialmente nel formato esadecimale della forma ''Big-Endian'', debbano essere convertiti in forma ''Little-Endian'', affinché altri pogrammi possano comprendere il loro reale significato e restituire quindi il vero valore.



Riga 24:		Riga 22:
	* funzioni di scorrimento dei bit a destra ed a sinistra;		* funzioni di scorrimento dei bit a destra ed a sinistra;
	* esplicite operazioni matematiche;		* esplicite operazioni matematiche;
	* Uso dell'operatore ''OR'' combinato con operazione di scorrimento dei bit a sinistra.		* Uso dell'operatore ''OR'' combinato con operazione di scorrimento dei bit a sinistra;
			* Uso degli operatori AND e OR.

	==Uso delle funzioni di scorrimento dei bit a destra ed a sinistra==		==Uso delle funzioni di scorrimento dei bit a destra ed a sinistra==
Riga 69:		Riga 68:
	End		End

	==Uso degli operatori AND e OR, nonché della sola funzione Shr()==		==Uso degli operatori AND e OR, nonché della sola funzione Shr()==
	Mostriamo una funzione di supporto che converte un intero a 16 bit in stringa 4 byte ''little endian'':		Mostriamo una funzione di supporto che converte un intero a 16 bit in stringa 4 byte ''little endian'':
	Private Function BigEndianToLittleEndian16_Shr(value As Short) As '''Short'''		Private Function BigEndianToLittleEndian16_Shr(value As Short) As '''Short'''
Riga 88:		Riga 87:

	End		End



Riga 97:		Riga 95:
	* funzioni di scorrimento dei bit a destra ed a sinistra;		* funzioni di scorrimento dei bit a destra ed a sinistra;
	* esplicite operazioni matematiche;		* esplicite operazioni matematiche;
	* Uso ~~dell'~~operatore ~~''OR'' combinato con operazione di scorrimento dei bit a sinistra~~.		* Uso degli operatori AND e OR;
			* Uso del solo operatore AND e della sola funzione Shr().

	==Uso delle funzioni di scorrimento dei bit a destra ed a sinistra==		==Uso delle funzioni di scorrimento dei bit a destra ed a sinistra==
Riga 106:		Riga 105:
	Va sottolineato che, se dalla conversione, il numero assumerà un valore superiore a quello supportato in Gambas dal tipo "Integer" (ossia superiore al valore espresso in esadecimale &7FFFFF), allora sarà opportuno dichiarare la variabile "valore" come tipo <SPAN Style="text-decoration:underline">Long</span>.		Va sottolineato che, se dalla conversione, il numero assumerà un valore superiore a quello supportato in Gambas dal tipo "Integer" (ossia superiore al valore espresso in esadecimale &7FFFFF), allora sarà opportuno dichiarare la variabile "valore" come tipo <SPAN Style="text-decoration:underline">Long</span>.

	===Uso di esplicite operazioni matematiche===		==Uso di esplicite operazioni matematiche==
	Se si vorranno utilizzare esplicite operazioni matematiche anziché funzioni Gambas, si potrà adoperare la seguente formula:		Se si vorranno utilizzare esplicite operazioni matematiche anziché funzioni Gambas, si potrà adoperare la seguente formula:
	Hex(((''valore'' \ CInt(2 ^ 24)) And &FF) Or ((''valore'' * CInt(2 ^ 8)) And &FF0000) Or ((''valore'' \ CInt(2 ^ 8)) And &FF00&) Or ((''valore'' * CInt(2 ^ 24)) And &FF000000), 8)		Hex(((''valore'' \ CInt(2 ^ 24)) And &FF) Or ((''valore'' * CInt(2 ^ 8)) And &FF0000) Or ((''valore'' \ CInt(2 ^ 8)) And &FF00&) Or ((''valore'' * CInt(2 ^ 24)) And &FF000000), 8)
Riga 154:		Riga 153:

	End		End




	=Rotazione dei byte mediante le funzioni esterne "ntohl()" e "ntohs()"=		=Rotazione dei byte mediante le funzioni esterne "ntohl()" e "ntohs()"=
	Mediante le funzioni ~~esterne ''~~ntohl( )'' e ''ntohs( )'', dichiarate nel file header "''/usr/include/netinet/in.h''", è possibile ottenere la rotazione dei byte rispettivamente di un valore di tipo ''Intero'' (32 bit) e di uno valore di tipo ''Intero Corto'' (16 bit).		Mediante le funzioni "ntohl()" e "ntohs() della libreria esterna "libc.so.6", dichiarate nel file header "''/usr/include/netinet/in.h''", è possibile ottenere la rotazione dei byte rispettivamente di un valore di tipo ''Intero'' (32 bit) e di uno valore di tipo ''Intero Corto'' (16 bit).

	Mostriamo un semplice esempio:		Mostriamo un semplice esempio: