?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libc: fix MIPS N64 fork
[uclibc-ng.git] / libc / stdio / _scanf.c
blob6ecb3cb1e02cd96df83ac51ff2f2fe42faf52b7e
1 /* Copyright (C) 2002-2004 Manuel Novoa III
2 *
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Library General Public
5 * License as published by the Free Software Foundation; either
6 * version 2 of the License, or (at your option) any later version.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Library General Public License for more details.
12 *
13 * You should have received a copy of the GNU Library General Public
14 * License along with this library; if not, see
15 * <http://www.gnu.org/licenses/>.
16 */
17
18 /* Aug 1, 2003
19 * New *scanf implementation with lots of bug fixes and *wscanf support.
20 * Also now optionally supports hexadecimal float notation, positional
21 * args, and glibc locale-specific digit grouping. Should now be
22 * standards compliant.
23 *
24 * Aug 18, 2003
25 * Bug fix: scanf %lc,%ls,%l[ would always set mb_fail on eof or error,
26 * even when just starting a new mb char.
27 * Bug fix: wscanf would incorrectly unget in certain situations.
28 *
29 * Sep 5, 2003
30 * Bug fix: store flag wasn't respected if no positional args.
31 * Implement vs{n}scanf for the non-buffered stdio no-wchar case.
32 *
33 * Sep 13, 2003
34 * Bug fix: Fix a problem reported by Atsushi Nemoto <anemo@mba.ocn.ne.jp>
35 * for environments where long and long long are the same.
36 *
37 * Sep 21, 2003
38 * Ugh... EOF handling by scanf was completely broken. :-( Regretably,
39 * I got my mind fixed in one mode and didn't comply with the standards.
40 * Things should be fixed now, but comparision testing is difficult when
41 * glibc's scanf is broken and they stubbornly refuse to even acknowledge
42 * that it is... even when confronted by specific examples from the C99
43 * standards and from an official C standard defect report.
44 */
45
46 #include <features.h>
47 #include "_stdio.h"
48 #include <stdlib.h>
49 #include <unistd.h>
50 #include <ctype.h>
51 #include <string.h>
52 #include <stdarg.h>
53 #include <stdint.h>
54 #include <errno.h>
55 #include <printf.h>
56
57 #ifdef __UCLIBC_HAS_WCHAR__
58 #include <bits/uClibc_uwchar.h>
59 #include <wchar.h>
60 #include <wctype.h>
61 #endif /* __UCLIBC_HAS_WCHAR__ */
62
63 #include <langinfo.h>
64 #include <locale.h>
65
66 #include <assert.h>
67 #include <limits.h>
68
69 #ifdef __UCLIBC_HAS_THREADS__
70 #include <stdio_ext.h>
71 #include <pthread.h>
72 #endif /* __UCLIBC_HAS_THREADS__ */
73
74 #ifdef __UCLIBC_HAS_FLOATS__
75 #include <float.h>
76 #include <bits/uClibc_fpmax.h>
77 #endif /* __UCLIBC_HAS_FLOATS__ */
78
79 #undef __STDIO_HAS_VSSCANF
80 #if defined(__STDIO_BUFFERS) || !defined(__UCLIBC_HAS_WCHAR__) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__)
81 #define __STDIO_HAS_VSSCANF 1
82
83 #if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__)
84 typedef struct {
85 FILE f;
86 unsigned char *bufread; /* pointer to 1 past end of buffer */
87 unsigned char *bufpos;
88 } __FILE_vsscanf;
89 #endif
90
91 #endif
92
93 #if defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX)
94
95 extern unsigned long long
96 _stdlib_strto_ll(register const char * __restrict str,
97 char ** __restrict endptr, int base, int sflag);
98 #if (ULLONG_MAX == UINTMAX_MAX)
99 #define STRTOUIM(s,e,b,sf) _stdlib_strto_ll(s,e,b,sf)
100 #endif
101
102 #else /* defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX) */
103
104 extern unsigned long
105 _stdlib_strto_l(register const char * __restrict str,
106 char ** __restrict endptr, int base, int sflag);
107
108 #if (ULONG_MAX == UINTMAX_MAX)
109 #define STRTOUIM(s,e,b,sf) _stdlib_strto_l(s,e,b,sf)
110 #endif
111
112 #endif /* defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX) */
113
114 #ifndef STRTOUIM
115 #error STRTOUIM conversion function is undefined!
116 #endif
117
118 /**********************************************************************/
119
120 /* The standards require EOF < 0. */
121 #if EOF >= CHAR_MIN
122 #define __isdigit_char_or_EOF(C) __isdigit_char((C))
123 #else
124 #define __isdigit_char_or_EOF(C) __isdigit_int((C))
125 #endif
126
127 /**********************************************************************/
128 #ifdef L_fscanf
129
130 int fscanf(FILE * __restrict stream, const char * __restrict format, ...)
131 {
132 va_list arg;
133 int rv;
134
135 va_start(arg, format);
136 rv = vfscanf(stream, format, arg);
137 va_end(arg);
138
139 return rv;
140 }
141 libc_hidden_def(fscanf)
142
143 #endif
144 /**********************************************************************/
145 #ifdef L_scanf
146
147 int scanf(const char * __restrict format, ...)
148 {
149 va_list arg;
150 int rv;
151
152 va_start(arg, format);
153 rv = vfscanf(stdin, format, arg);
154 va_end(arg);
155
156 return rv;
157 }
158
159 #endif
160 /**********************************************************************/
161 #ifdef L_sscanf
162
163 #ifdef __STDIO_HAS_VSSCANF
164
165 int sscanf(const char * __restrict str, const char * __restrict format, ...)
166 {
167 va_list arg;
168 int rv;
169
170 va_start(arg, format);
171 rv = vsscanf(str, format, arg);
172 va_end(arg);
173
174 return rv;
175 }
176 libc_hidden_def(sscanf)
177
178 #else /* __STDIO_HAS_VSSCANF */
179 #warning Skipping sscanf since no vsscanf!
180 #endif /* __STDIO_HAS_VSSCANF */
181
182 #endif
183 /**********************************************************************/
184 #ifdef L_vscanf
185
186 int vscanf(const char * __restrict format, va_list arg)
187 {
188 return vfscanf(stdin, format, arg);
189 }
190
191 #endif
192 /**********************************************************************/
193 #ifdef L_vsscanf
194
195 #ifdef __UCLIBC_MJN3_ONLY__
196 #warning WISHLIST: Implement vsscanf for non-buf and no custom stream case.
197 #endif /* __UCLIBC_MJN3_ONLY__ */
198
199 #ifdef __STDIO_BUFFERS
200
201 int vsscanf(const char *sp, const char *fmt, va_list ap)
202 {
203 FILE f;
204
205 /* __STDIO_STREAM_RESET_GCS(&f); */
206 #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
207 f.__cookie = &(f.__filedes);
208 f.__gcs.read = NULL;
209 f.__gcs.write = NULL;
210 f.__gcs.seek = NULL;
211 f.__gcs.close = NULL;
212 #endif
213
214 f.__filedes = __STDIO_STREAM_FAKE_VSSCANF_FILEDES;
215 f.__modeflags = (__FLAG_NARROW|__FLAG_READONLY|__FLAG_READING);
216
217 #ifdef __UCLIBC_HAS_WCHAR__
218 f.__ungot_width[0] = 0;
219 #endif
220 #ifdef __STDIO_MBSTATE
221 __INIT_MBSTATE(&(f.__state));
222 #endif
223
224 #ifdef __UCLIBC_HAS_THREADS__
225 f.__user_locking = 1; /* Set user locking. */
226 STDIO_INIT_MUTEX(f.__lock);
227 #endif
228 f.__nextopen = NULL;
229
230 /* Set these last since __bufgetc initialization depends on
231 * __user_locking and only gets set if user locking is on. */
232 f.__bufstart =
233 f.__bufpos = (unsigned char *) ((void *) sp);
234 f.__bufread =
235 f.__bufend = f.__bufstart + strlen(sp);
236 __STDIO_STREAM_ENABLE_GETC(&f);
237 __STDIO_STREAM_DISABLE_PUTC(&f);
238
239 return vfscanf(&f, fmt, ap);
240 }
241 libc_hidden_def(vsscanf)
242
243 #elif !defined(__UCLIBC_HAS_WCHAR__)
244
245 int vsscanf(const char *sp, const char *fmt, va_list ap)
246 {
247 __FILE_vsscanf f;
248
249 f.bufpos = (unsigned char *) ((void *) sp);
250 f.bufread = f.bufpos + strlen(sp);
251
252 /* __STDIO_STREAM_RESET_GCS(&f.f); */
253 #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
254 f.f.__cookie = &(f.f.__filedes);
255 f.f.__gcs.read = NULL;
256 f.f.__gcs.write = NULL;
257 f.f.__gcs.seek = NULL;
258 f.f.__gcs.close = NULL;
259 #endif
260
261 f.f.__filedes = __STDIO_STREAM_FAKE_VSSCANF_FILEDES_NB;
262 f.f.__modeflags = (__FLAG_NARROW|__FLAG_READONLY|__FLAG_READING);
263
264 /* #ifdef __UCLIBC_HAS_WCHAR__ */
265 /* f.f.__ungot_width[0] = 0; */
266 /* #endif */
267 #ifdef __STDIO_MBSTATE
268 #error __STDIO_MBSTATE is defined!
269 /* __INIT_MBSTATE(&(f.f.__state)); */
270 #endif
271
272 #ifdef __UCLIBC_HAS_THREADS__
273 f.f.__user_locking = 1; /* Set user locking. */
274 STDIO_INIT_MUTEX(f.f.__lock);
275 #endif
276 f.f.__nextopen = NULL;
277
278 return vfscanf(&f.f, fmt, ap);
279 }
280 libc_hidden_def(vsscanf)
281
282 #elif defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__)
283
284 int vsscanf(const char *sp, const char *fmt, va_list ap)
285 {
286 FILE *f;
287 int rv = EOF;
288
289 if ((f = fmemopen((char *)sp, strlen(sp), "r")) != NULL) {
290 rv = vfscanf(f, fmt, ap);
291 fclose(f);
292 }
293
294 return rv;
295 }
296 libc_hidden_def(vsscanf)
297
298 #else
299 #warning Skipping vsscanf since no buffering, no custom streams, and wchar enabled!
300 #ifdef __STDIO_HAS_VSSCANF
301 #error WHOA! __STDIO_HAS_VSSCANF is defined!
302 #endif
303 #endif
304
305 #endif
306 /**********************************************************************/
307 #ifdef L_fwscanf
308
309 int fwscanf(FILE * __restrict stream, const wchar_t * __restrict format, ...)
310 {
311 va_list arg;
312 int rv;
313
314 va_start(arg, format);
315 rv = vfwscanf(stream, format, arg);
316 va_end(arg);
317
318 return rv;
319 }
320
321 #endif
322 /**********************************************************************/
323 #ifdef L_wscanf
324
325 int wscanf(const wchar_t * __restrict format, ...)
326 {
327 va_list arg;
328 int rv;
329
330 va_start(arg, format);
331 rv = vfwscanf(stdin, format, arg);
332 va_end(arg);
333
334 return rv;
335 }
336
337 #endif
338 /**********************************************************************/
339 #ifdef L_swscanf
340
341 #ifdef __STDIO_BUFFERS
342
343 int swscanf(const wchar_t * __restrict str, const wchar_t * __restrict format,
344 ...)
345 {
346 va_list arg;
347 int rv;
348
349 va_start(arg, format);
350 rv = vswscanf(str, format, arg);
351 va_end(arg);
352
353 return rv;
354 }
355 #else /* __STDIO_BUFFERS */
356 #warning Skipping swscanf since no buffering!
357 #endif /* __STDIO_BUFFERS */
358
359 #endif
360 /**********************************************************************/
361 #ifdef L_vwscanf
362
363 int vwscanf(const wchar_t * __restrict format, va_list arg)
364 {
365 return vfwscanf(stdin, format, arg);
366 }
367
368 #endif
369 /**********************************************************************/
370 #ifdef L_vswscanf
371
372 #ifdef __STDIO_BUFFERS
373
374 int vswscanf(const wchar_t * __restrict str, const wchar_t * __restrict format,
375 va_list arg)
376 {
377 FILE f;
378
379 f.__bufstart =
380 f.__bufpos = (unsigned char *) str;
381 f.__bufread =
382 f.__bufend = (unsigned char *)(str + wcslen(str));
383 __STDIO_STREAM_DISABLE_GETC(&f);
384 __STDIO_STREAM_DISABLE_PUTC(&f);
385
386 /* __STDIO_STREAM_RESET_GCS(&f); */
387 #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
388 f.__cookie = &(f.__filedes);
389 f.__gcs.read = NULL;
390 f.__gcs.write = NULL;
391 f.__gcs.seek = NULL;
392 f.__gcs.close = NULL;
393 #endif
394
395 f.__filedes = __STDIO_STREAM_FAKE_VSWSCANF_FILEDES;
396 f.__modeflags = (__FLAG_WIDE|__FLAG_READONLY|__FLAG_READING);
397
398 #ifdef __UCLIBC_HAS_WCHAR__
399 f.__ungot_width[0] = 0;
400 #endif /* __UCLIBC_HAS_WCHAR__ */
401 #ifdef __STDIO_MBSTATE
402 __INIT_MBSTATE(&(f.__state));
403 #endif /* __STDIO_MBSTATE */
404
405 #ifdef __UCLIBC_HAS_THREADS__
406 f.__user_locking = 1; /* Set user locking. */
407 STDIO_INIT_MUTEX(f.__lock);
408 #endif
409 f.__nextopen = NULL;
410
411 return vfwscanf(&f, format, arg);
412 }
413 libc_hidden_def(vswscanf)
414 #else /* __STDIO_BUFFERS */
415 #warning Skipping vswscanf since no buffering!
416 #endif /* __STDIO_BUFFERS */
417
418 #endif
419 /**********************************************************************/
420 /**********************************************************************/
421
422
423
424 /* float layout 0123456789012345678901 repeat n for "l[" */
425 #define SPEC_CHARS "npxXoudifFeEgGaACSnmcs["
426 /* npxXoudif eEgG CS cs[ */
427 /* NOTE: the 'm' flag must come before any convs that support it */
428
429 /* NOTE: Ordering is important! The CONV_{C,S,LEFTBRACKET} must map
430 simply to their lowercase equivalents. */
431
432 enum {
433 CONV_n = 0,
434 CONV_p,
435 CONV_x, CONV_X, CONV_o, CONV_u, CONV_d, CONV_i,
436 CONV_f, CONV_F, CONV_e, CONV_E, CONV_g, CONV_G, CONV_a, CONV_A,
437 CONV_C, CONV_S, CONV_LEFTBRACKET, CONV_m, CONV_c, CONV_s, CONV_leftbracket,
438 CONV_percent, CONV_whitespace /* not in SPEC_* and no flags */
439 };
440
441 #ifdef __UCLIBC_HAS_FLOATS__
442 #ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
443 /* p x X o u d i f F e E g G a A */
444 #define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
445 #else
446 /* p x X o u d i f F e E g G a A */
447 #define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10 }
448 #endif
449 #else /* __UCLIBC_HAS_FLOATS__ */
450 /* p x X o u d i f F e E g G a A */
451 #define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0 }
452 #endif /* __UCLIBC_HAS_FLOATS__ */
453
454 #ifdef __UCLIBC_MJN3_ONLY__
455 #ifdef L_vfscanf
456 /* emit once */
457 #warning CONSIDER: Add a '0' flag to eat 0 padding when grouping?
458 #endif
459 #endif /* __UCLIBC_MJN3_ONLY__ */
460
461 #define SPEC_FLAGS "*'I"
462
463 enum {
464 FLAG_SURPRESS = 0x10, /* MUST BE 1ST!! See DO_FLAGS. */
465 FLAG_THOUSANDS = 0x20,
466 FLAG_I18N = 0x40, /* only works for d, i, u */
467 FLAG_MALLOC = 0x80, /* only works for c, s, S, and [ (and l[)*/
468 };
469
470
471 #define SPEC_RANGES { CONV_n, CONV_p, CONV_i, CONV_A, \
472 CONV_C, CONV_LEFTBRACKET, \
473 CONV_c, CONV_leftbracket }
474
475 /* Note: We treat L and ll as synonymous... for ints and floats. */
476
477 #define SPEC_ALLOWED_FLAGS { \
478 /* n */ (0x0f|FLAG_SURPRESS), \
479 /* p */ ( 0|FLAG_SURPRESS), \
480 /* oxXudi */ (0x0f|FLAG_SURPRESS|FLAG_THOUSANDS|FLAG_I18N), \
481 /* fFeEgGaA */ (0x0c|FLAG_SURPRESS|FLAG_THOUSANDS|FLAG_I18N), \
482 /* C */ ( 0|FLAG_SURPRESS), \
483 /* S and l[ */ ( 0|FLAG_SURPRESS|FLAG_MALLOC), \
484 /* c */ (0x04|FLAG_SURPRESS|FLAG_MALLOC), \
485 /* s and [ */ (0x04|FLAG_SURPRESS|FLAG_MALLOC), \
486 }
487
488
489 /**********************************************************************/
490 /*
491 * In order to ease translation to what arginfo and _print_info._flags expect,
492 * we map: 0:int 1:char 2:longlong 4:long 8:short
493 * and then _flags |= (((q << 7) + q) & 0x701) and argtype |= (_flags & 0x701)
494 */
495
496 /* TODO -- Fix the table below to take into account stdint.h. */
497 /* #ifndef LLONG_MAX */
498 /* #error fix QUAL_CHARS for no long long! Affects 'L', 'j', 'q', 'll'. */
499 /* #else */
500 /* #if LLONG_MAX != INTMAX_MAX */
501 /* #error fix QUAL_CHARS intmax_t entry 'j'! */
502 /* #endif */
503 /* #endif */
504
505 #ifdef PDS
506 #error PDS already defined!
507 #endif
508 #ifdef SS
509 #error SS already defined!
510 #endif
511 #ifdef IMS
512 #error IMS already defined!
513 #endif
514
515 #if PTRDIFF_MAX == INT_MAX
516 #define PDS 0
517 #elif PTRDIFF_MAX == LONG_MAX
518 #define PDS 4
519 #elif defined(LLONG_MAX) && (PTRDIFF_MAX == LLONG_MAX)
520 #define PDS 8
521 #else
522 #error fix QUAL_CHARS ptrdiff_t entry 't'!
523 #endif
524
525 #if SIZE_MAX == UINT_MAX
526 #define SS 0
527 #elif SIZE_MAX == ULONG_MAX
528 #define SS 4
529 #elif defined(LLONG_MAX) && (SIZE_MAX == ULLONG_MAX)
530 #define SS 8
531 #else
532 #error fix QUAL_CHARS size_t entries 'z', 'Z'!
533 #endif
534
535 #if INTMAX_MAX == INT_MAX
536 #define IMS 0
537 #elif INTMAX_MAX == LONG_MAX
538 #define IMS 4
539 #elif defined(LLONG_MAX) && (INTMAX_MAX == LLONG_MAX)
540 #define IMS 8
541 #else
542 #error fix QUAL_CHARS intmax_t entry 'j'!
543 #endif
544
545 #define QUAL_CHARS { \
546 /* j:(u)intmax_t z:(s)size_t t:ptrdiff_t \0:int q:long_long */ \
547 'h', 'l', 'L', 'j', 'z', 't', 'q', 0, \
548 2, 4, 8, IMS, SS, PDS, 8, 0, /* TODO -- fix!!! */ \
549 1, 8 \
550 }
551
552
553 /**********************************************************************/
554
555 #ifdef L_vfwscanf
556 /* FIXME: "warning: the right operand of ">" changes sign when promoted" */
557 #if WINT_MIN > EOF
558 #error Unfortunately, we currently need wint_t to be able to store EOF. Sorry.
559 #endif
560 #define W_EOF WEOF
561 #define Wint wint_t
562 #define Wchar wchar_t
563 #define Wuchar __uwchar_t
564 #define ISSPACE(C) iswspace((C))
565 #define VFSCANF vfwscanf
566 #define GETC(SC) (SC)->sc_getc((SC))
567 #else
568 typedef unsigned char __uchar_t;
569 #define W_EOF EOF
570 #define Wint int
571 #define Wchar char
572 #define Wuchar __uchar_t
573 #define ISSPACE(C) isspace((C))
574 #define VFSCANF vfscanf
575 #ifdef __UCLIBC_HAS_WCHAR__
576 #define GETC(SC) (SC)->sc_getc((SC))
577 #else /* __UCLIBC_HAS_WCHAR__ */
578 #define GETC(SC) getc_unlocked((SC)->fp)
579 #endif /* __UCLIBC_HAS_WCHAR__ */
580 #endif
581
582 struct scan_cookie {
583 Wint cc;
584 Wint ungot_char;
585 FILE *fp;
586 int nread;
587 int width;
588
589 #ifdef __UCLIBC_HAS_WCHAR__
590 wchar_t app_ungot; /* Match FILE struct member type. */
591 unsigned char ungot_wchar_width;
592 #else /* __UCLIBC_HAS_WCHAR__ */
593 unsigned char app_ungot; /* Match FILE struct member type. */
594 #endif /* __UCLIBC_HAS_WCHAR__ */
595
596 char ungot_flag;
597
598 #ifdef __UCLIBC_HAS_WCHAR__
599 char ungot_wflag; /* vfwscanf */
600 char mb_fail; /* vfscanf */
601 mbstate_t mbstate; /* vfscanf */
602 wint_t wc;
603 wint_t ungot_wchar; /* to support __scan_getc */
604 int (*sc_getc)(struct scan_cookie *);
605 #endif /* __UCLIBC_HAS_WCHAR__ */
606
607 #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
608 const char *grouping;
609 const unsigned char *thousands_sep;
610 int tslen;
611 #ifdef __UCLIBC_HAS_WCHAR__
612 wchar_t thousands_sep_wc;
613 #endif /* __UCLIBC_HAS_WCHAR__ */
614 #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
615
616 #ifdef __UCLIBC_HAS_FLOATS__
617 const unsigned char *decpt;
618 int decpt_len;
619 #ifdef __UCLIBC_HAS_WCHAR__
620 wchar_t decpt_wc;
621 #endif /* __UCLIBC_HAS_WCHAR__ */
622 const unsigned char *fake_decpt;
623 #endif /* __UCLIBC_HAS_FLOATS__ */
624
625 };
626
627 typedef struct {
628 #if defined(NL_ARGMAX) && (NL_ARGMAX > 0)
629 #if NL_ARGMAX > 10
630 #warning NL_ARGMAX > 10, and space is allocated on the stack for positional args.
631 #endif
632 void *pos_args[NL_ARGMAX];
633 int num_pos_args; /* Must start at -1. */
634 int cur_pos_arg;
635 #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */
636 void *cur_ptr;
637 const unsigned char *fmt;
638 int cnt, dataargtype, conv_num, max_width;
639 unsigned char store, flags;
640 } psfs_t; /* parse scanf format state */
641
642
643 /**********************************************************************/
644 /**********************************************************************/
645
646 extern void __init_scan_cookie(register struct scan_cookie *sc,
647 register FILE *fp) attribute_hidden;
648 extern int __scan_getc(register struct scan_cookie *sc) attribute_hidden;
649 extern void __scan_ungetc(register struct scan_cookie *sc) attribute_hidden;
650
651 #ifdef __UCLIBC_HAS_FLOATS__
652 extern int __scan_strtold(long double *ld, struct scan_cookie *sc);
653 #endif /* __UCLIBC_HAS_FLOATS__ */
654
655 extern int __psfs_parse_spec(psfs_t *psfs) attribute_hidden;
656 extern int __psfs_do_numeric(psfs_t *psfs, struct scan_cookie *sc) attribute_hidden;
657
658 /**********************************************************************/
659 #ifdef L___scan_cookie
660
661 #ifdef __UCLIBC_MJN3_ONLY__
662 #warning TODO: Remove dependence on decpt_str and fake_decpt in stub locale mode.
663 #endif
664 #ifndef __UCLIBC_HAS_LOCALE__
665 static const char decpt_str[] = ".";
666 #endif
667
668 void attribute_hidden __init_scan_cookie(register struct scan_cookie *sc,
669 register FILE *fp)
670 {
671 sc->fp = fp;
672 sc->nread = 0;
673 sc->ungot_flag = 0;
674 sc->app_ungot = ((fp->__modeflags & __FLAG_UNGOT) ? fp->__ungot[1] : 0);
675 #ifdef __UCLIBC_HAS_WCHAR__
676 sc->ungot_wflag = 0; /* vfwscanf */
677 sc->mb_fail = 0;
678 #endif /* __UCLIBC_HAS_WCHAR__ */
679
680 #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
681 if (*(sc->grouping = __UCLIBC_CURLOCALE->grouping)) {
682 sc->thousands_sep = (const unsigned char *) __UCLIBC_CURLOCALE->thousands_sep;
683 sc->tslen = __UCLIBC_CURLOCALE->thousands_sep_len;
684 #ifdef __UCLIBC_HAS_WCHAR__
685 sc->thousands_sep_wc = __UCLIBC_CURLOCALE->thousands_sep_wc;
686 #endif /* __UCLIBC_HAS_WCHAR__ */
687 }
688 #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
689
690 #ifdef __UCLIBC_HAS_FLOATS__
691 #ifdef __UCLIBC_HAS_LOCALE__
692 sc->decpt = (const unsigned char *) __UCLIBC_CURLOCALE->decimal_point;
693 sc->decpt_len = __UCLIBC_CURLOCALE->decimal_point_len;
694 #else /* __UCLIBC_HAS_LOCALE__ */
695 sc->fake_decpt = sc->decpt = (unsigned char *) decpt_str;
696 sc->decpt_len = 1;
697 #endif /* __UCLIBC_HAS_LOCALE__ */
698 #ifdef __UCLIBC_HAS_WCHAR__
699 #ifdef __UCLIBC_HAS_LOCALE__
700 sc->decpt_wc = __UCLIBC_CURLOCALE->decimal_point_wc;
701 #else
702 sc->decpt_wc = '.';
703 #endif
704 #endif /* __UCLIBC_HAS_WCHAR__ */
705 #endif /* __UCLIBC_HAS_FLOATS__ */
706
707 }
708
709 int attribute_hidden __scan_getc(register struct scan_cookie *sc)
710 {
711 int c;
712
713 #ifdef __UCLIBC_HAS_WCHAR__
714 assert(!sc->mb_fail);
715 #endif /* __UCLIBC_HAS_WCHAR__ */
716
717 sc->cc = EOF;
718
719 if (--sc->width < 0) {
720 sc->ungot_flag |= 2;
721 return -1;
722 }
723
724 if (sc->ungot_flag == 0) {
725 #if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__)
726 if (!__STDIO_STREAM_IS_FAKE_VSSCANF_NB(sc->fp)) {
727 c = GETC(sc);
728 } else {
729 __FILE_vsscanf *fv = (__FILE_vsscanf *)(sc->fp);
730 if (fv->bufpos < fv->bufread) {
731 c = *fv->bufpos++;
732 } else {
733 c = EOF;
734 sc->fp->__modeflags |= __FLAG_EOF;
735 }
736 }
737 if (c == EOF) {
738 sc->ungot_flag |= 2;
739 return -1;
740 }
741 #else
742 if ((c = GETC(sc)) == EOF) {
743 sc->ungot_flag |= 2;
744 return -1;
745 }
746 #endif
747 sc->ungot_char = c;
748 } else {
749 assert(sc->ungot_flag == 1);
750 sc->ungot_flag = 0;
751 }
752
753 ++sc->nread;
754 return sc->cc = sc->ungot_char;
755 }
756
757 void attribute_hidden __scan_ungetc(register struct scan_cookie *sc)
758 {
759 ++sc->width;
760 if (sc->ungot_flag == 2) { /* last was EOF */
761 sc->ungot_flag = 0;
762 sc->cc = sc->ungot_char;
763 } else if (sc->ungot_flag == 0) {
764 sc->ungot_flag = 1;
765 --sc->nread;
766 } else {
767 assert(0);
768 }
769 }
770
771 #endif
772 /**********************************************************************/
773 #ifdef L___psfs_parse_spec
774
775 #ifdef SPEC_FLAGS
776 static const unsigned char spec_flags[] = SPEC_FLAGS;
777 #endif /* SPEC_FLAGS */
778 static const unsigned char spec_chars[] = SPEC_CHARS;
779 static const unsigned char qual_chars[] = QUAL_CHARS;
780 static const unsigned char spec_ranges[] = SPEC_RANGES;
781 static const unsigned short spec_allowed[] = SPEC_ALLOWED_FLAGS;
782
783 int attribute_hidden __psfs_parse_spec(register psfs_t *psfs)
784 {
785 const unsigned char *p;
786 const unsigned char *fmt0 = psfs->fmt;
787 int i;
788 #ifdef SPEC_FLAGS
789 int j;
790 #endif
791 #if defined(NL_ARGMAX) && (NL_ARGMAX > 0)
792 unsigned char fail = 0;
793
794 i = 0; /* Do this here to avoid a warning. */
795
796 if (!__isdigit_char(*psfs->fmt)) { /* Not a positional arg. */
797 fail = 1;
798 goto DO_FLAGS;
799 }
800
801 /* parse the positional arg (or width) value */
802 do {
803 if (i <= ((INT_MAX - 9)/10)) {
804 i = (i * 10) + (*psfs->fmt++ - '0');
805 }
806 } while (__isdigit_char(*psfs->fmt));
807
808 if (*psfs->fmt != '$') { /* This is a max field width. */
809 if (psfs->num_pos_args >= 0) { /* Already saw a pos arg! */
810 goto ERROR_EINVAL;
811 }
812 psfs->max_width = i;
813 psfs->num_pos_args = -2;
814 goto DO_QUALIFIER;
815 }
816 ++psfs->fmt; /* Advance past '$'. */
817 #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */
818
819 #if defined(SPEC_FLAGS) || (defined(NL_ARGMAX) && (NL_ARGMAX > 0))
820 DO_FLAGS:
821 #endif /* defined(SPEC_FLAGS) || (defined(NL_ARGMAX) && (NL_ARGMAX > 0)) */
822 #ifdef SPEC_FLAGS
823 p = spec_flags;
824 j = FLAG_SURPRESS;
825 do {
826 if (*p == *psfs->fmt) {
827 ++psfs->fmt;
828 psfs->flags |= j;
829 goto DO_FLAGS;
830 }
831 j += j;
832 } while (*++p);
833
834 if (psfs->flags & FLAG_SURPRESS) { /* Suppress assignment. */
835 psfs->store = 0;
836 goto DO_WIDTH;
837 }
838 #else /* SPEC_FLAGS */
839 if (*psfs->fmt == '*') { /* Suppress assignment. */
840 ++psfs->fmt;
841 psfs->store = 0;
842 goto DO_WIDTH;
843 }
844 #endif /* SPEC_FLAGS */
845
846
847 #if defined(NL_ARGMAX) && (NL_ARGMAX > 0)
848 if (fail) {
849 /* Must be a non-positional arg */
850 if (psfs->num_pos_args >= 0) { /* Already saw a pos arg! */
851 goto ERROR_EINVAL;
852 }
853 psfs->num_pos_args = -2;
854 } else {
855 if ((psfs->num_pos_args == -2) || (((unsigned int)(--i)) >= NL_ARGMAX)) {
856 /* Already saw a non-pos arg or (0-based) num too large. */
857 goto ERROR_EINVAL;
858 }
859 psfs->cur_pos_arg = i;
860 }
861 #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */
862
863 DO_WIDTH:
864 for (i = 0 ; __isdigit_char(*psfs->fmt) ; ) {
865 if (i <= ((INT_MAX - 9)/10)) {
866 i = (i * 10) + (*psfs->fmt++ - '0');
867 psfs->max_width = i;
868 }
869 }
870
871 #if defined(NL_ARGMAX) && (NL_ARGMAX > 0)
872 DO_QUALIFIER:
873 #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */
874 p = qual_chars;
875 do {
876 if (*psfs->fmt == *p) {
877 ++psfs->fmt;
878 break;
879 }
880 } while (*++p);
881 if ((p - qual_chars < 2) && (*psfs->fmt == *p)) {
882 p += ((sizeof(qual_chars)-2) / 2);
883 ++psfs->fmt;
884 }
885 psfs->dataargtype = ((int)(p[(sizeof(qual_chars)-2) / 2])) << 8;
886
887 #ifdef __UCLIBC_MJN3_ONLY__
888 #warning CONSIDER: Should we validate that psfs->max_width > 0 in __psfs_parse_spec()? It would avoid whitespace consumption...
889 #warning CONSIDER: Should INT_MAX be a valid width (%c/%C)? See __psfs_parse_spec().
890 #endif /* __UCLIBC_MJN3_ONLY__ */
891
892 p = spec_chars;
893 do {
894 if (*psfs->fmt == *p) {
895 int p_m_spec_chars = p - spec_chars;
896
897 if (*p == 'm' &&
898 (psfs->fmt[1] == '[' || psfs->fmt[1] == 'c' ||
899 /* Assumes ascii for 's' and 'S' test. */
900 (psfs->fmt[1] | 0x20) == 's'))
901 {
902 if (psfs->store)
903 psfs->flags |= FLAG_MALLOC;
904 ++psfs->fmt;
905 ++p;
906 continue; /* The related conversions follow 'm'. */
907 }
908
909 for (p = spec_ranges; p_m_spec_chars > *p ; ++p) {}
910 if (((psfs->dataargtype >> 8) | psfs->flags)
911 & ~spec_allowed[(int)(p - spec_ranges)]
912 ) {
913 goto ERROR_EINVAL;
914 }
915
916 if (p_m_spec_chars == CONV_p) {
917 /* a pointer has the same size as 'long int' */
918 psfs->dataargtype = PA_FLAG_LONG;
919 } else if ((p_m_spec_chars >= CONV_c)
920 && (psfs->dataargtype & PA_FLAG_LONG)) {
921 p_m_spec_chars -= CONV_c - CONV_C; /* lc -> C, ls -> S, l[ -> ?? */
922 }
923
924 psfs->conv_num = p_m_spec_chars;
925 return psfs->fmt - fmt0;
926 }
927 if (!*++p) {
928 ERROR_EINVAL:
929 __set_errno(EINVAL);
930 return -1;
931 }
932 } while(1);
933
934 assert(0);
935 }
936
937 #endif
938 /**********************************************************************/
939 #if defined(L_vfscanf) || defined(L_vfwscanf)
940
941 #ifdef __UCLIBC_HAS_WCHAR__
942 #ifdef L_vfscanf
943 static int sc_getc(register struct scan_cookie *sc)
944 {
945 return (getc_unlocked)(sc->fp); /* Disable the macro. */
946 }
947
948 static int scan_getwc(register struct scan_cookie *sc)
949 {
950 size_t r;
951 int width;
952 wchar_t wc[1];
953 char b[1];
954
955 if (--sc->width < 0) {
956 sc->ungot_flag |= 2;
957 return -1;
958 }
959
960 width = sc->width; /* Preserve width. */
961 sc->width = INT_MAX; /* MB_CUR_MAX can invoke a function. */
962
963 assert(!sc->mb_fail);
964
965 r = (size_t)(-3);
966 while (__scan_getc(sc) >= 0) {
967 *b = sc->cc;
968
969 r = mbrtowc(wc, b, 1, &sc->mbstate);
970 if (((ssize_t) r) >= 0) { /* Successful completion of a wc. */
971 sc->wc = *wc;
972 goto SUCCESS;
973 } else if (r == ((size_t) -2)) {
974 /* Potentially valid but incomplete. */
975 continue;
976 }
977 break;
978 }
979
980 if (r == ((size_t)(-3))) { /* EOF or ERROR on first read */
981 sc->wc = WEOF;
982 r = (size_t)(-1);
983 } else {
984 /* If we reach here, either r == ((size_t)-1) and
985 * mbrtowc set errno to EILSEQ, or r == ((size_t)-2)
986 * and stream is in an error state or at EOF with a
987 * partially complete wchar. */
988 __set_errno(EILSEQ); /* In case of incomplete conversion. */
989 sc->mb_fail = 1;
990 }
991
992 SUCCESS:
993 sc->width = width; /* Restore width. */
994
995 return (int)((ssize_t) r);
996 }
997
998 #endif /* L_vfscanf */
999
1000 #ifdef L_vfwscanf
1001
1002 /* This gets called by __scan_getc. __scan_getc is called by vfwscanf
1003 * when the next wide char is expected to be valid ascii (digits).
1004 */
1005 static int sc_getc(register struct scan_cookie *sc)
1006 {
1007 wint_t wc;
1008
1009 if (__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp)) {
1010 if (sc->fp->__bufpos < sc->fp->__bufend) {
1011 wc = *((wchar_t *)(sc->fp->__bufpos));
1012 sc->fp->__bufpos += sizeof(wchar_t);
1013 } else {
1014 sc->fp->__modeflags |= __FLAG_EOF;
1015 return EOF;
1016 }
1017 } else if ((wc = fgetwc_unlocked(sc->fp)) == WEOF) {
1018 return EOF;
1019 }
1020
1021 sc->ungot_wflag = 1;
1022 sc->ungot_wchar = wc;
1023 sc->ungot_wchar_width = sc->fp->__ungot_width[0];
1024
1025 #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
1026 if (wc == sc->thousands_sep_wc) {
1027 wc = ',';
1028 } else
1029 #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
1030 #ifdef __UCLIBC_HAS_FLOATS__
1031 if (wc == sc->decpt_wc) {
1032 wc = '.';
1033 } else
1034 #endif /* __UCLIBC_HAS_FLOATS__ */
1035 sc->wc = sc->ungot_char = wc;
1036
1037 return (int) wc;
1038 }
1039
1040 static int scan_getwc(register struct scan_cookie *sc)
1041 {
1042 wint_t wc;
1043
1044 sc->wc = WEOF;
1045
1046 if (--sc->width < 0) {
1047 sc->ungot_flag |= 2;
1048 return -1;
1049 }
1050
1051 if (sc->ungot_flag == 0) {
1052 if (__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp)) {
1053 if (sc->fp->__bufpos < sc->fp->__bufend) {
1054 wc = *((wchar_t *)(sc->fp->__bufpos));
1055 sc->fp->__bufpos += sizeof(wchar_t);
1056 } else {
1057 sc->ungot_flag |= 2;
1058 return -1;
1059 }
1060 } else if ((wc = fgetwc_unlocked(sc->fp)) == WEOF) {
1061 sc->ungot_flag |= 2;
1062 return -1;
1063 }
1064 sc->ungot_wflag = 1;
1065 sc->ungot_char = wc;
1066 sc->ungot_wchar_width = sc->fp->__ungot_width[0];
1067 } else {
1068 assert(sc->ungot_flag == 1);
1069 sc->ungot_flag = 0;
1070 }
1071
1072 ++sc->nread;
1073 sc->wc = sc->ungot_char;
1074
1075 return 0;
1076 }
1077
1078
1079 #endif /* L_vfwscanf */
1080 #endif /* __UCLIBC_HAS_WCHAR__ */
1081
1082 static __inline void kill_scan_cookie(register struct scan_cookie *sc)
1083 {
1084 #ifdef L_vfscanf
1085
1086 if (sc->ungot_flag & 1) {
1087 #if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__)
1088 if (!__STDIO_STREAM_IS_FAKE_VSSCANF_NB(sc->fp)) {
1089 ungetc(sc->ungot_char, sc->fp);
1090 }
1091 #else
1092 ungetc(sc->ungot_char, sc->fp);
1093 #endif
1094 /* Deal with distiction between user and scanf ungots. */
1095 if (sc->nread == 0) { /* Only one char was read... app ungot? */
1096 sc->fp->__ungot[1] = sc->app_ungot; /* restore ungot state. */
1097 } else {
1098 sc->fp->__ungot[1] = 0;
1099 }
1100 }
1101
1102 #else
1103
1104 if ((sc->ungot_flag & 1) && (sc->ungot_wflag & 1)
1105 && !__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp)
1106 && (sc->fp->__state.__mask == 0)
1107 ) {
1108 ungetwc(sc->ungot_char, sc->fp);
1109 /* Deal with distiction between user and scanf ungots. */
1110 if (sc->nread == 0) { /* Only one char was read... app ungot? */
1111 sc->fp->__ungot[1] = sc->app_ungot; /* restore ungot state. */
1112 } else {
1113 sc->fp->__ungot[1] = 0;
1114 }
1115 sc->fp->__ungot_width[1] = sc->ungot_wchar_width;
1116 }
1117
1118 #endif
1119 }
1120
1121
1122 int VFSCANF (FILE *__restrict fp, const Wchar *__restrict format, va_list arg)
1123 {
1124 const Wuchar *fmt;
1125 unsigned char *b;
1126
1127 #ifdef L_vfwscanf
1128 wchar_t wbuf[1];
1129 wchar_t *wb;
1130 #endif /* L_vfwscanf */
1131
1132 #if defined(__UCLIBC_HAS_LOCALE__) && !defined(L_vfwscanf) || !defined(L_vfscanf)
1133 mbstate_t mbstate;
1134 #endif
1135
1136 struct scan_cookie sc;
1137 psfs_t psfs;
1138 int i;
1139
1140 #ifdef __UCLIBC_MJN3_ONLY__
1141 #warning TODO: Fix MAX_DIGITS. We do not do binary, so...!
1142 #endif
1143 #define MAX_DIGITS 65 /* Allow one leading 0. */
1144 unsigned char buf[MAX_DIGITS+2];
1145 #ifdef L_vfscanf
1146 unsigned char scanset[UCHAR_MAX + 1];
1147 unsigned char invert; /* Careful! Meaning changes. */
1148 #endif /* L_vfscanf */
1149 unsigned char fail;
1150 unsigned char zero_conversions = 1;
1151 __STDIO_AUTO_THREADLOCK_VAR;
1152
1153 #ifdef __UCLIBC_MJN3_ONLY__
1154 #warning TODO: Make checking of the format string in C locale an option.
1155 #endif
1156 /* To support old programs, don't check mb validity if in C locale. */
1157 #if defined(__UCLIBC_HAS_LOCALE__) && !defined(L_vfwscanf)
1158 /* ANSI/ISO C99 requires format string to be a valid multibyte string
1159 * beginning and ending in its initial shift state. */
1160 if (__UCLIBC_CURLOCALE->encoding != __ctype_encoding_7_bit) {
1161 const char *p = format;
1162 mbstate.__mask = 0; /* Initialize the mbstate. */
1163 if (mbsrtowcs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) {
1164 __set_errno(EINVAL); /* Format string is invalid. */
1165 return 0;
1166 }
1167 }
1168 #endif /* defined(__UCLIBC_HAS_LOCALE__) && !defined(L_vfwscanf) */
1169
1170 #if defined(NL_ARGMAX) && (NL_ARGMAX > 0)
1171 psfs.num_pos_args = -1; /* Must start at -1. */
1172 /* Initialize positional arg ptrs to NULL. */
1173 memset(psfs.pos_args, 0, sizeof(psfs.pos_args));
1174 #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */
1175
1176 __STDIO_AUTO_THREADLOCK(fp);
1177
1178 __STDIO_STREAM_VALIDATE(fp);
1179
1180 __init_scan_cookie(&sc,fp);
1181 #ifdef __UCLIBC_HAS_WCHAR__
1182 sc.sc_getc = sc_getc;
1183 sc.ungot_wchar_width = sc.fp->__ungot_width[1];
1184
1185 #ifdef L_vfwscanf
1186
1187 #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
1188 if (*sc.grouping) {
1189 sc.thousands_sep = (const unsigned char *) ",";
1190 sc.tslen = 1;
1191 }
1192 #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
1193
1194 #ifdef __UCLIBC_HAS_FLOATS__
1195 sc.fake_decpt = (const unsigned char *) ".";
1196 #endif /* __UCLIBC_HAS_FLOATS__ */
1197
1198 #else /* L_vfwscanf */
1199
1200 #ifdef __UCLIBC_HAS_FLOATS__
1201 sc.fake_decpt = sc.decpt;
1202 #endif /* __UCLIBC_HAS_FLOATS__ */
1203
1204 #endif /* L_vfwscanf */
1205
1206 #endif /* __UCLIBC_HAS_WCHAR__ */
1207 psfs.cnt = 0;
1208
1209 /* Note: If we ever wanted to support non-nice codesets, we
1210 * would really need to do a mb->wc conversion here in the
1211 * vfscanf case. Related changes would have to be made in
1212 * the code that follows... basicly wherever fmt appears. */
1213 for (fmt = (const Wuchar *) format ; *fmt ; /* ++fmt */) {
1214
1215 psfs.store = 1;
1216 psfs.flags = 0;
1217 #ifndef NDEBUG
1218 psfs.cur_ptr = NULL; /* Debugging aid. */
1219 #endif /* NDEBUG */
1220
1221
1222 sc.ungot_flag &= 1; /* Clear (possible fake) EOF. */
1223 sc.width = psfs.max_width = INT_MAX;
1224
1225 /* Note: According to the standards, vfscanf does use isspace
1226 * here. So, if we did a mb->wc conversion, we would have to do
1227 * something like
1228 * ((((__uwchar_t)wc) < UCHAR_MAX) && isspace(wc))
1229 * because wc might not be in the allowed domain. */
1230 if (ISSPACE(*fmt)) {
1231 do {
1232 ++fmt;
1233 } while (ISSPACE(*fmt));
1234 --fmt;
1235 psfs.conv_num = CONV_whitespace;
1236 goto DO_WHITESPACE;
1237 }
1238
1239 if (*fmt == '%') { /* Conversion specification. */
1240 if (*++fmt == '%') { /* Remember, '%' eats whitespace too. */
1241 /* Note: The standard says no conversion occurs.
1242 * So do not reset zero_conversions flag. */
1243 psfs.conv_num = CONV_percent;
1244 goto DO_CONVERSION;
1245 }
1246
1247
1248 #ifdef L_vfscanf
1249 psfs.fmt = fmt;
1250 #else /* L_vfscanf */
1251 {
1252 const __uwchar_t *wf = fmt;
1253 psfs.fmt = b = buf;
1254
1255 while (*wf && __isascii(*wf) && (b < buf + sizeof(buf) - 1)) {
1256 *b++ = *wf++;
1257 }
1258 *b = 0;
1259 if (b == buf) { /* Bad conversion specifier! */
1260 goto DONE;
1261 }
1262 }
1263 #endif /* L_vfscanf */
1264 if ((i = __psfs_parse_spec(&psfs)) < 0) { /* Bad conversion specifier! */
1265 goto DONE;
1266 }
1267 fmt += i;
1268
1269 if (psfs.store) {
1270 #if defined(NL_ARGMAX) && (NL_ARGMAX > 0)
1271 if (psfs.num_pos_args == -2) {
1272 psfs.cur_ptr = va_arg(arg, void *);
1273 } else {
1274 while (psfs.cur_pos_arg > psfs.num_pos_args) {
1275 psfs.pos_args[++psfs.num_pos_args] = va_arg(arg, void *);
1276 }
1277 psfs.cur_ptr = psfs.pos_args[psfs.cur_pos_arg];
1278 }
1279 #else /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */
1280 psfs.cur_ptr = va_arg(arg, void *);
1281 #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */
1282 }
1283
1284 DO_CONVERSION:
1285 /* First, consume white-space if not n, c, [, C, or l[. */
1286 if ((((1L << CONV_n)|(1L << CONV_C)|(1L << CONV_c)
1287 |(1L << CONV_LEFTBRACKET)|(1L << CONV_leftbracket))
1288 & (1L << psfs.conv_num)) == 0
1289 ) {
1290 DO_WHITESPACE:
1291 while ((__scan_getc(&sc) >= 0)
1292 #ifdef L_vfscanf
1293 && isspace(sc.cc)
1294 #else /* L_vfscanf */
1295 && iswspace(sc.wc)
1296 #endif /* L_vfscanf */
1297 ) {}
1298 __scan_ungetc(&sc);
1299 if (psfs.conv_num == CONV_whitespace) {
1300 goto NEXT_FMT;
1301 }
1302 }
1303
1304 sc.width = psfs.max_width; /* Now limit the max width. */
1305
1306 if (sc.width == 0) { /* 0 width is forbidden. */
1307 goto DONE;
1308 }
1309
1310
1311 if (psfs.conv_num == CONV_percent) {
1312 goto MATCH_CHAR;
1313 }
1314
1315 if (psfs.conv_num == CONV_n) {
1316 #ifdef __UCLIBC_MJN3_ONLY__
1317 #warning CONSIDER: Should %n count as a conversion as far as EOF return value?
1318 #endif
1319 /* zero_conversions = 0; */
1320 if (psfs.store) {
1321 _store_inttype(psfs.cur_ptr, psfs.dataargtype,
1322 (uintmax_t) sc.nread);
1323 }
1324 goto NEXT_FMT;
1325 }
1326
1327 if (psfs.conv_num <= CONV_A) { /* pointer, integer, or float spec */
1328 int r = __psfs_do_numeric(&psfs, &sc);
1329 #ifndef L_vfscanf
1330 if (sc.ungot_wflag == 1) { /* fix up '?', '.', and ',' hacks */
1331 sc.cc = sc.ungot_char = sc.ungot_wchar;
1332 }
1333 #endif
1334 if (r != -1) { /* Either success or a matching failure. */
1335 zero_conversions = 0;
1336 }
1337 if (r < 0) {
1338 goto DONE;
1339 }
1340 goto NEXT_FMT;
1341 }
1342
1343 /* Do string conversions here since they are not common code. */
1344
1345
1346 #ifdef L_vfscanf
1347
1348 if
1349 #ifdef __UCLIBC_HAS_WCHAR__
1350 (psfs.conv_num >= CONV_LEFTBRACKET)
1351 #else /* __UCLIBC_HAS_WCHAR__ */
1352 (psfs.conv_num >= CONV_c)
1353 #endif /* __UCLIBC_HAS_WCHAR__ */
1354 {
1355 b = (psfs.store ? ((unsigned char *) psfs.cur_ptr) : buf);
1356 fail = 1;
1357
1358 if (psfs.conv_num == CONV_c) {
1359 if (sc.width == INT_MAX) {
1360 sc.width = 1;
1361 }
1362
1363 while (__scan_getc(&sc) >= 0) {
1364 zero_conversions = 0;
1365 *b = sc.cc;
1366 b += psfs.store;
1367 }
1368 __scan_ungetc(&sc);
1369 if (sc.width > 0) { /* Failed to read all required. */
1370 goto DONE;
1371 }
1372 psfs.cnt += psfs.store;
1373 goto NEXT_FMT;
1374 }
1375
1376 if (psfs.conv_num == CONV_s) {
1377 /* We might have to handle the allocation ourselves */
1378 int len;
1379 /* With 'm', we actually got a pointer to a pointer */
1380 unsigned char **ptr = (void *)b;
1381
1382 i = 0;
1383 if (psfs.flags & FLAG_MALLOC) {
1384 len = 0;
1385 b = NULL;
1386 } else
1387 len = -1;
1388
1389 /* Yes, believe it or not, a %s conversion can store nuls. */
1390 while ((__scan_getc(&sc) >= 0) && !isspace(sc.cc)) {
1391 zero_conversions = 0;
1392 if (i == len) {
1393 /* Pick a size that won't trigger a lot of
1394 * mallocs early on ... */
1395 len += 256;
1396 b = realloc(b, len + 1);
1397 }
1398 b[i] = sc.cc;
1399 i += psfs.store;
1400 fail = 0;
1401 }
1402
1403 if (psfs.flags & FLAG_MALLOC)
1404 *ptr = b;
1405 /* The code below takes care of terminating NUL */
1406 b += i;
1407 } else {
1408 #ifdef __UCLIBC_HAS_WCHAR__
1409 assert((psfs.conv_num == CONV_LEFTBRACKET) || \
1410 (psfs.conv_num == CONV_leftbracket));
1411 #else /* __UCLIBC_HAS_WCHAR__ */
1412 assert((psfs.conv_num == CONV_leftbracket));
1413 #endif /* __UCLIBC_HAS_WCHAR__ */
1414
1415 invert = 0;
1416
1417 if (*++fmt == '^') {
1418 ++fmt;
1419 invert = 1;
1420 }
1421 memset(scanset, invert, sizeof(scanset));
1422 invert = 1-invert;
1423
1424 if (*fmt == ']') {
1425 scanset[(int)(']')] = invert;
1426 ++fmt;
1427 }
1428
1429 while (*fmt != ']') {
1430 if (!*fmt) { /* No closing ']'. */
1431 goto DONE;
1432 }
1433 if ((*fmt == '-') && (fmt[1] != ']')
1434 && (fmt[-1] < fmt[1]) /* sorted? */
1435 ) { /* range */
1436 ++fmt;
1437 i = fmt[-2];
1438 /* Note: scanset[i] should already have been done
1439 * in the previous iteration. */
1440 do {
1441 scanset[++i] = invert;
1442 } while (i < *fmt);
1443 /* Safe to fall through, and a bit smaller. */
1444 }
1445 /* literal char */
1446 scanset[(int) *fmt] = invert;
1447 ++fmt;
1448 }
1449
1450 #ifdef __UCLIBC_HAS_WCHAR__
1451 if (psfs.conv_num == CONV_LEFTBRACKET) {
1452 goto DO_LEFTBRACKET;
1453 }
1454 #endif /* __UCLIBC_HAS_WCHAR__ */
1455
1456
1457 while (__scan_getc(&sc) >= 0) {
1458 zero_conversions = 0;
1459 if (!scanset[sc.cc]) {
1460 break;
1461 }
1462 *b = sc.cc;
1463 b += psfs.store;
1464 fail = 0;
1465 }
1466 }
1467 /* Common tail for processing of %s and %[. */
1468
1469 __scan_ungetc(&sc);
1470 if (fail) { /* nothing stored! */
1471 goto DONE;
1472 }
1473 *b = 0; /* Nul-terminate string. */
1474 psfs.cnt += psfs.store;
1475 goto NEXT_FMT;
1476 }
1477
1478 #ifdef __UCLIBC_HAS_WCHAR__
1479 DO_LEFTBRACKET: /* Need to do common wide init. */
1480 if (psfs.conv_num >= CONV_C) {
1481 wchar_t wbuf[1];
1482 wchar_t *wb;
1483
1484 sc.mbstate.__mask = 0;
1485
1486 wb = (psfs.store ? ((wchar_t *) psfs.cur_ptr) : wbuf);
1487 fail = 1;
1488
1489 if (psfs.conv_num == CONV_C) {
1490 if (sc.width == INT_MAX) {
1491 sc.width = 1;
1492 }
1493
1494 while (scan_getwc(&sc) >= 0) {
1495 zero_conversions = 0;
1496 assert(sc.width >= 0);
1497 *wb = sc.wc;
1498 wb += psfs.store;
1499 }
1500
1501 __scan_ungetc(&sc);
1502 if (sc.width > 0) { /* Failed to read all required. */
1503 goto DONE;
1504 }
1505 psfs.cnt += psfs.store;
1506 goto NEXT_FMT;
1507 }
1508
1509
1510 if (psfs.conv_num == CONV_S) {
1511 /* Yes, believe it or not, a %s conversion can store nuls. */
1512 while (scan_getwc(&sc) >= 0) {
1513 zero_conversions = 0;
1514 if ((((__uwchar_t)(sc.wc)) <= UCHAR_MAX) && isspace(sc.wc)) {
1515 break;
1516 }
1517 *wb = sc.wc;
1518 wb += psfs.store;
1519 fail = 0;
1520 }
1521 } else {
1522 assert(psfs.conv_num == CONV_LEFTBRACKET);
1523
1524 while (scan_getwc(&sc) >= 0) {
1525 zero_conversions = 0;
1526 if (((__uwchar_t) sc.wc) <= UCHAR_MAX) {
1527 if (!scanset[sc.wc]) {
1528 break;
1529 }
1530 } else if (invert) {
1531 break;
1532 }
1533 *wb = sc.wc;
1534 wb += psfs.store;
1535 fail = 0;
1536 }
1537 }
1538 /* Common tail for processing of %ls and %l[. */
1539
1540 __scan_ungetc(&sc);
1541 if (fail || sc.mb_fail) { /* Nothing stored or mb error. */
1542 goto DONE;
1543 }
1544 *wb = 0; /* Nul-terminate string. */
1545 psfs.cnt += psfs.store;
1546 goto NEXT_FMT;
1547
1548 }
1549
1550 #endif /* __UCLIBC_HAS_WCHAR__ */
1551 #else /* L_vfscanf */
1552
1553 if (psfs.conv_num >= CONV_C) {
1554 b = buf;
1555 wb = wbuf;
1556 if (psfs.conv_num >= CONV_c) {
1557 mbstate.__mask = 0; /* Initialize the mbstate. */
1558 if (psfs.store) {
1559 b = (unsigned char *) psfs.cur_ptr;
1560 }
1561 } else {
1562 if (psfs.store) {
1563 wb = (wchar_t *) psfs.cur_ptr;
1564 }
1565 }
1566 fail = 1;
1567
1568
1569 if ((psfs.conv_num == CONV_C) || (psfs.conv_num == CONV_c)) {
1570 if (sc.width == INT_MAX) {
1571 sc.width = 1;
1572 }
1573
1574 while (scan_getwc(&sc) >= 0) {
1575 zero_conversions = 0;
1576 if (psfs.conv_num == CONV_C) {
1577 *wb = sc.wc;
1578 wb += psfs.store;
1579 } else {
1580 i = wcrtomb((char*) b, sc.wc, &mbstate);
1581 if (i < 0) { /* Conversion failure. */
1582 goto DONE_DO_UNGET;
1583 }
1584 if (psfs.store) {
1585 b += i;
1586 }
1587 }
1588 }
1589 __scan_ungetc(&sc);
1590 if (sc.width > 0) { /* Failed to read all required. */
1591 goto DONE;
1592 }
1593 psfs.cnt += psfs.store;
1594 goto NEXT_FMT;
1595 }
1596
1597 if ((psfs.conv_num == CONV_S) || (psfs.conv_num == CONV_s)) {
1598 /* Yes, believe it or not, a %s conversion can store nuls. */
1599 while (scan_getwc(&sc) >= 0) {
1600 zero_conversions = 0;
1601 if (iswspace(sc.wc)) {
1602 break;
1603 }
1604 if (psfs.conv_num == CONV_S) {
1605 *wb = sc.wc;
1606 wb += psfs.store;
1607 } else {
1608 i = wcrtomb((char*) b, sc.wc, &mbstate);
1609 if (i < 0) { /* Conversion failure. */
1610 goto DONE_DO_UNGET;
1611 }
1612 if (psfs.store) {
1613 b += i;
1614 }
1615 }
1616 fail = 0;
1617 }
1618 } else {
1619 const wchar_t *sss;
1620 const wchar_t *ssp;
1621 unsigned char invert = 0;
1622
1623 assert((psfs.conv_num == CONV_LEFTBRACKET)
1624 || (psfs.conv_num == CONV_leftbracket));
1625
1626 if (*++fmt == '^') {
1627 ++fmt;
1628 invert = 1;
1629 }
1630 sss = (const wchar_t *) fmt;
1631 if (*fmt == ']') {
1632 ++fmt;
1633 }
1634 while (*fmt != ']') {
1635 if (!*fmt) { /* No closing ']'. */
1636 goto DONE;
1637 }
1638 if ((*fmt == '-') && (fmt[1] != ']')
1639 && (fmt[-1] < fmt[1]) /* sorted? */
1640 ) { /* range */
1641 ++fmt;
1642 }
1643 ++fmt;
1644 }
1645 /* Ok... a valid scanset spec. */
1646
1647 while (scan_getwc(&sc) >= 0) {
1648 zero_conversions = 0;
1649 ssp = sss;
1650 do { /* We know sss < fmt. */
1651 if (*ssp == '-') { /* possible range... */
1652 /* Note: We accept a-c-e (ordered) as
1653 * equivalent to a-e. */
1654 if (ssp > sss) {
1655 if ((++ssp < (const wchar_t *) fmt)
1656 && (ssp[-2] < *ssp) /* sorted? */
1657 ) { /* yes */
1658 if ((sc.wc >= ssp[-2])
1659 && (sc.wc <= *ssp)) {
1660 break;
1661 }
1662 continue; /* not in range */
1663 }
1664 --ssp; /* oops... '-' at end, so back up */
1665 }
1666 /* false alarm... a literal '-' */
1667 }
1668 if (sc.wc == *ssp) { /* Matched literal char. */
1669 break;
1670 }
1671 } while (++ssp < (const wchar_t *) fmt);
1672
1673 if ((ssp == (const wchar_t *) fmt) ^ invert) {
1674 /* no match and not inverting
1675 * or match and inverting */
1676 break;
1677 }
1678 if (psfs.conv_num == CONV_LEFTBRACKET) {
1679 *wb = sc.wc;
1680 wb += psfs.store;
1681 } else {
1682 i = wcrtomb((char*) b, sc.wc, &mbstate);
1683 if (i < 0) { /* Conversion failure. */
1684 goto DONE_DO_UNGET;
1685 }
1686 if (psfs.store) {
1687 b += i;
1688 }
1689 }
1690 fail = 0;
1691 }
1692 }
1693 /* Common tail for processing of %s and %[. */
1694
1695 __scan_ungetc(&sc);
1696 if (fail) { /* nothing stored! */
1697 goto DONE;
1698 }
1699 *wb = 0; /* Nul-terminate string. */
1700 *b = 0;
1701 psfs.cnt += psfs.store;
1702 goto NEXT_FMT;
1703 }
1704
1705 #endif /* L_vfscanf */
1706
1707 assert(0);
1708 goto DONE;
1709 } /* conversion specification */
1710
1711 MATCH_CHAR:
1712 if (__scan_getc(&sc) != *fmt) {
1713 #ifdef L_vfwscanf
1714 DONE_DO_UNGET:
1715 #endif /* L_vfwscanf */
1716 __scan_ungetc(&sc);
1717 goto DONE;
1718 }
1719
1720 NEXT_FMT:
1721 ++fmt;
1722 if (__FERROR_UNLOCKED(fp)) {
1723 break;
1724 }
1725 }
1726
1727 DONE:
1728 if (__FERROR_UNLOCKED(fp) || (*fmt && zero_conversions && __FEOF_UNLOCKED(fp))) {
1729 psfs.cnt = EOF; /* Yes, vfwscanf also returns EOF. */
1730 }
1731
1732 kill_scan_cookie(&sc);
1733
1734 __STDIO_STREAM_VALIDATE(fp);
1735
1736 __STDIO_AUTO_THREADUNLOCK(fp);
1737
1738 return psfs.cnt;
1739 }
1740 libc_hidden_def(VFSCANF)
1741 #endif
1742 /**********************************************************************/
1743 #ifdef L___psfs_do_numeric
1744
1745 static const unsigned char spec_base[] = SPEC_BASE;
1746 static const unsigned char nil_string[] = "(nil)";
1747
1748 int attribute_hidden __psfs_do_numeric(psfs_t *psfs, struct scan_cookie *sc)
1749 {
1750 unsigned char *b;
1751 const unsigned char *p;
1752
1753 #ifdef __UCLIBC_HAS_FLOATS__
1754 int exp_adjust = 0;
1755 #endif
1756 #ifdef __UCLIBC_MJN3_ONLY__
1757 #warning TODO: Fix MAX_DIGITS. We do not do binary, so...!
1758 #warning TODO: Fix buf!
1759 #endif
1760 #define MAX_DIGITS 65 /* Allow one leading 0. */
1761 unsigned char buf[MAX_DIGITS+2+ 100];
1762 unsigned char usflag, base;
1763 unsigned char nonzero = 0;
1764 unsigned char seendigit = 0;
1765
1766 #ifdef __UCLIBC_MJN3_ONLY__
1767 #warning CONSIDER: What should be returned for an invalid conversion specifier?
1768 #endif
1769 #ifndef __UCLIBC_HAS_FLOATS__
1770 if (psfs->conv_num > CONV_i) { /* floating point */
1771 goto DONE;
1772 }
1773 #endif
1774
1775 base = spec_base[psfs->conv_num - CONV_p];
1776 usflag = (psfs->conv_num <= CONV_u); /* (1)0 if (un)signed */
1777 b = buf;
1778
1779
1780 if (psfs->conv_num == CONV_p) { /* Pointer */
1781 p = nil_string;
1782 do {
1783 if ((__scan_getc(sc) < 0) || (*p != sc->cc)) {
1784 __scan_ungetc(sc);
1785 if (p > nil_string) {
1786 /* We matched at least the '(' so even if we
1787 * are at eof, we can not match a pointer. */
1788 return -2; /* Matching failure */
1789 }
1790 break;
1791 }
1792 if (!*++p) { /* Matched (nil), so no unget necessary. */
1793 if (psfs->store) {
1794 ++psfs->cnt;
1795 _store_inttype(psfs->cur_ptr, psfs->dataargtype,
1796 (uintmax_t)0);
1797 }
1798 return 0;
1799 }
1800 } while (1);
1801
1802 #ifdef __UCLIBC_MJN3_ONLY__
1803 #warning CONSIDER: Should we require a 0x prefix and disallow +/- for pointer %p?
1804 #endif /* __UCLIBC_MJN3_ONLY__ */
1805 }
1806
1807 __scan_getc(sc);
1808 if (sc->cc < 0) {
1809 return -1; /* Input failure (nothing read yet). */
1810 }
1811
1812 if ((sc->cc == '+') || (sc->cc == '-')) { /* Handle leading sign.*/
1813 *b++ = sc->cc;
1814 __scan_getc(sc);
1815 }
1816
1817 if ((base & 0xef) == 0) { /* 0xef is ~16, so 16 or 0. */
1818 if (sc->cc == '0') { /* Possibly set base and handle prefix. */
1819 __scan_getc(sc);
1820 if ((sc->cc|0x20) == 'x') { /* Assumes ascii.. x or X. */
1821 if (__scan_getc(sc) < 0) {
1822 /* Either EOF or error (including wc outside char range).
1823 * If EOF or error, this is a matching failure (we read 0x).
1824 * If wc outside char range, this is also a matching failure.
1825 * Hence, we do an unget (although not really necessary here
1826 * and fail. */
1827 goto DONE_DO_UNGET; /* matching failure */
1828 }
1829 base = 16; /* Base 16 for sure now. */
1830 #ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
1831 /* The prefix is required for hexadecimal floats. */
1832 *b++ = '0';
1833 *b++ = 'x';
1834 #endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
1835 } else { /* oops... back up */
1836 __scan_ungetc(sc);
1837 sc->cc = '0'; /* NASTY HACK! */
1838
1839 base = (base >> 1) + 8; /* 0->8, 16->16. no 'if' */
1840 #ifdef __UCLIBC_HAS_FLOATS__
1841 if (psfs->conv_num > CONV_i) { /* floating point */
1842 base = 10;
1843 }
1844 #endif
1845 }
1846 } else if (!base) {
1847 base = 10;
1848 }
1849 }
1850
1851 /***************** digit grouping **********************/
1852 #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
1853
1854 if ((psfs->flags & FLAG_THOUSANDS) && (base == 10)
1855 && *(p = (const unsigned char *) sc->grouping)
1856 ) {
1857
1858 int nblk1, nblk2, nbmax, lastblock, pass, i;
1859
1860
1861 #ifdef __UCLIBC_MJN3_ONLY__
1862 #warning CONSIDER: Should we initalize the grouping blocks in __init_scan_cookie()?
1863 #endif /* __UCLIBC_MJN3_ONLY__ */
1864 nbmax = nblk2 = nblk1 = *p;
1865 if (*++p) {
1866 nblk2 = *p;
1867 if (nbmax < nblk2) {
1868 nbmax = nblk2;
1869 }
1870 assert(!p[1]);
1871 }
1872
1873 /* Note: for printf, if 0 and \' flags appear then
1874 * grouping is done before 0-padding. Should we
1875 * strip leading 0's first? Or add a 0 flag? */
1876
1877 /* For vfwscanf, sc_getc translates, so the value of sc->cc is
1878 * either EOF or a char. */
1879
1880 if (!__isdigit_char_or_EOF(sc->cc)) { /* No starting digit! */
1881 #ifdef __UCLIBC_HAS_FLOATS__
1882 if (psfs->conv_num > CONV_i) { /* floating point */
1883 goto NO_STARTING_DIGIT;
1884 }
1885 #endif
1886 goto DONE_DO_UNGET;
1887 }
1888
1889 if (sc->cc == '0') {
1890 seendigit = 1;
1891 *b++ = '0'; /* Store the first 0. */
1892 #ifdef __UCLIBC_MJN3_ONLY__
1893 #warning CONSIDER: Should leading 0s be skipped before digit grouping? (printf 0 pad)
1894 #endif /* __UCLIBC_MJN3_ONLY__ */
1895 #if 0
1896 do { /* But ignore all subsequent 0s. */
1897 __scan_getc(sc);
1898 } while (sc->cc == '0');
1899 #endif
1900 }
1901 pass = 0;
1902 lastblock = 0;
1903 do {
1904 i = 0;
1905 while (__isdigit_char_or_EOF(sc->cc)) {
1906 seendigit = 1;
1907 if (i == nbmax) { /* too many digits for a block */
1908 #ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__
1909 if (!pass) { /* treat as nongrouped */
1910 if (nonzero) {
1911 goto DO_NO_GROUP;
1912 }
1913 goto DO_TRIM_LEADING_ZEROS;
1914 }
1915 #endif
1916 if (nbmax > nblk1) {
1917 goto DONE_DO_UNGET; /* matching failure */
1918 }
1919 goto DONE_GROUPING_DO_UNGET; /* nbmax == nblk1 */
1920 }
1921 ++i;
1922
1923 if (nonzero || (sc->cc != '0')) {
1924 if (b < buf + MAX_DIGITS) {
1925 *b++ = sc->cc;
1926 nonzero = 1;
1927 #ifdef __UCLIBC_HAS_FLOATS__
1928 } else {
1929 ++exp_adjust;
1930 #endif
1931 }
1932 }
1933
1934 __scan_getc(sc);
1935 }
1936
1937 if (i) { /* we saw digits digits */
1938 if ((i == nblk2) || ((i < nblk2) && !pass)) {
1939 /* (possible) outer grp */
1940 p = sc->thousands_sep;
1941 if (*p == sc->cc) { /* first byte matches... */
1942 /* so check if grouping mb char */
1943 /* Since 1st matched, either match or fail now
1944 * unless EOF (yuk) */
1945 __scan_getc(sc);
1946 MBG_LOOP:
1947 if (!*++p) { /* is a grouping mb char */
1948 lastblock = i;
1949 ++pass;
1950 continue;
1951 }
1952 if (*p == sc->cc) {
1953 __scan_getc(sc);
1954 goto MBG_LOOP;
1955 }
1956 /* bad grouping mb char! */
1957 __scan_ungetc(sc);
1958 if ((sc->cc >= 0) || (p > sc->thousands_sep + 1)) {
1959 #ifdef __UCLIBC_HAS_FLOATS__
1960 /* We failed to match a thousep mb char, and
1961 * we've read too much to recover. But if
1962 * this is a floating point conversion and
1963 * the initial portion of the decpt mb char
1964 * matches, then we may still be able to
1965 * recover. */
1966 int k = p - sc->thousands_sep - 1;
1967
1968 if ((psfs->conv_num > CONV_i) /* float conversion */
1969 && (!pass || (i == nblk1)) /* possible last */
1970 && !memcmp(sc->thousands_sep, sc->fake_decpt, k)
1971 /* and prefix matched, so could be decpt */
1972 ) {
1973 __scan_getc(sc);
1974 p = sc->fake_decpt + k;
1975 do {
1976 if (!*++p) {
1977 strcpy((char*) b, (char*) sc->decpt);
1978 b += sc->decpt_len;
1979 goto GOT_DECPT;
1980 }
1981 if (*p != sc->cc) {
1982 __scan_ungetc(sc);
1983 break; /* failed */
1984 }
1985 __scan_getc(sc);
1986 } while (1);
1987 }
1988 #endif /* __UCLIBC_HAS_FLOATS__ */
1989 goto DONE;
1990 }
1991 /* was EOF and 1st, so recoverable. */
1992 }
1993 }
1994 if ((i == nblk1) || ((i < nblk1) && !pass)) {
1995 /* got an inner group */
1996 goto DONE_GROUPING_DO_UNGET;
1997 }
1998 goto DONE_DO_UNGET; /* Matching failure. */
1999 } /* i != 0 */
2000
2001 assert(pass);
2002
2003 goto DONE_DO_UNGET;
2004 } while (1);
2005
2006 assert(0); /* Should never get here. */
2007 }
2008
2009 #endif /***************** digit grouping **********************/
2010
2011 /* Not grouping so first trim all but one leading 0. */
2012 #ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__
2013 DO_TRIM_LEADING_ZEROS:
2014 #endif /* __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ */
2015 if (sc->cc == '0') {
2016 seendigit = 1;
2017 *b++ = '0'; /* Store the first 0. */
2018 do { /* But ignore all subsequent 0s. */
2019 __scan_getc(sc);
2020 } while (sc->cc == '0');
2021 }
2022
2023 #ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__
2024 DO_NO_GROUP:
2025 #endif /* __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ */
2026 /* At this point, we're ready to start reading digits. */
2027
2028 #define valid_digit(cc,base) (isxdigit(cc) && ((base == 16) || (cc - '0' < base)))
2029
2030 while (valid_digit(sc->cc,base)) { /* Now for significant digits.*/
2031 if (b - buf < MAX_DIGITS) {
2032 nonzero = seendigit = 1; /* Set nonzero too 0s trimmed above. */
2033 *b++ = sc->cc;
2034 #ifdef __UCLIBC_HAS_FLOATS__
2035 } else {
2036 ++exp_adjust;
2037 #endif
2038 }
2039 __scan_getc(sc);
2040 }
2041
2042 #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
2043 DONE_GROUPING_DO_UNGET:
2044 #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
2045 if (psfs->conv_num <= CONV_i) { /* integer conversion */
2046 __scan_ungetc(sc);
2047 *b = 0; /* null-terminate */
2048 if (!seendigit) {
2049 goto DONE; /* No digits! */
2050 }
2051 if (psfs->store) {
2052 if (*buf == '-') {
2053 usflag = 0;
2054 }
2055 ++psfs->cnt;
2056 _store_inttype(psfs->cur_ptr, psfs->dataargtype,
2057 (uintmax_t) STRTOUIM((char *) buf, NULL, base, 1-usflag));
2058 }
2059 return 0;
2060 }
2061
2062 #ifdef __UCLIBC_HAS_FLOATS__
2063
2064 /* At this point, we have everything left of the decimal point or exponent. */
2065 #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
2066 NO_STARTING_DIGIT:
2067 #endif
2068 p = sc->fake_decpt;
2069 do {
2070 if (!*p) {
2071 strcpy((char *) b, (char *) sc->decpt);
2072 b += sc->decpt_len;
2073 break;
2074 }
2075 if (*p != sc->cc) {
2076 if (p > sc->fake_decpt) {
2077 goto DONE_DO_UNGET; /* matching failure (read some of decpt) */
2078 }
2079 goto DO_DIGIT_CHECK;
2080 }
2081 ++p;
2082 __scan_getc(sc);
2083 } while (1);
2084
2085 #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
2086 GOT_DECPT:
2087 #endif
2088 if (!nonzero) {
2089 if (sc->cc == '0') {
2090 assert(exp_adjust == 0);
2091 *b++ = '0';
2092 ++exp_adjust;
2093 seendigit = 1;
2094 do {
2095 --exp_adjust;
2096 __scan_getc(sc);
2097 } while (sc->cc == '0');
2098 }
2099 }
2100
2101 while (valid_digit(sc->cc,base)) { /* Process fractional digits.*/
2102 if (b - buf < MAX_DIGITS) {
2103 seendigit = 1;
2104 *b++ = sc->cc;
2105 }
2106 __scan_getc(sc);
2107 }
2108
2109 DO_DIGIT_CHECK:
2110 /* Hmm... no decimal point. */
2111 if (!seendigit) {
2112 static const unsigned char nan_inf_str[] = "an\0nfinity";
2113
2114 if (base == 16) { /* We had a prefix, but no digits! */
2115 goto DONE_DO_UNGET; /* matching failure */
2116 }
2117
2118 /* Avoid tolower problems for INFINITY in the tr_TR locale. (yuk)*/
2119 #undef TOLOWER
2120 #define TOLOWER(C) ((C)|0x20)
2121
2122 switch (TOLOWER(sc->cc)) {
2123 case 'i':
2124 p = nan_inf_str + 3;
2125 break;
2126 case 'n':
2127 p = nan_inf_str;
2128 break;
2129 default:
2130 /* No digits and not inf or nan. */
2131 goto DONE_DO_UNGET;
2132 }
2133
2134 *b++ = sc->cc;
2135
2136 do {
2137 __scan_getc(sc);
2138 if (TOLOWER(sc->cc) == *p) {
2139 *b++ = sc->cc;
2140 ++p;
2141 continue;
2142 }
2143 if (!*p || (p == nan_inf_str + 5)) { /* match nan/infinity or inf */
2144 goto GOT_FLOAT;
2145 }
2146 /* Unrecoverable. Even if on 1st char, we had no digits. */
2147 goto DONE_DO_UNGET;
2148 } while (1);
2149 }
2150
2151 /* If we get here, we had some digits. */
2152
2153 if (
2154 #ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
2155 ((base == 16) && (((sc->cc)|0x20) == 'p')) ||
2156 #endif
2157 (((sc->cc)|0x20) == 'e')
2158 ) { /* Process an exponent. */
2159 *b++ = sc->cc;
2160
2161 __scan_getc(sc);
2162 if (sc->cc < 0) {
2163 goto DONE_DO_UNGET; /* matching failure.. no exponent digits */
2164 }
2165
2166 if ((sc->cc == '+') || (sc->cc == '-')) { /* Signed exponent? */
2167 *b++ = sc->cc;
2168 __scan_getc(sc);
2169 }
2170
2171 #ifdef __UCLIBC_MJN3_ONLY__
2172 #warning TODO: Fix MAX_EXP_DIGITS!
2173 #endif
2174 #define MAX_EXP_DIGITS 20
2175 assert(seendigit);
2176 seendigit = 0;
2177 nonzero = 0;
2178
2179 if (sc->cc == '0') {
2180 seendigit = 1;
2181 *b++ = '0';
2182 do {
2183 __scan_getc(sc);
2184 } while (sc->cc == '0');
2185 }
2186
2187 while (__isdigit_char_or_EOF(sc->cc)) { /* Exponent digits (base 10).*/
2188 if (seendigit < MAX_EXP_DIGITS) {
2189 ++seendigit;
2190 *b++ = sc->cc;
2191 }
2192 __scan_getc(sc);
2193 }
2194
2195 if (!seendigit) { /* No digits. Unrecoverable. */
2196 goto DONE_DO_UNGET;
2197 }
2198 }
2199
2200
2201 GOT_FLOAT:
2202 *b = 0;
2203 {
2204 __fpmax_t x;
2205 char *e;
2206 x = __strtofpmax((char *) buf, &e, exp_adjust);
2207 assert(!*e);
2208 if (psfs->store) {
2209 if (psfs->dataargtype & PA_FLAG_LONG_LONG) {
2210 *((long double *)psfs->cur_ptr) = (long double) x;
2211 } else if (psfs->dataargtype & PA_FLAG_LONG) {
2212 *((double *)psfs->cur_ptr) = (double) x;
2213 } else {
2214 *((float *)psfs->cur_ptr) = (float) x;
2215 }
2216 ++psfs->cnt;
2217 }
2218 __scan_ungetc(sc);
2219 return 0;
2220 }
2221 #endif /* __UCLIBC_HAS_FLOATS__ */
2222
2223 DONE_DO_UNGET:
2224 __scan_ungetc(sc);
2225 DONE:
2226 return -2; /* Matching failure. */
2227
2228 }
2229 #endif
2230 /**********************************************************************/
embedded C library