Conversione Big-Endian/Little-Endian

Big-Endian e Little-Endian sono due differenti modalità per memorizzare dati di dimensione superiore al semplice byte.

La differenza tra i due sistemi è data dall'ordine, con il quale i byte costituenti il dato vengono memorizzati:

• Big-Endian è il tipo di memorizzazione che inizia (da sinistra verso destra) dal byte più significativo (che è quello posto a sinistra) e termina con il byte meno significativo;
• Little-Endian è il tipo di memorizzazione che inizia (da destra verso sinistra) dal byte meno significativo (che è quello posto a destra) e termina con il byte più significativo. Quindi in sostanza nel sistema Little-Endian l'ordine dei byte nell'indirizzo di memoria è invertito ripetto al sistema Big-Endian.

Se ad esempio abbiamo il valore decimale 1234567, la memorizzazione nella seguente forma esadecimale:

12 D6 87

è di tipo Big-Endian.

Invece la memorizzazione di quello stesso numero nella forma:

87 D6 12

è, 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.

Conversione Big-Endian/Little-Endian e viceversa di un valore a 16-bit

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 le modalità sono molteplici per ottenere la conversione):

((valore >> 8) & 0x00FF) | ((valore << 8) & 0xFF00)

che in Gambas potremo tradurre, utilizzando uno dei seguenti metodi:

• funzioni di scorrimento dei bit a destra ed a sinistra;
• esplicite operazioni matematiche;
• Uso dell'operatore OR combinato con operazione di scorrimento dei bit a sinistra;
• 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

Questa modalità è in sintassi così in Gambas espressa:

Hex((Shr(valore, 8) And &FF) Or (Shl(valore, 8) And &FF00&), 4) As String

V'è da sottolineare che:
- 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 ! ^{[ nota 1 ]}
- 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 Integer.

Uso di esplicite operazioni matematiche

Se si vorranno utilizzare esplicite operazioni matematiche anziché funzioni Gambas, si potrà adoperare la seguente formula:

Hex(((valore \ CInt(2 ^ 8)) And &FF) Or ((valore * CInt(2 ^ 8)) And &FF00&), 4) As String

oppure

Hex(((valore \ CInt(2 ^ 8)) And &FF) Or CShort(((valore * CInt(2 ^ 8)) And &FF00)), 4) As String

Uso dell'operatore OR con operazione di scorrimento dei bit a sinistra

Mostriamo un esempio pratico con l'operatore OR combinato con operazione di scorrimento dei bit a sinistra, in cui convertiremo il valore esadecimale 0x2301 di tipo Short da Little-Endian a Big-Endian:

Public Sub Main()

  Dim valore, s1, s2, v As Short
  
  valore = &2301
  
  s1 = Shr(valore, 8)
  s2 = valore And 255
  
  v = s1
  v = v Or Shl(s2, 8)
  
  Print Hex(v, 4), v
   
End

Questo algoritmo è valido anche per la conversione contraria: da Big-Endian a Little-Endian.

Uso degli operatori AND e OR, nonché delle funzioni Shr() e Shl(), mantenendo il tipo Short

Ecco una funzione che prende in input un valore a 16 bit in Big-Endian e restituisce il corrispondente valore in Little-Endian, mantenendo il tipo Short:

Private Function BigEndianToLittleEndian16(value As Short) As Short

 Dim hi As Short = (value And &HFF00) Shr 8   ' Byte alto → spostato a destra
 Dim lo As Short = (value And &H00FF)         ' Byte basso → resta com’è

 Return lo Shl 8 Or hi                        ' Ricompone in ordine Little-Endian

End

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:

Private Function BigEndianToLittleEndian16_Shr(value As Short) As Short

 Dim hi As Short = (value And &HFF00) Shr 8     ' Isola il byte alto e lo porta in basso
 Dim lo As Short = (value And &H00FF)           ' Isola il byte basso

 Return lo * 256 Or hi                          ' Simula Shl 8 con * 256, ricompone con OR

End

Se si vuole ritornare un tipo String, allora avremo:

