Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Je dois determiner dans un code si je suis en architecture little ou
big endian, pour swapper ou non les octets de certains champs.
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je dois determiner dans un code si je suis en architecture little ou
big endian, pour swapper ou non les octets de certains champs.
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je dois determiner dans un code si je suis en architecture little ou
big endian, pour swapper ou non les octets de certains champs.
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Le Fri, 22 Apr 2011 10:56:25 +0200,
Alain BARTHE écrivait :Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Juste une question : est-ce que les ntoh[ls] ne sont pas ce que tu
cherches ?
Cordialement,
JKB
Le Fri, 22 Apr 2011 10:56:25 +0200,
Alain BARTHE<alain.barthe.65@free.fr> écrivait :
Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Juste une question : est-ce que les ntoh[ls] ne sont pas ce que tu
cherches ?
Cordialement,
JKB
Le Fri, 22 Apr 2011 10:56:25 +0200,
Alain BARTHE écrivait :Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Juste une question : est-ce que les ntoh[ls] ne sont pas ce que tu
cherches ?
Cordialement,
JKB
* Alain BARTHE in fr.comp.lang.c:Je dois determiner dans un code si je suis en architecture little ou
big endian, pour swapper ou non les octets de certains champs.
La suggestion de JKB pourrait être un piste.J'avais precedemment utilise :#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endifJe suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
Il n'y a pas de constante unique à ma connaissance, mais en plus de
__i386, tu peux aussi tester __amd64 ou __x86_64
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
autoconf fournit un moyen assez fiable, sinon c'est un problème assez
complexe, comme expliqué dans ce fil de discussion (en Anglais) :
http://gcc.gnu.org/ml/gcc-help/2007-07/msg00342.html
* Alain BARTHE<alain.barthe.65@free.fr> in fr.comp.lang.c:
Je dois determiner dans un code si je suis en architecture little ou
big endian, pour swapper ou non les octets de certains champs.
La suggestion de JKB pourrait être un piste.
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
Il n'y a pas de constante unique à ma connaissance, mais en plus de
__i386, tu peux aussi tester __amd64 ou __x86_64
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
autoconf fournit un moyen assez fiable, sinon c'est un problème assez
complexe, comme expliqué dans ce fil de discussion (en Anglais) :
http://gcc.gnu.org/ml/gcc-help/2007-07/msg00342.html
* Alain BARTHE in fr.comp.lang.c:Je dois determiner dans un code si je suis en architecture little ou
big endian, pour swapper ou non les octets de certains champs.
La suggestion de JKB pourrait être un piste.J'avais precedemment utilise :#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endifJe suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
Il n'y a pas de constante unique à ma connaissance, mais en plus de
__i386, tu peux aussi tester __amd64 ou __x86_64
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
autoconf fournit un moyen assez fiable, sinon c'est un problème assez
complexe, comme expliqué dans ce fil de discussion (en Anglais) :
http://gcc.gnu.org/ml/gcc-help/2007-07/msg00342.html
Le 22/04/2011 13:15, JKB a écrit :Le Fri, 22 Apr 2011 10:56:25 +0200,
Alain BARTHE écrivait :Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Juste une question : est-ce que les ntoh[ls] ne sont pas ce que tu
cherches ?
Cordialement,
JKB
Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
Je pourrais peut-etre utiliser ntoh[ls], mais ce me ferait reecrire mon
interface, ce que je voulais eviter.
J'ai juste besoin de savoir si je suis en little ou big endian.
Le 22/04/2011 13:15, JKB a écrit :
Le Fri, 22 Apr 2011 10:56:25 +0200,
Alain BARTHE<alain.barthe.65@free.fr> écrivait :
Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Juste une question : est-ce que les ntoh[ls] ne sont pas ce que tu
cherches ?
Cordialement,
JKB
Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
Je pourrais peut-etre utiliser ntoh[ls], mais ce me ferait reecrire mon
interface, ce que je voulais eviter.
J'ai juste besoin de savoir si je suis en little ou big endian.
Le 22/04/2011 13:15, JKB a écrit :Le Fri, 22 Apr 2011 10:56:25 +0200,
Alain BARTHE écrivait :Bonjour,
Je dois determiner dans un code si je suis en architecture little ou big
endian, pour swapper ou non les octets de certains champs.
Le meme code doit tourner sous Linux sur architecture Intel 32 ou 64
bits, et sous Solaris sur Sparc
J'avais precedemment utilise :
#ifdef __i386
#define HAVE_TO_SWAP_BYTES
#endif
Je suis maintenant passe sur un PC 64 bits et la constante __i386 ne
semble plus definie.
1) Quelle constante utiliser pour quelle marche dans tous les cas,
pour detecter une architecture INTEL (32 ou 64 bits)
2) Y a t-il un moyen plus propre pour savoir si on se trouve en
little ou big endian ?
Je predererais utiliser des #ifdef que faire un test de l'ordre des bits...
Juste une question : est-ce que les ntoh[ls] ne sont pas ce que tu
cherches ?
Cordialement,
JKB
Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
Je pourrais peut-etre utiliser ntoh[ls], mais ce me ferait reecrire mon
interface, ce que je voulais eviter.
J'ai juste besoin de savoir si je suis en little ou big endian.
Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
In article<4db1772f$0$21103$,
Alain BARTHE wrote:Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
Pourquoi ? c'est source d'erreur.J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
Ben le swap tu le fais avec ntohs et htons, ca te fait reecrire ton
implementation sans changer l'interface.
A priori, ce que tu veux c'est swapper les octes dans un cas d'endianess
et pas dans l'autre ? c'est exactement ce que font ntohs et htons...
In article<4db1772f$0$21103$426a74cc@news.free.fr>,
Alain BARTHE<alain.barthe.65@free.fr> wrote:
Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
Pourquoi ? c'est source d'erreur.
J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
Ben le swap tu le fais avec ntohs et htons, ca te fait reecrire ton
implementation sans changer l'interface.
A priori, ce que tu veux c'est swapper les octes dans un cas d'endianess
et pas dans l'autre ? c'est exactement ce que font ntohs et htons...
In article<4db1772f$0$21103$,
Alain BARTHE wrote:Ca pourrait etre une solution, mais je voulais passer par de la
compilation conditionnelle.
Pourquoi ? c'est source d'erreur.J'ai reecrit une surcouche de fread et fwrite que j'appelle
endian_read() et endian_write() qui permettent de lire a la maniere
fread() un nombre de champs de taille connue, tout en swappant les
octets si necessaire.
Ben le swap tu le fais avec ntohs et htons, ca te fait reecrire ton
implementation sans changer l'interface.
A priori, ce que tu veux c'est swapper les octes dans un cas d'endianess
et pas dans l'autre ? c'est exactement ce que font ntohs et htons...
Oui, je suis d'accord avec vous.
Si je devais le reecrire, c'est certainement ce que je ferais.
J'ai un code de quelques dizaines de lignes qui fonctionne parfaitement,
que j'avais essaye d'optimiser car je dois lire des donnees volumineuses
(gros tableaux de meme type)
Je charge en memoire avec fread() un paquet de size * items, d'un type
donne, et si je dois swapper, je swappe en memoire chacun de mes items.
Ca fonctionne parfaitement, relative vite, et ce depuis des annees.
Je n'avais pas envie d'y retoucher.
Le seul probleme c'est que j'avais un test #ifdef __i386, qui ne
fonctionne plus depuis l'architecture 64 bits.
Il faut maintenant :
#if defined(__i386) || defined (__x86_64)
#define HAVE_TO_SWAP
#endif
Mon probleme etait de determiner le plus proprement et durablement
possible si je suis en little ou big endian.
J'aimerais que mon code continue a fonctionner quand on passera en 128
bits avec une nouvelle macro #ifdef.
Je pense que le test #if defined(__BYTE_ORDER) && (__BYTE_ORDER ==
__LITTLE_ENDIAN) devrait correspondre parfaitement.
Oui, je suis d'accord avec vous.
Si je devais le reecrire, c'est certainement ce que je ferais.
J'ai un code de quelques dizaines de lignes qui fonctionne parfaitement,
que j'avais essaye d'optimiser car je dois lire des donnees volumineuses
(gros tableaux de meme type)
Je charge en memoire avec fread() un paquet de size * items, d'un type
donne, et si je dois swapper, je swappe en memoire chacun de mes items.
Ca fonctionne parfaitement, relative vite, et ce depuis des annees.
Je n'avais pas envie d'y retoucher.
Le seul probleme c'est que j'avais un test #ifdef __i386, qui ne
fonctionne plus depuis l'architecture 64 bits.
Il faut maintenant :
#if defined(__i386) || defined (__x86_64)
#define HAVE_TO_SWAP
#endif
Mon probleme etait de determiner le plus proprement et durablement
possible si je suis en little ou big endian.
J'aimerais que mon code continue a fonctionner quand on passera en 128
bits avec une nouvelle macro #ifdef.
Je pense que le test #if defined(__BYTE_ORDER) && (__BYTE_ORDER ==
__LITTLE_ENDIAN) devrait correspondre parfaitement.
Oui, je suis d'accord avec vous.
Si je devais le reecrire, c'est certainement ce que je ferais.
J'ai un code de quelques dizaines de lignes qui fonctionne parfaitement,
que j'avais essaye d'optimiser car je dois lire des donnees volumineuses
(gros tableaux de meme type)
Je charge en memoire avec fread() un paquet de size * items, d'un type
donne, et si je dois swapper, je swappe en memoire chacun de mes items.
Ca fonctionne parfaitement, relative vite, et ce depuis des annees.
Je n'avais pas envie d'y retoucher.
Le seul probleme c'est que j'avais un test #ifdef __i386, qui ne
fonctionne plus depuis l'architecture 64 bits.
Il faut maintenant :
#if defined(__i386) || defined (__x86_64)
#define HAVE_TO_SWAP
#endif
Mon probleme etait de determiner le plus proprement et durablement
possible si je suis en little ou big endian.
J'aimerais que mon code continue a fonctionner quand on passera en 128
bits avec une nouvelle macro #ifdef.
Je pense que le test #if defined(__BYTE_ORDER) && (__BYTE_ORDER ==
__LITTLE_ENDIAN) devrait correspondre parfaitement.
Oui, je suis d'accord avec vous.
Si je devais le reecrire, c'est certainement ce que je ferais.
J'ai un code de quelques dizaines de lignes qui fonctionne parfaitement,
que j'avais essaye d'optimiser car je dois lire des donnees volumineuses
(gros tableaux de meme type)
Je charge en memoire avec fread() un paquet de size * items, d'un type
donne, et si je dois swapper, je swappe en memoire chacun de mes items.
Ca fonctionne parfaitement, relative vite, et ce depuis des annees.
Je n'avais pas envie d'y retoucher.
Le seul probleme c'est que j'avais un test #ifdef __i386, qui ne
fonctionne plus depuis l'architecture 64 bits.
Il faut maintenant :
#if defined(__i386) || defined (__x86_64)
#define HAVE_TO_SWAP
#endif
Mon probleme etait de determiner le plus proprement et durablement
possible si je suis en little ou big endian.
J'aimerais que mon code continue a fonctionner quand on passera en 128
bits avec une nouvelle macro #ifdef.
Je pense que le test #if defined(__BYTE_ORDER)&& (__BYTE_ORDER = >> __LITTLE_ENDIAN) devrait correspondre parfaitement.
Bof, bof, bof.
L'avantage de htons et de ntohs, c'est qu'elles sont POSIX. Donc relativement
standard (a peu pres le plus general que tu puisses avoir apres C).
Oui, je suis d'accord avec vous.
Si je devais le reecrire, c'est certainement ce que je ferais.
J'ai un code de quelques dizaines de lignes qui fonctionne parfaitement,
que j'avais essaye d'optimiser car je dois lire des donnees volumineuses
(gros tableaux de meme type)
Je charge en memoire avec fread() un paquet de size * items, d'un type
donne, et si je dois swapper, je swappe en memoire chacun de mes items.
Ca fonctionne parfaitement, relative vite, et ce depuis des annees.
Je n'avais pas envie d'y retoucher.
Le seul probleme c'est que j'avais un test #ifdef __i386, qui ne
fonctionne plus depuis l'architecture 64 bits.
Il faut maintenant :
#if defined(__i386) || defined (__x86_64)
#define HAVE_TO_SWAP
#endif
Mon probleme etait de determiner le plus proprement et durablement
possible si je suis en little ou big endian.
J'aimerais que mon code continue a fonctionner quand on passera en 128
bits avec une nouvelle macro #ifdef.
Je pense que le test #if defined(__BYTE_ORDER)&& (__BYTE_ORDER = >> __LITTLE_ENDIAN) devrait correspondre parfaitement.
Bof, bof, bof.
L'avantage de htons et de ntohs, c'est qu'elles sont POSIX. Donc relativement
standard (a peu pres le plus general que tu puisses avoir apres C).
Oui, je suis d'accord avec vous.
Si je devais le reecrire, c'est certainement ce que je ferais.
J'ai un code de quelques dizaines de lignes qui fonctionne parfaitement,
que j'avais essaye d'optimiser car je dois lire des donnees volumineuses
(gros tableaux de meme type)
Je charge en memoire avec fread() un paquet de size * items, d'un type
donne, et si je dois swapper, je swappe en memoire chacun de mes items.
Ca fonctionne parfaitement, relative vite, et ce depuis des annees.
Je n'avais pas envie d'y retoucher.
Le seul probleme c'est que j'avais un test #ifdef __i386, qui ne
fonctionne plus depuis l'architecture 64 bits.
Il faut maintenant :
#if defined(__i386) || defined (__x86_64)
#define HAVE_TO_SWAP
#endif
Mon probleme etait de determiner le plus proprement et durablement
possible si je suis en little ou big endian.
J'aimerais que mon code continue a fonctionner quand on passera en 128
bits avec une nouvelle macro #ifdef.
Je pense que le test #if defined(__BYTE_ORDER)&& (__BYTE_ORDER = >> __LITTLE_ENDIAN) devrait correspondre parfaitement.
Bof, bof, bof.
L'avantage de htons et de ntohs, c'est qu'elles sont POSIX. Donc relativement
standard (a peu pres le plus general que tu puisses avoir apres C).
Bon apres, deja, en passant de __i386 a __BYTE_ORDER, il y a deja un progres,
parce que quid de i386/powerpc/arm/sparc64/longsoon/superH pour ne citer que
quelques archis couramment en usage ces jours-ci ?
Bon apres, deja, en passant de __i386 a __BYTE_ORDER, il y a deja un progres,
parce que quid de i386/powerpc/arm/sparc64/longsoon/superH pour ne citer que
quelques archis couramment en usage ces jours-ci ?
Bon apres, deja, en passant de __i386 a __BYTE_ORDER, il y a deja un progres,
parce que quid de i386/powerpc/arm/sparc64/longsoon/superH pour ne citer que
quelques archis couramment en usage ces jours-ci ?