msvcrt: Added support for unicode mode in write function.
[wine/multimedia.git] / dlls / msvcrt / scanf.h
blob7f618f4f2403e8b3bedf0a2a77e88e81fa4eea21
1 /*
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
26 #ifdef WIDE_SCANF
27 #define _CHAR_ MSVCRT_wchar_t
28 #define _EOF_ MSVCRT_WEOF
29 #define _EOF_RET (short)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 */
37 #define _CHAR_ char
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 */
48 #ifdef CONSOLE
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)
53 #ifdef WIDE_SCANF
54 #ifdef SECURE
55 #define _FUNCTION_ static int MSVCRT_vcwscanf_s_l(const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
56 #else /* SECURE */
57 #define _FUNCTION_ static int MSVCRT_vcwscanf_l(const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
58 #endif /* SECURE */
59 #else /* WIDE_SCANF */
60 #ifdef SECURE
61 #define _FUNCTION_ static int MSVCRT_vcscanf_s_l(const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
62 #else /* SECURE */
63 #define _FUNCTION_ static int MSVCRT_vcscanf_l(const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
64 #endif /* SECURE */
65 #endif /* WIDE_SCANF */
66 #else
67 #ifdef STRING
68 #undef _EOF_
69 #define _EOF_ 0
70 #ifdef STRING_LEN
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)
75 #ifdef WIDE_SCANF
76 #ifdef SECURE
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)
78 #else /* SECURE */
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)
80 #endif /* SECURE */
81 #else /* WIDE_SCANF */
82 #ifdef SECURE
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)
84 #else /* SECURE */
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)
86 #endif /* SECURE */
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)
93 #ifdef WIDE_SCANF
94 #ifdef SECURE
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)
96 #else /* SECURE */
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)
98 #endif /* SECURE */
99 #else /* WIDE_SCANF */
100 #ifdef SECURE
101 #define _FUNCTION_ static int MSVCRT_vsscanf_s_l(const char *file, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
102 #else /* SECURE */
103 #define _FUNCTION_ static int MSVCRT_vsscanf_l(const char *file, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
104 #endif /* SECURE */
105 #endif /* WIDE_SCANF */
106 #endif /* STRING_LEN */
107 #else /* STRING */
108 #ifdef WIDE_SCANF
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)
113 #ifdef SECURE
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)
115 #else /* SECURE */
116 #define _FUNCTION_ static int MSVCRT_vfwscanf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list ap)
117 #endif /* SECURE */
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)
123 #ifdef SECURE
124 #define _FUNCTION_ static int MSVCRT_vfscanf_s_l(MSVCRT_FILE* file, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
125 #else /* SECURE */
126 #define _FUNCTION_ static int MSVCRT_vfscanf_l(MSVCRT_FILE* file, const char *format, MSVCRT__locale_t locale, __ms_va_list ap)
127 #endif /* SECURE */
128 #endif /* WIDE_SCANF */
129 #endif /* STRING */
130 #endif /* CONSOLE */
132 _FUNCTION_ {
133 MSVCRT_pthreadlocinfo locinfo;
134 int rd = 0, consumed = 0;
135 int nch;
136 if (!*format) return 0;
137 #ifndef WIDE_SCANF
138 #ifdef CONSOLE
139 TRACE("(%s):\n", debugstr_a(format));
140 #else /* CONSOLE */
141 #ifdef STRING
142 TRACE("%s (%s)\n", debugstr_a(file), debugstr_a(format));
143 #else /* STRING */
144 TRACE("%p (%s)\n", file, debugstr_a(format));
145 #endif /* STRING */
146 #endif /* CONSOLE */
147 #endif /* WIDE_SCANF */
148 _LOCK_FILE_(file);
150 nch = _GETC_(file);
151 if (nch == _EOF_) {
152 _UNLOCK_FILE_(file);
153 return _EOF_RET;
156 if(!locale)
157 locinfo = get_locinfo();
158 else
159 locinfo = locale->locinfo;
161 while (*format) {
162 /* a whitespace character in the format string causes scanf to read,
163 * but not store, all consecutive white-space characters in the input
164 * up to the next non-white-space character. One white space character
165 * in the input matches any number (including zero) and combination of
166 * white-space characters in the input. */
167 if (_ISSPACE_(*format)) {
168 /* skip whitespace */
169 while ((nch!=_EOF_) && _ISSPACE_(nch))
170 nch = _GETC_(file);
172 /* a format specification causes scanf to read and convert characters
173 * in the input into values of a specified type. The value is assigned
174 * to an argument in the argument list. Format specifications have
175 * the form %[*][width][{h | l | I64 | L}]type */
176 else if (*format == '%') {
177 int st = 0; int suppress = 0; int width = 0;
178 int base;
179 int h_prefix = 0;
180 int l_prefix = 0;
181 int L_prefix = 0;
182 int w_prefix = 0;
183 int prefix_finished = 0;
184 int I64_prefix = 0;
185 format++;
186 /* look for leading asterisk, which means 'suppress assignment of
187 * this field'. */
188 if (*format=='*') {
189 format++;
190 suppress=1;
192 /* look for width specification */
193 while (_ISDIGIT_(*format)) {
194 width*=10;
195 width+=*format++ - '0';
197 if (width==0) width=-1; /* no width spec seen */
198 /* read prefix (if any) */
199 while (!prefix_finished) {
200 switch(*format) {
201 case 'h': h_prefix++; break;
202 case 'l':
203 if(*(format+1) == 'l') {
204 I64_prefix = 1;
205 format++;
207 l_prefix = 1;
208 break;
209 case 'w': w_prefix = 1; break;
210 case 'L': L_prefix = 1; break;
211 case 'I':
212 if (*(format + 1) == '6' &&
213 *(format + 2) == '4') {
214 I64_prefix = 1;
215 format += 2;
217 break;
218 default:
219 prefix_finished = 1;
221 if (!prefix_finished) format++;
223 /* read type */
224 switch(*format) {
225 case 'p':
226 case 'P': /* pointer. */
227 if (sizeof(void *) == sizeof(LONGLONG)) I64_prefix = 1;
228 /* fall through */
229 case 'x':
230 case 'X': /* hexadecimal integer. */
231 base = 16;
232 goto number;
233 case 'o': /* octal integer */
234 base = 8;
235 goto number;
236 case 'u': /* unsigned decimal integer */
237 base = 10;
238 goto number;
239 case 'd': /* signed decimal integer */
240 base = 10;
241 goto number;
242 case 'i': /* generic integer */
243 base = 0;
244 number: {
245 /* read an integer */
246 ULONGLONG cur = 0;
247 int negative = 0;
248 int seendigit=0;
249 /* skip initial whitespace */
250 while ((nch!=_EOF_) && _ISSPACE_(nch))
251 nch = _GETC_(file);
252 /* get sign */
253 if (nch == '-' || nch == '+') {
254 negative = (nch=='-');
255 nch = _GETC_(file);
256 if (width>0) width--;
258 /* look for leading indication of base */
259 if (width!=0 && nch == '0' && *format != 'p' && *format != 'P') {
260 nch = _GETC_(file);
261 if (width>0) width--;
262 seendigit=1;
263 if (width!=0 && (nch=='x' || nch=='X')) {
264 if (base==0)
265 base=16;
266 if (base==16) {
267 nch = _GETC_(file);
268 if (width>0) width--;
269 seendigit=0;
271 } else if (base==0)
272 base = 8;
274 /* format %i without indication of base */
275 if (base==0)
276 base = 10;
277 /* throw away leading zeros */
278 while (width!=0 && nch=='0') {
279 nch = _GETC_(file);
280 if (width>0) width--;
281 seendigit=1;
283 if (width!=0 && _CHAR2DIGIT_(nch, base)!=-1) {
284 cur = _CHAR2DIGIT_(nch, base);
285 nch = _GETC_(file);
286 if (width>0) width--;
287 seendigit=1;
289 /* read until no more digits */
290 while (width!=0 && (nch!=_EOF_) && _CHAR2DIGIT_(nch, base)!=-1) {
291 cur = cur*base + _CHAR2DIGIT_(nch, base);
292 nch = _GETC_(file);
293 if (width>0) width--;
294 seendigit=1;
296 /* okay, done! */
297 if (!seendigit) break; /* not a valid number */
298 st = 1;
299 if (!suppress) {
300 #define _SET_NUMBER_(type) *va_arg(ap, type*) = negative ? -cur : cur
301 if (I64_prefix) _SET_NUMBER_(LONGLONG);
302 else if (l_prefix) _SET_NUMBER_(LONG);
303 else if (h_prefix == 1) _SET_NUMBER_(short int);
304 else _SET_NUMBER_(int);
307 break;
308 case 'e':
309 case 'E':
310 case 'f':
311 case 'g':
312 case 'G': { /* read a float */
313 long double cur = 1, expcnt = 10;
314 ULONGLONG d, hlp;
315 int exp = 0, negative = 0;
316 unsigned fpcontrol;
317 BOOL negexp;
319 /* skip initial whitespace */
320 while ((nch!=_EOF_) && _ISSPACE_(nch))
321 nch = _GETC_(file);
323 /* get sign. */
324 if (nch == '-' || nch == '+') {
325 negative = (nch=='-');
326 if (width>0) width--;
327 if (width==0) break;
328 nch = _GETC_(file);
331 /* get first digit. */
332 if (*locinfo->lconv->decimal_point != nch) {
333 if (!_ISDIGIT_(nch)) break;
334 d = nch - '0';
335 nch = _GETC_(file);
336 if (width>0) width--;
337 /* read until no more digits */
338 while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
339 hlp = d*10 + nch - '0';
340 nch = _GETC_(file);
341 if (width>0) width--;
342 if(d > (ULONGLONG)-1/10 || hlp<d) {
343 exp++;
344 break;
346 else
347 d = hlp;
349 while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
350 exp++;
351 nch = _GETC_(file);
352 if (width>0) width--;
354 } else {
355 d = 0; /* Fix: .8 -> 0.8 */
358 /* handle decimals */
359 if (width!=0 && nch == *locinfo->lconv->decimal_point) {
360 nch = _GETC_(file);
361 if (width>0) width--;
363 while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
364 hlp = d*10 + nch - '0';
365 nch = _GETC_(file);
366 if (width>0) width--;
367 if(d > (ULONGLONG)-1/10 || hlp<d)
368 break;
370 d = hlp;
371 exp--;
373 while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
374 nch = _GETC_(file);
375 if (width>0) width--;
379 /* handle exponent */
380 if (width!=0 && (nch == 'e' || nch == 'E')) {
381 int sign = 1, e = 0;
383 nch = _GETC_(file);
384 if (width>0) width--;
385 if (width!=0 && (nch=='+' || nch=='-')) {
386 if(nch == '-')
387 sign = -1;
388 nch = _GETC_(file);
389 if (width>0) width--;
392 /* exponent digits */
393 while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
394 if(e > INT_MAX/10 || (e = e*10 + nch - '0')<0)
395 e = INT_MAX;
396 nch = _GETC_(file);
397 if (width>0) width--;
399 e *= sign;
401 if(exp<0 && e<0 && e+exp>0) exp = INT_MIN;
402 else if(exp>0 && e>0 && e+exp<0) exp = INT_MAX;
403 else exp += e;
406 fpcontrol = _control87(0, 0);
407 _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE
408 |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);
410 negexp = (exp < 0);
411 if(negexp)
412 exp = -exp;
413 /* update 'cur' with this exponent. */
414 while(exp) {
415 if(exp & 1)
416 cur *= expcnt;
417 exp /= 2;
418 expcnt = expcnt*expcnt;
420 cur = (negexp ? d/cur : d*cur);
422 _control87(fpcontrol, 0xffffffff);
424 st = 1;
425 if (!suppress) {
426 if (L_prefix) _SET_NUMBER_(double);
427 else if (l_prefix) _SET_NUMBER_(double);
428 else _SET_NUMBER_(float);
431 break;
432 /* According to msdn,
433 * 's' reads a character string in a call to fscanf
434 * and 'S' a wide character string and vice versa in a
435 * call to fwscanf. The 'h', 'w' and 'l' prefixes override
436 * this behaviour. 'h' forces reading char * but 'l' and 'w'
437 * force reading WCHAR. */
438 case 's':
439 if (w_prefix || l_prefix) goto widecharstring;
440 else if (h_prefix) goto charstring;
441 #ifdef WIDE_SCANF
442 else goto widecharstring;
443 #else /* WIDE_SCANF */
444 else goto charstring;
445 #endif /* WIDE_SCANF */
446 case 'S':
447 if (w_prefix || l_prefix) goto widecharstring;
448 else if (h_prefix) goto charstring;
449 #ifdef WIDE_SCANF
450 else goto charstring;
451 #else /* WIDE_SCANF */
452 else goto widecharstring;
453 #endif /* WIDE_SCANF */
454 charstring: { /* read a word into a char */
455 char *sptr = suppress ? NULL : va_arg(ap, char*);
456 char *sptr_beg = sptr;
457 #ifdef SECURE
458 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned);
459 #else
460 unsigned size = UINT_MAX;
461 #endif
462 /* skip initial whitespace */
463 while ((nch!=_EOF_) && _ISSPACE_(nch))
464 nch = _GETC_(file);
465 /* read until whitespace */
466 while (width!=0 && (nch!=_EOF_) && !_ISSPACE_(nch)) {
467 if (!suppress) {
468 *sptr++ = _CHAR2SUPPORTED_(nch);
469 if(size>1) size--;
470 else {
471 _UNLOCK_FILE_(file);
472 *sptr_beg = 0;
473 return rd;
476 st++;
477 nch = _GETC_(file);
478 if (width>0) width--;
480 /* terminate */
481 if (!suppress) *sptr = 0;
483 break;
484 widecharstring: { /* read a word into a wchar_t* */
485 MSVCRT_wchar_t *sptr = suppress ? NULL : va_arg(ap, MSVCRT_wchar_t*);
486 MSVCRT_wchar_t *sptr_beg = sptr;
487 #ifdef SECURE
488 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned);
489 #else
490 unsigned size = UINT_MAX;
491 #endif
492 /* skip initial whitespace */
493 while ((nch!=_EOF_) && _ISSPACE_(nch))
494 nch = _GETC_(file);
495 /* read until whitespace */
496 while (width!=0 && (nch!=_EOF_) && !_ISSPACE_(nch)) {
497 if (!suppress) {
498 *sptr++ = _WIDE2SUPPORTED_(nch);
499 if(size>1) size--;
500 else {
501 _UNLOCK_FILE_(file);
502 *sptr_beg = 0;
503 return rd;
506 st++;
507 nch = _GETC_(file);
508 if (width>0) width--;
510 /* terminate */
511 if (!suppress) *sptr = 0;
513 break;
514 /* 'c' and 'C work analogously to 's' and 'S' as described
515 * above */
516 case 'c':
517 if (w_prefix || l_prefix) goto widecharacter;
518 else if (h_prefix) goto character;
519 #ifdef WIDE_SCANF
520 else goto widecharacter;
521 #else /* WIDE_SCANF */
522 else goto character;
523 #endif /* WIDE_SCANF */
524 case 'C':
525 if (w_prefix || l_prefix) goto widecharacter;
526 else if (h_prefix) goto character;
527 #ifdef WIDE_SCANF
528 else goto character;
529 #else /* WIDE_SCANF */
530 else goto widecharacter;
531 #endif /* WIDE_SCANF */
532 character: { /* read single character into char */
533 char *str = suppress ? NULL : va_arg(ap, char*);
534 char *pstr = str;
535 #ifdef SECURE
536 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned)/sizeof(char);
537 #else
538 unsigned size = UINT_MAX;
539 #endif
540 if (width == -1) width = 1;
541 while (width && (nch != _EOF_))
543 if (!suppress) {
544 *str++ = _CHAR2SUPPORTED_(nch);
545 if(size) size--;
546 else {
547 _UNLOCK_FILE_(file);
548 *pstr = 0;
549 return rd;
552 st++;
553 width--;
554 nch = _GETC_(file);
557 break;
558 widecharacter: { /* read single character into a wchar_t */
559 MSVCRT_wchar_t *str = suppress ? NULL : va_arg(ap, MSVCRT_wchar_t*);
560 MSVCRT_wchar_t *pstr = str;
561 #ifdef SECURE
562 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned)/sizeof(MSVCRT_wchar_t);
563 #else
564 unsigned size = UINT_MAX;
565 #endif
566 if (width == -1) width = 1;
567 while (width && (nch != _EOF_))
569 if (!suppress) {
570 *str++ = _WIDE2SUPPORTED_(nch);
571 if(size) size--;
572 else {
573 _UNLOCK_FILE_(file);
574 *pstr = 0;
575 return rd;
578 st++;
579 width--;
580 nch = _GETC_(file);
583 break;
584 case 'n': {
585 if (!suppress) {
586 int*n = va_arg(ap, int*);
587 *n = consumed - 1;
589 /* This is an odd one: according to the standard,
590 * "Execution of a %n directive does not increment the
591 * assignment count returned at the completion of
592 * execution" even if it wasn't suppressed with the
593 * '*' flag. The Corrigendum to the standard seems
594 * to contradict this (comment out the assignment to
595 * suppress below if you want to implement these
596 * alternate semantics) but the windows program I'm
597 * looking at expects the behavior I've coded here
598 * (which happens to be what glibc does as well).
600 suppress = 1;
601 st = 1;
603 break;
604 case '[': {
605 _CHAR_ *str = suppress ? NULL : va_arg(ap, _CHAR_*);
606 _CHAR_ *sptr = str;
607 RTL_BITMAP bitMask;
608 ULONG *Mask;
609 int invert = 0; /* Set if we are NOT to find the chars */
610 #ifdef SECURE
611 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned)/sizeof(_CHAR_);
612 #else
613 unsigned size = UINT_MAX;
614 #endif
616 /* Init our bitmap */
617 Mask = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, _BITMAPSIZE_/8);
618 RtlInitializeBitMap(&bitMask, Mask, _BITMAPSIZE_);
620 /* Read the format */
621 format++;
622 if(*format == '^') {
623 invert = 1;
624 format++;
626 if(*format == ']') {
627 RtlSetBits(&bitMask, ']', 1);
628 format++;
630 while(*format && (*format != ']')) {
631 /* According to msdn:
632 * "Note that %[a-z] and %[z-a] are interpreted as equivalent to %[abcde...z]." */
633 if((*format == '-') && (*(format + 1) != ']')) {
634 if ((*(format - 1)) < *(format + 1))
635 RtlSetBits(&bitMask, *(format - 1) +1 , *(format + 1) - *(format - 1));
636 else
637 RtlSetBits(&bitMask, *(format + 1) , *(format - 1) - *(format + 1));
638 format++;
639 } else
640 RtlSetBits(&bitMask, *format, 1);
641 format++;
643 /* read until char is not suitable */
644 while ((width != 0) && (nch != _EOF_)) {
645 if(!invert) {
646 if(RtlAreBitsSet(&bitMask, nch, 1)) {
647 if (!suppress) *sptr++ = _CHAR2SUPPORTED_(nch);
648 } else
649 break;
650 } else {
651 if(RtlAreBitsClear(&bitMask, nch, 1)) {
652 if (!suppress) *sptr++ = _CHAR2SUPPORTED_(nch);
653 } else
654 break;
656 st++;
657 nch = _GETC_(file);
658 if (width>0) width--;
659 if(size>1) size--;
660 else {
661 _UNLOCK_FILE_(file);
662 *str = 0;
663 return rd;
666 /* terminate */
667 if (!suppress) *sptr = 0;
668 HeapFree(GetProcessHeap(), 0, Mask);
670 break;
671 default:
672 /* From spec: "if a percent sign is followed by a character
673 * that has no meaning as a format-control character, that
674 * character and the following characters are treated as
675 * an ordinary sequence of characters, that is, a sequence
676 * of characters that must match the input. For example,
677 * to specify that a percent-sign character is to be input,
678 * use %%." */
679 while ((nch!=_EOF_) && _ISSPACE_(nch))
680 nch = _GETC_(file);
681 if (nch==*format) {
682 suppress = 1; /* whoops no field to be read */
683 st = 1; /* but we got what we expected */
684 nch = _GETC_(file);
686 break;
688 if (st && !suppress) rd++;
689 else if (!st) break;
691 /* a non-white-space character causes scanf to read, but not store,
692 * a matching non-white-space character. */
693 else {
694 /* check for character match */
695 if (nch == *format) {
696 nch = _GETC_(file);
697 } else break;
699 format++;
701 if (nch!=_EOF_) {
702 _UNGETC_(nch, file);
705 TRACE("returning %d\n", rd);
706 _UNLOCK_FILE_(file);
707 return rd;
710 #undef _CHAR_
711 #undef _EOF_
712 #undef _EOF_RET
713 #undef _ISSPACE_
714 #undef _ISDIGIT_
715 #undef _CHAR2SUPPORTED_
716 #undef _WIDE2SUPPORTED_
717 #undef _CHAR2DIGIT_
718 #undef _GETC_
719 #undef _UNGETC_
720 #undef _LOCK_FILE_
721 #undef _UNLOCK_FILE_
722 #undef _FUNCTION_
723 #undef _BITMAPSIZE_