Discussion :

[Nikolas]

Bonjour,



Que je tourne sous une machine en petit ou gros boutiste, je souhaiterais lire une structures de fichier qui soit aussi bien dans un ordre que dans l'autre.

Est-ce propre à l'affichage ou à la lecture ? (à la manière d'un flottant et d'un entier qui vont être différenciés à l'affichage uniquement).



Comment puis-je décider de l'ordre ?

[Philou67430]

Il m'avait semblé que le boutisme ne concernait pas les flottants, mais seulement les entiers. Cela dit, j'ai un doute.

Ensuite, selon le boutisme du fichier, tu dois ou non appliquer des fonctions de swap (htonl, htons, ntohl, ntohs).
Un article (en anglais) sur la gestion de fichier "indépendamment du boutisme" : http://www.scribd.com/doc/3294375/Wr...dent-code-in-C

[Mac LAK]

Comment puis-je décider de l'ordre ?

Sauf dans de très rares cas, tu ne décides pas de l'endianness : tu peux la détecter et la gérer, ou t'adapter à une autre endianness, mais pas décider de celle de ta machine.

Attention aux définitions de structures, qui peuvent varier fortement d'une plate-forme à l'autre (notamment avec les bitfields...).

Attention aux fonctions htonl, htons, ntohl, ntohs : sur une machine big-endian, ces fonctions ne font rien. Le "H" signifie "Host" (machine locale), et "N" signifie "Network" (qui est en big-endian usuellement sur Ethernet).
Donc, si ton but était de lire une structure little-endian sur une machine big-endian, ces fonctions ne te seront d'aucune utilité et il te faudra écrire des équivalents.

Sinon, il est plutôt aisé d'écrire un petit module de détection / adaptation de l'endianness...

[Médinoc]

Un petit exemple de fonctions-à-tout-faire pour des unsigned short (16 bits):

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
typedef unsigned short ushort;
typedef unsigned char byte;
#define LowByte(w)  ((byte)( (w)        & 0x00FFu))
#define HighByte(w) ((byte)(((w) >> 8 ) & 0x00FFu))
 
ushort HtoBE(ushort h)
{
	byte by[2] = { HighByte(h), LowByte(h) };
	byte *pby = by;
	ushort *pbe = (ushort*)pby;
	return *pbe;
}

Avec un tel code,

• sur une machine big-endian, aucun changement n'est fait
• sur une machine little-endian, le mot est inversé.

Ainsi, on peut écrire la même chose pour du little-endian:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
ushort HtoLE(ushort h)
{
	byte by[2] = { LowByte(h), HighByte(h)};
	byte *pby = by;
	ushort *pbe = (ushort*)pby;
	return *pbe;
}

Avec un tel code,

• sur une machine little-endian, aucun changement n'est fait
• sur une machine big-endian, le mot est inversé.

Pour le reste, à moins d'être sur une architecture un peu "spéciale", les fonctions inverses peuvent juste être des macros ou fonctions inline:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
#define BEtoH HtoBE
#define LEtoH HtoLE

[Mac LAK]

Un petit exemple de fonctions-à-tout-faire pour des unsigned short (16 bits):

Fonctions qui marchent très bien, mais qui peuvent avoir l'inconvénient d'être lentes dans le cadre de communications réseau (cela dépend beaucoup du compilateur, en fait)...

Dans ce cas, on préfèrera parfois utiliser des fonctions à base de macros, dans ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#ifdef BIG_ENDIAN
    #define HtoBE_16(uInt16) (uInt16)
#else
    #define HtoBE_16(uInt16) (((uInt16)<<8) | ((uInt16)>>8))
#endif

Ceci étant dit, ce genre de code est relativement lourd à faire (un paquet de fonctions à définir...), pose le souci des conflits de noms si c'est en macros (=> passer en inline pour compenser), et requiert de savoir plus ou moins à l'avance sur quel type de plate-forme on travaille.

