[CRT] Fix MSVC warnings
[reactos.git] / reactos / lib / sdk / crt / string / scanf.h
1 /*
2 * general implementation of scanf used by scanf, sscanf, fscanf,
3 * _cscanf, wscanf, swscanf and fwscanf
4 *
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
10 *
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.
15 *
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.
20 *
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
24 */
25
26 #ifdef WIDE_SCANF
27 #define _CHAR_ wchar_t
28 #define _EOF_ WEOF
29 #define _EOF_RET (short)WEOF
30 #define _ISSPACE_(c) iswspace(c)
31 #define _ISDIGIT_(c) 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_ EOF
39 #define _EOF_RET 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 */
47
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) _lock_file(stdin)
52 #define _UNLOCK_FILE_(file) _unlock_file(stdin)
53 #ifdef WIDE_SCANF
54 #ifdef SECURE
55 #define _FUNCTION_ static int vcwscanf_s_l(const char *format, _locale_t locale, __ms_va_list ap)
56 #else /* SECURE */
57 #define _FUNCTION_ static int vcwscanf_l(const char *format, _locale_t locale, __ms_va_list ap)
58 #endif /* SECURE */
59 #else /* WIDE_SCANF */
60 #ifdef SECURE
61 #define _FUNCTION_ static int vcscanf_s_l(const char *format, _locale_t locale, __ms_va_list ap)
62 #else /* SECURE */
63 #define _FUNCTION_ static int vcscanf_l(const char *format, _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 vsnwscanf_s_l(const wchar_t *file, size_t length, const wchar_t *format, _locale_t locale, __ms_va_list ap)
78 #else /* SECURE */
79 #define _FUNCTION_ static int vsnwscanf_l(const wchar_t *file, size_t length, const wchar_t *format, _locale_t locale, __ms_va_list ap)
80 #endif /* SECURE */
81 #else /* WIDE_SCANF */
82 #ifdef SECURE
83 #define _FUNCTION_ static int vsnscanf_s_l(const char *file, size_t length, const char *format, _locale_t locale, __ms_va_list ap)
84 #else /* SECURE */
85 #define _FUNCTION_ static int vsnscanf_l(const char *file, size_t length, const char *format, _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 vswscanf_s_l(const wchar_t *file, const wchar_t *format, _locale_t locale, __ms_va_list ap)
96 #else /* SECURE */
97 #define _FUNCTION_ static int vswscanf_l(const wchar_t *file, const wchar_t *format, _locale_t locale, __ms_va_list ap)
98 #endif /* SECURE */
99 #else /* WIDE_SCANF */
100 #ifdef SECURE
101 #define _FUNCTION_ static int vsscanf_s_l(const char *file, const char *format, _locale_t locale, __ms_va_list ap)
102 #else /* SECURE */
103 #define _FUNCTION_ static int vsscanf_l(const char *file, const char *format, _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++, fgetwc(file))
110 #define _UNGETC_(nch, file) do { ungetwc(nch, file); consumed--; } while(0)
111 #define _LOCK_FILE_(file) _lock_file(file)
112 #define _UNLOCK_FILE_(file) _unlock_file(file)
113 #ifdef SECURE
114 #define _FUNCTION_ static int vfwscanf_s_l(FILE* file, const wchar_t *format, _locale_t locale, __ms_va_list ap)
115 #else /* SECURE */
116 #define _FUNCTION_ static int vfwscanf_l(FILE* file, const wchar_t *format, _locale_t locale, __ms_va_list ap)
117 #endif /* SECURE */
118 #else /* WIDE_SCANF */
119 #define _GETC_(file) (consumed++, fgetc(file))
120 #define _UNGETC_(nch, file) do { ungetc(nch, file); consumed--; } while(0)
121 #define _LOCK_FILE_(file) _lock_file(file)
122 #define _UNLOCK_FILE_(file) _unlock_file(file)
123 #ifdef SECURE
124 #define _FUNCTION_ static int vfscanf_s_l(FILE* file, const char *format, _locale_t locale, __ms_va_list ap)
125 #else /* SECURE */
126 #define _FUNCTION_ static int vfscanf_l(FILE* file, const char *format, _locale_t locale, __ms_va_list ap)
127 #endif /* SECURE */
128 #endif /* WIDE_SCANF */
129 #endif /* STRING */
130 #endif /* CONSOLE */
131
132 _FUNCTION_ {
133 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);
149
150 nch = _GETC_(file);
151 if (nch == _EOF_) {
152 _UNLOCK_FILE_(file);
153 return _EOF_RET;
154 }
155
156 if(!locale)
157 locinfo = get_locinfo();
158 else
159 locinfo = locale->locinfo;
160
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);
171 }
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;
191 }
192 /* look for width specification */
193 while (_ISDIGIT_(*format)) {
194 width*=10;
195 width+=*format++ - '0';
196 }
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++;
206 }
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;
216 }
217 break;
218 default:
219 prefix_finished = 1;
220 }
221 if (!prefix_finished) format++;
222 }
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--;
257 }
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;
270 }
271 } else if (base==0)
272 base = 8;
273 }
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;
282 }
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;
288 }
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;
295 }
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 ? -(LONGLONG)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);
305 }
306 }
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;
318
319 /* skip initial whitespace */
320 while ((nch!=_EOF_) && _ISSPACE_(nch))
321 nch = _GETC_(file);
322
323 /* get sign. */
324 if (nch == '-' || nch == '+') {
325 negative = (nch=='-');
326 if (width>0) width--;
327 if (width==0) break;
328 nch = _GETC_(file);
329 }
330
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;
345 }
346 else
347 d = hlp;
348 }
349 while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
350 exp++;
351 nch = _GETC_(file);
352 if (width>0) width--;
353 }
354 } else {
355 d = 0; /* Fix: .8 -> 0.8 */
356 }
357
358 /* handle decimals */
359 if (width!=0 && nch == *locinfo->lconv->decimal_point) {
360 nch = _GETC_(file);
361 if (width>0) width--;
362
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;
369
370 d = hlp;
371 exp--;
372 }
373 while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
374 nch = _GETC_(file);
375 if (width>0) width--;
376 }
377 }
378
379 /* handle exponent */
380 if (width!=0 && (nch == 'e' || nch == 'E')) {
381 int sign = 1, e = 0;
382
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--;
390 }
391
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--;
398 }
399 e *= sign;
400
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;
404 }
405
406 #ifdef __REACTOS__
407 /* ReactOS: don't inline float processing (kernel/freeldr don't like that! */
408 _internal_handle_float(negative, exp, suppress, d, l_prefix || L_prefix, &ap);
409 st = 1;
410 #else
411 fpcontrol = _control87(0, 0);
412 _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE
413 |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);
414
415 negexp = (exp < 0);
416 if(negexp)
417 exp = -exp;
418 /* update 'cur' with this exponent. */
419 while(exp) {
420 if(exp & 1)
421 cur *= expcnt;
422 exp /= 2;
423 expcnt = expcnt*expcnt;
424 }
425 cur = (negexp ? d/cur : d*cur);
426
427 _control87(fpcontrol, 0xffffffff);
428
429 st = 1;
430 if (!suppress) {
431 if (L_prefix) _SET_NUMBER_(double);
432 else if (l_prefix) _SET_NUMBER_(double);
433 else _SET_NUMBER_(float);
434 }
435 #endif /* __REACTOS__ */
436 }
437 break;
438 /* According to msdn,
439 * 's' reads a character string in a call to fscanf
440 * and 'S' a wide character string and vice versa in a
441 * call to fwscanf. The 'h', 'w' and 'l' prefixes override
442 * this behaviour. 'h' forces reading char * but 'l' and 'w'
443 * force reading WCHAR. */
444 case 's':
445 if (w_prefix || l_prefix) goto widecharstring;
446 else if (h_prefix) goto charstring;
447 #ifdef WIDE_SCANF
448 else goto widecharstring;
449 #else /* WIDE_SCANF */
450 else goto charstring;
451 #endif /* WIDE_SCANF */
452 case 'S':
453 if (w_prefix || l_prefix) goto widecharstring;
454 else if (h_prefix) goto charstring;
455 #ifdef WIDE_SCANF
456 else goto charstring;
457 #else /* WIDE_SCANF */
458 else goto widecharstring;
459 #endif /* WIDE_SCANF */
460 charstring: { /* read a word into a char */
461 char *sptr = suppress ? NULL : va_arg(ap, char*);
462 char *sptr_beg = sptr;
463 #ifdef SECURE
464 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned);
465 #else
466 unsigned size = UINT_MAX;
467 #endif
468 /* skip initial whitespace */
469 while ((nch!=_EOF_) && _ISSPACE_(nch))
470 nch = _GETC_(file);
471 /* read until whitespace */
472 while (width!=0 && (nch!=_EOF_) && !_ISSPACE_(nch)) {
473 if (!suppress) {
474 *sptr++ = _CHAR2SUPPORTED_(nch);
475 if(size>1) size--;
476 else {
477 _UNLOCK_FILE_(file);
478 *sptr_beg = 0;
479 return rd;
480 }
481 }
482 st++;
483 nch = _GETC_(file);
484 if (width>0) width--;
485 }
486 /* terminate */
487 if (st && !suppress) *sptr = 0;
488 }
489 break;
490 widecharstring: { /* read a word into a wchar_t* */
491 wchar_t *sptr = suppress ? NULL : va_arg(ap, wchar_t*);
492 wchar_t *sptr_beg = sptr;
493 #ifdef SECURE
494 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned);
495 #else
496 unsigned size = UINT_MAX;
497 #endif
498 /* skip initial whitespace */
499 while ((nch!=_EOF_) && _ISSPACE_(nch))
500 nch = _GETC_(file);
501 /* read until whitespace */
502 while (width!=0 && (nch!=_EOF_) && !_ISSPACE_(nch)) {
503 if (!suppress) {
504 *sptr++ = _WIDE2SUPPORTED_(nch);
505 if(size>1) size--;
506 else {
507 _UNLOCK_FILE_(file);
508 *sptr_beg = 0;
509 return rd;
510 }
511 }
512 st++;
513 nch = _GETC_(file);
514 if (width>0) width--;
515 }
516 /* terminate */
517 if (st && !suppress) *sptr = 0;
518 }
519 break;
520 /* 'c' and 'C work analogously to 's' and 'S' as described
521 * above */
522 case 'c':
523 if (w_prefix || l_prefix) goto widecharacter;
524 else if (h_prefix) goto character;
525 #ifdef WIDE_SCANF
526 else goto widecharacter;
527 #else /* WIDE_SCANF */
528 else goto character;
529 #endif /* WIDE_SCANF */
530 case 'C':
531 if (w_prefix || l_prefix) goto widecharacter;
532 else if (h_prefix) goto character;
533 #ifdef WIDE_SCANF
534 else goto character;
535 #else /* WIDE_SCANF */
536 else goto widecharacter;
537 #endif /* WIDE_SCANF */
538 character: { /* read single character into char */
539 char *str = suppress ? NULL : va_arg(ap, char*);
540 char *pstr = str;
541 #ifdef SECURE
542 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned)/sizeof(char);
543 #else
544 unsigned size = UINT_MAX;
545 #endif
546 if (width == -1) width = 1;
547 while (width && (nch != _EOF_))
548 {
549 if (!suppress) {
550 *str++ = _CHAR2SUPPORTED_(nch);
551 if(size) size--;
552 else {
553 _UNLOCK_FILE_(file);
554 *pstr = 0;
555 return rd;
556 }
557 }
558 st++;
559 width--;
560 nch = _GETC_(file);
561 }
562 }
563 break;
564 widecharacter: { /* read single character into a wchar_t */
565 wchar_t *str = suppress ? NULL : va_arg(ap, wchar_t*);
566 wchar_t *pstr = str;
567 #ifdef SECURE
568 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned)/sizeof(wchar_t);
569 #else
570 unsigned size = UINT_MAX;
571 #endif
572 if (width == -1) width = 1;
573 while (width && (nch != _EOF_))
574 {
575 if (!suppress) {
576 *str++ = _WIDE2SUPPORTED_(nch);
577 if(size) size--;
578 else {
579 _UNLOCK_FILE_(file);
580 *pstr = 0;
581 return rd;
582 }
583 }
584 st++;
585 width--;
586 nch = _GETC_(file);
587 }
588 }
589 break;
590 case 'n': {
591 if (!suppress) {
592 int*n = va_arg(ap, int*);
593 *n = consumed - 1;
594 }
595 /* This is an odd one: according to the standard,
596 * "Execution of a %n directive does not increment the
597 * assignment count returned at the completion of
598 * execution" even if it wasn't suppressed with the
599 * '*' flag. The Corrigendum to the standard seems
600 * to contradict this (comment out the assignment to
601 * suppress below if you want to implement these
602 * alternate semantics) but the windows program I'm
603 * looking at expects the behavior I've coded here
604 * (which happens to be what glibc does as well).
605 */
606 suppress = 1;
607 st = 1;
608 }
609 break;
610 case '[': {
611 _CHAR_ *str = suppress ? NULL : va_arg(ap, _CHAR_*);
612 _CHAR_ *sptr = str;
613 RTL_BITMAP bitMask;
614 ULONG *Mask;
615 int invert = 0; /* Set if we are NOT to find the chars */
616 #ifdef SECURE
617 unsigned size = suppress ? UINT_MAX : va_arg(ap, unsigned)/sizeof(_CHAR_);
618 #else
619 unsigned size = UINT_MAX;
620 #endif
621
622 /* Init our bitmap */
623 Mask = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, _BITMAPSIZE_/8);
624 RtlInitializeBitMap(&bitMask, Mask, _BITMAPSIZE_);
625
626 /* Read the format */
627 format++;
628 if(*format == '^') {
629 invert = 1;
630 format++;
631 }
632 if(*format == ']') {
633 RtlSetBits(&bitMask, ']', 1);
634 format++;
635 }
636 while(*format && (*format != ']')) {
637 /* According to msdn:
638 * "Note that %[a-z] and %[z-a] are interpreted as equivalent to %[abcde...z]." */
639 if((*format == '-') && (*(format + 1) != ']')) {
640 if ((*(format - 1)) < *(format + 1))
641 RtlSetBits(&bitMask, *(format - 1) +1 , *(format + 1) - *(format - 1));
642 else
643 RtlSetBits(&bitMask, *(format + 1) , *(format - 1) - *(format + 1));
644 format++;
645 } else
646 RtlSetBits(&bitMask, *format, 1);
647 format++;
648 }
649 /* read until char is not suitable */
650 while ((width != 0) && (nch != _EOF_)) {
651 if(!invert) {
652 if(RtlAreBitsSet(&bitMask, nch, 1)) {
653 if (!suppress) *sptr++ = _CHAR2SUPPORTED_(nch);
654 } else
655 break;
656 } else {
657 if(RtlAreBitsClear(&bitMask, nch, 1)) {
658 if (!suppress) *sptr++ = _CHAR2SUPPORTED_(nch);
659 } else
660 break;
661 }
662 st++;
663 nch = _GETC_(file);
664 if (width>0) width--;
665 if(size>1) size--;
666 else {
667 _UNLOCK_FILE_(file);
668 *str = 0;
669 return rd;
670 }
671 }
672 /* terminate */
673 if (!suppress) *sptr = 0;
674 HeapFree(GetProcessHeap(), 0, Mask);
675 }
676 break;
677 default:
678 /* From spec: "if a percent sign is followed by a character
679 * that has no meaning as a format-control character, that
680 * character and the following characters are treated as
681 * an ordinary sequence of characters, that is, a sequence
682 * of characters that must match the input. For example,
683 * to specify that a percent-sign character is to be input,
684 * use %%." */
685 while ((nch!=_EOF_) && _ISSPACE_(nch))
686 nch = _GETC_(file);
687 if (nch==*format) {
688 suppress = 1; /* whoops no field to be read */
689 st = 1; /* but we got what we expected */
690 nch = _GETC_(file);
691 }
692 break;
693 }
694 if (st && !suppress) rd++;
695 else if (!st) break;
696 }
697 /* a non-white-space character causes scanf to read, but not store,
698 * a matching non-white-space character. */
699 else {
700 /* check for character match */
701 if (nch == *format) {
702 nch = _GETC_(file);
703 } else break;
704 }
705 format++;
706 }
707 if (nch!=_EOF_) {
708 _UNGETC_(nch, file);
709 }
710
711 TRACE("returning %d\n", rd);
712 _UNLOCK_FILE_(file);
713 return rd;
714 }
715
716 #undef _CHAR_
717 #undef _EOF_
718 #undef _EOF_RET
719 #undef _ISSPACE_
720 #undef _ISDIGIT_
721 #undef _CHAR2SUPPORTED_
722 #undef _WIDE2SUPPORTED_
723 #undef _CHAR2DIGIT_
724 #undef _GETC_
725 #undef _UNGETC_
726 #undef _LOCK_FILE_
727 #undef _UNLOCK_FILE_
728 #undef _FUNCTION_
729 #undef _BITMAPSIZE_