test/testplatform.c

   1
   2 #include <stdio.h>
   3
   4 #include "SDL.h"
   5 #include "SDL_endian.h"
   6 #include "SDL_cpuinfo.h"
   7
   8 /*
   9  * Watcom C flags these as Warning 201: "Unreachable code" if you just
  10  *  compare them directly, so we push it through a function to keep the
  11  *  compiler quiet.  --ryan.
  12  */
  13 static int badsize(size_t sizeoftype, size_t hardcodetype)
  14 {
  15     return sizeoftype != hardcodetype;
  16 }
  17
  18 int TestTypes(SDL_bool verbose)
  19 {
  20         int error = 0;
  21
  22         if ( badsize(sizeof(Uint8), 1) ) {
  23                 if ( verbose )
  24                         printf("sizeof(Uint8) != 1, instead = %ul\n",
  25                                                                 sizeof(Uint8));
  26                 ++error;
  27         }
  28         if ( badsize(sizeof(Uint16), 2) ) {
  29                 if ( verbose )
  30                         printf("sizeof(Uint16) != 2, instead = %ul\n",
  31                                                                 sizeof(Uint16));
  32                 ++error;
  33         }
  34         if ( badsize(sizeof(Uint32), 4) ) {
  35                 if ( verbose )
  36                         printf("sizeof(Uint32) != 4, instead = %ul\n",
  37                                                                 sizeof(Uint32));
  38                 ++error;
  39         }
  40 #ifdef SDL_HAS_64BIT_TYPE
  41         if ( badsize(sizeof(Uint64), 8) ) {
  42                 if ( verbose )
  43                         printf("sizeof(Uint64) != 8, instead = %ul\n",
  44                                                                 sizeof(Uint64));
  45                 ++error;
  46         }
  47 #else
  48         if ( verbose ) {
  49                 printf("WARNING: No 64-bit datatype on this platform\n");
  50         }
  51 #endif
  52         if ( verbose && !error )
  53                 printf("All data types are the expected size.\n");
  54
  55         return( error ? 1 : 0 );
  56 }
  57
  58 int TestEndian(SDL_bool verbose)
  59 {
  60         int error = 0;
  61         Uint16 value = 0x1234;
  62         int real_byteorder;
  63         Uint16 value16 = 0xCDAB;
  64         Uint16 swapped16 = 0xABCD;
  65         Uint32 value32 = 0xEFBEADDE;
  66         Uint32 swapped32 = 0xDEADBEEF;
  67 #ifdef SDL_HAS_64BIT_TYPE
  68         Uint64 value64, swapped64;
  69         value64 = 0xEFBEADDE;
  70         value64 <<= 32;
  71         value64 |= 0xCDAB3412;
  72         swapped64 = 0x1234ABCD;
  73         swapped64 <<= 32;
  74         swapped64 |= 0xDEADBEEF;
  75 #endif
  76
  77         if ( verbose ) {
  78                 printf("Detected a %s endian machine.\n",
  79                         (SDL_BYTEORDER == SDL_LIL_ENDIAN) ? "little" : "big");
  80         }
  81         if ( (*((char *)&value) >> 4) == 0x1 ) {
  82                 real_byteorder = SDL_BIG_ENDIAN;
  83         } else {
  84                 real_byteorder = SDL_LIL_ENDIAN;
  85         }
  86         if ( real_byteorder != SDL_BYTEORDER ) {
  87                 if ( verbose ) {
  88                         printf("Actually a %s endian machine!\n",
  89                                 (real_byteorder == SDL_LIL_ENDIAN) ? "little" : "big");
  90                 }
  91                 ++error;
  92         }
  93         if ( verbose ) {
  94                 printf("Value 16 = 0x%X, swapped = 0x%X\n", value16, SDL_Swap16(value16));
  95         }
  96         if ( SDL_Swap16(value16) != swapped16 ) {
  97                 if ( verbose ) {
  98                         printf("16 bit value swapped incorrectly!\n");
  99                 }
 100                 ++error;
 101         }
 102         if ( verbose ) {
 103                 printf("Value 32 = 0x%X, swapped = 0x%X\n", value32, SDL_Swap32(value32));
 104         }
 105         if ( SDL_Swap32(value32) != swapped32 ) {
 106                 if ( verbose ) {
 107                         printf("32 bit value swapped incorrectly!\n");
 108                 }
 109                 ++error;
 110         }
 111 #ifdef SDL_HAS_64BIT_TYPE
 112         if ( verbose ) {
 113 #ifdef _MSC_VER
 114                 printf("Value 64 = 0x%I64X, swapped = 0x%I64X\n", value64, SDL_Swap64(value64));
 115 #else
 116                 printf("Value 64 = 0x%llX, swapped = 0x%llX\n", value64, SDL_Swap64(value64));
 117 #endif
 118         }
 119         if ( SDL_Swap64(value64) != swapped64 ) {
 120                 if ( verbose ) {
 121                         printf("64 bit value swapped incorrectly!\n");
 122                 }
 123                 ++error;
 124         }
 125 #endif
 126         return( error ? 1 : 0 );
 127 }
 128
 129
 130 int TestCPUInfo(SDL_bool verbose)
 131 {
 132         if ( verbose ) {
 133                 printf("RDTSC %s\n", SDL_HasRDTSC() ? "detected" : "not detected");
 134                 printf("MMX %s\n", SDL_HasMMX() ? "detected" : "not detected");
 135                 printf("MMX Ext %s\n", SDL_HasMMXExt() ? "detected" : "not detected");
 136                 printf("3DNow %s\n", SDL_Has3DNow() ? "detected" : "not detected");
 137                 printf("3DNow Ext %s\n", SDL_Has3DNowExt() ? "detected" : "not detected");
 138                 printf("SSE %s\n", SDL_HasSSE() ? "detected" : "not detected");
 139                 printf("SSE2 %s\n", SDL_HasSSE2() ? "detected" : "not detected");
 140                 printf("AltiVec %s\n", SDL_HasAltiVec() ? "detected" : "not detected");
 141         }
 142         return(0);
 143 }
 144
 145 int main(int argc, char *argv[])
 146 {
 147         SDL_bool verbose = SDL_TRUE;
 148         int status = 0;
 149
 150         if ( argv[1] && (SDL_strcmp(argv[1], "-q") == 0) ) {
 151                 verbose = SDL_FALSE;
 152         }
 153         if ( verbose ) {
 154                 printf("This system is running %s\n",
 155 #if __AIX__
 156                         "AIX"
 157 #elif __HAIKU__
 158 /* Haiku must appear here before BeOS, since it also defines __BEOS__ */
 159                         "Haiku"
 160 #elif __BEOS__
 161                         "BeOS"
 162 #elif __BSDI__
 163                         "BSDI"
 164 #elif __DREAMCAST__
 165                         "Dreamcast"
 166 #elif __FREEBSD__
 167                         "FreeBSD"
 168 #elif __HPUX__
 169                         "HP-UX"
 170 #elif __IRIX__
 171                         "Irix"
 172 #elif __LINUX__
 173                         "Linux"
 174 #elif __MINT__
 175                         "Atari MiNT"
 176 #elif __MACOS__
 177                         "MacOS Classic"
 178 #elif __MACOSX__
 179                         "Mac OS X"
 180 #elif __NETBSD__
 181                         "NetBSD"
 182 #elif __OPENBSD__
 183                         "OpenBSD"
 184 #elif __OS2__
 185                         "OS/2"
 186 #elif __OSF__
 187                         "OSF/1"
 188 #elif __QNXNTO__
 189                         "QNX Neutrino"
 190 #elif __RISCOS__
 191                         "RISC OS"
 192 #elif __SOLARIS__
 193                         "Solaris"
 194 #elif __WIN32__
 195 #ifdef _WIN32_WCE
 196                         "Windows CE"
 197 #else
 198                         "Windows"
 199 #endif
 200 #else
 201                         "an unknown operating system! (see SDL_platform.h)"
 202 #endif
 203                 );
 204         }
 205
 206         status += TestTypes(verbose);
 207         status += TestEndian(verbose);
 208         status += TestCPUInfo(verbose);
 209         return status;
 210 }