Juste pour info, voici un code (licence BSD) pour déterminer l'endianness de la machine actuelle sans overhead d'exécution, uniquement à la phase du préprocesseur... Courage, fuyez, et je suis certain qu'il existe tout un tas de plate-formes qui ne seront pas prises en compte en plus.

Note : le fichier est zippé pour contourner un bug apparemment... Que ce soit en balises "code" ou directement attaché en .H, impossible de joindre cet entête à ce message de façon normale, seule une archive ZIP est passée.

[Médinoc]

Ce que je n'aime pas à propos des macros, c'est qu'il n'y a pas de constante absolument universelle pour l'endianness, ni de moyen de la vérifier à la compilation.

C'est pourquoi je préfère utiliser des fonctions (inline si on veut), qui exploitent la mémoire pour avoir la bonne endianness dans tous les cas.

[Nikolas]

Merci de répondre !


En fait, il s'agit de la manipulation de fichier, pour être exact.

Comme lire un flottant en gros-boutiste dans un fichier et l'écrire en petit-boutiste dans un autre (ou inversement).


Précisément, est-il possible de définir manuellement cet ordre ?




Édition :


Afin d'être parfaitement compris, je prends l'exemple d'un flottant 32 bits de la norme IEEE 754 valant 1 dont j'écris les quatre octets en hexadécimal.


Petit-boutiste = 0000803F

Gros-boutiste = 3F800000


Il s'agirait donc de pouvoir optenir 1 avec ces deux valeurs dont le boutisme est déjà connu.

[Mac LAK]

Ce que je n'aime pas à propos des macros, c'est qu'il n'y a pas de constante absolument universelle pour l'endianness, ni de moyen de la vérifier à la compilation.

Si, regarde le header que j'ai linké. C'est pas forcément parfait, mais on peut vérifier l'endianness à la compilation de façon "statique", et ne pas tester dynamiquement à l'exécution l'endianness (ou un flag l'indiquant) avant chaque opération.

C'est pourquoi je préfère utiliser des fonctions (inline si on veut), qui exploitent la mémoire pour avoir la bonne endianness dans tous les cas.

Tu as raison, mais seulement si les performances ne sont pas primordiales. Ce qui n'est par exemple pas le cas dans un driver réseau... Et ce qui n'a aucune importance dans le cas d'un décodage de fichier.

Comme lire un flottant en gros-boutiste dans un fichier et l'écrire en petit-boutiste dans un autre (ou inversement).

Un float, c'est 32 bits. Tu le lis comme un entier, tu l'écris comme un entier et ça passera.

Précisément, est-il possible de définir manuellement cet ordre ?

Oui, en implémentant une lecture d'un entier 32 bits big-endian (fonction du genre "BEtoH32"), et une fonction d'écriture d'un entier 32 bits "natif" vers du little-endian (type "HtoLE32").

[Nikolas]

Sinon, est-il simplement possible de lire des types multioctets à partir d'un tableau d'octets ?

Ça résoudrait le problème de boutisme avec une vulgaire fonction d'inversement des octets.


Je vais essayer de me renseigner sur ces fonctions, Mac LAK.

(J'étais plutôt loin du compte en m'attendant à un simple préfixe à un type de données ou à mettre dans un printf. )

[Mac LAK]

Sinon, est-il simplement possible de lire des types multioctets à partir d'un tableau d'octets ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
static inline void SwapBytes ( void* toSwap, int Count ) {
	unsigned char* b = (unsigned char*)((void*)(&toSwap)) ;
	register int i = 0;
	register int j = (Count)-1;
	unsigned char t ;
	while (i<j) {
		t = b[i] ;
		b[i] = b[j] ;
		b[j] = t ;
		i++, j--;
	}
}

Un peu barbare toutefois si c'est juste pour renverser 32 bits...


Quant aux fonctions que je cite, il te faudra les écrire en te basant sur les exemples de Médinoc et moi-même : elles n'existent pas par défaut en C.

[Philou67430]

Pourquoi prendre l'adresse toSwap (et le mettre dans b) et swaper ces octets sur une longueur de Count ?

