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