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