Détecter l'Endianness

Au moment de la compilation en C, vous ne pouvez pas faire beaucoup plus que de faire confiance à préprocesseur #defines, et il n'y a pas de solutions standard, car la norme n'est pas concerné par l'endianness.

Encore, vous pourriez ajouter une assertion qui est fait à l'exécution, au démarrage du programme pour s'assurer que l'hypothèse faite lors de la compilation était vrai:

inline int IsBigEndian()
{
    int i=1;
    return ! *((char *)&i);
}

/* ... */

#ifdef COMPILED_FOR_BIG_ENDIAN
assert(IsBigEndian());
#elif COMPILED_FOR_LITTLE_ENDIAN
assert(!IsBigEndian());
#else
#error "No endianness macro defined"
#endif

(où COMPILED_FOR_BIG_ENDIAN et COMPILED_FOR_LITTLE_ENDIAN sont des macros #defined précédemment selon votre préprocesseur endianness contrôles)

Comme indiqué précédemment, la seule "vraie" façon de détecter les Big Endian est l'utilisation d'exécution des tests.

Cependant, parfois, une macro peut être préféré.

Malheureusement, je n'ai pas trouvé un seul "test" pour détecter cette situation, plutôt une collection d'entre eux.

Par exemple, GCC recommande : __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ . Toutefois, cela ne fonctionne qu'avec les versions les plus récentes et les versions antérieures (et d'autres compilateurs) donnera à ce test une fausse valeur "true", depuis NULL == NULL. Si vous avez besoin de la version la plus complète : defined(__BYTE_ORDER__)&&(__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)

OK, maintenant cela fonctionne pour les plus récentes de GCC, mais quid des autres compilateurs ?

Vous pouvez essayer __BIG_ENDIAN__ ou __BIG_ENDIAN ou _BIG_ENDIAN qui sont souvent définis sur big endian compilateurs.

Cela permettra d'améliorer la détection. Mais si vous cibler spécifiquement les plates-formes PowerPC, vous pouvez ajouter un peu plus de tests afin d'améliorer encore plus la détection. Essayez _ARCH_PPC ou __PPC__ ou __PPC ou PPC ou __powerpc__ ou __powerpc ou même powerpc. Lier toutes ces définit ensemble, et vous avez une assez bonne chance pour détecter big endian systèmes, et powerpc en particulier, quel que soit le compilateur et sa version.

Donc, pour résumer, il n'y a pas une telle chose comme un "standard macros prédéfinies" qui garantit à détecter big-endian CPU sur toutes les plates-formes et les compilateurs, mais il ya beaucoup de ces macros prédéfinies qui, collectivement, à accorder une haute probabilité de détecter correctement big endian dans la plupart des circonstances.

Essayez quelque chose comme:

if(*(char *)(int[]){1}) {
    /* little endian code */
} else {
    /* big endian code */
}

et de voir si votre compilateur résout au moment de la compilation. Si non, vous pourriez avoir plus de chance de faire la même chose avec un syndicat. En fait j'aime définir des macros à l'aide de syndicats qui évaluent à 0,1 ou 1,0 (respectivement), de sorte que je peux juste faire des choses comme l'accès buf[HI] et buf[LO].

Vous ne pouvez pas détecter au moment de la compilation pour être portable à travers tous les compilateurs. Peut-être que vous pouvez modifier le code pour le faire au moment de l'exécution - ce qui est réalisable.

Cela vient de p. 45 de les Pointeurs en C:

#include <stdio.h>
#define BIG_ENDIAN 0
#define LITTLE_ENDIAN 1

int endian()
{
   short int word = 0x0001;
   char *byte = (char *) &word;
   return (byte[0] ? LITTLE_ENDIAN : BIG_ENDIAN);
}

int main(int argc, char* argv[])
{
   int value;
   value = endian();
   if (value == 1)
      printf("The machine is Little Endian\n");
   else
      printf("The machine is Big Endian\n");
   return 0;
}

#define BIG_ENDIAN ((1 >> 1 == 0) ? 0 : 1)