Mercurial > sdl-ios-xcode

comparison src/stdlib/SDL_string.c @ 1895:c121d94672cb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.
author Sam Lantinga <slouken@libsdl.org>
date Mon, 10 Jul 2006 21:04:37 +0000
parents 887c3600826b
children f1828a500391
comparison
equal deleted inserted replaced
1894:c69cee13dd76 1895:c121d94672cb
28 28
29 #define SDL_isupperhex(X) (((X) >= 'A') && ((X) <= 'F')) 29 #define SDL_isupperhex(X) (((X) >= 'A') && ((X) <= 'F'))
30 #define SDL_islowerhex(X) (((X) >= 'a') && ((X) <= 'f')) 30 #define SDL_islowerhex(X) (((X) >= 'a') && ((X) <= 'f'))
31 31
32 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOL) 32 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOL)
33 static size_t SDL_ScanLong(const char *text, int radix, long *valuep) 33 static size_t
34 SDL_ScanLong(const char *text, int radix, long *valuep)
34 { 35 {
35 const char *textstart = text; 36 const char *textstart = text;
36 long value = 0; 37 long value = 0;
37 SDL_bool negative = SDL_FALSE; 38 SDL_bool negative = SDL_FALSE;
38 39
39 if ( *text == '-' ) { 40 if (*text == '-') {
40 negative = SDL_TRUE; 41 negative = SDL_TRUE;
41 ++text; 42 ++text;
42 } 43 }
43 if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { 44 if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
44 text += 2; 45 text += 2;
45 } 46 }
46 for ( ; ; ) { 47 for (;;) {
47 int v; 48 int v;
48 if ( SDL_isdigit(*text) ) { 49 if (SDL_isdigit(*text)) {
49 v = *text - '0'; 50 v = *text - '0';
50 } else if ( radix == 16 && SDL_isupperhex(*text) ) { 51 } else if (radix == 16 && SDL_isupperhex(*text)) {
51 v = 10 + (*text - 'A'); 52 v = 10 + (*text - 'A');
52 } else if ( radix == 16 && SDL_islowerhex(*text) ) { 53 } else if (radix == 16 && SDL_islowerhex(*text)) {
53 v = 10 + (*text - 'a'); 54 v = 10 + (*text - 'a');
54 } else { 55 } else {
55 break; 56 break;
56 } 57 }
57 value *= radix; 58 value *= radix;
58 value += v; 59 value += v;
59 ++text; 60 ++text;
60 } 61 }
61 if ( valuep ) { 62 if (valuep) {
62 if ( negative && value ) { 63 if (negative && value) {
63 *valuep = -value; 64 *valuep = -value;
64 } else { 65 } else {
65 *valuep = value; 66 *valuep = value;
66 } 67 }
67 } 68 }
68 return (text - textstart); 69 return (text - textstart);
69 } 70 }
70 #endif 71 #endif
71 72
72 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD) 73 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD)
73 static size_t SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *valuep) 74 static size_t
75 SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *valuep)
74 { 76 {
75 const char *textstart = text; 77 const char *textstart = text;
76 unsigned long value = 0; 78 unsigned long value = 0;
77 79
78 if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { 80 if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
79 text += 2; 81 text += 2;
80 } 82 }
81 for ( ; ; ) { 83 for (;;) {
82 int v; 84 int v;
83 if ( SDL_isdigit(*text) ) { 85 if (SDL_isdigit(*text)) {
84 v = *text - '0'; 86 v = *text - '0';
85 } else if ( radix == 16 && SDL_isupperhex(*text) ) { 87 } else if (radix == 16 && SDL_isupperhex(*text)) {
86 v = 10 + (*text - 'A'); 88 v = 10 + (*text - 'A');
87 } else if ( radix == 16 && SDL_islowerhex(*text) ) { 89 } else if (radix == 16 && SDL_islowerhex(*text)) {
88 v = 10 + (*text - 'a'); 90 v = 10 + (*text - 'a');
89 } else { 91 } else {
90 break; 92 break;
91 } 93 }
92 value *= radix; 94 value *= radix;
93 value += v; 95 value += v;
94 ++text; 96 ++text;
95 } 97 }
96 if ( valuep ) { 98 if (valuep) {
97 *valuep = value; 99 *valuep = value;
98 } 100 }
99 return (text - textstart); 101 return (text - textstart);
100 } 102 }
101 #endif 103 #endif
102 104
103 #ifndef HAVE_SSCANF 105 #ifndef HAVE_SSCANF
104 static size_t SDL_ScanUintPtrT(const char *text, int radix, uintptr_t *valuep) 106 static size_t
107 SDL_ScanUintPtrT(const char *text, int radix, uintptr_t * valuep)
105 { 108 {
106 const char *textstart = text; 109 const char *textstart = text;
107 uintptr_t value = 0; 110 uintptr_t value = 0;
108 111
109 if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { 112 if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
110 text += 2; 113 text += 2;
111 } 114 }
112 for ( ; ; ) { 115 for (;;) {
113 int v; 116 int v;
114 if ( SDL_isdigit(*text) ) { 117 if (SDL_isdigit(*text)) {
115 v = *text - '0'; 118 v = *text - '0';
116 } else if ( radix == 16 && SDL_isupperhex(*text) ) { 119 } else if (radix == 16 && SDL_isupperhex(*text)) {
117 v = 10 + (*text - 'A'); 120 v = 10 + (*text - 'A');
118 } else if ( radix == 16 && SDL_islowerhex(*text) ) { 121 } else if (radix == 16 && SDL_islowerhex(*text)) {
119 v = 10 + (*text - 'a'); 122 v = 10 + (*text - 'a');
120 } else { 123 } else {
121 break; 124 break;
122 } 125 }
123 value *= radix; 126 value *= radix;
124 value += v; 127 value += v;
125 ++text; 128 ++text;
126 } 129 }
127 if ( valuep ) { 130 if (valuep) {
128 *valuep = value; 131 *valuep = value;
129 } 132 }
130 return (text - textstart); 133 return (text - textstart);
131 } 134 }
132 #endif 135 #endif
133 136
134 #ifdef SDL_HAS_64BIT_TYPE 137 #ifdef SDL_HAS_64BIT_TYPE
135 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOLL) 138 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOLL)
136 static size_t SDL_ScanLongLong(const char *text, int radix, Sint64 *valuep) 139 static size_t
140 SDL_ScanLongLong(const char *text, int radix, Sint64 * valuep)
137 { 141 {
138 const char *textstart = text; 142 const char *textstart = text;
139 Sint64 value = 0; 143 Sint64 value = 0;
140 SDL_bool negative = SDL_FALSE; 144 SDL_bool negative = SDL_FALSE;
141 145
142 if ( *text == '-' ) { 146 if (*text == '-') {
143 negative = SDL_TRUE; 147 negative = SDL_TRUE;
144 ++text; 148 ++text;
145 } 149 }
146 if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { 150 if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
147 text += 2; 151 text += 2;
148 } 152 }
149 for ( ; ; ) { 153 for (;;) {
150 int v; 154 int v;
151 if ( SDL_isdigit(*text) ) { 155 if (SDL_isdigit(*text)) {
152 v = *text - '0'; 156 v = *text - '0';
153 } else if ( radix == 16 && SDL_isupperhex(*text) ) { 157 } else if (radix == 16 && SDL_isupperhex(*text)) {
154 v = 10 + (*text - 'A'); 158 v = 10 + (*text - 'A');
155 } else if ( radix == 16 && SDL_islowerhex(*text) ) { 159 } else if (radix == 16 && SDL_islowerhex(*text)) {
156 v = 10 + (*text - 'a'); 160 v = 10 + (*text - 'a');
157 } else { 161 } else {
158 break; 162 break;
159 } 163 }
160 value *= radix; 164 value *= radix;
161 value += v; 165 value += v;
162 ++text; 166 ++text;
163 } 167 }
164 if ( valuep ) { 168 if (valuep) {
165 if ( negative && value ) { 169 if (negative && value) {
166 *valuep = -value; 170 *valuep = -value;
167 } else { 171 } else {
168 *valuep = value; 172 *valuep = value;
169 } 173 }
170 } 174 }
171 return (text - textstart); 175 return (text - textstart);
172 } 176 }
173 #endif 177 #endif
174 178
175 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOULL) 179 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOULL)
176 static size_t SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 *valuep) 180 static size_t
181 SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 * valuep)
177 { 182 {
178 const char *textstart = text; 183 const char *textstart = text;
179 Uint64 value = 0; 184 Uint64 value = 0;
180 185
181 if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { 186 if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
182 text += 2; 187 text += 2;
183 } 188 }
184 for ( ; ; ) { 189 for (;;) {
185 int v; 190 int v;
186 if ( SDL_isdigit(*text) ) { 191 if (SDL_isdigit(*text)) {
187 v = *text - '0'; 192 v = *text - '0';
188 } else if ( radix == 16 && SDL_isupperhex(*text) ) { 193 } else if (radix == 16 && SDL_isupperhex(*text)) {
189 v = 10 + (*text - 'A'); 194 v = 10 + (*text - 'A');
190 } else if ( radix == 16 && SDL_islowerhex(*text) ) { 195 } else if (radix == 16 && SDL_islowerhex(*text)) {
191 v = 10 + (*text - 'a'); 196 v = 10 + (*text - 'a');
192 } else { 197 } else {
193 break; 198 break;
194 } 199 }
195 value *= radix; 200 value *= radix;
196 value += v; 201 value += v;
197 ++text; 202 ++text;
198 } 203 }
199 if ( valuep ) { 204 if (valuep) {
200 *valuep = value; 205 *valuep = value;
201 } 206 }
202 return (text - textstart); 207 return (text - textstart);
203 } 208 }
204 #endif 209 #endif
205 #endif /* SDL_HAS_64BIT_TYPE */ 210 #endif /* SDL_HAS_64BIT_TYPE */
206 211
207 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOD) 212 #if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOD)
208 static size_t SDL_ScanFloat(const char *text, double *valuep) 213 static size_t
214 SDL_ScanFloat(const char *text, double *valuep)
209 { 215 {
210 const char *textstart = text; 216 const char *textstart = text;
211 unsigned long lvalue = 0; 217 unsigned long lvalue = 0;
212 double value = 0.0; 218 double value = 0.0;
213 SDL_bool negative = SDL_FALSE; 219 SDL_bool negative = SDL_FALSE;
214 220
215 if ( *text == '-' ) { 221 if (*text == '-') {
216 negative = SDL_TRUE; 222 negative = SDL_TRUE;
217 ++text; 223 ++text;
218 } 224 }
219 text += SDL_ScanUnsignedLong(text, 10, &lvalue); 225 text += SDL_ScanUnsignedLong(text, 10, &lvalue);
220 value += lvalue; 226 value += lvalue;
221 if ( *text == '.' ) { 227 if (*text == '.') {
222 int mult = 10; 228 int mult = 10;
223 ++text; 229 ++text;
224 while ( SDL_isdigit(*text) ) { 230 while (SDL_isdigit(*text)) {
225 lvalue = *text - '0'; 231 lvalue = *text - '0';
226 value += (double)lvalue / mult; 232 value += (double) lvalue / mult;
227 mult *= 10; 233 mult *= 10;
228 ++text; 234 ++text;
229 } 235 }
230 } 236 }
231 if ( valuep ) { 237 if (valuep) {
232 if ( negative && value ) { 238 if (negative && value) {
233 *valuep = -value; 239 *valuep = -value;
234 } else { 240 } else {
235 *valuep = value; 241 *valuep = value;
236 } 242 }
237 } 243 }
238 return (text - textstart); 244 return (text - textstart);
239 } 245 }
240 #endif 246 #endif
241 247
242 #ifndef SDL_memset 248 #ifndef SDL_memset
243 void *SDL_memset(void *dst, int c, size_t len) 249 void *
250 SDL_memset(void *dst, int c, size_t len)
244 { 251 {
245 size_t left = (len % 4); 252 size_t left = (len % 4);
246 if ( len >= 4 ) { 253 if (len >= 4) {
247 Uint32 value = 0; 254 Uint32 value = 0;
248 Uint32 *dstp = (Uint32 *)dst; 255 Uint32 *dstp = (Uint32 *) dst;
249 int i; 256 int i;
250 for (i = 0; i < 4; ++i) { 257 for (i = 0; i < 4; ++i) {
251 value <<= 8; 258 value <<= 8;
252 value |= c; 259 value |= c;
253 } 260 }
254 len /= 4; 261 len /= 4;
255 while ( len-- ) { 262 while (len--) {
256 *dstp++ = value; 263 *dstp++ = value;
257 } 264 }
258 } 265 }
259 if ( left > 0 ) { 266 if (left > 0) {
260 Uint8 value = (Uint8)c; 267 Uint8 value = (Uint8) c;
261 Uint8 *dstp = (Uint8 *)dst; 268 Uint8 *dstp = (Uint8 *) dst;
262 switch(left) { 269 switch (left) {
263 case 3: 270 case 3:
264 *dstp++ = value; 271 *dstp++ = value;
265 case 2: 272 case 2:
266 *dstp++ = value; 273 *dstp++ = value;
267 case 1: 274 case 1:
268 *dstp++ = value; 275 *dstp++ = value;
269 } 276 }
270 } 277 }
271 return dst; 278 return dst;
272 } 279 }
273 #endif 280 #endif
274 281
275 #ifndef SDL_memcpy 282 #ifndef SDL_memcpy
276 void *SDL_memcpy(void *dst, const void *src, size_t len) 283 void *
277 { 284 SDL_memcpy(void *dst, const void *src, size_t len)
278 char *srcp = (char *)src; 285 {
279 char *dstp = (char *)dst; 286 char *srcp = (char *) src;
280 while ( len-- ) { 287 char *dstp = (char *) dst;
288 while (len--) {
281 *dstp++ = *srcp++; 289 *dstp++ = *srcp++;
282 } 290 }
283 return dst; 291 return dst;
284 } 292 }
285 #endif 293 #endif
286 294
287 #ifndef SDL_revcpy 295 #ifndef SDL_revcpy
288 void *SDL_revcpy(void *dst, const void *src, size_t len) 296 void *
289 { 297 SDL_revcpy(void *dst, const void *src, size_t len)
290 char *srcp = (char *)src; 298 {
291 char *dstp = (char *)dst; 299 char *srcp = (char *) src;
300 char *dstp = (char *) dst;
292 srcp += len; 301 srcp += len;
293 dstp += len; 302 dstp += len;
294 while ( len-- ) { 303 while (len--) {
295 *dstp-- = *srcp--; 304 *dstp-- = *srcp--;
296 } 305 }
297 return dst; 306 return dst;
298 } 307 }
299 #endif 308 #endif
300 309
301 #ifndef SDL_memcmp 310 #ifndef SDL_memcmp
302 int SDL_memcmp(const void *s1, const void *s2, size_t len) 311 int
303 { 312 SDL_memcmp(const void *s1, const void *s2, size_t len)
304 char *s1p = (char *)s1; 313 {
305 char *s2p = (char *)s2; 314 char *s1p = (char *) s1;
306 while ( len-- ) { 315 char *s2p = (char *) s2;
307 if ( *s1p != *s2p ) { 316 while (len--) {
317 if (*s1p != *s2p) {
308 return (*s1p - *s2p); 318 return (*s1p - *s2p);
309 } 319 }
310 ++s1p; 320 ++s1p;
311 ++s2p; 321 ++s2p;
312 } 322 }
313 return 0; 323 return 0;
314 } 324 }
315 #endif 325 #endif
316 326
317 #ifndef HAVE_STRLEN 327 #ifndef HAVE_STRLEN
318 size_t SDL_strlen(const char *string) 328 size_t
329 SDL_strlen(const char *string)
319 { 330 {
320 size_t len = 0; 331 size_t len = 0;
321 while ( *string++ ) { 332 while (*string++) {
322 ++len; 333 ++len;
323 } 334 }
324 return len; 335 return len;
325 } 336 }
326 #endif 337 #endif
327 338
328 #ifndef HAVE_STRLCPY 339 #ifndef HAVE_STRLCPY
329 size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen) 340 size_t
341 SDL_strlcpy(char *dst, const char *src, size_t maxlen)
330 { 342 {
331 size_t srclen = SDL_strlen(src); 343 size_t srclen = SDL_strlen(src);
332 if ( maxlen > 0 ) { 344 if (maxlen > 0) {
333 size_t len = SDL_min(srclen, maxlen-1); 345 size_t len = SDL_min(srclen, maxlen - 1);
334 SDL_memcpy(dst, src, len); 346 SDL_memcpy(dst, src, len);
335 dst[len] = '\0'; 347 dst[len] = '\0';
336 } 348 }
337 return srclen; 349 return srclen;
338 } 350 }
339 #endif 351 #endif
340 352
341 #ifndef HAVE_STRLCAT 353 #ifndef HAVE_STRLCAT
342 size_t SDL_strlcat(char *dst, const char *src, size_t maxlen) 354 size_t
355 SDL_strlcat(char *dst, const char *src, size_t maxlen)
343 { 356 {
344 size_t dstlen = SDL_strlen(dst); 357 size_t dstlen = SDL_strlen(dst);
345 size_t srclen = SDL_strlen(src); 358 size_t srclen = SDL_strlen(src);
346 if ( dstlen < maxlen ) { 359 if (dstlen < maxlen) {
347 SDL_strlcpy(dst+dstlen, src, maxlen-dstlen); 360 SDL_strlcpy(dst + dstlen, src, maxlen - dstlen);
348 } 361 }
349 return dstlen+srclen; 362 return dstlen + srclen;
350 } 363 }
351 #endif 364 #endif
352 365
353 #ifndef HAVE_STRDUP 366 #ifndef HAVE_STRDUP
354 char *SDL_strdup(const char *string) 367 char *
355 { 368 SDL_strdup(const char *string)
356 size_t len = SDL_strlen(string)+1; 369 {
370 size_t len = SDL_strlen(string) + 1;
357 char *newstr = SDL_malloc(len); 371 char *newstr = SDL_malloc(len);
358 if ( newstr ) { 372 if (newstr) {
359 SDL_strlcpy(newstr, string, len); 373 SDL_strlcpy(newstr, string, len);
360 } 374 }
361 return newstr; 375 return newstr;
362 } 376 }
363 #endif 377 #endif
364 378
365 #ifndef HAVE__STRREV 379 #ifndef HAVE__STRREV
366 char *SDL_strrev(char *string) 380 char *
381 SDL_strrev(char *string)
367 { 382 {
368 size_t len = SDL_strlen(string); 383 size_t len = SDL_strlen(string);
369 char *a = &string[0]; 384 char *a = &string[0];
370 char *b = &string[len-1]; 385 char *b = &string[len - 1];
371 len /= 2; 386 len /= 2;
372 while ( len-- ) { 387 while (len--) {
373 char c = *a; 388 char c = *a;
374 *a++ = *b; 389 *a++ = *b;
375 *b-- = c; 390 *b-- = c;
376 } 391 }
377 return string; 392 return string;
378 } 393 }
379 #endif 394 #endif
380 395
381 #ifndef HAVE__STRUPR 396 #ifndef HAVE__STRUPR
382 char *SDL_strupr(char *string) 397 char *
398 SDL_strupr(char *string)
383 { 399 {
384 char *bufp = string; 400 char *bufp = string;
385 while ( *bufp ) { 401 while (*bufp) {
386 *bufp = SDL_toupper(*bufp); 402 *bufp = SDL_toupper(*bufp);
387 ++bufp; 403 ++bufp;
388 } 404 }
389 return string; 405 return string;
390 } 406 }
391 #endif 407 #endif
392 408
393 #ifndef HAVE__STRLWR 409 #ifndef HAVE__STRLWR
394 char *SDL_strlwr(char *string) 410 char *
411 SDL_strlwr(char *string)
395 { 412 {
396 char *bufp = string; 413 char *bufp = string;
397 while ( *bufp ) { 414 while (*bufp) {
398 *bufp = SDL_tolower(*bufp); 415 *bufp = SDL_tolower(*bufp);
399 ++bufp; 416 ++bufp;
400 } 417 }
401 return string; 418 return string;
402 } 419 }
403 #endif 420 #endif
404 421
405 #ifndef HAVE_STRCHR 422 #ifndef HAVE_STRCHR
406 char *SDL_strchr(const char *string, int c) 423 char *
407 { 424 SDL_strchr(const char *string, int c)
408 while ( *string ) { 425 {
409 if ( *string == c ) { 426 while (*string) {
410 return (char *)string; 427 if (*string == c) {
411 } 428 return (char *) string;
412 ++string; 429 }
430 ++string;
413 } 431 }
414 return NULL; 432 return NULL;
415 } 433 }
416 #endif 434 #endif
417 435
418 #ifndef HAVE_STRRCHR 436 #ifndef HAVE_STRRCHR
419 char *SDL_strrchr(const char *string, int c) 437 char *
438 SDL_strrchr(const char *string, int c)
420 { 439 {
421 const char *bufp = string + SDL_strlen(string) - 1; 440 const char *bufp = string + SDL_strlen(string) - 1;
422 while ( bufp >= string ) { 441 while (bufp >= string) {
423 if ( *bufp == c ) { 442 if (*bufp == c) {
424 return (char *)bufp; 443 return (char *) bufp;
425 } 444 }
426 --bufp; 445 --bufp;
427 } 446 }
428 return NULL; 447 return NULL;
429 } 448 }
430 #endif 449 #endif
431 450
432 #ifndef HAVE_STRSTR 451 #ifndef HAVE_STRSTR
433 char *SDL_strstr(const char *haystack, const char *needle) 452 char *
453 SDL_strstr(const char *haystack, const char *needle)
434 { 454 {
435 size_t length = SDL_strlen(needle); 455 size_t length = SDL_strlen(needle);
436 while ( *haystack ) { 456 while (*haystack) {
437 if ( SDL_strncmp(haystack, needle, length) == 0 ) { 457 if (SDL_strncmp(haystack, needle, length) == 0) {
438 return (char *)haystack; 458 return (char *) haystack;
439 } 459 }
440 ++haystack; 460 ++haystack;
441 } 461 }
442 return NULL; 462 return NULL;
443 } 463 }
444 #endif 464 #endif
445 465
452 'U', 'V', 'W', 'X', 'Y', 'Z' 472 'U', 'V', 'W', 'X', 'Y', 'Z'
453 }; 473 };
454 #endif /* ntoa() conversion table */ 474 #endif /* ntoa() conversion table */
455 475
456 #ifndef HAVE__LTOA 476 #ifndef HAVE__LTOA
457 char *SDL_ltoa(long value, char *string, int radix) 477 char *
478 SDL_ltoa(long value, char *string, int radix)
458 { 479 {
459 char *bufp = string; 480 char *bufp = string;
460 481
461 if ( value < 0 ) { 482 if (value < 0) {
462 *bufp++ = '-'; 483 *bufp++ = '-';
463 value = -value; 484 value = -value;
464 } 485 }
465 if ( value ) { 486 if (value) {
466 while ( value > 0 ) { 487 while (value > 0) {
467 *bufp++ = ntoa_table[value % radix]; 488 *bufp++ = ntoa_table[value % radix];
468 value /= radix; 489 value /= radix;
469 } 490 }
470 } else { 491 } else {
471 *bufp++ = '0'; 492 *bufp++ = '0';
472 } 493 }
473 *bufp = '\0'; 494 *bufp = '\0';
474 495
475 /* The numbers went into the string backwards. :) */ 496 /* The numbers went into the string backwards. :) */
476 if ( *string == '-' ) { 497 if (*string == '-') {
477 SDL_strrev(string+1); 498 SDL_strrev(string + 1);
478 } else { 499 } else {
479 SDL_strrev(string); 500 SDL_strrev(string);
480 } 501 }
481 502
482 return string; 503 return string;
483 } 504 }
484 #endif 505 #endif
485 506
486 #ifndef HAVE__ULTOA 507 #ifndef HAVE__ULTOA
487 char *SDL_ultoa(unsigned long value, char *string, int radix) 508 char *
509 SDL_ultoa(unsigned long value, char *string, int radix)
488 { 510 {
489 char *bufp = string; 511 char *bufp = string;
490 512
491 if ( value ) { 513 if (value) {
492 while ( value > 0 ) { 514 while (value > 0) {
493 *bufp++ = ntoa_table[value % radix]; 515 *bufp++ = ntoa_table[value % radix];
494 value /= radix; 516 value /= radix;
495 } 517 }
496 } else { 518 } else {
497 *bufp++ = '0'; 519 *bufp++ = '0';
504 return string; 526 return string;
505 } 527 }
506 #endif 528 #endif
507 529
508 #ifndef HAVE_STRTOL 530 #ifndef HAVE_STRTOL
509 long SDL_strtol(const char *string, char **endp, int base) 531 long
532 SDL_strtol(const char *string, char **endp, int base)
510 { 533 {
511 size_t len; 534 size_t len;
512 long value; 535 long value;
513 536
514 if ( !base ) { 537 if (!base) {
515 if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) { 538 if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
516 base = 16; 539 base = 16;
517 } else { 540 } else {
518 base = 10; 541 base = 10;
519 } 542 }
520 } 543 }
521 544
522 len = SDL_ScanLong(string, base, &value); 545 len = SDL_ScanLong(string, base, &value);
523 if ( endp ) { 546 if (endp) {
524 *endp = (char *)string + len; 547 *endp = (char *) string + len;
525 } 548 }
526 return value; 549 return value;
527 } 550 }
528 #endif 551 #endif
529 552
530 #ifndef HAVE_STRTOUL 553 #ifndef HAVE_STRTOUL
531 unsigned long SDL_strtoul(const char *string, char **endp, int base) 554 unsigned long
555 SDL_strtoul(const char *string, char **endp, int base)
532 { 556 {
533 size_t len; 557 size_t len;
534 unsigned long value; 558 unsigned long value;
535 559
536 if ( !base ) { 560 if (!base) {
537 if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) { 561 if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
538 base = 16; 562 base = 16;
539 } else { 563 } else {
540 base = 10; 564 base = 10;
541 } 565 }
542 } 566 }
543 567
544 len = SDL_ScanUnsignedLong(string, base, &value); 568 len = SDL_ScanUnsignedLong(string, base, &value);
545 if ( endp ) { 569 if (endp) {
546 *endp = (char *)string + len; 570 *endp = (char *) string + len;
547 } 571 }
548 return value; 572 return value;
549 } 573 }
550 #endif 574 #endif
551 575
552 #ifdef SDL_HAS_64BIT_TYPE 576 #ifdef SDL_HAS_64BIT_TYPE
553 577
554 #ifndef HAVE__I64TOA 578 #ifndef HAVE__I64TOA
555 char *SDL_lltoa(Sint64 value, char *string, int radix) 579 char *
580 SDL_lltoa(Sint64 value, char *string, int radix)
556 { 581 {
557 char *bufp = string; 582 char *bufp = string;
558 583
559 if ( value < 0 ) { 584 if (value < 0) {
560 *bufp++ = '-'; 585 *bufp++ = '-';
561 value = -value; 586 value = -value;
562 } 587 }
563 if ( value ) { 588 if (value) {
564 while ( value > 0 ) { 589 while (value > 0) {
565 *bufp++ = ntoa_table[value % radix]; 590 *bufp++ = ntoa_table[value % radix];
566 value /= radix; 591 value /= radix;
567 } 592 }
568 } else { 593 } else {
569 *bufp++ = '0'; 594 *bufp++ = '0';
570 } 595 }
571 *bufp = '\0'; 596 *bufp = '\0';
572 597
573 /* The numbers went into the string backwards. :) */ 598 /* The numbers went into the string backwards. :) */
574 if ( *string == '-' ) { 599 if (*string == '-') {
575 SDL_strrev(string+1); 600 SDL_strrev(string + 1);
576 } else { 601 } else {
577 SDL_strrev(string); 602 SDL_strrev(string);
578 } 603 }
579 604
580 return string; 605 return string;
581 } 606 }
582 #endif 607 #endif
583 608
584 #ifndef HAVE__UI64TOA 609 #ifndef HAVE__UI64TOA
585 char *SDL_ulltoa(Uint64 value, char *string, int radix) 610 char *
611 SDL_ulltoa(Uint64 value, char *string, int radix)
586 { 612 {
587 char *bufp = string; 613 char *bufp = string;
588 614
589 if ( value ) { 615 if (value) {
590 while ( value > 0 ) { 616 while (value > 0) {
591 *bufp++ = ntoa_table[value % radix]; 617 *bufp++ = ntoa_table[value % radix];
592 value /= radix; 618 value /= radix;
593 } 619 }
594 } else { 620 } else {
595 *bufp++ = '0'; 621 *bufp++ = '0';
602 return string; 628 return string;
603 } 629 }
604 #endif 630 #endif
605 631
606 #ifndef HAVE_STRTOLL 632 #ifndef HAVE_STRTOLL
607 Sint64 SDL_strtoll(const char *string, char **endp, int base) 633 Sint64
634 SDL_strtoll(const char *string, char **endp, int base)
608 { 635 {
609 size_t len; 636 size_t len;
610 Sint64 value; 637 Sint64 value;
611 638
612 if ( !base ) { 639 if (!base) {
613 if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) { 640 if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
614 base = 16; 641 base = 16;
615 } else { 642 } else {
616 base = 10; 643 base = 10;
617 } 644 }
618 } 645 }
619 646
620 len = SDL_ScanLongLong(string, base, &value); 647 len = SDL_ScanLongLong(string, base, &value);
621 if ( endp ) { 648 if (endp) {
622 *endp = (char *)string + len; 649 *endp = (char *) string + len;
623 } 650 }
624 return value; 651 return value;
625 } 652 }
626 #endif 653 #endif
627 654
628 #ifndef HAVE_STRTOULL 655 #ifndef HAVE_STRTOULL
629 Uint64 SDL_strtoull(const char *string, char **endp, int base) 656 Uint64
657 SDL_strtoull(const char *string, char **endp, int base)
630 { 658 {
631 size_t len; 659 size_t len;
632 Uint64 value; 660 Uint64 value;
633 661
634 if ( !base ) { 662 if (!base) {
635 if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) { 663 if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
636 base = 16; 664 base = 16;
637 } else { 665 } else {
638 base = 10; 666 base = 10;
639 } 667 }
640 } 668 }
641 669
642 len = SDL_ScanUnsignedLongLong(string, base, &value); 670 len = SDL_ScanUnsignedLongLong(string, base, &value);
643 if ( endp ) { 671 if (endp) {
644 *endp = (char *)string + len; 672 *endp = (char *) string + len;
645 } 673 }
646 return value; 674 return value;
647 } 675 }
648 #endif 676 #endif
649 677
650 #endif /* SDL_HAS_64BIT_TYPE */ 678 #endif /* SDL_HAS_64BIT_TYPE */
651 679
652 #ifndef HAVE_STRTOD 680 #ifndef HAVE_STRTOD
653 double SDL_strtod(const char *string, char **endp) 681 double
682 SDL_strtod(const char *string, char **endp)
654 { 683 {
655 size_t len; 684 size_t len;
656 double value; 685 double value;
657 686
658 len = SDL_ScanFloat(string, &value); 687 len = SDL_ScanFloat(string, &value);
659 if ( endp ) { 688 if (endp) {
660 *endp = (char *)string + len; 689 *endp = (char *) string + len;
661 } 690 }
662 return value; 691 return value;
663 } 692 }
664 #endif 693 #endif
665 694
666 #ifndef HAVE_STRCMP 695 #ifndef HAVE_STRCMP
667 int SDL_strcmp(const char *str1, const char *str2) 696 int
697 SDL_strcmp(const char *str1, const char *str2)
668 { 698 {
669 while (*str1 && *str2) { 699 while (*str1 && *str2) {
670 if ( *str1 != *str2 ) 700 if (*str1 != *str2)
671 break; 701 break;
672 ++str1; 702 ++str1;
673 ++str2; 703 ++str2;
674 } 704 }
675 return (int)((unsigned char)*str1 - (unsigned char)*str2); 705 return (int) ((unsigned char) *str1 - (unsigned char) *str2);
676 } 706 }
677 #endif 707 #endif
678 708
679 #ifndef HAVE_STRNCMP 709 #ifndef HAVE_STRNCMP
680 int SDL_strncmp(const char *str1, const char *str2, size_t maxlen) 710 int
681 { 711 SDL_strncmp(const char *str1, const char *str2, size_t maxlen)
682 while ( *str1 && *str2 && maxlen ) { 712 {
683 if ( *str1 != *str2 ) 713 while (*str1 && *str2 && maxlen) {
714 if (*str1 != *str2)
684 break; 715 break;
685 ++str1; 716 ++str1;
686 ++str2; 717 ++str2;
687 --maxlen; 718 --maxlen;
688 } 719 }
689 if ( ! maxlen ) { 720 if (!maxlen) {
690 return 0; 721 return 0;
691 } 722 }
692 return (int)((unsigned char)*str1 - (unsigned char)*str2); 723 return (int) ((unsigned char) *str1 - (unsigned char) *str2);
693 } 724 }
694 #endif 725 #endif
695 726
696 #if !defined(HAVE_STRCASECMP) && !defined(HAVE__STRICMP) 727 #if !defined(HAVE_STRCASECMP) && !defined(HAVE__STRICMP)
697 int SDL_strcasecmp(const char *str1, const char *str2) 728 int
729 SDL_strcasecmp(const char *str1, const char *str2)
698 { 730 {
699 char a = 0; 731 char a = 0;
700 char b = 0; 732 char b = 0;
701 while ( *str1 && *str2 ) { 733 while (*str1 && *str2) {
702 a = SDL_tolower(*str1); 734 a = SDL_tolower(*str1);
703 b = SDL_tolower(*str2); 735 b = SDL_tolower(*str2);
704 if ( a != b ) 736 if (a != b)
705 break; 737 break;
706 ++str1; 738 ++str1;
707 ++str2; 739 ++str2;
708 } 740 }
709 return (int)((unsigned char)a - (unsigned char)b); 741 return (int) ((unsigned char) a - (unsigned char) b);
710 } 742 }
711 #endif 743 #endif
712 744
713 #if !defined(HAVE_STRNCASECMP) && !defined(HAVE__STRNICMP) 745 #if !defined(HAVE_STRNCASECMP) && !defined(HAVE__STRNICMP)
714 int SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen) 746 int
747 SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen)
715 { 748 {
716 char a = 0; 749 char a = 0;
717 char b = 0; 750 char b = 0;
718 while ( *str1 && *str2 && maxlen ) { 751 while (*str1 && *str2 && maxlen) {
719 a = SDL_tolower(*str1); 752 a = SDL_tolower(*str1);
720 b = SDL_tolower(*str2); 753 b = SDL_tolower(*str2);
721 if ( a != b ) 754 if (a != b)
722 break; 755 break;
723 ++str1; 756 ++str1;
724 ++str2; 757 ++str2;
725 --maxlen; 758 --maxlen;
726 } 759 }
727 return (int)((unsigned char)a - (unsigned char)b); 760 return (int) ((unsigned char) a - (unsigned char) b);
728 } 761 }
729 #endif 762 #endif
730 763
731 #ifndef HAVE_SSCANF 764 #ifndef HAVE_SSCANF
732 int SDL_sscanf(const char *text, const char *fmt, ...) 765 int
766 SDL_sscanf(const char *text, const char *fmt, ...)
733 { 767 {
734 va_list ap; 768 va_list ap;
735 int retval = 0; 769 int retval = 0;
736 770
737 va_start(ap, fmt); 771 va_start(ap, fmt);
738 while ( *fmt ) { 772 while (*fmt) {
739 if ( *fmt == ' ' ) { 773 if (*fmt == ' ') {
740 while ( SDL_isspace(*text) ) { 774 while (SDL_isspace(*text)) {
741 ++text; 775 ++text;
742 } 776 }
743 ++fmt; 777 ++fmt;
744 continue; 778 continue;
745 } 779 }
746 if ( *fmt == '%' ) { 780 if (*fmt == '%') {
747 SDL_bool done = SDL_FALSE; 781 SDL_bool done = SDL_FALSE;
748 long count = 0; 782 long count = 0;
749 int radix = 10; 783 int radix = 10;
750 enum { 784 enum
785 {
751 DO_SHORT, 786 DO_SHORT,
752 DO_INT, 787 DO_INT,
753 DO_LONG, 788 DO_LONG,
754 DO_LONGLONG 789 DO_LONGLONG
755 } inttype = DO_INT; 790 } inttype = DO_INT;
756 SDL_bool suppress = SDL_FALSE; 791 SDL_bool suppress = SDL_FALSE;
757 792
758 ++fmt; 793 ++fmt;
759 if ( *fmt == '%' ) { 794 if (*fmt == '%') {
760 if ( *text == '%' ) { 795 if (*text == '%') {
761 ++text; 796 ++text;
762 ++fmt; 797 ++fmt;
763 continue; 798 continue;
764 } 799 }
765 break; 800 break;
766 } 801 }
767 if ( *fmt == '*' ) { 802 if (*fmt == '*') {
768 suppress = SDL_TRUE; 803 suppress = SDL_TRUE;
769 ++fmt; 804 ++fmt;
770 } 805 }
771 fmt += SDL_ScanLong(fmt, 10, &count); 806 fmt += SDL_ScanLong(fmt, 10, &count);
772 807
773 if ( *fmt == 'c' ) { 808 if (*fmt == 'c') {
774 if ( ! count ) { 809 if (!count) {
775 count = 1; 810 count = 1;
776 } 811 }
777 if ( suppress ) { 812 if (suppress) {
778 while ( count-- ) { 813 while (count--) {
779 ++text; 814 ++text;
780 } 815 }
781 } else { 816 } else {
782 char *valuep = va_arg(ap, char*); 817 char *valuep = va_arg(ap, char *);
783 while ( count-- ) { 818 while (count--) {
784 *valuep++ = *text++; 819 *valuep++ = *text++;
785 } 820 }
786 ++retval; 821 ++retval;
787 } 822 }
788 continue; 823 continue;
789 } 824 }
790 825
791 while ( SDL_isspace(*text) ) { 826 while (SDL_isspace(*text)) {
792 ++text; 827 ++text;
793 } 828 }
794 829
795 /* FIXME: implement more of the format specifiers */ 830 /* FIXME: implement more of the format specifiers */
796 while (!done) { 831 while (!done) {
797 switch(*fmt) { 832 switch (*fmt) {
798 case '*': 833 case '*':
799 suppress = SDL_TRUE; 834 suppress = SDL_TRUE;
800 break; 835 break;
801 case 'h': 836 case 'h':
802 if ( inttype > DO_SHORT ) { 837 if (inttype > DO_SHORT) {
803 ++inttype; 838 ++inttype;
839 }
840 break;
841 case 'l':
842 if (inttype < DO_LONGLONG) {
843 ++inttype;
844 }
845 break;
846 case 'I':
847 if (SDL_strncmp(fmt, "I64", 3) == 0) {
848 fmt += 2;
849 inttype = DO_LONGLONG;
850 }
851 break;
852 case 'i':
853 {
854 int index = 0;
855 if (text[index] == '-') {
856 ++index;
804 } 857 }
805 break; 858 if (text[index] == '0') {
806 case 'l': 859 if (SDL_tolower(text[index + 1]) == 'x') {
807 if ( inttype < DO_LONGLONG ) { 860 radix = 16;
808 ++inttype; 861 } else {
862 radix = 8;
863 }
809 } 864 }
810 break; 865 }
811 case 'I': 866 /* Fall through to %d handling */
812 if ( SDL_strncmp(fmt, "I64", 3) == 0 ) { 867 case 'd':
813 fmt += 2; 868 #ifdef SDL_HAS_64BIT_TYPE
814 inttype = DO_LONGLONG; 869 if (inttype == DO_LONGLONG) {
870 Sint64 value;
871 text += SDL_ScanLongLong(text, radix, &value);
872 if (!suppress) {
873 Sint64 *valuep = va_arg(ap, Sint64 *);
874 *valuep = value;
875 ++retval;
815 } 876 }
816 break; 877 } else
817 case 'i': 878 #endif /* SDL_HAS_64BIT_TYPE */
818 { 879 {
819 int index = 0; 880 long value;
820 if ( text[index] == '-' ) { 881 text += SDL_ScanLong(text, radix, &value);
821 ++index; 882 if (!suppress) {
883 switch (inttype) {
884 case DO_SHORT:
885 {
886 short *valuep = va_arg(ap, short *);
887 *valuep = (short) value;
888 }
889 break;
890 case DO_INT:
891 {
892 int *valuep = va_arg(ap, int *);
893 *valuep = (int) value;
894 }
895 break;
896 case DO_LONG:
897 {
898 long *valuep = va_arg(ap, long *);
899 *valuep = value;
900 }
901 break;
902 case DO_LONGLONG:
903 /* Handled above */
904 break;
822 } 905 }
823 if ( text[index] == '0' ) { 906 ++retval;
824 if ( SDL_tolower(text[index+1]) == 'x' ) { 907 }
825 radix = 16; 908 }
826 } else { 909 done = SDL_TRUE;
827 radix = 8; 910 break;
911 case 'o':
912 if (radix == 10) {
913 radix = 8;
914 }
915 /* Fall through to unsigned handling */
916 case 'x':
917 case 'X':
918 if (radix == 10) {
919 radix = 16;
920 }
921 /* Fall through to unsigned handling */
922 case 'u':
923 #ifdef SDL_HAS_64BIT_TYPE
924 if (inttype == DO_LONGLONG) {
925 Uint64 value;
926 text += SDL_ScanUnsignedLongLong(text, radix, &value);
927 if (!suppress) {
928 Uint64 *valuep = va_arg(ap, Uint64 *);
929 *valuep = value;
930 ++retval;
931 }
932 } else
933 #endif /* SDL_HAS_64BIT_TYPE */
934 {
935 unsigned long value;
936 text += SDL_ScanUnsignedLong(text, radix, &value);
937 if (!suppress) {
938 switch (inttype) {
939 case DO_SHORT:
940 {
941 short *valuep = va_arg(ap, short *);
942 *valuep = (short) value;
943 }
944 break;
945 case DO_INT:
946 {
947 int *valuep = va_arg(ap, int *);
948 *valuep = (int) value;
949 }
950 break;
951 case DO_LONG:
952 {
953 long *valuep = va_arg(ap, long *);
954 *valuep = value;
955 }
956 break;
957 case DO_LONGLONG:
958 /* Handled above */
959 break;
960 }
961 ++retval;
962 }
963 }
964 done = SDL_TRUE;
965 break;
966 case 'p':
967 {
968 uintptr_t value;
969 text += SDL_ScanUintPtrT(text, 16, &value);
970 if (!suppress) {
971 void **valuep = va_arg(ap, void **);
972 *valuep = (void *) value;
973 ++retval;
974 }
975 }
976 done = SDL_TRUE;
977 break;
978 case 'f':
979 {
980 double value;
981 text += SDL_ScanFloat(text, &value);
982 if (!suppress) {
983 float *valuep = va_arg(ap, float *);
984 *valuep = (float) value;
985 ++retval;
986 }
987 }
988 done = SDL_TRUE;
989 break;
990 case 's':
991 if (suppress) {
992 while (!SDL_isspace(*text)) {
993 ++text;
994 if (count) {
995 if (--count == 0) {
996 break;
828 } 997 }
829 } 998 }
830 } 999 }
831 /* Fall through to %d handling */ 1000 } else {
832 case 'd': 1001 char *valuep = va_arg(ap, char *);
833 #ifdef SDL_HAS_64BIT_TYPE 1002 while (!SDL_isspace(*text)) {
834 if ( inttype == DO_LONGLONG ) { 1003 *valuep++ = *text++;
835 Sint64 value; 1004 if (count) {
836 text += SDL_ScanLongLong(text, radix, &value); 1005 if (--count == 0) {
837 if ( ! suppress ) { 1006 break;
838 Sint64 *valuep = va_arg(ap, Sint64*); 1007 }
839 *valuep = value;
840 ++retval;
841 } 1008 }
842 } 1009 }
843 else 1010 *valuep = '\0';
844 #endif /* SDL_HAS_64BIT_TYPE */ 1011 ++retval;
845 { 1012 }
846 long value; 1013 done = SDL_TRUE;
847 text += SDL_ScanLong(text, radix, &value); 1014 break;
848 if ( ! suppress ) { 1015 default:
849 switch (inttype) { 1016 done = SDL_TRUE;
850 case DO_SHORT: 1017 break;
851 { short* valuep = va_arg(ap, short*);
852 *valuep = (short)value;
853 }
854 break;
855 case DO_INT:
856 { int* valuep = va_arg(ap, int*);
857 *valuep = (int)value;
858 }
859 break;
860 case DO_LONG:
861 { long* valuep = va_arg(ap, long*);
862 *valuep = value;
863 }
864 break;
865 case DO_LONGLONG:
866 /* Handled above */
867 break;
868 }
869 ++retval;
870 }
871 }
872 done = SDL_TRUE;
873 break;
874 case 'o':
875 if ( radix == 10 ) {
876 radix = 8;
877 }
878 /* Fall through to unsigned handling */
879 case 'x':
880 case 'X':
881 if ( radix == 10 ) {
882 radix = 16;
883 }
884 /* Fall through to unsigned handling */
885 case 'u':
886 #ifdef SDL_HAS_64BIT_TYPE
887 if ( inttype == DO_LONGLONG ) {
888 Uint64 value;
889 text += SDL_ScanUnsignedLongLong(text, radix, &value);
890 if ( ! suppress ) {
891 Uint64 *valuep = va_arg(ap, Uint64*);
892 *valuep = value;
893 ++retval;
894 }
895 }
896 else
897 #endif /* SDL_HAS_64BIT_TYPE */
898 {
899 unsigned long value;
900 text += SDL_ScanUnsignedLong(text, radix, &value);
901 if ( ! suppress ) {
902 switch (inttype) {
903 case DO_SHORT:
904 { short* valuep = va_arg(ap, short*);
905 *valuep = (short)value;
906 }
907 break;
908 case DO_INT:
909 { int* valuep = va_arg(ap, int*);
910 *valuep = (int)value;
911 }
912 break;
913 case DO_LONG:
914 { long* valuep = va_arg(ap, long*);
915 *valuep = value;
916 }
917 break;
918 case DO_LONGLONG:
919 /* Handled above */
920 break;
921 }
922 ++retval;
923 }
924 }
925 done = SDL_TRUE;
926 break;
927 case 'p':
928 {
929 uintptr_t value;
930 text += SDL_ScanUintPtrT(text, 16, &value);
931 if ( ! suppress ) {
932 void** valuep = va_arg(ap, void**);
933 *valuep = (void*)value;
934 ++retval;
935 }
936 }
937 done = SDL_TRUE;
938 break;
939 case 'f':
940 {
941 double value;
942 text += SDL_ScanFloat(text, &value);
943 if ( ! suppress ) {
944 float* valuep = va_arg(ap, float*);
945 *valuep = (float)value;
946 ++retval;
947 }
948 }
949 done = SDL_TRUE;
950 break;
951 case 's':
952 if ( suppress ) {
953 while ( !SDL_isspace(*text) ) {
954 ++text;
955 if ( count ) {
956 if ( --count == 0 ) {
957 break;
958 }
959 }
960 }
961 } else {
962 char *valuep = va_arg(ap, char*);
963 while ( !SDL_isspace(*text) ) {
964 *valuep++ = *text++;
965 if ( count ) {
966 if ( --count == 0 ) {
967 break;
968 }
969 }
970 }
971 *valuep = '\0';
972 ++retval;
973 }
974 done = SDL_TRUE;
975 break;
976 default:
977 done = SDL_TRUE;
978 break;
979 } 1018 }
980 ++fmt; 1019 ++fmt;
981 } 1020 }
982 continue; 1021 continue;
983 } 1022 }
984 if ( *text == *fmt ) { 1023 if (*text == *fmt) {
985 ++text; 1024 ++text;
986 ++fmt; 1025 ++fmt;
987 continue; 1026 continue;
988 } 1027 }
989 /* Text didn't match format specifier */ 1028 /* Text didn't match format specifier */
994 return retval; 1033 return retval;
995 } 1034 }
996 #endif 1035 #endif
997 1036
998 #ifndef HAVE_SNPRINTF 1037 #ifndef HAVE_SNPRINTF
999 int SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...) 1038 int
1039 SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...)
1000 { 1040 {
1001 va_list ap; 1041 va_list ap;
1002 int retval; 1042 int retval;
1003 1043
1004 va_start(ap, fmt); 1044 va_start(ap, fmt);
1008 return retval; 1048 return retval;
1009 } 1049 }
1010 #endif 1050 #endif
1011 1051
1012 #ifndef HAVE_VSNPRINTF 1052 #ifndef HAVE_VSNPRINTF
1013 static size_t SDL_PrintLong(char *text, long value, int radix, size_t maxlen) 1053 static size_t
1054 SDL_PrintLong(char *text, long value, int radix, size_t maxlen)
1014 { 1055 {
1015 char num[130]; 1056 char num[130];
1016 size_t size; 1057 size_t size;
1017 1058
1018 SDL_ltoa(value, num, radix); 1059 SDL_ltoa(value, num, radix);
1019 size = SDL_strlen(num); 1060 size = SDL_strlen(num);
1020 if ( size >= maxlen ) { 1061 if (size >= maxlen) {
1021 size = maxlen-1; 1062 size = maxlen - 1;
1022 } 1063 }
1023 SDL_strlcpy(text, num, size+1); 1064 SDL_strlcpy(text, num, size + 1);
1024 1065
1025 return size; 1066 return size;
1026 } 1067 }
1027 static size_t SDL_PrintUnsignedLong(char *text, unsigned long value, int radix, size_t maxlen) 1068
1069 static size_t
1070 SDL_PrintUnsignedLong(char *text, unsigned long value, int radix,
1071 size_t maxlen)
1028 { 1072 {
1029 char num[130]; 1073 char num[130];
1030 size_t size; 1074 size_t size;
1031 1075
1032 SDL_ultoa(value, num, radix); 1076 SDL_ultoa(value, num, radix);
1033 size = SDL_strlen(num); 1077 size = SDL_strlen(num);
1034 if ( size >= maxlen ) { 1078 if (size >= maxlen) {
1035 size = maxlen-1; 1079 size = maxlen - 1;
1036 } 1080 }
1037 SDL_strlcpy(text, num, size+1); 1081 SDL_strlcpy(text, num, size + 1);
1038 1082
1039 return size; 1083 return size;
1040 } 1084 }
1085
1041 #ifdef SDL_HAS_64BIT_TYPE 1086 #ifdef SDL_HAS_64BIT_TYPE
1042 static size_t SDL_PrintLongLong(char *text, Sint64 value, int radix, size_t maxlen) 1087 static size_t
1088 SDL_PrintLongLong(char *text, Sint64 value, int radix, size_t maxlen)
1043 { 1089 {
1044 char num[130]; 1090 char num[130];
1045 size_t size; 1091 size_t size;
1046 1092
1047 SDL_lltoa(value, num, radix); 1093 SDL_lltoa(value, num, radix);
1048 size = SDL_strlen(num); 1094 size = SDL_strlen(num);
1049 if ( size >= maxlen ) { 1095 if (size >= maxlen) {
1050 size = maxlen-1; 1096 size = maxlen - 1;
1051 } 1097 }
1052 SDL_strlcpy(text, num, size+1); 1098 SDL_strlcpy(text, num, size + 1);
1053 1099
1054 return size; 1100 return size;
1055 } 1101 }
1056 static size_t SDL_PrintUnsignedLongLong(char *text, Uint64 value, int radix, size_t maxlen) 1102
1103 static size_t
1104 SDL_PrintUnsignedLongLong(char *text, Uint64 value, int radix, size_t maxlen)
1057 { 1105 {
1058 char num[130]; 1106 char num[130];
1059 size_t size; 1107 size_t size;
1060 1108
1061 SDL_ulltoa(value, num, radix); 1109 SDL_ulltoa(value, num, radix);
1062 size = SDL_strlen(num); 1110 size = SDL_strlen(num);
1063 if ( size >= maxlen ) { 1111 if (size >= maxlen) {
1064 size = maxlen-1; 1112 size = maxlen - 1;
1065 } 1113 }
1066 SDL_strlcpy(text, num, size+1); 1114 SDL_strlcpy(text, num, size + 1);
1067 1115
1068 return size; 1116 return size;
1069 } 1117 }
1070 #endif /* SDL_HAS_64BIT_TYPE */ 1118 #endif /* SDL_HAS_64BIT_TYPE */
1071 static size_t SDL_PrintFloat(char *text, double arg, size_t maxlen) 1119 static size_t
1120 SDL_PrintFloat(char *text, double arg, size_t maxlen)
1072 { 1121 {
1073 char *textstart = text; 1122 char *textstart = text;
1074 if ( arg ) { 1123 if (arg) {
1075 /* This isn't especially accurate, but hey, it's easy. :) */ 1124 /* This isn't especially accurate, but hey, it's easy. :) */
1076 const double precision = 0.00000001; 1125 const double precision = 0.00000001;
1077 size_t len; 1126 size_t len;
1078 unsigned long value; 1127 unsigned long value;
1079 1128
1080 if ( arg < 0 ) { 1129 if (arg < 0) {
1081 *text++ = '-'; 1130 *text++ = '-';
1082 --maxlen; 1131 --maxlen;
1083 arg = -arg; 1132 arg = -arg;
1084 } 1133 }
1085 value = (unsigned long)arg; 1134 value = (unsigned long) arg;
1086 len = SDL_PrintUnsignedLong(text, value, 10, maxlen); 1135 len = SDL_PrintUnsignedLong(text, value, 10, maxlen);
1087 text += len; 1136 text += len;
1088 maxlen -= len; 1137 maxlen -= len;
1089 arg -= value; 1138 arg -= value;
1090 if ( arg > precision && maxlen ) { 1139 if (arg > precision && maxlen) {
1091 int mult = 10; 1140 int mult = 10;
1092 *text++ = '.'; 1141 *text++ = '.';
1093 while ( (arg > precision) && maxlen ) { 1142 while ((arg > precision) && maxlen) {
1094 value = (unsigned long)(arg * mult); 1143 value = (unsigned long) (arg * mult);
1095 len = SDL_PrintUnsignedLong(text, value, 10, maxlen); 1144 len = SDL_PrintUnsignedLong(text, value, 10, maxlen);
1096 text += len; 1145 text += len;
1097 maxlen -= len; 1146 maxlen -= len;
1098 arg -= (double)value / mult; 1147 arg -= (double) value / mult;
1099 mult *= 10; 1148 mult *= 10;
1100 } 1149 }
1101 } 1150 }
1102 } else { 1151 } else {
1103 *text++ = '0'; 1152 *text++ = '0';
1104 } 1153 }
1105 return (text - textstart); 1154 return (text - textstart);
1106 } 1155 }
1107 static size_t SDL_PrintString(char *text, const char *string, size_t maxlen) 1156
1157 static size_t
1158 SDL_PrintString(char *text, const char *string, size_t maxlen)
1108 { 1159 {
1109 char *textstart = text; 1160 char *textstart = text;
1110 while ( *string && maxlen-- ) { 1161 while (*string && maxlen--) {
1111 *text++ = *string++; 1162 *text++ = *string++;
1112 } 1163 }
1113 return (text - textstart); 1164 return (text - textstart);
1114 } 1165 }
1115 int SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap) 1166
1167 int
1168 SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap)
1116 { 1169 {
1117 char *textstart = text; 1170 char *textstart = text;
1118 if ( maxlen <= 0 ) { 1171 if (maxlen <= 0) {
1119 return 0; 1172 return 0;
1120 } 1173 }
1121 --maxlen; /* For the trailing '\0' */ 1174 --maxlen; /* For the trailing '\0' */
1122 while ( *fmt && maxlen ) { 1175 while (*fmt && maxlen) {
1123 if ( *fmt == '%' ) { 1176 if (*fmt == '%') {
1124 SDL_bool done = SDL_FALSE; 1177 SDL_bool done = SDL_FALSE;
1125 size_t len = 0; 1178 size_t len = 0;
1126 SDL_bool do_lowercase = SDL_FALSE; 1179 SDL_bool do_lowercase = SDL_FALSE;
1127 int radix = 10; 1180 int radix = 10;
1128 enum { 1181 enum
1182 {
1129 DO_INT, 1183 DO_INT,
1130 DO_LONG, 1184 DO_LONG,
1131 DO_LONGLONG 1185 DO_LONGLONG
1132 } inttype = DO_INT; 1186 } inttype = DO_INT;
1133 1187
1134 ++fmt; 1188 ++fmt;
1135 /* FIXME: implement more of the format specifiers */ 1189 /* FIXME: implement more of the format specifiers */
1136 while ( *fmt == '.' || (*fmt >= '0' && *fmt <= '9') ) { 1190 while (*fmt == '.' || (*fmt >= '0' && *fmt <= '9')) {
1137 ++fmt; 1191 ++fmt;
1138 } 1192 }
1139 while (!done) { 1193 while (!done) {
1140 switch(*fmt) { 1194 switch (*fmt) {
1141 case '%': 1195 case '%':
1142 *text = '%'; 1196 *text = '%';
1143 len = 1; 1197 len = 1;
1144 done = SDL_TRUE; 1198 done = SDL_TRUE;
1199 break;
1200 case 'c':
1201 /* char is promoted to int when passed through (...) */
1202 *text = (char) va_arg(ap, int);
1203 len = 1;
1204 done = SDL_TRUE;
1205 break;
1206 case 'h':
1207 /* short is promoted to int when passed through (...) */
1208 break;
1209 case 'l':
1210 if (inttype < DO_LONGLONG) {
1211 ++inttype;
1212 }
1213 break;
1214 case 'I':
1215 if (SDL_strncmp(fmt, "I64", 3) == 0) {
1216 fmt += 2;
1217 inttype = DO_LONGLONG;
1218 }
1219 break;
1220 case 'i':
1221 case 'd':
1222 switch (inttype) {
1223 case DO_INT:
1224 len =
1225 SDL_PrintLong(text,
1226 (long) va_arg(ap, int),
1227 radix, maxlen);
1145 break; 1228 break;
1146 case 'c': 1229 case DO_LONG:
1147 /* char is promoted to int when passed through (...) */ 1230 len =
1148 *text = (char)va_arg(ap, int); 1231 SDL_PrintLong(text, va_arg(ap, long),
1149 len = 1; 1232 radix, maxlen);
1150 done = SDL_TRUE;
1151 break; 1233 break;
1152 case 'h': 1234 case DO_LONGLONG:
1153 /* short is promoted to int when passed through (...) */ 1235 #ifdef SDL_HAS_64BIT_TYPE
1236 len =
1237 SDL_PrintLongLong(text,
1238 va_arg(ap, Sint64),
1239 radix, maxlen);
1240 #else
1241 len =
1242 SDL_PrintLong(text, va_arg(ap, long),
1243 radix, maxlen);
1244 #endif
1154 break; 1245 break;
1155 case 'l': 1246 }
1156 if ( inttype < DO_LONGLONG ) { 1247 done = SDL_TRUE;
1157 ++inttype; 1248 break;
1158 } 1249 case 'p':
1250 case 'x':
1251 do_lowercase = SDL_TRUE;
1252 /* Fall through to 'X' handling */
1253 case 'X':
1254 if (radix == 10) {
1255 radix = 16;
1256 }
1257 if (*fmt == 'p') {
1258 inttype = DO_LONG;
1259 }
1260 /* Fall through to unsigned handling */
1261 case 'o':
1262 if (radix == 10) {
1263 radix = 8;
1264 }
1265 /* Fall through to unsigned handling */
1266 case 'u':
1267 switch (inttype) {
1268 case DO_INT:
1269 len = SDL_PrintUnsignedLong(text, (unsigned long)
1270 va_arg(ap,
1271 unsigned
1272 int),
1273 radix, maxlen);
1159 break; 1274 break;
1160 case 'I': 1275 case DO_LONG:
1161 if ( SDL_strncmp(fmt, "I64", 3) == 0 ) { 1276 len =
1162 fmt += 2; 1277 SDL_PrintUnsignedLong(text,
1163 inttype = DO_LONGLONG; 1278 va_arg(ap,
1164 } 1279 unsigned
1280 long),
1281 radix, maxlen);
1165 break; 1282 break;
1166 case 'i': 1283 case DO_LONGLONG:
1167 case 'd':
1168 switch (inttype) {
1169 case DO_INT:
1170 len = SDL_PrintLong(text, (long)va_arg(ap, int), radix, maxlen);
1171 break;
1172 case DO_LONG:
1173 len = SDL_PrintLong(text, va_arg(ap, long), radix, maxlen);
1174 break;
1175 case DO_LONGLONG:
1176 #ifdef SDL_HAS_64BIT_TYPE 1284 #ifdef SDL_HAS_64BIT_TYPE
1177 len = SDL_PrintLongLong(text, va_arg(ap, Sint64), radix, maxlen); 1285 len =
1286 SDL_PrintUnsignedLongLong(text,
1287 va_arg(ap,
1288 Uint64),
1289 radix, maxlen);
1178 #else 1290 #else
1179 len = SDL_PrintLong(text, va_arg(ap, long), radix, maxlen); 1291 len =
1180 #endif 1292 SDL_PrintUnsignedLong(text,
1181 break; 1293 va_arg(ap,
1182 } 1294 unsigned
1183 done = SDL_TRUE; 1295 long),
1296 radix, maxlen);
1297 #endif
1184 break; 1298 break;
1185 case 'p': 1299 }
1186 case 'x': 1300 if (do_lowercase) {
1187 do_lowercase = SDL_TRUE; 1301 SDL_strlwr(text);
1188 /* Fall through to 'X' handling */ 1302 }
1189 case 'X': 1303 done = SDL_TRUE;
1190 if ( radix == 10 ) { 1304 break;
1191 radix = 16; 1305 case 'f':
1192 } 1306 len = SDL_PrintFloat(text, va_arg(ap, double), maxlen);
1193 if ( *fmt == 'p' ) { 1307 done = SDL_TRUE;
1194 inttype = DO_LONG; 1308 break;
1195 } 1309 case 's':
1196 /* Fall through to unsigned handling */ 1310 len = SDL_PrintString(text, va_arg(ap, char *), maxlen);
1197 case 'o': 1311 done = SDL_TRUE;
1198 if ( radix == 10 ) { 1312 break;
1199 radix = 8; 1313 default:
1200 } 1314 done = SDL_TRUE;
1201 /* Fall through to unsigned handling */ 1315 break;
1202 case 'u':
1203 switch (inttype) {
1204 case DO_INT:
1205 len = SDL_PrintUnsignedLong(text, (unsigned long)va_arg(ap, unsigned int), radix, maxlen);
1206 break;
1207 case DO_LONG:
1208 len = SDL_PrintUnsignedLong(text, va_arg(ap, unsigned long), radix, maxlen);
1209 break;
1210 case DO_LONGLONG:
1211 #ifdef SDL_HAS_64BIT_TYPE
1212 len = SDL_PrintUnsignedLongLong(text, va_arg(ap, Uint64), radix, maxlen);
1213 #else
1214 len = SDL_PrintUnsignedLong(text, va_arg(ap, unsigned long), radix, maxlen);
1215 #endif
1216 break;
1217 }
1218 if ( do_lowercase ) {
1219 SDL_strlwr(text);
1220 }
1221 done = SDL_TRUE;
1222 break;
1223 case 'f':
1224 len = SDL_PrintFloat(text, va_arg(ap, double), maxlen);
1225 done = SDL_TRUE;
1226 break;
1227 case 's':
1228 len = SDL_PrintString(text, va_arg(ap, char*), maxlen);
1229 done = SDL_TRUE;
1230 break;
1231 default:
1232 done = SDL_TRUE;
1233 break;
1234 } 1316 }
1235 ++fmt; 1317 ++fmt;
1236 } 1318 }
1237 text += len; 1319 text += len;
1238 maxlen -= len; 1320 maxlen -= len;
1244 *text = '\0'; 1326 *text = '\0';
1245 1327
1246 return (text - textstart); 1328 return (text - textstart);
1247 } 1329 }
1248 #endif 1330 #endif
1331 /* vi: set ts=4 sw=4 expandtab: */