2 * general implementation of scanf used by scanf, sscanf, fscanf,
3 * _cscanf, wscanf, swscanf and fwscanf
5 * Copyright 1996,1998 Marcus Meissner
6 * Copyright 1996 Jukka Iivonen
7 * Copyright 1997,2000, 2003 Uwe Bonnes
8 * Copyright 2000 Jon Griffiths
9 * Copyright 2002 Daniel Gudbjartsson
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #define _CHAR_ MSVCRT_wchar_t
28 #define _EOF_ MSVCRT_WEOF
29 #define _EOF_RET MSVCRT_WEOF
30 #define _ISSPACE_(c) MSVCRT_iswspace(c)
31 #define _ISDIGIT_(c) MSVCRT_iswdigit(c)
32 #define _WIDE2SUPPORTED_(c) c /* No conversion needed (wide to wide) */
33 #define _CHAR2SUPPORTED_(c) c /* FIXME: convert char to wide char */
34 #define _CHAR2DIGIT_(c, base) wchar2digit((c), (base))
35 #define _BITMAPSIZE_ 256*256
36 #else /* WIDE_SCANF */
38 #define _EOF_ MSVCRT_EOF
39 #define _EOF_RET MSVCRT_EOF
40 #define _ISSPACE_(c) isspace(c)
41 #define _ISDIGIT_(c) isdigit(c)
42 #define _WIDE2SUPPORTED_(c) c /* FIXME: convert wide char to char */
43 #define _CHAR2SUPPORTED_(c) c /* No conversion needed (char to char) */
44 #define _CHAR2DIGIT_(c, base) char2digit((c), (base))
45 #define _BITMAPSIZE_ 256
46 #endif /* WIDE_SCANF */
49 #define _GETC_(file) (consumed++, _getch())
50 #define _UNGETC_(nch, file) do { _ungetch(nch); consumed--; } while(0)
51 #define _LOCK_FILE_(file) MSVCRT__lock_file(MSVCRT_stdin)
52 #define _UNLOCK_FILE_(file) MSVCRT__unlock_file(MSVCRT_stdin)
55 #define _FUNCTION_ static int MSVCRT_vcwscanf_s_l(const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
57 #define _FUNCTION_ static int MSVCRT_vcwscanf_l(const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
59 #else /* WIDE_SCANF */
61 #define _FUNCTION_ static int MSVCRT_vcscanf_s_l(const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
63 #define _FUNCTION_ static int MSVCRT_vcscanf_l(const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
65 #endif /* WIDE_SCANF */
71 #define _GETC_(file) (consumed==length ? '\0' : (consumed++, *file++))
72 #define _UNGETC_(nch, file) do { file--; consumed--; } while(0)
73 #define _LOCK_FILE_(file) do {} while(0)
74 #define _UNLOCK_FILE_(file) do {} while(0)
77 #define _FUNCTION_ static int MSVCRT_vsnwscanf_s_l(const MSVCRT_wchar_t *file, MSVCRT_size_t length, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list ap)
79 #define _FUNCTION_ static int MSVCRT_vsnwscanf_l(const MSVCRT_wchar_t *file, MSVCRT_size_t length, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list ap)
81 #else /* WIDE_SCANF */
83 #define _FUNCTION_ static int MSVCRT_vsnscanf_s_l(const char *file, MSVCRT_size_t length, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
85 #define _FUNCTION_ static int MSVCRT_vsnscanf_l(const char *file, MSVCRT_size_t length, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
87 #endif /* WIDE_SCANF */
88 #else /* STRING_LEN */
89 #define _GETC_(file) (consumed++, *file++)
90 #define _UNGETC_(nch, file) do { file--; consumed--; } while(0)
91 #define _LOCK_FILE_(file) do {} while(0)
92 #define _UNLOCK_FILE_(file) do {} while(0)
95 #define _FUNCTION_ static int MSVCRT_vswscanf_s_l(const MSVCRT_wchar_t *file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list ap)
97 #define _FUNCTION_ static int MSVCRT_vswscanf_l(const MSVCRT_wchar_t *file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list ap)
99 #else /* WIDE_SCANF */
101 #define _FUNCTION_ static int MSVCRT_vsscanf_s_l(const char *file, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
103 #define _FUNCTION_ static int MSVCRT_vsscanf_l(const char *file, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
105 #endif /* WIDE_SCANF */
106 #endif /* STRING_LEN */
109 #define _GETC_(file) (consumed++, MSVCRT_fgetwc(file))
110 #define _UNGETC_(nch, file) do { MSVCRT_ungetwc(nch, file); consumed--; } while(0)
111 #define _LOCK_FILE_(file) MSVCRT__lock_file(file)
112 #define _UNLOCK_FILE_(file) MSVCRT__unlock_file(file)
114 #define _FUNCTION_ static int MSVCRT_vfwscanf_s_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list ap)
116 #define _FUNCTION_ static int MSVCRT_vfwscanf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list ap)
118 #else /* WIDE_SCANF */
119 #define _GETC_(file) (consumed++, MSVCRT_fgetc(file))
120 #define _UNGETC_(nch, file) do { MSVCRT_ungetc(nch, file); consumed--; } while(0)
121 #define _LOCK_FILE_(file) MSVCRT__lock_file(file)
122 #define _UNLOCK_FILE_(file) MSVCRT__unlock_file(file)
124 #define _FUNCTION_ static int MSVCRT_vfscanf_s_l(MSVCRT_FILE* file, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
126 #define _FUNCTION_ static int MSVCRT_vfscanf_l(MSVCRT_FILE* file, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
128 #endif /* WIDE_SCANF */
133 int rd
= 0, consumed
= 0;
135 if (!*format
) return 0;
138 TRACE("(%s):\n", debugstr_a(format
));
141 TRACE("%s (%s)\n", debugstr_a(file
), debugstr_a(format
));
143 TRACE("%p (%s)\n", file
, debugstr_a(format
));
146 #endif /* WIDE_SCANF */
156 locale
= get_locale();
159 /* a whitespace character in the format string causes scanf to read,
160 * but not store, all consecutive white-space characters in the input
161 * up to the next non-white-space character. One white space character
162 * in the input matches any number (including zero) and combination of
163 * white-space characters in the input. */
164 if (_ISSPACE_(*format
)) {
165 /* skip whitespace */
166 while ((nch
!=_EOF_
) && _ISSPACE_(nch
))
169 /* a format specification causes scanf to read and convert characters
170 * in the input into values of a specified type. The value is assigned
171 * to an argument in the argument list. Format specifications have
172 * the form %[*][width][{h | l | I64 | L}]type */
173 else if (*format
== '%') {
174 int st
= 0; int suppress
= 0; int width
= 0;
180 int prefix_finished
= 0;
183 /* look for leading asterisk, which means 'suppress assignment of
189 /* look for width specification */
190 while (_ISDIGIT_(*format
)) {
192 width
+=*format
++ - '0';
194 if (width
==0) width
=-1; /* no width spec seen */
195 /* read prefix (if any) */
196 while (!prefix_finished
) {
198 case 'h': h_prefix
= 1; break;
199 case 'l': l_prefix
= 1; break;
200 case 'w': w_prefix
= 1; break;
201 case 'L': L_prefix
= 1; break;
203 if (*(format
+ 1) == '6' &&
204 *(format
+ 2) == '4') {
212 if (!prefix_finished
) format
++;
217 case 'P': /* pointer. */
218 if (sizeof(void *) == sizeof(LONGLONG
)) I64_prefix
= 1;
221 case 'X': /* hexadecimal integer. */
224 case 'o': /* octal integer */
227 case 'u': /* unsigned decimal integer */
230 case 'd': /* signed decimal integer */
233 case 'i': /* generic integer */
236 /* read an integer */
240 /* skip initial whitespace */
241 while ((nch
!=_EOF_
) && _ISSPACE_(nch
))
244 if (nch
== '-' || nch
== '+') {
245 negative
= (nch
=='-');
247 if (width
>0) width
--;
249 /* look for leading indication of base */
250 if (width
!=0 && nch
== '0' && *format
!= 'p' && *format
!= 'P') {
252 if (width
>0) width
--;
254 if (width
!=0 && (nch
=='x' || nch
=='X')) {
259 if (width
>0) width
--;
265 /* format %i without indication of base */
268 /* throw away leading zeros */
269 while (width
!=0 && nch
=='0') {
271 if (width
>0) width
--;
274 if (width
!=0 && _CHAR2DIGIT_(nch
, base
)!=-1) {
275 cur
= _CHAR2DIGIT_(nch
, base
);
277 if (width
>0) width
--;
280 /* read until no more digits */
281 while (width
!=0 && (nch
!=_EOF_
) && _CHAR2DIGIT_(nch
, base
)!=-1) {
282 cur
= cur
*base
+ _CHAR2DIGIT_(nch
, base
);
284 if (width
>0) width
--;
288 if (!seendigit
) break; /* not a valid number */
291 #define _SET_NUMBER_(type) *va_arg(ap, type*) = negative ? -cur : cur
292 if (I64_prefix
) _SET_NUMBER_(LONGLONG
);
293 else if (l_prefix
) _SET_NUMBER_(LONG
);
294 else if (h_prefix
) _SET_NUMBER_(short int);
295 else _SET_NUMBER_(int);
303 case 'G': { /* read a float */
306 /* skip initial whitespace */
307 while ((nch
!=_EOF_
) && _ISSPACE_(nch
))
310 if (nch
== '-' || nch
== '+') {
311 negative
= (nch
=='-');
312 if (width
>0) width
--;
316 /* get first digit. */
317 if (*locale
->locinfo
->lconv
->decimal_point
!= nch
) {
318 if (!_ISDIGIT_(nch
)) break;
321 if (width
>0) width
--;
322 /* read until no more digits */
323 while (width
!=0 && (nch
!=_EOF_
) && _ISDIGIT_(nch
)) {
324 cur
= cur
*10 + (nch
- '0');
326 if (width
>0) width
--;
329 cur
= 0; /* Fix: .8 -> 0.8 */
331 /* handle decimals */
332 if (width
!=0 && nch
== *locale
->locinfo
->lconv
->decimal_point
) {
335 if (width
>0) width
--;
336 while (width
!=0 && (nch
!=_EOF_
) && _ISDIGIT_(nch
)) {
338 cur
+= dec
* (nch
- '0');
340 if (width
>0) width
--;
343 /* handle exponent */
344 if (width
!=0 && (nch
== 'e' || nch
== 'E')) {
345 int exponent
= 0, negexp
= 0;
348 if (width
>0) width
--;
349 /* possible sign on the exponent */
350 if (width
!=0 && (nch
=='+' || nch
=='-')) {
353 if (width
>0) width
--;
355 /* exponent digits */
356 while (width
!=0 && (nch
!=_EOF_
) && _ISDIGIT_(nch
)) {
358 exponent
+= (nch
- '0');
360 if (width
>0) width
--;
362 /* update 'cur' with this exponent. */
363 expcnt
= negexp
? .1 : 10;
364 while (exponent
!=0) {
368 expcnt
=expcnt
*expcnt
;
373 if (L_prefix
) _SET_NUMBER_(long double);
374 else if (l_prefix
) _SET_NUMBER_(double);
375 else _SET_NUMBER_(float);
379 /* According to msdn,
380 * 's' reads a character string in a call to fscanf
381 * and 'S' a wide character string and vice versa in a
382 * call to fwscanf. The 'h', 'w' and 'l' prefixes override
383 * this behaviour. 'h' forces reading char * but 'l' and 'w'
384 * force reading WCHAR. */
386 if (w_prefix
|| l_prefix
) goto widecharstring
;
387 else if (h_prefix
) goto charstring
;
389 else goto widecharstring
;
390 #else /* WIDE_SCANF */
391 else goto charstring
;
392 #endif /* WIDE_SCANF */
394 if (w_prefix
|| l_prefix
) goto widecharstring
;
395 else if (h_prefix
) goto charstring
;
397 else goto charstring
;
398 #else /* WIDE_SCANF */
399 else goto widecharstring
;
400 #endif /* WIDE_SCANF */
401 charstring
: { /* read a word into a char */
402 char *sptr
= suppress
? NULL
: va_arg(ap
, char*);
403 char *sptr_beg
= sptr
;
405 unsigned size
= suppress
? UINT_MAX
: va_arg(ap
, unsigned);
407 unsigned size
= UINT_MAX
;
409 /* skip initial whitespace */
410 while ((nch
!=_EOF_
) && _ISSPACE_(nch
))
412 /* read until whitespace */
413 while (width
!=0 && (nch
!=_EOF_
) && !_ISSPACE_(nch
)) {
415 *sptr
++ = _CHAR2SUPPORTED_(nch
);
425 if (width
>0) width
--;
428 if (!suppress
) *sptr
= 0;
431 widecharstring
: { /* read a word into a wchar_t* */
432 MSVCRT_wchar_t
*sptr
= suppress
? NULL
: va_arg(ap
, MSVCRT_wchar_t
*);
433 MSVCRT_wchar_t
*sptr_beg
= sptr
;
435 unsigned size
= suppress
? UINT_MAX
: va_arg(ap
, unsigned);
437 unsigned size
= UINT_MAX
;
439 /* skip initial whitespace */
440 while ((nch
!=_EOF_
) && _ISSPACE_(nch
))
442 /* read until whitespace */
443 while (width
!=0 && (nch
!=_EOF_
) && !_ISSPACE_(nch
)) {
445 *sptr
++ = _WIDE2SUPPORTED_(nch
);
455 if (width
>0) width
--;
458 if (!suppress
) *sptr
= 0;
461 /* 'c' and 'C work analogously to 's' and 'S' as described
464 if (w_prefix
|| l_prefix
) goto widecharacter
;
465 else if (h_prefix
) goto character
;
467 else goto widecharacter
;
468 #else /* WIDE_SCANF */
470 #endif /* WIDE_SCANF */
472 if (w_prefix
|| l_prefix
) goto widecharacter
;
473 else if (h_prefix
) goto character
;
476 #else /* WIDE_SCANF */
477 else goto widecharacter
;
478 #endif /* WIDE_SCANF */
479 character
: { /* read single character into char */
480 char *str
= suppress
? NULL
: va_arg(ap
, char*);
483 unsigned size
= suppress
? UINT_MAX
: va_arg(ap
, unsigned)/sizeof(char);
485 unsigned size
= UINT_MAX
;
487 if (width
== -1) width
= 1;
488 while (width
&& (nch
!= _EOF_
))
491 *str
++ = _CHAR2SUPPORTED_(nch
);
505 widecharacter
: { /* read single character into a wchar_t */
506 MSVCRT_wchar_t
*str
= suppress
? NULL
: va_arg(ap
, MSVCRT_wchar_t
*);
507 MSVCRT_wchar_t
*pstr
= str
;
509 unsigned size
= suppress
? UINT_MAX
: va_arg(ap
, unsigned)/sizeof(MSVCRT_wchar_t
);
511 unsigned size
= UINT_MAX
;
513 if (width
== -1) width
= 1;
514 while (width
&& (nch
!= _EOF_
))
517 *str
++ = _WIDE2SUPPORTED_(nch
);
533 int*n
= va_arg(ap
, int*);
536 /* This is an odd one: according to the standard,
537 * "Execution of a %n directive does not increment the
538 * assignment count returned at the completion of
539 * execution" even if it wasn't suppressed with the
540 * '*' flag. The Corrigendum to the standard seems
541 * to contradict this (comment out the assignment to
542 * suppress below if you want to implement these
543 * alternate semantics) but the windows program I'm
544 * looking at expects the behavior I've coded here
545 * (which happens to be what glibc does as well).
552 _CHAR_
*str
= suppress
? NULL
: va_arg(ap
, _CHAR_
*);
556 int invert
= 0; /* Set if we are NOT to find the chars */
558 unsigned size
= suppress
? UINT_MAX
: va_arg(ap
, unsigned)/sizeof(_CHAR_
);
560 unsigned size
= UINT_MAX
;
563 /* Init our bitmap */
564 Mask
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, _BITMAPSIZE_
/8);
565 RtlInitializeBitMap(&bitMask
, Mask
, _BITMAPSIZE_
);
567 /* Read the format */
574 RtlSetBits(&bitMask
, ']', 1);
577 while(*format
&& (*format
!= ']')) {
578 /* According to msdn:
579 * "Note that %[a-z] and %[z-a] are interpreted as equivalent to %[abcde...z]." */
580 if((*format
== '-') && (*(format
+ 1) != ']')) {
581 if ((*(format
- 1)) < *(format
+ 1))
582 RtlSetBits(&bitMask
, *(format
- 1) +1 , *(format
+ 1) - *(format
- 1));
584 RtlSetBits(&bitMask
, *(format
+ 1) , *(format
- 1) - *(format
+ 1));
587 RtlSetBits(&bitMask
, *format
, 1);
590 /* read until char is not suitable */
591 while ((width
!= 0) && (nch
!= _EOF_
)) {
593 if(RtlAreBitsSet(&bitMask
, nch
, 1)) {
594 if (!suppress
) *sptr
++ = _CHAR2SUPPORTED_(nch
);
598 if(RtlAreBitsClear(&bitMask
, nch
, 1)) {
599 if (!suppress
) *sptr
++ = _CHAR2SUPPORTED_(nch
);
605 if (width
>0) width
--;
614 if (!suppress
) *sptr
= 0;
615 HeapFree(GetProcessHeap(), 0, Mask
);
619 /* From spec: "if a percent sign is followed by a character
620 * that has no meaning as a format-control character, that
621 * character and the following characters are treated as
622 * an ordinary sequence of characters, that is, a sequence
623 * of characters that must match the input. For example,
624 * to specify that a percent-sign character is to be input,
626 while ((nch
!=_EOF_
) && _ISSPACE_(nch
))
629 suppress
= 1; /* whoops no field to be read */
630 st
= 1; /* but we got what we expected */
635 if (st
&& !suppress
) rd
++;
638 /* a non-white-space character causes scanf to read, but not store,
639 * a matching non-white-space character. */
641 /* check for character match */
642 if (nch
== *format
) {
652 TRACE("returning %d\n", rd
);
662 #undef _CHAR2SUPPORTED_
663 #undef _WIDE2SUPPORTED_