[Mac LAK]

Pourquoi prendre l'adresse toSwap (et le mettre dans b) et swaper ces octets sur une longueur de Count ?

Mauvais copier/coller, c'est "void* toSwap" dans la signature, je corrige le post précédent.

Ensuite, l'OP voulait une fonction d'inversion des octets, c'est ce qu'elle fait.

[Philou67430]

J'avoue que je reste perplexe... j'aurais plutôt écrit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
/* Usage :
unsigned char *array[10];
SwapBytes(array, sizeof(array));
*/
static inline void SwapBytes (char *toSwap, int Count ) {
	register int i = 0;
	register int j = (Count)-1;
	unsigned char t ;
	while (i<j) {
		t = toSwap[i] ;
		toSwap[i] = toSwap[j] ;
		toSwap[j] = t ;
		i++, j--;
	}
}

Ou alors, je n'ai pas compris ce que fait ta fonction...

[Mac LAK]

Oh, simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
float truc1 ;
double truc2 ;
 
SwapBytes(&truc1, sizeof(truc1));
SwapBytes(&truc2, sizeof(truc2));

C'est plus clair ainsi ? Avec un void*, on peut passer n'importe quoi comme pointeur... Ce qui évite certains casts très laids (et plutôt lourds), là c'est limité au code interne de la fonction de swap.

[Nikolas]

Avec ce code, j'ai une incompatibilité du type de pointeur dans le premier argument.

En fait, faudrait une fonction qui fasse l'inverse de read() pour pouvoir découper un type multioctet en un tableau d'octets.

[nicolas.sitbon]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <stdio.h>
 
static inline void swap_bytes(void * const bytes, size_t const size) 
{
   unsigned char * const tab = bytes;
 
   for(size_t i = 0, j = size - 1; i < j; i++, j--)
   {
      unsigned char byte = tab[i];
      tab[i] = tab[j];
      tab[j] = byte;		
   }
}
 
static void dump_bytes(void * const bytes, size_t const size)
{
   unsigned char * const tab = bytes;
 
   for(size_t i = 0; i < size; i++)
   {
      printf("%02hhX ", tab[i]);
   }
 
   putchar('\n');
}
 
int main(void)
{
   char var[] = "test";
 
   dump_bytes(var, sizeof var);
   swap_bytes(var, sizeof var);
   dump_bytes(var, sizeof var);
 
   return 0;
}

[Nikolas]

En effet, ça marche comme ça !

Mais pourquoi ça ne marche pas en modifiant directement la variable du premier paramètre (bytes) ?


Je ne comprends pas non plus ce que ça change, de mettre const après l'étoile...

[orfix]

Mais pourquoi ça ne marche pas en modifiant directement la variable du premier paramètre (bytes) ?

Euh si tu peux le faire directement, mais comme bytes est un void*, il faudra caster à chaque déréférencement, mettre un ((unsigned char*)bytes)[i] ou tab[i] je préfère de loin la deuxième écriture

Je ne comprends pas non plus ce que ça change, de mettre const après l'étoile...

Le pointeur ne seras pas modifié, mais bon même sans const on est sûr qu'il ne sera pas modifié puisque les passages sont par valeur, personnellement je ne mettrais aucun const dans le cas présent.

[nicolas.sitbon]

Le pointeur ne seras pas modifié, mais bon même sans const on est sûr qu'il ne sera pas modifié puisque les passages sont par valeur,

Heu, non, sans le const, rien n'empêche de modifier le pointeur ou la taille dans la fonction, ça reste une bonne indication pour le compilateur ou même pour de la revue de code sur des plus grosses fonctions.

[Philou67430]

Non Mac LAK, ce n'est pas l'usage que je remets en cause, c'est cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	unsigned char* b = (unsigned char*)((void*)(&toSwap)) ;

toSwap est déjà un pointeur, et tu prends son addresse : du coup, tu swap l'adresse les octets de l'adresse du float ou du long, et pas le long ou le float lui-même.