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