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.