This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_string.c
1422 lines (1317 loc) · 35.5 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
22
#include "SDL_config.h"
23
24
25
/* This file contains portable string manipulation functions for SDL */
26
#include "SDL_stdinc.h"
27
28
29
30
#define SDL_isupperhex(X) (((X) >= 'A') && ((X) <= 'F'))
#define SDL_islowerhex(X) (((X) >= 'a') && ((X) <= 'f'))
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#define UTF8_IsLeadByte(c) ((c) >= 0xC0 && (c) <= 0xF4)
#define UTF8_IsTrailingByte(c) ((c) >= 0x80 && (c) <= 0xBF)
int UTF8_TrailingBytes(unsigned char c)
{
if (c >= 0xC0 && c<= 0xDF)
return 1;
else if (c >= 0xE0 && c <= 0xEF)
return 2;
else if (c >= 0xF0 && c <= 0xF4)
return 3;
else
return 0;
}
47
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOL)
48
49
static size_t
SDL_ScanLong(const char *text, int radix, long *valuep)
50
51
52
53
54
{
const char *textstart = text;
long value = 0;
SDL_bool negative = SDL_FALSE;
55
if (*text == '-') {
56
57
58
negative = SDL_TRUE;
++text;
}
59
if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
60
61
text += 2;
}
62
for (;;) {
63
int v;
64
if (SDL_isdigit((unsigned char) *text)) {
65
v = *text - '0';
66
} else if (radix == 16 && SDL_isupperhex(*text)) {
67
v = 10 + (*text - 'A');
68
} else if (radix == 16 && SDL_islowerhex(*text)) {
69
70
71
72
73
74
75
76
v = 10 + (*text - 'a');
} else {
break;
}
value *= radix;
value += v;
++text;
}
77
78
if (valuep) {
if (negative && value) {
79
80
81
82
83
84
85
86
87
*valuep = -value;
} else {
*valuep = value;
}
}
return (text - textstart);
}
#endif
88
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD)
89
90
static size_t
SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *valuep)
91
92
93
94
{
const char *textstart = text;
unsigned long value = 0;
95
if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
96
97
text += 2;
}
98
for (;;) {
99
int v;
100
if (SDL_isdigit((unsigned char) *text)) {
101
v = *text - '0';
102
} else if (radix == 16 && SDL_isupperhex(*text)) {
103
v = 10 + (*text - 'A');
104
} else if (radix == 16 && SDL_islowerhex(*text)) {
105
106
107
108
109
110
111
112
v = 10 + (*text - 'a');
} else {
break;
}
value *= radix;
value += v;
++text;
}
113
if (valuep) {
114
115
116
117
118
119
*valuep = value;
}
return (text - textstart);
}
#endif
120
#ifndef HAVE_SSCANF
121
122
static size_t
SDL_ScanUintPtrT(const char *text, int radix, uintptr_t * valuep)
123
124
125
126
{
const char *textstart = text;
uintptr_t value = 0;
127
if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
128
129
text += 2;
}
130
for (;;) {
131
int v;
132
if (SDL_isdigit((unsigned char) *text)) {
133
v = *text - '0';
134
} else if (radix == 16 && SDL_isupperhex(*text)) {
135
v = 10 + (*text - 'A');
136
} else if (radix == 16 && SDL_islowerhex(*text)) {
137
138
139
140
141
142
143
144
v = 10 + (*text - 'a');
} else {
break;
}
value *= radix;
value += v;
++text;
}
145
if (valuep) {
146
147
148
149
150
151
*valuep = value;
}
return (text - textstart);
}
#endif
152
153
#ifdef SDL_HAS_64BIT_TYPE
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOLL)
154
155
static size_t
SDL_ScanLongLong(const char *text, int radix, Sint64 * valuep)
156
157
158
159
160
{
const char *textstart = text;
Sint64 value = 0;
SDL_bool negative = SDL_FALSE;
161
if (*text == '-') {
162
163
164
negative = SDL_TRUE;
++text;
}
165
if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
166
167
text += 2;
}
168
for (;;) {
169
int v;
170
if (SDL_isdigit((unsigned char) *text)) {
171
v = *text - '0';
172
} else if (radix == 16 && SDL_isupperhex(*text)) {
173
v = 10 + (*text - 'A');
174
} else if (radix == 16 && SDL_islowerhex(*text)) {
175
176
177
178
179
180
181
182
v = 10 + (*text - 'a');
} else {
break;
}
value *= radix;
value += v;
++text;
}
183
184
if (valuep) {
if (negative && value) {
185
186
187
188
189
190
191
192
193
*valuep = -value;
} else {
*valuep = value;
}
}
return (text - textstart);
}
#endif
194
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOULL)
195
196
static size_t
SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 * valuep)
197
198
199
200
{
const char *textstart = text;
Uint64 value = 0;
201
if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
202
203
text += 2;
}
204
for (;;) {
205
int v;
206
if (SDL_isdigit((unsigned char) *text)) {
207
v = *text - '0';
208
} else if (radix == 16 && SDL_isupperhex(*text)) {
209
v = 10 + (*text - 'A');
210
} else if (radix == 16 && SDL_islowerhex(*text)) {
211
212
213
214
215
216
217
218
v = 10 + (*text - 'a');
} else {
break;
}
value *= radix;
value += v;
++text;
}
219
if (valuep) {
220
221
222
223
224
225
226
*valuep = value;
}
return (text - textstart);
}
#endif
#endif /* SDL_HAS_64BIT_TYPE */
227
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOD)
228
229
static size_t
SDL_ScanFloat(const char *text, double *valuep)
230
231
232
233
234
235
{
const char *textstart = text;
unsigned long lvalue = 0;
double value = 0.0;
SDL_bool negative = SDL_FALSE;
236
if (*text == '-') {
237
238
239
240
241
negative = SDL_TRUE;
++text;
}
text += SDL_ScanUnsignedLong(text, 10, &lvalue);
value += lvalue;
242
if (*text == '.') {
243
244
int mult = 10;
++text;
245
while (SDL_isdigit((unsigned char) *text)) {
246
lvalue = *text - '0';
247
value += (double) lvalue / mult;
248
249
250
251
mult *= 10;
++text;
}
}
252
253
if (valuep) {
if (negative && value) {
254
255
256
257
258
259
260
261
262
263
*valuep = -value;
} else {
*valuep = value;
}
}
return (text - textstart);
}
#endif
#ifndef SDL_memset
264
265
void *
SDL_memset(void *dst, int c, size_t len)
266
267
{
size_t left = (len % 4);
268
if (len >= 4) {
269
Uint32 value = 0;
270
Uint32 *dstp = (Uint32 *) dst;
271
272
273
274
275
276
int i;
for (i = 0; i < 4; ++i) {
value <<= 8;
value |= c;
}
len /= 4;
277
while (len--) {
278
279
280
*dstp++ = value;
}
}
281
282
283
284
285
if (left > 0) {
Uint8 value = (Uint8) c;
Uint8 *dstp = (Uint8 *) dst;
switch (left) {
case 3:
286
*dstp++ = value;
287
case 2:
288
*dstp++ = value;
289
case 1:
290
291
292
293
294
295
296
297
*dstp++ = value;
}
}
return dst;
}
#endif
#ifndef SDL_memcpy
298
299
void *
SDL_memcpy(void *dst, const void *src, size_t len)
300
{
301
302
303
char *srcp = (char *) src;
char *dstp = (char *) dst;
while (len--) {
304
305
306
307
308
309
310
*dstp++ = *srcp++;
}
return dst;
}
#endif
#ifndef SDL_revcpy
311
312
void *
SDL_revcpy(void *dst, const void *src, size_t len)
313
{
314
315
char *srcp = (char *) src;
char *dstp = (char *) dst;
316
317
srcp += len - 1;
dstp += len - 1;
318
while (len--) {
319
320
321
322
323
324
325
*dstp-- = *srcp--;
}
return dst;
}
#endif
#ifndef SDL_memcmp
326
327
int
SDL_memcmp(const void *s1, const void *s2, size_t len)
328
{
329
330
331
332
char *s1p = (char *) s1;
char *s2p = (char *) s2;
while (len--) {
if (*s1p != *s2p) {
333
return (*s1p - *s2p);
334
335
336
}
++s1p;
++s2p;
337
338
339
340
341
342
}
return 0;
}
#endif
#ifndef HAVE_STRLEN
343
344
size_t
SDL_strlen(const char *string)
345
346
{
size_t len = 0;
347
while (*string++) {
348
349
350
351
352
353
++len;
}
return len;
}
#endif
354
355
#ifndef HAVE_WCSLEN
size_t
356
SDL_wcslen(const wchar_t * string)
357
358
359
360
361
362
363
364
365
{
size_t len = 0;
while (*string++) {
++len;
}
return len;
}
#endif
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
#ifndef HAVE_WCSLCPY
size_t
SDL_wcslcpy(wchar_t *dst, const wchar_t *src, size_t maxlen)
{
size_t srclen = SDL_wcslen(src);
if (maxlen > 0) {
size_t len = SDL_min(srclen, maxlen - 1);
SDL_memcpy(dst, src, len * sizeof(wchar_t));
dst[len] = '\0';
}
return srclen;
}
#endif
#ifndef HAVE_WCSLCAT
size_t
SDL_wcslcat(wchar_t *dst, const wchar_t *src, size_t maxlen)
{
size_t dstlen = SDL_wcslen(dst);
size_t srclen = SDL_wcslen(src);
if (dstlen < maxlen) {
SDL_wcslcpy(dst + dstlen, src, maxlen - dstlen);
}
return dstlen + srclen;
}
#endif
393
#ifndef HAVE_STRLCPY
394
395
size_t
SDL_strlcpy(char *dst, const char *src, size_t maxlen)
396
{
397
size_t srclen = SDL_strlen(src);
398
399
if (maxlen > 0) {
size_t len = SDL_min(srclen, maxlen - 1);
400
401
SDL_memcpy(dst, src, len);
dst[len] = '\0';
402
}
403
return srclen;
404
405
406
}
#endif
407
408
409
410
size_t SDL_utf8strlcpy(char *dst, const char *src, size_t dst_bytes)
{
size_t src_bytes = SDL_strlen(src);
size_t bytes = SDL_min(src_bytes, dst_bytes - 1);
411
size_t i = 0;
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
char trailing_bytes = 0;
if (bytes)
{
unsigned char c = (unsigned char)src[bytes - 1];
if (UTF8_IsLeadByte(c))
--bytes;
else if (UTF8_IsTrailingByte(c))
{
for (i = bytes - 1; i != 0; --i)
{
c = (unsigned char)src[i];
trailing_bytes = UTF8_TrailingBytes(c);
if (trailing_bytes)
{
if (bytes - i != trailing_bytes + 1)
bytes = i;
break;
}
}
}
SDL_memcpy(dst, src, bytes);
}
dst[bytes] = '\0';
return bytes;
}
439
#ifndef HAVE_STRLCAT
440
441
size_t
SDL_strlcat(char *dst, const char *src, size_t maxlen)
442
{
443
444
size_t dstlen = SDL_strlen(dst);
size_t srclen = SDL_strlen(src);
445
446
if (dstlen < maxlen) {
SDL_strlcpy(dst + dstlen, src, maxlen - dstlen);
447
}
448
return dstlen + srclen;
449
450
451
}
#endif
452
#ifndef HAVE_STRDUP
453
454
char *
SDL_strdup(const char *string)
455
{
456
size_t len = SDL_strlen(string) + 1;
457
char *newstr = SDL_malloc(len);
458
if (newstr) {
459
SDL_strlcpy(newstr, string, len);
460
461
462
463
464
}
return newstr;
}
#endif
465
#ifndef HAVE__STRREV
466
467
char *
SDL_strrev(char *string)
468
469
470
{
size_t len = SDL_strlen(string);
char *a = &string[0];
471
char *b = &string[len - 1];
472
len /= 2;
473
while (len--) {
474
475
476
477
478
479
480
481
482
char c = *a;
*a++ = *b;
*b-- = c;
}
return string;
}
#endif
#ifndef HAVE__STRUPR
483
484
char *
SDL_strupr(char *string)
485
486
{
char *bufp = string;
487
while (*bufp) {
488
*bufp = SDL_toupper((unsigned char) *bufp);
489
++bufp;
490
491
492
493
494
495
}
return string;
}
#endif
#ifndef HAVE__STRLWR
496
497
char *
SDL_strlwr(char *string)
498
499
{
char *bufp = string;
500
while (*bufp) {
501
*bufp = SDL_tolower((unsigned char) *bufp);
502
++bufp;
503
504
505
506
507
508
}
return string;
}
#endif
#ifndef HAVE_STRCHR
509
510
char *
SDL_strchr(const char *string, int c)
511
{
512
513
514
while (*string) {
if (*string == c) {
return (char *) string;
515
}
516
++string;
517
518
519
520
521
522
}
return NULL;
}
#endif
#ifndef HAVE_STRRCHR
523
524
char *
SDL_strrchr(const char *string, int c)
525
{
526
const char *bufp = string + SDL_strlen(string) - 1;
527
528
529
while (bufp >= string) {
if (*bufp == c) {
return (char *) bufp;
530
}
531
--bufp;
532
533
534
535
536
537
}
return NULL;
}
#endif
#ifndef HAVE_STRSTR
538
539
char *
SDL_strstr(const char *haystack, const char *needle)
540
{
541
size_t length = SDL_strlen(needle);
542
543
544
while (*haystack) {
if (SDL_strncmp(haystack, needle, length) == 0) {
return (char *) haystack;
545
}
546
++haystack;
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
}
return NULL;
}
#endif
#if !defined(HAVE__LTOA) || !defined(HAVE__I64TOA) || \
!defined(HAVE__ULTOA) || !defined(HAVE__UI64TOA)
static const char ntoa_table[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z'
};
#endif /* ntoa() conversion table */
#ifndef HAVE__LTOA
563
564
char *
SDL_ltoa(long value, char *string, int radix)
565
566
567
{
char *bufp = string;
568
if (value < 0) {
569
570
571
*bufp++ = '-';
value = -value;
}
572
573
if (value) {
while (value > 0) {
574
575
576
577
578
579
580
581
582
*bufp++ = ntoa_table[value % radix];
value /= radix;
}
} else {
*bufp++ = '0';
}
*bufp = '\0';
/* The numbers went into the string backwards. :) */
583
584
if (*string == '-') {
SDL_strrev(string + 1);
585
} else {
586
SDL_strrev(string);
587
588
589
590
591
592
593
}
return string;
}
#endif
#ifndef HAVE__ULTOA
594
595
char *
SDL_ultoa(unsigned long value, char *string, int radix)
596
597
598
{
char *bufp = string;
599
600
if (value) {
while (value > 0) {
601
602
603
604
605
606
607
608
609
*bufp++ = ntoa_table[value % radix];
value /= radix;
}
} else {
*bufp++ = '0';
}
*bufp = '\0';
/* The numbers went into the string backwards. :) */
610
SDL_strrev(string);
611
612
613
614
615
616
return string;
}
#endif
#ifndef HAVE_STRTOL
617
618
long
SDL_strtol(const char *string, char **endp, int base)
619
620
621
622
{
size_t len;
long value;
623
624
if (!base) {
if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
625
626
627
628
629
630
631
base = 16;
} else {
base = 10;
}
}
len = SDL_ScanLong(string, base, &value);
632
633
if (endp) {
*endp = (char *) string + len;
634
635
636
637
638
}
return value;
}
#endif
639
#ifndef HAVE_STRTOUL
640
641
unsigned long
SDL_strtoul(const char *string, char **endp, int base)
642
643
644
645
{
size_t len;
unsigned long value;
646
647
if (!base) {
if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
648
649
650
651
652
653
654
base = 16;
} else {
base = 10;
}
}
len = SDL_ScanUnsignedLong(string, base, &value);
655
656
if (endp) {
*endp = (char *) string + len;
657
658
659
660
661
}
return value;
}
#endif
662
663
664
#ifdef SDL_HAS_64BIT_TYPE
#ifndef HAVE__I64TOA
665
666
char *
SDL_lltoa(Sint64 value, char *string, int radix)
667
668
669
{
char *bufp = string;
670
if (value < 0) {
671
672
673
*bufp++ = '-';
value = -value;
}
674
675
if (value) {
while (value > 0) {
676
677
678
679
680
681
682
683
684
*bufp++ = ntoa_table[value % radix];
value /= radix;
}
} else {
*bufp++ = '0';
}
*bufp = '\0';
/* The numbers went into the string backwards. :) */
685
686
if (*string == '-') {
SDL_strrev(string + 1);
687
} else {
688
SDL_strrev(string);
689
690
691
692
693
694
695
}
return string;
}
#endif
#ifndef HAVE__UI64TOA
696
697
char *
SDL_ulltoa(Uint64 value, char *string, int radix)
698
699
700
{
char *bufp = string;
701
702
if (value) {
while (value > 0) {
703
704
705
706
707
708
709
710
711
*bufp++ = ntoa_table[value % radix];
value /= radix;
}
} else {
*bufp++ = '0';
}
*bufp = '\0';
/* The numbers went into the string backwards. :) */
712
SDL_strrev(string);
713
714
715
716
717
718
return string;
}
#endif
#ifndef HAVE_STRTOLL
719
720
Sint64
SDL_strtoll(const char *string, char **endp, int base)
721
722
723
724
{
size_t len;
Sint64 value;
725
726
if (!base) {
if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
727
728
729
730
731
732
733
base = 16;
} else {
base = 10;
}
}
len = SDL_ScanLongLong(string, base, &value);
734
735
if (endp) {
*endp = (char *) string + len;
736
737
738
739
740
}
return value;
}
#endif
741
#ifndef HAVE_STRTOULL
742
743
Uint64
SDL_strtoull(const char *string, char **endp, int base)
744
745
746
747
{
size_t len;
Uint64 value;
748
749
if (!base) {
if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
750
751
752
753
754
755
756
base = 16;
} else {
base = 10;
}
}
len = SDL_ScanUnsignedLongLong(string, base, &value);
757
758
if (endp) {
*endp = (char *) string + len;
759
760
761
762
763
}
return value;
}
#endif
764
765
#endif /* SDL_HAS_64BIT_TYPE */
766
#ifndef HAVE_STRTOD
767
768
double
SDL_strtod(const char *string, char **endp)
769
770
771
772
773
{
size_t len;
double value;
len = SDL_ScanFloat(string, &value);
774
775
if (endp) {
*endp = (char *) string + len;
776
777
778
779
780
}
return value;
}
#endif
781
#ifndef HAVE_STRCMP
782
783
int
SDL_strcmp(const char *str1, const char *str2)
784
785
{
while (*str1 && *str2) {
786
if (*str1 != *str2)
787
788
789
790
break;
++str1;
++str2;
}
791
return (int) ((unsigned char) *str1 - (unsigned char) *str2);
792
793
794
795
}
#endif
#ifndef HAVE_STRNCMP
796
797
int
SDL_strncmp(const char *str1, const char *str2, size_t maxlen)
798
{
799
800
while (*str1 && *str2 && maxlen) {
if (*str1 != *str2)
801
802
803
804
805
break;
++str1;
++str2;
--maxlen;
}
806
if (!maxlen) {
807
808
return 0;
}
809
return (int) ((unsigned char) *str1 - (unsigned char) *str2);
810
811
812
}
#endif
813
#if !defined(HAVE_STRCASECMP) && !defined(HAVE__STRICMP)
814
815
int
SDL_strcasecmp(const char *str1, const char *str2)
816
817
818
{
char a = 0;
char b = 0;
819
while (*str1 && *str2) {
820
821
a = SDL_tolower((unsigned char) *str1);
b = SDL_tolower((unsigned char) *str2);
822
if (a != b)
823
824
825
826
break;
++str1;
++str2;
}
827
828
a = SDL_tolower(*str1);
b = SDL_tolower(*str2);
829
return (int) ((unsigned char) a - (unsigned char) b);
830
831
832
}
#endif
833
#if !defined(HAVE_STRNCASECMP) && !defined(HAVE__STRNICMP)
834
835
int
SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen)
836
837
838
{
char a = 0;
char b = 0;
839
while (*str1 && *str2 && maxlen) {
840
841
a = SDL_tolower((unsigned char) *str1);
b = SDL_tolower((unsigned char) *str2);
842
if (a != b)
843
844
845
846
847
break;
++str1;
++str2;
--maxlen;
}
848
849
a = SDL_tolower(*str1);
b = SDL_tolower(*str2);
850
return (int) ((unsigned char) a - (unsigned char) b);
851
852
853
}
#endif
854
#ifndef HAVE_SSCANF
855
856
int
SDL_sscanf(const char *text, const char *fmt, ...)
857
858
859
860
861
{
va_list ap;
int retval = 0;
va_start(ap, fmt);
862
863
while (*fmt) {
if (*fmt == ' ') {
864
while (SDL_isspace((unsigned char) *text)) {
865
866
867
868
869
++text;
}
++fmt;
continue;
}
870
if (*fmt == '%') {
871
872
873
SDL_bool done = SDL_FALSE;
long count = 0;
int radix = 10;
874
875
enum
{
876
877
878
879
880
881
882
883
DO_SHORT,
DO_INT,
DO_LONG,
DO_LONGLONG
} inttype = DO_INT;
SDL_bool suppress = SDL_FALSE;
++fmt;
884
885
if (*fmt == '%') {
if (*text == '%') {
886
887
888
889
890
891
++text;
++fmt;
continue;
}
break;
}
892
if (*fmt == '*') {
893
894
895
896
897
suppress = SDL_TRUE;
++fmt;
}
fmt += SDL_ScanLong(fmt, 10, &count);
898
899
if (*fmt == 'c') {
if (!count) {
900
901
count = 1;
}
902
903
if (suppress) {
while (count--) {
904
905
906
++text;
}
} else {
907
908
char *valuep = va_arg(ap, char *);
while (count--) {
909
910
911
912
913
914
915
*valuep++ = *text++;
}
++retval;
}
continue;
}
916
while (SDL_isspace((unsigned char) *text)) {
917
918
919
920
921
++text;
}
/* FIXME: implement more of the format specifiers */
while (!done) {
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
switch (*fmt) {
case '*':
suppress = SDL_TRUE;
break;
case 'h':
if (inttype > DO_SHORT) {
++inttype;
}
break;
case 'l':
if (inttype < DO_LONGLONG) {
++inttype;
}
break;
case 'I':
if (SDL_strncmp(fmt, "I64", 3) == 0) {
fmt += 2;
inttype = DO_LONGLONG;
}
break;
case 'i':
{
int index = 0;
if (text[index] == '-') {
++index;
947
}
948
if (text[index] == '0') {
949
950
if (SDL_tolower((unsigned char) text[index + 1])
== 'x') {
951
952
953
radix = 16;
} else {
radix = 8;
954
955
}
}
956
957
958
}
/* Fall through to %d handling */
case 'd':
959
#ifdef SDL_HAS_64BIT_TYPE
960
961
962
963
964
965
966
if (inttype == DO_LONGLONG) {
Sint64 value;
text += SDL_ScanLongLong(text, radix, &value);
if (!suppress) {
Sint64 *valuep = va_arg(ap, Sint64 *);
*valuep = value;
++retval;
967
}
968
} else
969
#endif /* SDL_HAS_64BIT_TYPE */
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
{
long value;
text += SDL_ScanLong(text, radix, &value);
if (!suppress) {
switch (inttype) {
case DO_SHORT:
{
short *valuep = va_arg(ap, short *);
*valuep = (short) value;
}
break;
case DO_INT:
{
int *valuep = va_arg(ap, int *);
*valuep = (int) value;
985
}
986
987
988
989
990
991
992
993
994
995
break;
case DO_LONG:
{
long *valuep = va_arg(ap, long *);
*valuep = value;
}
break;
case DO_LONGLONG:
/* Handled above */
break;
996
}
997
++retval;
998
}
999
1000
}
done = SDL_TRUE;