?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
*** empty log message ***
[glibc.git] / stdio-common / vfscanf.c
blob0b53d7e0b66831886dddea83154012c79fa7b3bf
1 /* Copyright (C) 1991-1999, 2000, 2001 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, write to the Free
16 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17 02111-1307 USA. */
18
19 #include <assert.h>
20 #include <errno.h>
21 #include <limits.h>
22 #include <ctype.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <stdint.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <wchar.h>
29 #include <wctype.h>
30 #include <bits/libc-lock.h>
31 #include <locale/localeinfo.h>
32
33 #ifdef __GNUC__
34 # define HAVE_LONGLONG
35 # define LONGLONG long long
36 #else
37 # define LONGLONG long
38 #endif
39
40 /* Determine whether we have to handle `long long' at all. */
41 #if LONG_MAX == LONG_LONG_MAX
42 # define need_longlong 0
43 #else
44 # define need_longlong 1
45 #endif
46
47 /* Determine whether we have to handle `long'. */
48 #if INT_MAX == LONG_MAX
49 # define need_long 0
50 #else
51 # define need_long 1
52 #endif
53
54 /* Those are flags in the conversion format. */
55 #define LONG 0x001 /* l: long or double */
56 #define LONGDBL 0x002 /* L: long long or long double */
57 #define SHORT 0x004 /* h: short */
58 #define SUPPRESS 0x008 /* *: suppress assignment */
59 #define POINTER 0x010 /* weird %p pointer (`fake hex') */
60 #define NOSKIP 0x020 /* do not skip blanks */
61 #define WIDTH 0x040 /* width was given */
62 #define GROUP 0x080 /* ': group numbers */
63 #define MALLOC 0x100 /* a: malloc strings */
64 #define CHAR 0x200 /* hh: char */
65 #define I18N 0x400 /* I: use locale's digits */
66
67
68 #ifdef USE_IN_LIBIO
69 # include <libioP.h>
70 # include <libio.h>
71
72 # undef va_list
73 # define va_list _IO_va_list
74
75 # ifdef COMPILE_WSCANF
76 # define ungetc(c, s) ((void) (c == WEOF \
77 || (--read_in, \
78 _IO_sputbackwc (s, c))))
79 # define ungetc_not_eof(c, s) ((void) (--read_in, \
80 _IO_sputbackwc (s, c)))
81 # define inchar() (c == WEOF ? WEOF \
82 : ((c = _IO_getwc_unlocked (s)), \
83 (void) (c != WEOF && ++read_in), c))
84
85 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
86 # define ISSPACE(Ch) iswspace (Ch)
87 # define ISDIGIT(Ch) iswdigit (Ch)
88 # define ISXDIGIT(Ch) iswxdigit (Ch)
89 # define TOLOWER(Ch) towlower (Ch)
90 # define ORIENT if (_IO_fwide (s, 1) != 1) return WEOF
91 # define __strtoll_internal __wcstoll_internal
92 # define __strtoull_internal __wcstoull_internal
93 # define __strtol_internal __wcstol_internal
94 # define __strtoul_internal __wcstoul_internal
95 # define __strtold_internal __wcstold_internal
96 # define __strtod_internal __wcstod_internal
97 # define __strtof_internal __wcstof_internal
98
99 # define L_(Str) L##Str
100 # define CHAR_T wchar_t
101 # define UCHAR_T unsigned int
102 # define WINT_T wint_t
103 # undef EOF
104 # define EOF WEOF
105 # else
106 # define ungetc(c, s) ((void) ((int) c == EOF \
107 || (--read_in, \
108 _IO_sputbackc (s, (unsigned char) c))))
109 # define ungetc_not_eof(c, s) ((void) (--read_in, \
110 _IO_sputbackc (s, (unsigned char) c)))
111 # define inchar() (c == EOF ? EOF \
112 : ((c = _IO_getc_unlocked (s)), \
113 (void) (c != EOF && ++read_in), c))
114 # define MEMCPY(d, s, n) memcpy (d, s, n)
115 # define ISSPACE(Ch) isspace (Ch)
116 # define ISDIGIT(Ch) isdigit (Ch)
117 # define ISXDIGIT(Ch) isxdigit (Ch)
118 # define TOLOWER(Ch) tolower (Ch)
119 # define ORIENT if (s->_vtable_offset == 0 \
120 && _IO_fwide (s, -1) != -1) \
121 return EOF
122
123 # define L_(Str) Str
124 # define CHAR_T char
125 # define UCHAR_T unsigned char
126 # define WINT_T int
127 # endif
128
129 # define encode_error() do { \
130 if (errp != NULL) *errp |= 4; \
131 _IO_funlockfile (s); \
132 __libc_cleanup_end (0); \
133 __set_errno (EILSEQ); \
134 return done; \
135 } while (0)
136 # define conv_error() do { \
137 if (errp != NULL) *errp |= 2; \
138 _IO_funlockfile (s); \
139 __libc_cleanup_end (0); \
140 return done; \
141 } while (0)
142 # define input_error() do { \
143 _IO_funlockfile (s); \
144 if (errp != NULL) *errp |= 1; \
145 __libc_cleanup_end (0); \
146 return done ?: EOF; \
147 } while (0)
148 # define memory_error() do { \
149 _IO_funlockfile (s); \
150 __set_errno (ENOMEM); \
151 __libc_cleanup_end (0); \
152 return EOF; \
153 } while (0)
154 # define ARGCHECK(s, format) \
155 do \
156 { \
157 /* Check file argument for consistence. */ \
158 CHECK_FILE (s, EOF); \
159 if (s->_flags & _IO_NO_READS) \
160 { \
161 __set_errno (EBADF); \
162 return EOF; \
163 } \
164 else if (format == NULL) \
165 { \
166 MAYBE_SET_EINVAL; \
167 return EOF; \
168 } \
169 } while (0)
170 # define LOCK_STREAM(S) \
171 __libc_cleanup_region_start (1, (void (*) (void *)) &_IO_funlockfile, (S)); \
172 _IO_flockfile (S)
173 # define UNLOCK_STREAM(S) \
174 _IO_funlockfile (S); \
175 __libc_cleanup_region_end (0)
176 #else
177 # define ungetc(c, s) ((void) (c != EOF && --read_in), ungetc (c, s))
178 # define ungetc_not_eof(c, s) (--read_in, (ungetc) (c, s))
179 # define inchar() (c == EOF ? EOF \
180 : ((c = getc (s)), (void) (c != EOF && ++read_in), c))
181 # define MEMCPY(d, s, n) memcpy (d, s, n)
182 # define ISSPACE(Ch) isspace (Ch)
183 # define ISDIGIT(Ch) isdigit (Ch)
184 # define ISXDIGIT(Ch) isxdigit (Ch)
185 # define TOLOWER(Ch) tolower (Ch)
186
187 # define L_(Str) Str
188 # define CHAR_T char
189 # define UCHAR_T unsigned char
190 # define WINT_T int
191
192 # define encode_error() do { \
193 funlockfile (s); \
194 __set_errno (EILSEQ); \
195 return done; \
196 } while (0)
197 # define conv_error() do { \
198 funlockfile (s); \
199 return done; \
200 } while (0)
201 # define input_error() do { \
202 funlockfile (s); \
203 return done ?: EOF; \
204 } while (0)
205 # define memory_error() do { \
206 funlockfile (s); \
207 __set_errno (ENOMEM); \
208 return EOF; \
209 } while (0)
210 # define ARGCHECK(s, format) \
211 do \
212 { \
213 /* Check file argument for consistence. */ \
214 if (!__validfp (s) || !s->__mode.__read) \
215 { \
216 __set_errno (EBADF); \
217 return EOF; \
218 } \
219 else if (format == NULL) \
220 { \
221 __set_errno (EINVAL); \
222 return EOF; \
223 } \
224 } while (0)
225 #if 1
226 /* XXX For now !!! */
227 # define flockfile(S) /* nothing */
228 # define funlockfile(S) /* nothing */
229 # define LOCK_STREAM(S)
230 # define UNLOCK_STREAM(S)
231 #else
232 # define LOCK_STREAM(S) \
233 __libc_cleanup_region_start (&__funlockfile, (S)); \
234 __flockfile (S)
235 # define UNLOCK_STREAM(S) \
236 __funlockfile (S); \
237 __libc_cleanup_region_end (0)
238 #endif
239 #endif
240
241
242 /* Read formatted input from S according to the format string
243 FORMAT, using the argument list in ARG.
244 Return the number of assignments made, or -1 for an input error. */
245 #ifdef USE_IN_LIBIO
246 # ifdef COMPILE_WSCANF
247 int
248 _IO_vfwscanf (s, format, argptr, errp)
249 _IO_FILE *s;
250 const wchar_t *format;
251 _IO_va_list argptr;
252 int *errp;
253 # else
254 int
255 _IO_vfscanf (s, format, argptr, errp)
256 _IO_FILE *s;
257 const char *format;
258 _IO_va_list argptr;
259 int *errp;
260 # endif
261 #else
262 int
263 __vfscanf (FILE *s, const char *format, va_list argptr)
264 #endif
265 {
266 va_list arg;
267 register const CHAR_T *f = format;
268 register UCHAR_T fc; /* Current character of the format. */
269 register WINT_T done = 0; /* Assignments done. */
270 register size_t read_in = 0; /* Chars read in. */
271 register WINT_T c = 0; /* Last char read. */
272 register int width; /* Maximum field width. */
273 register int flags; /* Modifiers for current format element. */
274
275 /* Status for reading F-P nums. */
276 char got_dot, got_e, negative;
277 /* If a [...] is a [^...]. */
278 CHAR_T not_in;
279 #define exp_char not_in
280 /* Base for integral numbers. */
281 int base;
282 /* Signedness for integral numbers. */
283 int number_signed;
284 #define is_hexa number_signed
285 /* Decimal point character. */
286 #ifdef COMPILE_WSCANF
287 wchar_t decimal;
288 #else
289 const char *decimal;
290 #endif
291 /* The thousands character of the current locale. */
292 #ifdef COMPILE_WSCANF
293 wchar_t thousands;
294 #else
295 const char *thousands;
296 #endif
297 /* State for the conversions. */
298 mbstate_t state;
299 /* Integral holding variables. */
300 union
301 {
302 long long int q;
303 unsigned long long int uq;
304 long int l;
305 unsigned long int ul;
306 } num;
307 /* Character-buffer pointer. */
308 char *str = NULL;
309 wchar_t *wstr = NULL;
310 char **strptr = NULL;
311 ssize_t strsize = 0;
312 /* We must not react on white spaces immediately because they can
313 possibly be matched even if in the input stream no character is
314 available anymore. */
315 int skip_space = 0;
316 /* Nonzero if we are reading a pointer. */
317 int read_pointer;
318 /* Workspace. */
319 CHAR_T *tw; /* Temporary pointer. */
320 CHAR_T *wp = NULL; /* Workspace. */
321 size_t wpmax = 0; /* Maximal size of workspace. */
322 size_t wpsize; /* Currently used bytes in workspace. */
323 #define ADDW(Ch) \
324 do \
325 { \
326 if (wpsize == wpmax) \
327 { \
328 CHAR_T *old = wp; \
329 wpmax = (UCHAR_MAX + 1 > 2 * wpmax ? UCHAR_MAX + 1 : 2 * wpmax); \
330 wp = (CHAR_T *) alloca (wpmax * sizeof (wchar_t)); \
331 if (old != NULL) \
332 MEMCPY (wp, old, wpsize); \
333 } \
334 wp[wpsize++] = (Ch); \
335 } \
336 while (0)
337
338 #ifdef __va_copy
339 __va_copy (arg, argptr);
340 #else
341 arg = (va_list) argptr;
342 #endif
343
344 #ifdef ORIENT
345 ORIENT;
346 #endif
347
348 ARGCHECK (s, format);
349
350 /* Figure out the decimal point character. */
351 #ifdef COMPILE_WSCANF
352 decimal = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC);
353 #else
354 decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
355 #endif
356 /* Figure out the thousands separator character. */
357 #ifdef COMPILE_WSCANF
358 thousands = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_THOUSANDS_SEP_WC);
359 #else
360 thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
361 if (*thousands == '\0')
362 thousands = NULL;
363 #endif
364
365 /* Lock the stream. */
366 LOCK_STREAM (s);
367
368
369 #ifndef COMPILE_WSCANF
370 /* From now on we use `state' to convert the format string. */
371 memset (&state, '\0', sizeof (state));
372 #endif
373
374 /* Run through the format string. */
375 while (*f != '\0')
376 {
377 unsigned int argpos;
378 /* Extract the next argument, which is of type TYPE.
379 For a %N$... spec, this is the Nth argument from the beginning;
380 otherwise it is the next argument after the state now in ARG. */
381 #ifdef __va_copy
382 # define ARG(type) (argpos == 0 ? va_arg (arg, type) : \
383 ({ unsigned int pos = argpos; \
384 va_list arg; \
385 __va_copy (arg, argptr); \
386 while (--pos > 0) \
387 (void) va_arg (arg, void *); \
388 va_arg (arg, type); \
389 }))
390 #else
391 # if 0
392 /* XXX Possible optimization. */
393 # define ARG(type) (argpos == 0 ? va_arg (arg, type) : \
394 ({ va_list arg = (va_list) argptr; \
395 arg = (va_list) ((char *) arg \
396 + (argpos - 1) \
397 * __va_rounded_size (void *)); \
398 va_arg (arg, type); \
399 }))
400 # else
401 # define ARG(type) (argpos == 0 ? va_arg (arg, type) : \
402 ({ unsigned int pos = argpos; \
403 va_list arg = (va_list) argptr; \
404 while (--pos > 0) \
405 (void) va_arg (arg, void *); \
406 va_arg (arg, type); \
407 }))
408 # endif
409 #endif
410
411 #ifndef COMPILE_WSCANF
412 if (!isascii ((unsigned char) *f))
413 {
414 /* Non-ASCII, may be a multibyte. */
415 int len = __mbrlen (f, strlen (f), &state);
416 if (len > 0)
417 {
418 do
419 {
420 c = inchar ();
421 if (c == EOF)
422 input_error ();
423 else if (c != (unsigned char) *f++)
424 {
425 ungetc_not_eof (c, s);
426 conv_error ();
427 }
428 }
429 while (--len > 0);
430 continue;
431 }
432 }
433 #endif
434
435 fc = *f++;
436 if (fc != '%')
437 {
438 /* Remember to skip spaces. */
439 if (ISSPACE (fc))
440 {
441 skip_space = 1;
442 continue;
443 }
444
445 /* Read a character. */
446 c = inchar ();
447
448 /* Characters other than format specs must just match. */
449 if (c == EOF)
450 input_error ();
451
452 /* We saw white space char as the last character in the format
453 string. Now it's time to skip all leading white space. */
454 if (skip_space)
455 {
456 while (ISSPACE (c))
457 if (inchar () == EOF && errno == EINTR)
458 conv_error ();
459 skip_space = 0;
460 }
461
462 if (c != fc)
463 {
464 ungetc (c, s);
465 conv_error ();
466 }
467
468 continue;
469 }
470
471 /* This is the start of the conversion string. */
472 flags = 0;
473
474 /* Not yet decided whether we read a pointer or not. */
475 read_pointer = 0;
476
477 /* Initialize state of modifiers. */
478 argpos = 0;
479
480 /* Prepare temporary buffer. */
481 wpsize = 0;
482
483 /* Check for a positional parameter specification. */
484 if (ISDIGIT ((UCHAR_T) *f))
485 {
486 argpos = (UCHAR_T) *f++ - L_('0');
487 while (ISDIGIT ((UCHAR_T) *f))
488 argpos = argpos * 10 + ((UCHAR_T) *f++ - L_('0'));
489 if (*f == L_('$'))
490 ++f;
491 else
492 {
493 /* Oops; that was actually the field width. */
494 width = argpos;
495 flags |= WIDTH;
496 argpos = 0;
497 goto got_width;
498 }
499 }
500
501 /* Check for the assignment-suppressing, the number grouping flag,
502 and the signal to use the locale's digit representation. */
503 while (*f == L_('*') || *f == L_('\'') || *f == L_('I'))
504 switch (*f++)
505 {
506 case L_('*'):
507 flags |= SUPPRESS;
508 break;
509 case L_('\''):
510 flags |= GROUP;
511 break;
512 case L_('I'):
513 flags |= I18N;
514 break;
515 }
516
517 /* We have seen width. */
518 if (ISDIGIT ((UCHAR_T) *f))
519 flags |= WIDTH;
520
521 /* Find the maximum field width. */
522 width = 0;
523 while (ISDIGIT ((UCHAR_T) *f))
524 {
525 width *= 10;
526 width += (UCHAR_T) *f++ - L_('0');
527 }
528 got_width:
529 if (width == 0)
530 width = -1;
531
532 /* Check for type modifiers. */
533 switch (*f++)
534 {
535 case L_('h'):
536 /* ints are short ints or chars. */
537 if (*f == L_('h'))
538 {
539 ++f;
540 flags |= CHAR;
541 }
542 else
543 flags |= SHORT;
544 break;
545 case L_('l'):
546 if (*f == L_('l'))
547 {
548 /* A double `l' is equivalent to an `L'. */
549 ++f;
550 flags |= LONGDBL | LONG;
551 }
552 else
553 /* ints are long ints. */
554 flags |= LONG;
555 break;
556 case L_('q'):
557 case L_('L'):
558 /* doubles are long doubles, and ints are long long ints. */
559 flags |= LONGDBL | LONG;
560 break;
561 case L_('a'):
562 /* The `a' is used as a flag only if followed by `s', `S' or
563 `['. */
564 if (*f != L_('s') && *f != L_('S') && *f != L_('['))
565 {
566 --f;
567 break;
568 }
569 /* String conversions (%s, %[) take a `char **'
570 arg and fill it in with a malloc'd pointer. */
571 flags |= MALLOC;
572 break;
573 case L_('z'):
574 if (need_longlong && sizeof (size_t) > sizeof (unsigned long int))
575 flags |= LONGDBL;
576 else if (sizeof (size_t) > sizeof (unsigned int))
577 flags |= LONG;
578 break;
579 case L_('j'):
580 if (need_longlong && sizeof (uintmax_t) > sizeof (unsigned long int))
581 flags |= LONGDBL;
582 else if (sizeof (uintmax_t) > sizeof (unsigned int))
583 flags |= LONG;
584 break;
585 case L_('t'):
586 if (need_longlong && sizeof (ptrdiff_t) > sizeof (long int))
587 flags |= LONGDBL;
588 else if (sizeof (ptrdiff_t) > sizeof (int))
589 flags |= LONG;
590 break;
591 default:
592 /* Not a recognized modifier. Backup. */
593 --f;
594 break;
595 }
596
597 /* End of the format string? */
598 if (*f == L_('\0'))
599 conv_error ();
600
601 /* Find the conversion specifier. */
602 fc = *f++;
603 if (skip_space || (fc != L_('[') && fc != L_('c')
604 && fc != L_('C') && fc != L_('n')))
605 {
606 /* Eat whitespace. */
607 int save_errno = errno;
608 errno = 0;
609 do
610 if (inchar () == EOF && errno == EINTR)
611 input_error ();
612 while (ISSPACE (c));
613 errno = save_errno;
614 ungetc (c, s);
615 skip_space = 0;
616 }
617
618 switch (fc)
619 {
620 case L_('%'): /* Must match a literal '%'. */
621 c = inchar ();
622 if (c == EOF)
623 input_error ();
624 if (c != fc)
625 {
626 ungetc_not_eof (c, s);
627 conv_error ();
628 }
629 break;
630
631 case L_('n'): /* Answer number of assignments done. */
632 /* Corrigendum 1 to ISO C 1990 describes the allowed flags
633 with the 'n' conversion specifier. */
634 if (!(flags & SUPPRESS))
635 {
636 /* Don't count the read-ahead. */
637 if (need_longlong && (flags & LONGDBL))
638 *ARG (long long int *) = read_in;
639 else if (need_long && (flags & LONG))
640 *ARG (long int *) = read_in;
641 else if (flags & SHORT)
642 *ARG (short int *) = read_in;
643 else if (!(flags & CHAR))
644 *ARG (int *) = read_in;
645 else
646 *ARG (char *) = read_in;
647
648 #ifdef NO_BUG_IN_ISO_C_CORRIGENDUM_1
649 /* We have a severe problem here. The ISO C standard
650 contradicts itself in explaining the effect of the %n
651 format in `scanf'. While in ISO C:1990 and the ISO C
652 Amendement 1:1995 the result is described as
653
654 Execution of a %n directive does not effect the
655 assignment count returned at the completion of
656 execution of the f(w)scanf function.
657
658 in ISO C Corrigendum 1:1994 the following was added:
659
660 Subclause 7.9.6.2
661 Add the following fourth example:
662 In:
663 #include <stdio.h>
664 int d1, d2, n1, n2, i;
665 i = sscanf("123", "%d%n%n%d", &d1, &n1, &n2, &d2);
666 the value 123 is assigned to d1 and the value3 to n1.
667 Because %n can never get an input failure the value
668 of 3 is also assigned to n2. The value of d2 is not
669 affected. The value 3 is assigned to i.
670
671 We go for now with the historically correct code from ISO C,
672 i.e., we don't count the %n assignments. When it ever
673 should proof to be wrong just remove the #ifdef above. */
674 ++done;
675 #endif
676 }
677 break;
678
679 case L_('c'): /* Match characters. */
680 if ((flags & LONG) == 0)
681 {
682 if (!(flags & SUPPRESS))
683 {
684 str = ARG (char *);
685 if (str == NULL)
686 conv_error ();
687 }
688
689 c = inchar ();
690 if (c == EOF)
691 input_error ();
692
693 if (width == -1)
694 width = 1;
695
696 #ifdef COMPILE_WSCANF
697 /* We have to convert the wide character(s) into multibyte
698 characters and store the result. */
699 memset (&state, '\0', sizeof (state));
700
701 do
702 {
703 size_t n;
704
705 n = __wcrtomb (!(flags & SUPPRESS) ? str : NULL, c, &state);
706 if (n == (size_t) -1)
707 /* No valid wide character. */
708 input_error ();
709
710 /* Increment the output pointer. Even if we don't
711 write anything. */
712 str += n;
713 }
714 while (--width > 0 && inchar () != EOF);
715 #else
716 if (!(flags & SUPPRESS))
717 {
718 do
719 *str++ = c;
720 while (--width > 0 && inchar () != EOF);
721 }
722 else
723 while (--width > 0 && inchar () != EOF);
724 #endif
725
726 if (!(flags & SUPPRESS))
727 ++done;
728
729 break;
730 }
731 /* FALLTHROUGH */
732 case L_('C'):
733 if (!(flags & SUPPRESS))
734 {
735 wstr = ARG (wchar_t *);
736 if (wstr == NULL)
737 conv_error ();
738 }
739
740 c = inchar ();
741 if (c == EOF)
742 input_error ();
743
744 #ifdef COMPILE_WSCANF
745 /* Just store the incoming wide characters. */
746 if (!(flags & SUPPRESS))
747 {
748 do
749 *wstr++ = c;
750 while (--width > 0 && inchar () != EOF);
751 }
752 else
753 while (--width > 0 && inchar () != EOF);
754 #else
755 {
756 /* We have to convert the multibyte input sequence to wide
757 characters. */
758 char buf[1];
759 mbstate_t cstate;
760
761 memset (&cstate, '\0', sizeof (cstate));
762
763 do
764 {
765 /* This is what we present the mbrtowc function first. */
766 buf[0] = c;
767
768 while (1)
769 {
770 size_t n;
771
772 n = __mbrtowc (!(flags & SUPPRESS) ? wstr : NULL,
773 buf, 1, &cstate);
774
775 if (n == (size_t) -2)
776 {
777 /* Possibly correct character, just not enough
778 input. */
779 if (inchar () == EOF)
780 encode_error ();
781
782 buf[0] = c;
783 continue;
784 }
785
786 if (n != 1)
787 encode_error ();
788
789 /* We have a match. */
790 break;
791 }
792
793 /* Advance the result pointer. */
794 ++wstr;
795 }
796 while (--width > 0 && inchar () != EOF);
797 }
798 #endif
799
800 if (!(flags & SUPPRESS))
801 ++done;
802
803 break;
804
805 case L_('s'): /* Read a string. */
806 if (!(flags & LONG))
807 {
808 #define STRING_ARG(Str, Type) \
809 do if (!(flags & SUPPRESS)) \
810 { \
811 if (flags & MALLOC) \
812 { \
813 /* The string is to be stored in a malloc'd buffer. */ \
814 strptr = ARG (char **); \
815 if (strptr == NULL) \
816 conv_error (); \
817 /* Allocate an initial buffer. */ \
818 strsize = 100; \
819 *strptr = (char *) malloc (strsize * sizeof (Type)); \
820 Str = (Type *) *strptr; \
821 } \
822 else \
823 Str = ARG (Type *); \
824 if (Str == NULL) \
825 conv_error (); \
826 } while (0)
827 STRING_ARG (str, char);
828
829 c = inchar ();
830 if (c == EOF)
831 input_error ();
832
833 #ifdef COMPILE_WSCANF
834 memset (&state, '\0', sizeof (state));
835 #endif
836
837 do
838 {
839 if (ISSPACE (c))
840 {
841 ungetc_not_eof (c, s);
842 break;
843 }
844
845 #ifdef COMPILE_WSCANF
846 /* This is quite complicated. We have to convert the
847 wide characters into multibyte characters and then
848 store them. */
849 {
850 size_t n;
851
852 if (!(flags & SUPPRESS) && (flags & MALLOC)
853 && str + MB_CUR_MAX >= *strptr + strsize)
854 {
855 /* We have to enlarge the buffer if the `a' flag
856 was given. */
857 size_t strleng = str - *strptr;
858 char *newstr;
859
860 newstr = (char *) realloc (*strptr, strsize * 2);
861 if (newstr == NULL)
862 {
863 /* Can't allocate that much. Last-ditch
864 effort. */
865 newstr = (char *) realloc (*strptr,
866 strleng + MB_CUR_MAX);
867 if (newstr == NULL)
868 {
869 /* We lose. Oh well. Terminate the
870 string and stop converting,
871 so at least we don't skip any input. */
872 ((char *) (*strptr))[strleng] = '\0';
873 ++done;
874 conv_error ();
875 }
876 else
877 {
878 *strptr = newstr;
879 str = newstr + strleng;
880 strsize = strleng + MB_CUR_MAX;
881 }
882 }
883 else
884 {
885 *strptr = newstr;
886 str = newstr + strleng;
887 strsize *= 2;
888 }
889 }
890
891 n = __wcrtomb (!(flags & SUPPRESS) ? str : NULL, c,
892 &state);
893 if (n == (size_t) -1)
894 encode_error ();
895
896 assert (n <= MB_CUR_MAX);
897 str += n;
898 }
899 #else
900 /* This is easy. */
901 if (!(flags & SUPPRESS))
902 {
903 *str++ = c;
904 if ((flags & MALLOC)
905 && (char *) str == *strptr + strsize)
906 {
907 /* Enlarge the buffer. */
908 str = (char *) realloc (*strptr, 2 * strsize);
909 if (str == NULL)
910 {
911 /* Can't allocate that much. Last-ditch
912 effort. */
913 str = (char *) realloc (*strptr, strsize + 1);
914 if (str == NULL)
915 {
916 /* We lose. Oh well. Terminate the
917 string and stop converting,
918 so at least we don't skip any input. */
919 ((char *) (*strptr))[strsize - 1] = '\0';
920 ++done;
921 conv_error ();
922 }
923 else
924 {
925 *strptr = (char *) str;
926 str += strsize;
927 ++strsize;
928 }
929 }
930 else
931 {
932 *strptr = (char *) str;
933 str += strsize;
934 strsize *= 2;
935 }
936 }
937 }
938 #endif
939 }
940 while ((width <= 0 || --width > 0) && inchar () != EOF);
941
942 if (!(flags & SUPPRESS))
943 {
944 #ifdef COMPILE_WSCANF
945 /* We have to emit the code to get into the initial
946 state. */
947 char buf[MB_LEN_MAX];
948 size_t n = __wcrtomb (buf, L'\0', &state);
949 if (n > 0 && (flags & MALLOC)
950 && str + n >= *strptr + strsize)
951 {
952 /* Enlarge the buffer. */
953 size_t strleng = str - *strptr;
954 char *newstr;
955
956 newstr = (char *) realloc (*strptr, strleng + n + 1);
957 if (newstr == NULL)
958 {
959 /* We lose. Oh well. Terminate the string
960 and stop converting, so at least we don't
961 skip any input. */
962 ((char *) (*strptr))[strleng] = '\0';
963 ++done;
964 conv_error ();
965 }
966 else
967 {
968 *strptr = newstr;
969 str = newstr + strleng;
970 strsize = strleng + n + 1;
971 }
972 }
973
974 str = __mempcpy (str, buf, n);
975 #endif
976 *str++ = '\0';
977
978 if ((flags & MALLOC) && str - *strptr != strsize)
979 {
980 char *cp = (char *) realloc (*strptr, str - *strptr);
981 if (cp != NULL)
982 *strptr = cp;
983 }
984
985 ++done;
986 }
987 break;
988 }
989 /* FALLTHROUGH */
990
991 case L_('S'):
992 {
993 #ifndef COMPILE_WSCANF
994 mbstate_t cstate;
995 #endif
996
997 /* Wide character string. */
998 STRING_ARG (wstr, wchar_t);
999
1000 c = inchar ();
1001 if (c == EOF)
1002 input_error ();
1003
1004 #ifndef COMPILE_WSCANF
1005 memset (&cstate, '\0', sizeof (cstate));
1006 #endif
1007
1008 do
1009 {
1010 if (ISSPACE (c))
1011 {
1012 ungetc_not_eof (c, s);
1013 break;
1014 }
1015
1016 #ifdef COMPILE_WSCANF
1017 /* This is easy. */
1018 if (!(flags & SUPPRESS))
1019 {
1020 *wstr++ = c;
1021 if ((flags & MALLOC)
1022 && wstr == (wchar_t *) *strptr + strsize)
1023 {
1024 /* Enlarge the buffer. */
1025 wstr = (wchar_t *) realloc (*strptr,
1026 (2 * strsize)
1027 * sizeof (wchar_t));
1028 if (wstr == NULL)
1029 {
1030 /* Can't allocate that much. Last-ditch
1031 effort. */
1032 wstr = (wchar_t *) realloc (*strptr,
1033 (strsize + 1)
1034 * sizeof (wchar_t));
1035 if (wstr == NULL)
1036 {
1037 /* We lose. Oh well. Terminate the string
1038 and stop converting, so at least we don't
1039 skip any input. */
1040 ((wchar_t *) (*strptr))[strsize - 1] = L'\0';
1041 ++done;
1042 conv_error ();
1043 }
1044 else
1045 {
1046 *strptr = (char *) wstr;
1047 wstr += strsize;
1048 ++strsize;
1049 }
1050 }
1051 else
1052 {
1053 *strptr = (char *) wstr;
1054 wstr += strsize;
1055 strsize *= 2;
1056 }
1057 }
1058 }
1059 #else
1060 {
1061 char buf[1];
1062
1063 buf[0] = c;
1064
1065 while (1)
1066 {
1067 size_t n;
1068
1069 n = __mbrtowc (!(flags & SUPPRESS) ? wstr : NULL,
1070 buf, 1, &cstate);
1071
1072 if (n == (size_t) -2)
1073 {
1074 /* Possibly correct character, just not enough
1075 input. */
1076 if (inchar () == EOF)
1077 encode_error ();
1078
1079 buf[0] = c;
1080 continue;
1081 }
1082
1083 if (n != 1)
1084 encode_error ();
1085
1086 /* We have a match. */
1087 ++wstr;
1088 break;
1089 }
1090
1091 if (!(flags & SUPPRESS) && (flags & MALLOC)
1092 && wstr == (wchar_t *) *strptr + strsize)
1093 {
1094 /* Enlarge the buffer. */
1095 wstr = (wchar_t *) realloc (*strptr,
1096 (2 * strsize
1097 * sizeof (wchar_t)));
1098 if (wstr == NULL)
1099 {
1100 /* Can't allocate that much. Last-ditch effort. */
1101 wstr = (wchar_t *) realloc (*strptr,
1102 ((strsize + 1)
1103 * sizeof (wchar_t)));
1104 if (wstr == NULL)
1105 {
1106 /* We lose. Oh well. Terminate the
1107 string and stop converting, so at
1108 least we don't skip any input. */
1109 ((wchar_t *) (*strptr))[strsize - 1] = L'\0';
1110 ++done;
1111 conv_error ();
1112 }
1113 else
1114 {
1115 *strptr = (char *) wstr;
1116 wstr += strsize;
1117 ++strsize;
1118 }
1119 }
1120 else
1121 {
1122 *strptr = (char *) wstr;
1123 wstr += strsize;
1124 strsize *= 2;
1125 }
1126 }
1127 }
1128 #endif
1129 }
1130 while ((width <= 0 || --width > 0) && inchar () != EOF);
1131
1132 if (!(flags & SUPPRESS))
1133 {
1134 *wstr++ = L'\0';
1135
1136 if ((flags & MALLOC) && wstr - (wchar_t *) *strptr != strsize)
1137 {
1138 wchar_t *cp = (wchar_t *) realloc (*strptr,
1139 ((wstr
1140 - (wchar_t *) *strptr)
1141 * sizeof(wchar_t)));
1142 if (cp != NULL)
1143 *strptr = (char *) cp;
1144 }
1145
1146 ++done;
1147 }
1148 }
1149 break;
1150
1151 case L_('x'): /* Hexadecimal integer. */
1152 case L_('X'): /* Ditto. */
1153 base = 16;
1154 number_signed = 0;
1155 goto number;
1156
1157 case L_('o'): /* Octal integer. */
1158 base = 8;
1159 number_signed = 0;
1160 goto number;
1161
1162 case L_('u'): /* Unsigned decimal integer. */
1163 base = 10;
1164 number_signed = 0;
1165 goto number;
1166
1167 case L_('d'): /* Signed decimal integer. */
1168 base = 10;
1169 number_signed = 1;
1170 goto number;
1171
1172 case L_('i'): /* Generic number. */
1173 base = 0;
1174 number_signed = 1;
1175
1176 number:
1177 c = inchar ();
1178 if (c == EOF)
1179 input_error ();
1180
1181 /* Check for a sign. */
1182 if (c == L_('-') || c == L_('+'))
1183 {
1184 ADDW (c);
1185 if (width > 0)
1186 --width;
1187 c = inchar ();
1188 }
1189
1190 /* Look for a leading indication of base. */
1191 if (width != 0 && c == L_('0'))
1192 {
1193 if (width > 0)
1194 --width;
1195
1196 ADDW (c);
1197 c = inchar ();
1198
1199 if (width != 0 && TOLOWER (c) == L_('x'))
1200 {
1201 if (base == 0)
1202 base = 16;
1203 if (base == 16)
1204 {
1205 if (width > 0)
1206 --width;
1207 c = inchar ();
1208 }
1209 }
1210 else if (base == 0)
1211 base = 8;
1212 }
1213
1214 if (base == 0)
1215 base = 10;
1216
1217 if (base == 10 && (flags & I18N) != 0)
1218 {
1219 int from_level;
1220 int to_level;
1221 int level;
1222 #ifdef COMPILE_WSCANF
1223 const wchar_t *wcdigits[10];
1224 #else
1225 const char *mbdigits[10];
1226 #endif
1227 int n;
1228
1229 from_level = 0;
1230 #ifdef COMPILE_WSCANF
1231 to_level = _NL_CURRENT_WORD (LC_CTYPE,
1232 _NL_CTYPE_INDIGITS_WC_LEN) - 1;
1233 #else
1234 to_level = _NL_CURRENT_WORD (LC_CTYPE,
1235 _NL_CTYPE_INDIGITS_MB_LEN) - 1;
1236 #endif
1237
1238 /* Read the number into workspace. */
1239 while (c != EOF && width != 0)
1240 {
1241 /* In this round we get the pointer to the digit strings
1242 and also perform the first round of comparisons. */
1243 for (n = 0; n < 10; ++n)
1244 {
1245 /* Get the string for the digits with value N. */
1246 #ifdef COMPILE_WSCANF
1247 wcdigits[n] = (const wchar_t *)
1248 _NL_CURRENT (LC_CTYPE, _NL_CTYPE_INDIGITS0_WC + n);
1249 wcdigits[n] += from_level;
1250
1251 if (c == *wcdigits[n])
1252 {
1253 to_level = from_level;
1254 break;
1255 }
1256
1257 /* Advance the pointer to the next string. */
1258 ++wcdigits[n];
1259 #else
1260 const char *cmpp;
1261 int avail = width > 0 ? width : INT_MAX;
1262
1263 mbdigits[n] = _NL_CURRENT (LC_CTYPE,
1264 _NL_CTYPE_INDIGITS0_MB + n);
1265
1266 for (level = 0; level < from_level; level++)
1267 mbdigits[n] = strchr (mbdigits[n], '\0') + 1;
1268
1269 cmpp = mbdigits[n];
1270 while ((unsigned char) *cmpp == c && avail > 0)
1271 {
1272 if (*++cmpp == '\0')
1273 break;
1274 else
1275 {
1276 if ((c = inchar ()) == EOF)
1277 break;
1278 --avail;
1279 }
1280 }
1281
1282 if (*cmpp == '\0')
1283 {
1284 if (width > 0)
1285 width = avail;
1286 to_level = from_level;
1287 break;
1288 }
1289
1290 /* We are pushing all read characters back. */
1291 if (cmpp > mbdigits[n])
1292 {
1293 ungetc (c, s);
1294 while (--cmpp > mbdigits[n])
1295 ungetc_not_eof ((unsigned char) *cmpp, s);
1296 c = (unsigned char) *cmpp;
1297 }
1298
1299 /* Advance the pointer to the next string. */
1300 mbdigits[n] = strchr (mbdigits[n], '\0') + 1;
1301 #endif
1302 }
1303
1304 if (n == 10)
1305 {
1306 /* Have not yet found the digit. */
1307 for (level = from_level + 1; level <= to_level; ++level)
1308 {
1309 /* Search all ten digits of this level. */
1310 for (n = 0; n < 10; ++n)
1311 {
1312 #ifdef COMPILE_WSCANF
1313 if (c == *wcdigits[n])
1314 break;
1315
1316 /* Advance the pointer to the next string. */
1317 ++wcdigits[n];
1318 #else
1319 const char *cmpp;
1320 int avail = width > 0 ? width : INT_MAX;
1321
1322 cmpp = mbdigits[n];
1323 while ((unsigned char) *cmpp == c && avail > 0)
1324 {
1325 if (*++cmpp == '\0')
1326 break;
1327 else
1328 {
1329 if ((c = inchar ()) == EOF)
1330 break;
1331 --avail;
1332 }
1333 }
1334
1335 if (*cmpp == '\0')
1336 {
1337 if (width > 0)
1338 width = avail;
1339 break;
1340 }
1341
1342 /* We are pushing all read characters back. */
1343 if (cmpp > mbdigits[n])
1344 {
1345 ungetc (c, s);
1346 while (--cmpp > mbdigits[n])
1347 ungetc_not_eof ((unsigned char) *cmpp, s);
1348 c = (unsigned char) *cmpp;
1349 }
1350
1351 /* Advance the pointer to the next string. */
1352 mbdigits[n] = strchr (mbdigits[n], '\0') + 1;
1353 #endif
1354 }
1355
1356 if (n < 10)
1357 {
1358 /* Found it. */
1359 from_level = level;
1360 to_level = level;
1361 break;
1362 }
1363 }
1364 }
1365
1366 if (n < 10)
1367 c = L_('0') + n;
1368 else if ((flags & GROUP)
1369 #ifdef COMPILE_WSCANF
1370 && thousands != L'\0'
1371 #else
1372 && thousands != NULL
1373 #endif
1374 )
1375 {
1376 /* Try matching against the thousands separator. */
1377 #ifdef COMPILE_WSCANF
1378 if (c != thousands)
1379 break;
1380 #else
1381 const char *cmpp = thousands;
1382 int avail = width > 0 ? width : INT_MAX;
1383
1384 while ((unsigned char) *cmpp == c && avail > 0)
1385 {
1386 ADDW (c);
1387 if (*++cmpp == '\0')
1388 break;
1389 else
1390 {
1391 if ((c = inchar ()) == EOF)
1392 break;
1393 --avail;
1394 }
1395 }
1396
1397 if (*cmpp != '\0')
1398 {
1399 /* We are pushing all read characters back. */
1400 if (cmpp > thousands)
1401 {
1402 wpsize -= cmpp - thousands;
1403 ungetc (c, s);
1404 while (--cmpp > thousands)
1405 ungetc_not_eof ((unsigned char) *cmpp, s);
1406 c = (unsigned char) *cmpp;
1407 }
1408 break;
1409 }
1410
1411 if (width > 0)
1412 width = avail;
1413
1414 /* The last thousands character will be added back by
1415 the ADDW below. */
1416 --wpsize;
1417 #endif
1418 }
1419 else
1420 break;
1421
1422 ADDW (c);
1423 if (width > 0)
1424 --width;
1425
1426 c = inchar ();
1427 }
1428 }
1429 else
1430 /* Read the number into workspace. */
1431 while (c != EOF && width != 0)
1432 {
1433 if (base == 16)
1434 {
1435 if (!ISXDIGIT (c))
1436 break;
1437 }
1438 else if (!ISDIGIT (c) || c - L_('0') >= base)
1439 {
1440 if (base == 10 && (flags & GROUP)
1441 #ifdef COMPILE_WSCANF
1442 && thousands != L'\0'
1443 #else
1444 && thousands != NULL
1445 #endif
1446 )
1447 {
1448 /* Try matching against the thousands separator. */
1449 #ifdef COMPILE_WSCANF
1450 if (c != thousands)
1451 break;
1452 #else
1453 const char *cmpp = thousands;
1454 int avail = width > 0 ? width : INT_MAX;
1455
1456 while ((unsigned char) *cmpp == c && avail > 0)
1457 {
1458 ADDW (c);
1459 if (*++cmpp == '\0')
1460 break;
1461 else
1462 {
1463 if ((c = inchar ()) == EOF)
1464 break;
1465 --avail;
1466 }
1467 }
1468
1469 if (*cmpp != '\0')
1470 {
1471 /* We are pushing all read characters back. */
1472 if (cmpp > thousands)
1473 {
1474 wpsize -= cmpp - thousands;
1475 ungetc (c, s);
1476 while (--cmpp > thousands)
1477 ungetc_not_eof ((unsigned char) *cmpp, s);
1478 c = (unsigned char) *cmpp;
1479 }
1480 break;
1481 }
1482
1483 if (width > 0)
1484 width = avail;
1485
1486 /* The last thousands character will be added back by
1487 the ADDW below. */
1488 --wpsize;
1489 #endif
1490 }
1491 else
1492 break;
1493 }
1494 ADDW (c);
1495 if (width > 0)
1496 --width;
1497
1498 c = inchar ();
1499 }
1500
1501 if (wpsize == 0
1502 || (wpsize == 1 && (wp[0] == L_('+') || wp[0] == L_('-'))))
1503 {
1504 /* There was no number. If we are supposed to read a pointer
1505 we must recognize "(nil)" as well. */
1506 if (wpsize == 0 && read_pointer && (width < 0 || width >= 0)
1507 && c == '('
1508 && TOLOWER (inchar ()) == L_('n')
1509 && TOLOWER (inchar ()) == L_('i')
1510 && TOLOWER (inchar ()) == L_('l')
1511 && inchar () == L_(')'))
1512 /* We must produce the value of a NULL pointer. A single
1513 '0' digit is enough. */
1514 ADDW (L_('0'));
1515 else
1516 {
1517 /* The last read character is not part of the number
1518 anymore. */
1519 ungetc (c, s);
1520
1521 conv_error ();
1522 }
1523 }
1524 else
1525 /* The just read character is not part of the number anymore. */
1526 ungetc (c, s);
1527
1528 /* Convert the number. */
1529 ADDW (L_('\0'));
1530 if (need_longlong && (flags & LONGDBL))
1531 {
1532 if (number_signed)
1533 num.q = __strtoll_internal (wp, &tw, base, flags & GROUP);
1534 else
1535 num.uq = __strtoull_internal (wp, &tw, base, flags & GROUP);
1536 }
1537 else
1538 {
1539 if (number_signed)
1540 num.l = __strtol_internal (wp, &tw, base, flags & GROUP);
1541 else
1542 num.ul = __strtoul_internal (wp, &tw, base, flags & GROUP);
1543 }
1544 if (wp == tw)
1545 conv_error ();
1546
1547 if (!(flags & SUPPRESS))
1548 {
1549 if (! number_signed)
1550 {
1551 if (need_longlong && (flags & LONGDBL))
1552 *ARG (unsigned LONGLONG int *) = num.uq;
1553 else if (need_long && (flags & LONG))
1554 *ARG (unsigned long int *) = num.ul;
1555 else if (flags & SHORT)
1556 *ARG (unsigned short int *)
1557 = (unsigned short int) num.ul;
1558 else if (!(flags & CHAR))
1559 *ARG (unsigned int *) = (unsigned int) num.ul;
1560 else
1561 *ARG (unsigned char *) = (unsigned char) num.ul;
1562 }
1563 else
1564 {
1565 if (need_longlong && (flags & LONGDBL))
1566 *ARG (LONGLONG int *) = num.q;
1567 else if (need_long && (flags & LONG))
1568 *ARG (long int *) = num.l;
1569 else if (flags & SHORT)
1570 *ARG (short int *) = (short int) num.l;
1571 else if (!(flags & CHAR))
1572 *ARG (int *) = (int) num.l;
1573 else
1574 *ARG (signed char *) = (signed char) num.ul;
1575 }
1576 ++done;
1577 }
1578 break;
1579
1580 case L_('e'): /* Floating-point numbers. */
1581 case L_('E'):
1582 case L_('f'):
1583 case L_('F'):
1584 case L_('g'):
1585 case L_('G'):
1586 case L_('a'):
1587 case L_('A'):
1588 c = inchar ();
1589 if (c == EOF)
1590 input_error ();
1591
1592 /* Check for a sign. */
1593 if (c == L_('-') || c == L_('+'))
1594 {
1595 negative = c == L_('-');
1596 if (width == 0 || inchar () == EOF)
1597 /* EOF is only an input error before we read any chars. */
1598 conv_error ();
1599 if (! ISDIGIT (c) && TOLOWER (c) != L_('i'))
1600 {
1601 #ifdef COMPILE_WSCANF
1602 if (c != decimal)
1603 {
1604 /* This is no valid number. */
1605 ungetc (c, s);
1606 conv_error ();
1607 }
1608 #else
1609 /* Match against the decimal point. At this point
1610 we are taking advantage of the fact that we can
1611 push more than one character back. This is
1612 (almost) never necessary since the decimal point
1613 string hopefully never contains more than one
1614 byte. */
1615 const char *cmpp = decimal;
1616 int avail = width > 0 ? width : INT_MAX;
1617
1618 while ((unsigned char) *cmpp == c && avail > 0)
1619 if (*++cmpp == '\0')
1620 break;
1621 else
1622 {
1623 if (inchar () == EOF)
1624 break;
1625 --avail;
1626 }
1627
1628 if (*cmpp != '\0')
1629 {
1630 /* This is no valid number. */
1631 while (1)
1632 {
1633 ungetc (c, s);
1634 if (cmpp == decimal)
1635 break;
1636 c = (unsigned char) *--cmpp;
1637 }
1638
1639 conv_error ();
1640 }
1641 if (width > 0)
1642 width = avail;
1643 #endif
1644 }
1645 if (width > 0)
1646 --width;
1647 }
1648 else
1649 negative = 0;
1650
1651 /* Take care for the special arguments "nan" and "inf". */
1652 if (TOLOWER (c) == L_('n'))
1653 {
1654 /* Maybe "nan". */
1655 ADDW (c);
1656 if (width == 0 || inchar () == EOF || TOLOWER (c) != L_('a'))
1657 input_error ();
1658 if (width > 0)
1659 --width;
1660 ADDW (c);
1661 if (width == 0 || inchar () == EOF || TOLOWER (c) != L_('n'))
1662 input_error ();
1663 if (width > 0)
1664 --width;
1665 ADDW (c);
1666 /* It is "nan". */
1667 goto scan_float;
1668 }
1669 else if (TOLOWER (c) == L_('i'))
1670 {
1671 /* Maybe "inf" or "infinity". */
1672 ADDW (c);
1673 if (width == 0 || inchar () == EOF || TOLOWER (c) != L_('n'))
1674 input_error ();
1675 if (width > 0)
1676 --width;
1677 ADDW (c);
1678 if (width == 0 || inchar () == EOF || TOLOWER (c) != L_('f'))
1679 input_error ();
1680 if (width > 0)
1681 --width;
1682 ADDW (c);
1683 /* It is as least "inf". */
1684 if (width != 0 && inchar () != EOF)
1685 {
1686 if (TOLOWER (c) == L_('i'))
1687 {
1688 if (width > 0)
1689 --width;
1690 /* Now we have to read the rest as well. */
1691 ADDW (c);
1692 if (width == 0 || inchar () == EOF
1693 || TOLOWER (c) != L_('n'))
1694 input_error ();
1695 if (width > 0)
1696 --width;
1697 ADDW (c);
1698 if (width == 0 || inchar () == EOF
1699 || TOLOWER (c) != L_('i'))
1700 input_error ();
1701 if (width > 0)
1702 --width;
1703 ADDW (c);
1704 if (width == 0 || inchar () == EOF
1705 || TOLOWER (c) != L_('t'))
1706 input_error ();
1707 if (width > 0)
1708 --width;
1709 ADDW (c);
1710 if (width == 0 || inchar () == EOF
1711 || TOLOWER (c) != L_('y'))
1712 input_error ();
1713 if (width > 0)
1714 --width;
1715 ADDW (c);
1716 }
1717 else
1718 /* Never mind. */
1719 ungetc (c, s);
1720 }
1721 goto scan_float;
1722 }
1723
1724 is_hexa = 0;
1725 exp_char = L_('e');
1726 if (width != 0 && c == L_('0'))
1727 {
1728 ADDW (c);
1729 c = inchar ();
1730 if (width > 0)
1731 --width;
1732 if (width != 0 && TOLOWER (c) == L_('x'))
1733 {
1734 /* It is a number in hexadecimal format. */
1735 ADDW (c);
1736
1737 is_hexa = 1;
1738 exp_char = L_('p');
1739
1740 /* Grouping is not allowed. */
1741 flags &= ~GROUP;
1742 c = inchar ();
1743 if (width > 0)
1744 --width;
1745 }
1746 }
1747
1748 got_dot = got_e = 0;
1749 do
1750 {
1751 if (ISDIGIT (c))
1752 ADDW (c);
1753 else if (!got_e && is_hexa && ISXDIGIT (c))
1754 ADDW (c);
1755 else if (got_e && wp[wpsize - 1] == exp_char
1756 && (c == L_('-') || c == L_('+')))
1757 ADDW (c);
1758 else if (wpsize > 0 && !got_e && TOLOWER (c) == exp_char)
1759 {
1760 ADDW (exp_char);
1761 got_e = got_dot = 1;
1762 }
1763 else
1764 {
1765 #ifdef COMPILE_WSCANF
1766 if (! got_dot && c == decimal)
1767 {
1768 ADDW (c);
1769 got_dot = 1;
1770 }
1771 else if (thousands != L'\0' && ! got_dot && c == thousands)
1772 ADDW (c);
1773 else
1774 {
1775 /* The last read character is not part of the number
1776 anymore. */
1777 ungetc (c, s);
1778 break;
1779 }
1780 #else
1781 const char *cmpp = decimal;
1782 int avail = width > 0 ? width : INT_MAX;
1783
1784 if (! got_dot)
1785 {
1786 while ((unsigned char) *cmpp == c && avail > 0)
1787 if (*++cmpp == '\0')
1788 break;
1789 else
1790 {
1791 if (inchar () == EOF)
1792 break;
1793 --avail;
1794 }
1795 }
1796
1797 if (*cmpp == '\0')
1798 {
1799 /* Add all the characters. */
1800 for (cmpp = decimal; *cmpp != '\0'; ++cmpp)
1801 ADDW ((unsigned char) *cmpp);
1802 if (width > 0)
1803 width = avail;
1804 got_dot = 1;
1805 }
1806 else
1807 {
1808 /* Figure out whether it is a thousands separator.
1809 There is one problem: we possibly read more than
1810 one character. We cannot push them back but since
1811 we know that parts of the `decimal' string matched,
1812 we can compare against it. */
1813 const char *cmp2p = thousands;
1814
1815 if (thousands != NULL && ! got_dot)
1816 {
1817 while (cmp2p < cmpp
1818 && *cmp2p == decimal[cmp2p - thousands])
1819 ++cmp2p;
1820 if (cmp2p == cmpp)
1821 {
1822 while ((unsigned char) *cmp2p == c && avail > 0)
1823 if (*++cmp2p == '\0')
1824 break;
1825 else
1826 {
1827 if (inchar () == EOF)
1828 break;
1829 --avail;
1830 }
1831 }
1832 }
1833
1834 if (cmp2p != NULL && *cmp2p == '\0')
1835 {
1836 /* Add all the characters. */
1837 for (cmpp = thousands; *cmpp != '\0'; ++cmpp)
1838 ADDW ((unsigned char) *cmpp);
1839 if (width > 0)
1840 width = avail;
1841 }
1842 else
1843 {
1844 /* The last read character is not part of the number
1845 anymore. */
1846 ungetc (c, s);
1847 break;
1848 }
1849 }
1850 #endif
1851 }
1852 if (width > 0)
1853 --width;
1854 }
1855 while (width != 0 && inchar () != EOF);
1856
1857 /* Have we read any character? If we try to read a number
1858 in hexadecimal notation and we have read only the `0x'
1859 prefix or no exponent this is an error. */
1860 if (wpsize == 0 || (is_hexa && (wpsize == 2 || ! got_e)))
1861 conv_error ();
1862
1863 scan_float:
1864 /* Convert the number. */
1865 ADDW (L_('\0'));
1866 if (flags & LONGDBL)
1867 {
1868 long double d = __strtold_internal (wp, &tw, flags & GROUP);
1869 if (!(flags & SUPPRESS) && tw != wp)
1870 *ARG (long double *) = negative ? -d : d;
1871 }
1872 else if (flags & LONG)
1873 {
1874 double d = __strtod_internal (wp, &tw, flags & GROUP);
1875 if (!(flags & SUPPRESS) && tw != wp)
1876 *ARG (double *) = negative ? -d : d;
1877 }
1878 else
1879 {
1880 float d = __strtof_internal (wp, &tw, flags & GROUP);
1881 if (!(flags & SUPPRESS) && tw != wp)
1882 *ARG (float *) = negative ? -d : d;
1883 }
1884
1885 if (tw == wp)
1886 conv_error ();
1887
1888 if (!(flags & SUPPRESS))
1889 ++done;
1890 break;
1891
1892 case L_('['): /* Character class. */
1893 if (flags & LONG)
1894 STRING_ARG (wstr, wchar_t);
1895 else
1896 STRING_ARG (str, char);
1897
1898 if (*f == L_('^'))
1899 {
1900 ++f;
1901 not_in = 1;
1902 }
1903 else
1904 not_in = 0;
1905
1906 if (width < 0)
1907 /* There is no width given so there is also no limit on the
1908 number of characters we read. Therefore we set width to
1909 a very high value to make the algorithm easier. */
1910 width = INT_MAX;
1911
1912 #ifdef COMPILE_WSCANF
1913 /* Find the beginning and the end of the scanlist. We are not
1914 creating a lookup table since it would have to be too large.
1915 Instead we search each time through the string. This is not
1916 a constant lookup time but who uses this feature deserves to
1917 be punished. */
1918 tw = (wchar_t *) f; /* Marks the beginning. */
1919
1920 if (*f == L']')
1921 ++f;
1922
1923 while ((fc = *f++) != L'\0' && fc != L']');
1924
1925 if (fc == L'\0')
1926 conv_error ();
1927 wp = (wchar_t *) f - 1;
1928 #else
1929 /* Fill WP with byte flags indexed by character.
1930 We will use this flag map for matching input characters. */
1931 if (wpmax < UCHAR_MAX + 1)
1932 {
1933 wpmax = UCHAR_MAX + 1;
1934 wp = (char *) alloca (wpmax);
1935 }
1936 memset (wp, '\0', UCHAR_MAX + 1);
1937
1938 fc = *f;
1939 if (fc == ']' || fc == '-')
1940 {
1941 /* If ] or - appears before any char in the set, it is not
1942 the terminator or separator, but the first char in the
1943 set. */
1944 wp[fc] = 1;
1945 ++f;
1946 }
1947
1948 while ((fc = *f++) != '\0' && fc != ']')
1949 if (fc == '-' && *f != '\0' && *f != ']'
1950 && (unsigned char) f[-2] <= (unsigned char) *f)
1951 {
1952 /* Add all characters from the one before the '-'
1953 up to (but not including) the next format char. */
1954 for (fc = (unsigned char) f[-2]; fc < (unsigned char) *f; ++fc)
1955 wp[fc] = 1;
1956 }
1957 else
1958 /* Add the character to the flag map. */
1959 wp[fc] = 1;
1960
1961 if (fc == '\0')
1962 conv_error();
1963 #endif
1964
1965 if (flags & LONG)
1966 {
1967 size_t now = read_in;
1968 #ifdef COMPILE_WSCANF
1969 if (inchar () == WEOF)
1970 input_error ();
1971
1972 do
1973 {
1974 wchar_t *runp;
1975
1976 /* Test whether it's in the scanlist. */
1977 runp = tw;
1978 while (runp < wp)
1979 {
1980 if (runp[0] == L'-' && runp[1] != '\0' && runp + 1 != wp
1981 && runp != tw
1982 && (unsigned int) runp[-1] <= (unsigned int) runp[1])
1983 {
1984 /* Match against all characters in between the
1985 first and last character of the sequence. */
1986 wchar_t wc;
1987
1988 for (wc = runp[-1] + 1; wc <= runp[1]; ++wc)
1989 if (wc == c)
1990 break;
1991
1992 if (wc <= runp[1] && !not_in)
1993 break;
1994 if (wc <= runp[1] && not_in)
1995 {
1996 /* The current character is not in the
1997 scanset. */
1998 ungetwc (c, s);
1999 goto out;
2000 }
2001
2002 runp += 2;
2003 }
2004 else
2005 {
2006 if (*runp == c && !not_in)
2007 break;
2008 if (*runp == c && not_in)
2009 {
2010 ungetwc (c, s);
2011 goto out;
2012 }
2013
2014 ++runp;
2015 }
2016 }
2017
2018 if (runp == wp && !not_in)
2019 {
2020 ungetwc (c, s);
2021 goto out;
2022 }
2023
2024 if (!(flags & SUPPRESS))
2025 {
2026 *wstr++ = c;
2027
2028 if ((flags & MALLOC)
2029 && wstr == (wchar_t *) *strptr + strsize)
2030 {
2031 /* Enlarge the buffer. */
2032 wstr = (wchar_t *) realloc (*strptr,
2033 (2 * strsize)
2034 * sizeof (wchar_t));
2035 if (wstr == NULL)
2036 {
2037 /* Can't allocate that much. Last-ditch
2038 effort. */
2039 wstr = (wchar_t *)
2040 realloc (*strptr, (strsize + 1)
2041 * sizeof (wchar_t));
2042 if (wstr == NULL)
2043 {
2044 /* We lose. Oh well. Terminate the string
2045 and stop converting, so at least we don't
2046 skip any input. */
2047 ((wchar_t *) (*strptr))[strsize - 1] = L'\0';
2048 ++done;
2049 conv_error ();
2050 }
2051 else
2052 {
2053 *strptr = (char *) wstr;
2054 wstr += strsize;
2055 ++strsize;
2056 }
2057 }
2058 else
2059 {
2060 *strptr = (char *) wstr;
2061 wstr += strsize;
2062 strsize *= 2;
2063 }
2064 }
2065 }
2066 }
2067 while (--width > 0 && inchar () != WEOF);
2068 out:
2069 #else
2070 char buf[MB_LEN_MAX];
2071 size_t cnt = 0;
2072 mbstate_t cstate;
2073
2074 if (inchar () == EOF)
2075 input_error ();
2076
2077 memset (&cstate, '\0', sizeof (cstate));
2078
2079 do
2080 {
2081 if (wp[c] == not_in)
2082 {
2083 ungetc_not_eof (c, s);
2084 break;
2085 }
2086
2087 /* This is easy. */
2088 if (!(flags & SUPPRESS))
2089 {
2090 size_t n;
2091
2092 /* Convert it into a wide character. */
2093 buf[0] = c;
2094 n = __mbrtowc (wstr, buf, 1, &cstate);
2095
2096 if (n == (size_t) -2)
2097 {
2098 /* Possibly correct character, just not enough
2099 input. */
2100 ++cnt;
2101 assert (cnt < MB_CUR_MAX);
2102 continue;
2103 }
2104
2105 ++wstr;
2106 if ((flags & MALLOC)
2107 && wstr == (wchar_t *) *strptr + strsize)
2108 {
2109 /* Enlarge the buffer. */
2110 wstr = (wchar_t *) realloc (*strptr,
2111 (2 * strsize
2112 * sizeof (wchar_t)));
2113 if (wstr == NULL)
2114 {
2115 /* Can't allocate that much. Last-ditch
2116 effort. */
2117 wstr = (wchar_t *)
2118 realloc (*strptr, ((strsize + 1)
2119 * sizeof (wchar_t)));
2120 if (wstr == NULL)
2121 {
2122 /* We lose. Oh well. Terminate the
2123 string and stop converting,
2124 so at least we don't skip any input. */
2125 ((wchar_t *) (*strptr))[strsize - 1] = L'\0';
2126 ++done;
2127 conv_error ();
2128 }
2129 else
2130 {
2131 *strptr = (char *) wstr;
2132 wstr += strsize;
2133 ++strsize;
2134 }
2135 }
2136 else
2137 {
2138 *strptr = (char *) wstr;
2139 wstr += strsize;
2140 strsize *= 2;
2141 }
2142 }
2143 }
2144
2145 if (--width <= 0)
2146 break;
2147 }
2148 while (inchar () != EOF);
2149
2150 if (cnt != 0)
2151 /* We stopped in the middle of recognizing another
2152 character. That's a problem. */
2153 encode_error ();
2154 #endif
2155
2156 if (now == read_in)
2157 /* We haven't succesfully read any character. */
2158 conv_error ();
2159
2160 if (!(flags & SUPPRESS))
2161 {
2162 *wstr++ = L'\0';
2163
2164 if ((flags & MALLOC)
2165 && wstr - (wchar_t *) *strptr != strsize)
2166 {
2167 wchar_t *cp = (wchar_t *)
2168 realloc (*strptr, ((wstr - (wchar_t *) *strptr)
2169 * sizeof(wchar_t)));
2170 if (cp != NULL)
2171 *strptr = (char *) cp;
2172 }
2173
2174 ++done;
2175 }
2176 }
2177 else
2178 {
2179 size_t now = read_in;
2180
2181 if (inchar () == EOF)
2182 input_error ();
2183
2184 #ifdef COMPILE_WSCANF
2185
2186 memset (&state, '\0', sizeof (state));
2187
2188 do
2189 {
2190 wchar_t *runp;
2191 size_t n;
2192
2193 /* Test whether it's in the scanlist. */
2194 runp = tw;
2195 while (runp < wp)
2196 {
2197 if (runp[0] == L'-' && runp[1] != '\0' && runp + 1 != wp
2198 && runp != tw
2199 && (unsigned int) runp[-1] <= (unsigned int) runp[1])
2200 {
2201 /* Match against all characters in between the
2202 first and last character of the sequence. */
2203 wchar_t wc;
2204
2205 for (wc = runp[-1] + 1; wc <= runp[1]; ++wc)
2206 if (wc == c)
2207 break;
2208
2209 if (wc <= runp[1] && !not_in)
2210 break;
2211 if (wc <= runp[1] && not_in)
2212 {
2213 /* The current character is not in the
2214 scanset. */
2215 ungetwc (c, s);
2216 goto out2;
2217 }
2218
2219 runp += 2;
2220 }
2221 else
2222 {
2223 if (*runp == c && !not_in)
2224 break;
2225 if (*runp == c && not_in)
2226 {
2227 ungetwc (c, s);
2228 goto out2;
2229 }
2230
2231 ++runp;
2232 }
2233 }
2234
2235 if (runp == wp && !not_in)
2236 {
2237 ungetwc (c, s);
2238 goto out2;
2239 }
2240
2241 if (!(flags & SUPPRESS))
2242 {
2243 if ((flags & MALLOC)
2244 && str + MB_CUR_MAX >= *strptr + strsize)
2245 {
2246 /* Enlarge the buffer. */
2247 size_t strleng = str - *strptr;
2248 char *newstr;
2249
2250 newstr = (char *) realloc (*strptr, 2 * strsize);
2251 if (newstr == NULL)
2252 {
2253 /* Can't allocate that much. Last-ditch
2254 effort. */
2255 newstr = (char *) realloc (*strptr,
2256 strleng + MB_CUR_MAX);
2257 if (newstr == NULL)
2258 {
2259 /* We lose. Oh well. Terminate the string
2260 and stop converting, so at least we don't
2261 skip any input. */
2262 ((char *) (*strptr))[strleng] = '\0';
2263 ++done;
2264 conv_error ();
2265 }
2266 else
2267 {
2268 *strptr = newstr;
2269 str = newstr + strleng;
2270 strsize = strleng + MB_CUR_MAX;
2271 }
2272 }
2273 else
2274 {
2275 *strptr = newstr;
2276 str = newstr + strleng;
2277 strsize *= 2;
2278 }
2279 }
2280 }
2281
2282 n = __wcrtomb (!(flags & SUPPRESS) ? str : NULL, c, &state);
2283 if (n == (size_t) -1)
2284 encode_error ();
2285
2286 assert (n <= MB_CUR_MAX);
2287 str += n;
2288 }
2289 while (--width > 0 && inchar () != WEOF);
2290 out2:
2291 #else
2292 do
2293 {
2294 if (wp[c] == not_in)
2295 {
2296 ungetc_not_eof (c, s);
2297 break;
2298 }
2299
2300 /* This is easy. */
2301 if (!(flags & SUPPRESS))
2302 {
2303 *str++ = c;
2304 if ((flags & MALLOC)
2305 && (char *) str == *strptr + strsize)
2306 {
2307 /* Enlarge the buffer. */
2308 str = (char *) realloc (*strptr, 2 * strsize);
2309 if (str == NULL)
2310 {
2311 /* Can't allocate that much. Last-ditch
2312 effort. */
2313 str = (char *) realloc (*strptr, strsize + 1);
2314 if (str == NULL)
2315 {
2316 /* We lose. Oh well. Terminate the
2317 string and stop converting,
2318 so at least we don't skip any input. */
2319 ((char *) (*strptr))[strsize - 1] = '\0';
2320 ++done;
2321 conv_error ();
2322 }
2323 else
2324 {
2325 *strptr = (char *) str;
2326 str += strsize;
2327 ++strsize;
2328 }
2329 }
2330 else
2331 {
2332 *strptr = (char *) str;
2333 str += strsize;
2334 strsize *= 2;
2335 }
2336 }
2337 }
2338 }
2339 while (--width > 0 && inchar () != EOF);
2340 #endif
2341
2342 if (now == read_in)
2343 /* We haven't succesfully read any character. */
2344 conv_error ();
2345
2346 if (!(flags & SUPPRESS))
2347 {
2348 #ifdef COMPILE_WSCANF
2349 /* We have to emit the code to get into the initial
2350 state. */
2351 char buf[MB_LEN_MAX];
2352 size_t n = __wcrtomb (buf, L'\0', &state);
2353 if (n > 0 && (flags & MALLOC)
2354 && str + n >= *strptr + strsize)
2355 {
2356 /* Enlarge the buffer. */
2357 size_t strleng = str - *strptr;
2358 char *newstr;
2359
2360 newstr = (char *) realloc (*strptr, strleng + n + 1);
2361 if (newstr == NULL)
2362 {
2363 /* We lose. Oh well. Terminate the string
2364 and stop converting, so at least we don't
2365 skip any input. */
2366 ((char *) (*strptr))[strleng] = '\0';
2367 ++done;
2368 conv_error ();
2369 }
2370 else
2371 {
2372 *strptr = newstr;
2373 str = newstr + strleng;
2374 strsize = strleng + n + 1;
2375 }
2376 }
2377
2378 str = __mempcpy (str, buf, n);
2379 #endif
2380 *str++ = '\0';
2381
2382 if ((flags & MALLOC) && str - *strptr != strsize)
2383 {
2384 char *cp = (char *) realloc (*strptr, str - *strptr);
2385 if (cp != NULL)
2386 *strptr = cp;
2387 }
2388
2389 ++done;
2390 }
2391 }
2392 break;
2393
2394 case L_('p'): /* Generic pointer. */
2395 base = 16;
2396 /* A PTR must be the same size as a `long int'. */
2397 flags &= ~(SHORT|LONGDBL);
2398 if (need_long)
2399 flags |= LONG;
2400 number_signed = 0;
2401 read_pointer = 1;
2402 goto number;
2403
2404 default:
2405 /* If this is an unknown format character punt. */
2406 conv_error ();
2407 }
2408 }
2409
2410 /* The last thing we saw int the format string was a white space.
2411 Consume the last white spaces. */
2412 if (skip_space)
2413 {
2414 do
2415 c = inchar ();
2416 while (ISSPACE (c));
2417 ungetc (c, s);
2418 }
2419
2420 /* Unlock stream. */
2421 UNLOCK_STREAM (s);
2422
2423 return done;
2424 }
2425
2426 #ifdef USE_IN_LIBIO
2427 # ifdef COMPILE_WSCANF
2428 int
2429 __vfwscanf (FILE *s, const wchar_t *format, va_list argptr)
2430 {
2431 return _IO_vfwscanf (s, format, argptr, NULL);
2432 }
2433 # else
2434 int
2435 __vfscanf (FILE *s, const char *format, va_list argptr)
2436 {
2437 return _IO_vfscanf (s, format, argptr, NULL);
2438 }
2439 # endif
2440 #endif
2441
2442 #ifdef COMPILE_WSCANF
2443 weak_alias (__vfwscanf, vfwscanf)
2444 #else
2445 weak_alias (__vfscanf, vfscanf)
2446 #endif
sources.redhat.com git mirror of glibc CVS