Private Function ShortToLittleEndianString(value As Short) As String

 Dim lo As Byte = value And &H00FF              ' Byte meno significativo
 Dim hi As Byte = (value And &HFF00) Shr 8      ' Byte più significativo spostato a destra

 Return Hex(lo) & Hex(hi)                       ' Costruzione stringa Little-Endian

End

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)

La suddetta formula in Gambas potrà essere tradotta utilizzando uno dei seguenti metodi:

• funzioni di scorrimento dei bit a destra ed a sinistra;
• esplicite operazioni matematiche;
• 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

Questa modalità è in sintassi così espressa:

Hex((Shr(valore, 24) And &FF) Or (Shl(valore, 8) And &FF0000) Or (Shr(valore, 8) And &FF00&) Or (Shl(valore, 24) And &FF000000), 8) As String

oppure

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 Long.

Uso di esplicite operazioni matematiche

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)

oppure quest'altra:

Hex(((valore \ CInt(2 ^ 24)) And &FF) Or ((valore * CInt(2 ^ 8)) And &FF0000) Or CShort(((valore \ CInt(2 ^ 8)) And &FF00)) Or ((valore * CInt(2 ^ 24)) And &FF000000), 8)

Usando gli operatori AND e OR, nonché le funzioni Shr() e Shl(), mantenendo il tipo Integer

Ecco una funzione che prende in input un valore a 32 bit in Big-Endian e restituisce il corrispondente valore in Little-Endian, mantenendo il tipo Integer:

Private Function BigEndianToLittleEndian32(value As Integer) As Integer

 Dim b1 As Integer = Shr(value And &HFF000000, 24)
' Anche così la funzione "Shr()" va bene:
 Dim b2 As Integer = (value And &H00FF0000) Shr 8

 Dim b3 As Integer = (value And &H0000FF00) Shl 8
' Anche così la funzione "Shl()" va bene:
 Dim b4 As Integer = (value And &H000000FF) Shl 24

 Return b1 Or b2 Or b3 Or b4

End

o anche:

Private Function BigEndianToLittleEndian32(value As Integer) As Integer

 Dim b1, b2, b3, b4 As Integer

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

 Return (b4 Shl 24) Or (b3 Shl 16) Or (b2 Shl 8) Or b1

End

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:

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

Rotazione dei byte mediante le funzioni esterne "ntohl()" e "ntohs()"

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:

Library "libc:6"

' uint32_t ntohl (uint32_t __netlong)
' Converts the unsigned integer netlong from network byte order to host byte order.
Private Extern ntohl(__netlong As Integer) As Integer

' uint16_t ntohs (uint16_t __netshort)
' Converts the unsigned short integer netshort from network byte order to host byte order.
Private Extern ntohs(__netshort As Short) As Short


Public Sub Main()
 
  Dim i As Integer
  Dim c As Short
 
  i = ntohl(&01020304)
  Print Hex(i, 8)
  
  c = ntohs(&0908)
  Print Hex(c, 4)
  
End

Note

[1] Interpellato al riguardo Benoît Minisini ha così spiegato il problema e suggerito la soluzione:
« Because of weird Visual Basic compatibility, &FF00 is sign-extended, i.e. &FF00 = &FFFFFF00
To prevent automatic sign-extension, write &FF00& (with an extra '&' at the end).
Otherwise, I don't know where your data comes from, but Swap$() does endianness conversion provided that each integer is stored inside a string. »

Riferimenti

• https://it.wikipedia.org/wiki/Ordine_dei_byte‎
• http://en.wikipedia.org/wiki/Endianness
• http://betterexplained.com/articles/understanding-big-and-little-endian-byte-order/
• https://www.cs.umd.edu/~meesh/cmsc311/clin-cmsc311/Lectures/lecture6/endian.pdf
• https://www.geeksforgeeks.org/little-and-big-endian-mystery/
• http://people.cs.umass.edu/~verts/cs32/endian.html
• https://www.youtube.com/watch?v=n6lPuep66aM
• https://www.youtube.com/watch?v=JrNF0KRAlyo