| /* Copyright (C) 2002-2004 Manuel Novoa III |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public |
| * License along with this library; if not, write to the Free |
| * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| */ |
| |
| /* Aug 1, 2003 |
| * New *scanf implementation with lots of bug fixes and *wscanf support. |
| * Also now optionally supports hexadecimal float notation, positional |
| * args, and glibc locale-specific digit grouping. Should now be |
| * standards compliant. |
| * |
| * Aug 18, 2003 |
| * Bug fix: scanf %lc,%ls,%l[ would always set mb_fail on eof or error, |
| * even when just starting a new mb char. |
| * Bug fix: wscanf would incorrectly unget in certain situations. |
| * |
| * Sep 5, 2003 |
| * Bug fix: store flag wasn't respected if no positional args. |
| * Implement vs{n}scanf for the non-buffered stdio no-wchar case. |
| * |
| * Sep 13, 2003 |
| * Bug fix: Fix a problem reported by Atsushi Nemoto <anemo@mba.ocn.ne.jp> |
| * for environments where long and long long are the same. |
| * |
| * Sep 21, 2003 |
| * Ugh... EOF handling by scanf was completely broken. :-( Regretably, |
| * I got my mind fixed in one mode and didn't comply with the standards. |
| * Things should be fixed now, but comparision testing is difficult when |
| * glibc's scanf is broken and they stubbornly refuse to even acknowledge |
| * that it is... even when confronted by specific examples from the C99 |
| * standards and from an official C standard defect report. |
| */ |
| |
| #define _ISOC99_SOURCE /* for LLONG_MAX primarily... */ |
| #include <features.h> |
| #include "_stdio.h" |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <ctype.h> |
| #include <string.h> |
| #include <stdarg.h> |
| #include <stdint.h> |
| #include <errno.h> |
| #include <printf.h> |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| #include <bits/uClibc_uwchar.h> |
| #include <wchar.h> |
| #include <wctype.h> |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| |
| #include <langinfo.h> |
| #include <locale.h> |
| |
| #include <assert.h> |
| #include <limits.h> |
| |
| #ifdef __UCLIBC_HAS_THREADS__ |
| #include <stdio_ext.h> |
| #include <pthread.h> |
| #endif /* __UCLIBC_HAS_THREADS__ */ |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| #include <float.h> |
| #include <bits/uClibc_fpmax.h> |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| |
| #ifdef __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ |
| #ifdef L_vfscanf |
| /* only emit this once */ |
| #warning Forcing undef of __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ until implemented! |
| #endif |
| #undef __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ |
| #endif |
| |
| #undef __STDIO_HAS_VSSCANF |
| #if defined(__STDIO_BUFFERS) || !defined(__UCLIBC_HAS_WCHAR__) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__) |
| #define __STDIO_HAS_VSSCANF 1 |
| |
| #if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__) |
| typedef struct { |
| FILE f; |
| unsigned char *bufread; /* pointer to 1 past end of buffer */ |
| unsigned char *bufpos; |
| } __FILE_vsscanf; |
| #endif |
| |
| #endif |
| |
| extern void _store_inttype(void *dest, int desttype, uintmax_t val); |
| |
| #if defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX) |
| |
| extern unsigned long long |
| _stdlib_strto_ll(register const char * __restrict str, |
| char ** __restrict endptr, int base, int sflag); |
| #if (ULLONG_MAX == UINTMAX_MAX) |
| #define STRTOUIM(s,e,b,sf) _stdlib_strto_ll(s,e,b,sf) |
| #endif |
| |
| #else /* defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX) */ |
| |
| extern unsigned long |
| _stdlib_strto_l(register const char * __restrict str, |
| char ** __restrict endptr, int base, int sflag); |
| |
| #if (ULONG_MAX == UINTMAX_MAX) |
| #define STRTOUIM(s,e,b,sf) _stdlib_strto_l(s,e,b,sf) |
| #endif |
| |
| #endif /* defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX) */ |
| |
| #ifndef STRTOUIM |
| #error STRTOUIM conversion function is undefined! |
| #endif |
| |
| /**********************************************************************/ |
| |
| /* The standards require EOF < 0. */ |
| #if EOF >= CHAR_MIN |
| #define __isdigit_char_or_EOF(C) __isdigit_char((C)) |
| #else |
| #define __isdigit_char_or_EOF(C) __isdigit_int((C)) |
| #endif |
| |
| /**********************************************************************/ |
| #ifdef L_fscanf |
| |
| int fscanf(FILE * __restrict stream, const char * __restrict format, ...) |
| { |
| va_list arg; |
| int rv; |
| |
| va_start(arg, format); |
| rv = vfscanf(stream, format, arg); |
| va_end(arg); |
| |
| return rv; |
| } |
| libc_hidden_def(fscanf) |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_scanf |
| |
| int scanf(const char * __restrict format, ...) |
| { |
| va_list arg; |
| int rv; |
| |
| va_start(arg, format); |
| rv = vfscanf(stdin, format, arg); |
| va_end(arg); |
| |
| return rv; |
| } |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_sscanf |
| |
| #ifdef __STDIO_HAS_VSSCANF |
| |
| int sscanf(const char * __restrict str, const char * __restrict format, ...) |
| { |
| va_list arg; |
| int rv; |
| |
| va_start(arg, format); |
| rv = vsscanf(str, format, arg); |
| va_end(arg); |
| |
| return rv; |
| } |
| libc_hidden_def(sscanf) |
| |
| #else /* __STDIO_HAS_VSSCANF */ |
| #warning Skipping sscanf since no vsscanf! |
| #endif /* __STDIO_HAS_VSSCANF */ |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_vscanf |
| |
| int vscanf(const char * __restrict format, va_list arg) |
| { |
| return vfscanf(stdin, format, arg); |
| } |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_vsscanf |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning WISHLIST: Implement vsscanf for non-buf and no custom stream case. |
| #endif /* __UCLIBC_MJN3_ONLY__ */ |
| |
| #ifdef __STDIO_BUFFERS |
| |
| int vsscanf(__const char *sp, __const char *fmt, va_list ap) |
| { |
| FILE f; |
| |
| /* __STDIO_STREAM_RESET_GCS(&f); */ |
| #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ |
| f.__cookie = &(f.__filedes); |
| f.__gcs.read = NULL; |
| f.__gcs.write = NULL; |
| f.__gcs.seek = NULL; |
| f.__gcs.close = NULL; |
| #endif |
| |
| f.__filedes = __STDIO_STREAM_FAKE_VSSCANF_FILEDES; |
| f.__modeflags = (__FLAG_NARROW|__FLAG_READONLY|__FLAG_READING); |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| f.__ungot_width[0] = 0; |
| #endif |
| #ifdef __STDIO_MBSTATE |
| __INIT_MBSTATE(&(f.__state)); |
| #endif |
| |
| #ifdef __UCLIBC_HAS_THREADS__ |
| f.__user_locking = 1; /* Set user locking. */ |
| STDIO_INIT_MUTEX(f.__lock); |
| #endif |
| f.__nextopen = NULL; |
| |
| /* Set these last since __bufgetc initialization depends on |
| * __user_locking and only gets set if user locking is on. */ |
| f.__bufstart = |
| f.__bufpos = (unsigned char *) ((void *) sp); |
| f.__bufread = |
| f.__bufend = f.__bufstart + strlen(sp); |
| __STDIO_STREAM_ENABLE_GETC(&f); |
| __STDIO_STREAM_DISABLE_PUTC(&f); |
| |
| return vfscanf(&f, fmt, ap); |
| } |
| libc_hidden_def(vsscanf) |
| |
| #elif !defined(__UCLIBC_HAS_WCHAR__) |
| |
| int vsscanf(__const char *sp, __const char *fmt, va_list ap) |
| { |
| __FILE_vsscanf f; |
| |
| f.bufpos = (unsigned char *) ((void *) sp); |
| f.bufread = f.bufpos + strlen(sp); |
| |
| /* __STDIO_STREAM_RESET_GCS(&f.f); */ |
| #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ |
| f.f.__cookie = &(f.f.__filedes); |
| f.f.__gcs.read = NULL; |
| f.f.__gcs.write = NULL; |
| f.f.__gcs.seek = NULL; |
| f.f.__gcs.close = NULL; |
| #endif |
| |
| f.f.__filedes = __STDIO_STREAM_FAKE_VSSCANF_FILEDES_NB; |
| f.f.__modeflags = (__FLAG_NARROW|__FLAG_READONLY|__FLAG_READING); |
| |
| /* #ifdef __UCLIBC_HAS_WCHAR__ */ |
| /* f.f.__ungot_width[0] = 0; */ |
| /* #endif */ |
| #ifdef __STDIO_MBSTATE |
| #error __STDIO_MBSTATE is defined! |
| /* __INIT_MBSTATE(&(f.f.__state)); */ |
| #endif |
| |
| #ifdef __UCLIBC_HAS_THREADS__ |
| f.f.__user_locking = 1; /* Set user locking. */ |
| STDIO_INIT_MUTEX(f.f.__lock); |
| #endif |
| f.f.__nextopen = NULL; |
| |
| return vfscanf(&f.f, fmt, ap); |
| } |
| libc_hidden_def(vsscanf) |
| |
| #elif defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__) |
| |
| int vsscanf(__const char *sp, __const char *fmt, va_list ap) |
| { |
| FILE *f; |
| int rv = EOF; |
| |
| if ((f = fmemopen((char *)sp, strlen(sp), "r")) != NULL) { |
| rv = vfscanf(f, fmt, ap); |
| fclose(f); |
| } |
| |
| return rv; |
| } |
| libc_hidden_def(vsscanf) |
| |
| #else |
| #warning Skipping vsscanf since no buffering, no custom streams, and wchar enabled! |
| #ifdef __STDIO_HAS_VSSCANF |
| #error WHOA! __STDIO_HAS_VSSCANF is defined! |
| #endif |
| #endif |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_fwscanf |
| |
| int fwscanf(FILE * __restrict stream, const wchar_t * __restrict format, ...) |
| { |
| va_list arg; |
| int rv; |
| |
| va_start(arg, format); |
| rv = vfwscanf(stream, format, arg); |
| va_end(arg); |
| |
| return rv; |
| } |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_wscanf |
| |
| int wscanf(const wchar_t * __restrict format, ...) |
| { |
| va_list arg; |
| int rv; |
| |
| va_start(arg, format); |
| rv = vfwscanf(stdin, format, arg); |
| va_end(arg); |
| |
| return rv; |
| } |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_swscanf |
| |
| #ifdef __STDIO_BUFFERS |
| |
| int swscanf(const wchar_t * __restrict str, const wchar_t * __restrict format, |
| ...) |
| { |
| va_list arg; |
| int rv; |
| |
| va_start(arg, format); |
| rv = vswscanf(str, format, arg); |
| va_end(arg); |
| |
| return rv; |
| } |
| #else /* __STDIO_BUFFERS */ |
| #warning Skipping swscanf since no buffering! |
| #endif /* __STDIO_BUFFERS */ |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_vwscanf |
| |
| int vwscanf(const wchar_t * __restrict format, va_list arg) |
| { |
| return vfwscanf(stdin, format, arg); |
| } |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L_vswscanf |
| |
| #ifdef __STDIO_BUFFERS |
| |
| int vswscanf(const wchar_t * __restrict str, const wchar_t * __restrict format, |
| va_list arg) |
| { |
| FILE f; |
| |
| f.__bufstart = |
| f.__bufpos = (char *) str; |
| f.__bufread = |
| f.__bufend = (char *)(str + wcslen(str)); |
| __STDIO_STREAM_DISABLE_GETC(&f); |
| __STDIO_STREAM_DISABLE_PUTC(&f); |
| |
| /* __STDIO_STREAM_RESET_GCS(&f); */ |
| #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ |
| f.__cookie = &(f.__filedes); |
| f.__gcs.read = NULL; |
| f.__gcs.write = NULL; |
| f.__gcs.seek = NULL; |
| f.__gcs.close = NULL; |
| #endif |
| |
| f.__filedes = __STDIO_STREAM_FAKE_VSWSCANF_FILEDES; |
| f.__modeflags = (__FLAG_WIDE|__FLAG_READONLY|__FLAG_READING); |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| f.__ungot_width[0] = 0; |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| #ifdef __STDIO_MBSTATE |
| __INIT_MBSTATE(&(f.__state)); |
| #endif /* __STDIO_MBSTATE */ |
| |
| #ifdef __UCLIBC_HAS_THREADS__ |
| f.__user_locking = 1; /* Set user locking. */ |
| STDIO_INIT_MUTEX(f.__lock); |
| #endif |
| f.__nextopen = NULL; |
| |
| return vfwscanf(&f, format, arg); |
| } |
| libc_hidden_def(vswscanf) |
| #else /* __STDIO_BUFFERS */ |
| #warning Skipping vswscanf since no buffering! |
| #endif /* __STDIO_BUFFERS */ |
| |
| #endif |
| /**********************************************************************/ |
| /**********************************************************************/ |
| |
| |
| |
| /* float layout 0123456789012345678901 repeat n for "l[" */ |
| #define SPEC_CHARS "npxXoudifFeEgGaACSncs[" |
| /* npxXoudif eEgG CS cs[ */ |
| |
| /* NOTE: Ordering is important! In particular, CONV_LEFTBRACKET |
| * must immediately precede CONV_c. */ |
| |
| enum { |
| CONV_n = 0, |
| CONV_p, |
| CONV_x, CONV_X, CONV_o, CONV_u, CONV_d, CONV_i, |
| CONV_f, CONV_F, CONV_e, CONV_E, CONV_g, CONV_G, CONV_a, CONV_A, |
| CONV_C, CONV_S, CONV_LEFTBRACKET, CONV_c, CONV_s, CONV_leftbracket, |
| CONV_percent, CONV_whitespace /* not in SPEC_* and no flags */ |
| }; |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| #ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__ |
| /* p x X o u d i f F e E g G a A */ |
| #define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0 } |
| #else |
| /* p x X o u d i f F e E g G a A */ |
| #define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10 } |
| #endif |
| #else /* __UCLIBC_HAS_FLOATS__ */ |
| /* p x X o u d i f F e E g G a A */ |
| #define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0 } |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #ifdef L_vfscanf |
| /* emit once */ |
| #warning CONSIDER: Add a '0' flag to eat 0 padding when grouping? |
| #endif |
| #endif /* __UCLIBC_MJN3_ONLY__ */ |
| |
| #define SPEC_FLAGS "*'I" |
| |
| enum { |
| FLAG_SURPRESS = 0x10, /* MUST BE 1ST!! See DO_FLAGS. */ |
| FLAG_THOUSANDS = 0x20, |
| FLAG_I18N = 0x40, /* only works for d, i, u */ |
| FLAG_MALLOC = 0x80, /* only works for s, S, and [ (and l[)*/ |
| }; |
| |
| |
| #define SPEC_RANGES { CONV_n, CONV_p, CONV_i, CONV_A, \ |
| CONV_C, CONV_LEFTBRACKET, \ |
| CONV_c, CONV_leftbracket } |
| |
| /* Note: We treat L and ll as synonymous... for ints and floats. */ |
| |
| #define SPEC_ALLOWED_FLAGS { \ |
| /* n */ (0x0f|FLAG_SURPRESS), \ |
| /* p */ ( 0|FLAG_SURPRESS), \ |
| /* oxXudi */ (0x0f|FLAG_SURPRESS|FLAG_THOUSANDS|FLAG_I18N), \ |
| /* fFeEgGaA */ (0x0c|FLAG_SURPRESS|FLAG_THOUSANDS|FLAG_I18N), \ |
| /* C */ ( 0|FLAG_SURPRESS), \ |
| /* S and l[ */ ( 0|FLAG_SURPRESS|FLAG_MALLOC), \ |
| /* c */ (0x04|FLAG_SURPRESS), \ |
| /* s and [ */ (0x04|FLAG_SURPRESS|FLAG_MALLOC), \ |
| } |
| |
| |
| /**********************************************************************/ |
| /* |
| * In order to ease translation to what arginfo and _print_info._flags expect, |
| * we map: 0:int 1:char 2:longlong 4:long 8:short |
| * and then _flags |= (((q << 7) + q) & 0x701) and argtype |= (_flags & 0x701) |
| */ |
| |
| /* TODO -- Fix the table below to take into account stdint.h. */ |
| /* #ifndef LLONG_MAX */ |
| /* #error fix QUAL_CHARS for no long long! Affects 'L', 'j', 'q', 'll'. */ |
| /* #else */ |
| /* #if LLONG_MAX != INTMAX_MAX */ |
| /* #error fix QUAL_CHARS intmax_t entry 'j'! */ |
| /* #endif */ |
| /* #endif */ |
| |
| #ifdef PDS |
| #error PDS already defined! |
| #endif |
| #ifdef SS |
| #error SS already defined! |
| #endif |
| #ifdef IMS |
| #error IMS already defined! |
| #endif |
| |
| #if PTRDIFF_MAX == INT_MAX |
| #define PDS 0 |
| #elif PTRDIFF_MAX == LONG_MAX |
| #define PDS 4 |
| #elif defined(LLONG_MAX) && (PTRDIFF_MAX == LLONG_MAX) |
| #define PDS 8 |
| #else |
| #error fix QUAL_CHARS ptrdiff_t entry 't'! |
| #endif |
| |
| #if SIZE_MAX == UINT_MAX |
| #define SS 0 |
| #elif SIZE_MAX == ULONG_MAX |
| #define SS 4 |
| #elif defined(LLONG_MAX) && (SIZE_MAX == ULLONG_MAX) |
| #define SS 8 |
| #else |
| #error fix QUAL_CHARS size_t entries 'z', 'Z'! |
| #endif |
| |
| #if INTMAX_MAX == INT_MAX |
| #define IMS 0 |
| #elif INTMAX_MAX == LONG_MAX |
| #define IMS 4 |
| #elif defined(LLONG_MAX) && (INTMAX_MAX == LLONG_MAX) |
| #define IMS 8 |
| #else |
| #error fix QUAL_CHARS intmax_t entry 'j'! |
| #endif |
| |
| #define QUAL_CHARS { \ |
| /* j:(u)intmax_t z:(s)size_t t:ptrdiff_t \0:int q:long_long */ \ |
| 'h', 'l', 'L', 'j', 'z', 't', 'q', 0, \ |
| 2, 4, 8, IMS, SS, PDS, 8, 0, /* TODO -- fix!!! */ \ |
| 1, 8 \ |
| } |
| |
| |
| /**********************************************************************/ |
| |
| #ifdef L_vfwscanf |
| /* FIXME: "warning: the right operand of ">" changes sign when promoted" */ |
| #if WINT_MIN > EOF |
| #error Unfortunately, we currently need wint_t to be able to store EOF. Sorry. |
| #endif |
| #define W_EOF WEOF |
| #define Wint wint_t |
| #define Wchar wchar_t |
| #define Wuchar __uwchar_t |
| #define ISSPACE(C) iswspace((C)) |
| #define VFSCANF vfwscanf |
| #define GETC(SC) (SC)->sc_getc((SC)) |
| #else |
| typedef unsigned char __uchar_t; |
| #define W_EOF EOF |
| #define Wint int |
| #define Wchar char |
| #define Wuchar __uchar_t |
| #define ISSPACE(C) isspace((C)) |
| #define VFSCANF vfscanf |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| #define GETC(SC) (SC)->sc_getc((SC)) |
| #else /* __UCLIBC_HAS_WCHAR__ */ |
| #define GETC(SC) getc_unlocked((SC)->fp) |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| #endif |
| |
| struct scan_cookie { |
| Wint cc; |
| Wint ungot_char; |
| FILE *fp; |
| int nread; |
| int width; |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| wchar_t app_ungot; /* Match FILE struct member type. */ |
| unsigned char ungot_wchar_width; |
| #else /* __UCLIBC_HAS_WCHAR__ */ |
| unsigned char app_ungot; /* Match FILE struct member type. */ |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| |
| char ungot_flag; |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| char ungot_wflag; /* vfwscanf */ |
| char mb_fail; /* vfscanf */ |
| mbstate_t mbstate; /* vfscanf */ |
| wint_t wc; |
| wint_t ungot_wchar; /* to support __scan_getc */ |
| int (*sc_getc)(struct scan_cookie *); |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| |
| #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ |
| const char *grouping; |
| const unsigned char *thousands_sep; |
| int tslen; |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| wchar_t thousands_sep_wc; |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| const unsigned char *decpt; |
| int decpt_len; |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| wchar_t decpt_wc; |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| const unsigned char *fake_decpt; |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| |
| }; |
| |
| typedef struct { |
| #if defined(NL_ARGMAX) && (NL_ARGMAX > 0) |
| #if NL_ARGMAX > 10 |
| #warning NL_ARGMAX > 10, and space is allocated on the stack for positional args. |
| #endif |
| void *pos_args[NL_ARGMAX]; |
| int num_pos_args; /* Must start at -1. */ |
| int cur_pos_arg; |
| #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ |
| void *cur_ptr; |
| const unsigned char *fmt; |
| int cnt, dataargtype, conv_num, max_width; |
| unsigned char store, flags; |
| } psfs_t; /* parse scanf format state */ |
| |
| |
| /**********************************************************************/ |
| /**********************************************************************/ |
| |
| extern void __init_scan_cookie(register struct scan_cookie *sc, |
| register FILE *fp) attribute_hidden; |
| extern int __scan_getc(register struct scan_cookie *sc) attribute_hidden; |
| extern void __scan_ungetc(register struct scan_cookie *sc) attribute_hidden; |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| extern int __scan_strtold(long double *ld, struct scan_cookie *sc); |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| |
| extern int __psfs_parse_spec(psfs_t *psfs) attribute_hidden; |
| extern int __psfs_do_numeric(psfs_t *psfs, struct scan_cookie *sc) attribute_hidden; |
| |
| /**********************************************************************/ |
| #ifdef L___scan_cookie |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning TODO: Remove dependence on decpt_str and fake_decpt in stub locale mode. |
| #endif |
| #ifndef __UCLIBC_HAS_LOCALE__ |
| static const char decpt_str[] = "."; |
| #endif |
| |
| void attribute_hidden __init_scan_cookie(register struct scan_cookie *sc, |
| register FILE *fp) |
| { |
| sc->fp = fp; |
| sc->nread = 0; |
| sc->ungot_flag = 0; |
| sc->app_ungot = ((fp->__modeflags & __FLAG_UNGOT) ? fp->__ungot[1] : 0); |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| sc->ungot_wflag = 0; /* vfwscanf */ |
| sc->mb_fail = 0; |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| |
| #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ |
| if (*(sc->grouping = __UCLIBC_CURLOCALE->grouping)) { |
| sc->thousands_sep = (const unsigned char *) __UCLIBC_CURLOCALE->thousands_sep; |
| sc->tslen = __UCLIBC_CURLOCALE->thousands_sep_len; |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| sc->thousands_sep_wc = __UCLIBC_CURLOCALE->thousands_sep_wc; |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| } |
| #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| #ifdef __UCLIBC_HAS_LOCALE__ |
| sc->decpt = (const unsigned char *) __UCLIBC_CURLOCALE->decimal_point; |
| sc->decpt_len = __UCLIBC_CURLOCALE->decimal_point_len; |
| #else /* __UCLIBC_HAS_LOCALE__ */ |
| sc->fake_decpt = sc->decpt = (unsigned char *) decpt_str; |
| sc->decpt_len = 1; |
| #endif /* __UCLIBC_HAS_LOCALE__ */ |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| #ifdef __UCLIBC_HAS_LOCALE__ |
| sc->decpt_wc = __UCLIBC_CURLOCALE->decimal_point_wc; |
| #else |
| sc->decpt_wc = '.'; |
| #endif |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| |
| } |
| |
| int attribute_hidden __scan_getc(register struct scan_cookie *sc) |
| { |
| int c; |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| assert(!sc->mb_fail); |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| |
| sc->cc = EOF; |
| |
| if (--sc->width < 0) { |
| sc->ungot_flag |= 2; |
| return -1; |
| } |
| |
| if (sc->ungot_flag == 0) { |
| #if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__) |
| if (!__STDIO_STREAM_IS_FAKE_VSSCANF_NB(sc->fp)) { |
| c = GETC(sc); |
| } else { |
| __FILE_vsscanf *fv = (__FILE_vsscanf *)(sc->fp); |
| if (fv->bufpos < fv->bufread) { |
| c = *fv->bufpos++; |
| } else { |
| c = EOF; |
| sc->fp->__modeflags |= __FLAG_EOF; |
| } |
| } |
| if (c == EOF) { |
| sc->ungot_flag |= 2; |
| return -1; |
| } |
| #else |
| if ((c = GETC(sc)) == EOF) { |
| sc->ungot_flag |= 2; |
| return -1; |
| } |
| #endif |
| sc->ungot_char = c; |
| } else { |
| assert(sc->ungot_flag == 1); |
| sc->ungot_flag = 0; |
| } |
| |
| ++sc->nread; |
| return sc->cc = sc->ungot_char; |
| } |
| |
| void attribute_hidden __scan_ungetc(register struct scan_cookie *sc) |
| { |
| ++sc->width; |
| if (sc->ungot_flag == 2) { /* last was EOF */ |
| sc->ungot_flag = 0; |
| sc->cc = sc->ungot_char; |
| } else if (sc->ungot_flag == 0) { |
| sc->ungot_flag = 1; |
| --sc->nread; |
| } else { |
| assert(0); |
| } |
| } |
| |
| #endif |
| /**********************************************************************/ |
| #ifdef L___psfs_parse_spec |
| |
| #ifdef SPEC_FLAGS |
| static const unsigned char spec_flags[] = SPEC_FLAGS; |
| #endif /* SPEC_FLAGS */ |
| static const unsigned char spec_chars[] = SPEC_CHARS; |
| static const unsigned char qual_chars[] = QUAL_CHARS; |
| static const unsigned char spec_ranges[] = SPEC_RANGES; |
| static const unsigned short spec_allowed[] = SPEC_ALLOWED_FLAGS; |
| |
| int attribute_hidden __psfs_parse_spec(register psfs_t *psfs) |
| { |
| const unsigned char *p; |
| const unsigned char *fmt0 = psfs->fmt; |
| int i; |
| #ifdef SPEC_FLAGS |
| int j; |
| #endif |
| #if defined(NL_ARGMAX) && (NL_ARGMAX > 0) |
| unsigned char fail = 0; |
| |
| i = 0; /* Do this here to avoid a warning. */ |
| |
| if (!__isdigit_char(*psfs->fmt)) { /* Not a positional arg. */ |
| fail = 1; |
| goto DO_FLAGS; |
| } |
| |
| /* parse the positional arg (or width) value */ |
| do { |
| if (i <= ((INT_MAX - 9)/10)) { |
| i = (i * 10) + (*psfs->fmt++ - '0'); |
| } |
| } while (__isdigit_char(*psfs->fmt)); |
| |
| if (*psfs->fmt != '$') { /* This is a max field width. */ |
| if (psfs->num_pos_args >= 0) { /* Already saw a pos arg! */ |
| goto ERROR_EINVAL; |
| } |
| psfs->max_width = i; |
| psfs->num_pos_args = -2; |
| goto DO_QUALIFIER; |
| } |
| ++psfs->fmt; /* Advance past '$'. */ |
| #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ |
| |
| #if defined(SPEC_FLAGS) || (defined(NL_ARGMAX) && (NL_ARGMAX > 0)) |
| DO_FLAGS: |
| #endif /* defined(SPEC_FLAGS) || (defined(NL_ARGMAX) && (NL_ARGMAX > 0)) */ |
| #ifdef SPEC_FLAGS |
| p = spec_flags; |
| j = FLAG_SURPRESS; |
| do { |
| if (*p == *psfs->fmt) { |
| ++psfs->fmt; |
| psfs->flags |= j; |
| goto DO_FLAGS; |
| } |
| j += j; |
| } while (*++p); |
| |
| if (psfs->flags & FLAG_SURPRESS) { /* Suppress assignment. */ |
| psfs->store = 0; |
| goto DO_WIDTH; |
| } |
| #else /* SPEC_FLAGS */ |
| if (*psfs->fmt == '*') { /* Suppress assignment. */ |
| ++psfs->fmt; |
| psfs->store = 0; |
| goto DO_WIDTH; |
| } |
| #endif /* SPEC_FLAGS */ |
| |
| |
| #if defined(NL_ARGMAX) && (NL_ARGMAX > 0) |
| if (fail) { |
| /* Must be a non-positional arg */ |
| if (psfs->num_pos_args >= 0) { /* Already saw a pos arg! */ |
| goto ERROR_EINVAL; |
| } |
| psfs->num_pos_args = -2; |
| } else { |
| if ((psfs->num_pos_args == -2) || (((unsigned int)(--i)) >= NL_ARGMAX)) { |
| /* Already saw a non-pos arg or (0-based) num too large. */ |
| goto ERROR_EINVAL; |
| } |
| psfs->cur_pos_arg = i; |
| } |
| #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ |
| |
| DO_WIDTH: |
| for (i = 0 ; __isdigit_char(*psfs->fmt) ; ) { |
| if (i <= ((INT_MAX - 9)/10)) { |
| i = (i * 10) + (*psfs->fmt++ - '0'); |
| psfs->max_width = i; |
| } |
| } |
| |
| #if defined(NL_ARGMAX) && (NL_ARGMAX > 0) |
| DO_QUALIFIER: |
| #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ |
| p = qual_chars; |
| do { |
| if (*psfs->fmt == *p) { |
| ++psfs->fmt; |
| break; |
| } |
| } while (*++p); |
| if ((p - qual_chars < 2) && (*psfs->fmt == *p)) { |
| p += ((sizeof(qual_chars)-2) / 2); |
| ++psfs->fmt; |
| } |
| psfs->dataargtype = ((int)(p[(sizeof(qual_chars)-2) / 2])) << 8; |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning CONSIDER: Should we validate that psfs->max_width > 0 in __psfs_parse_spec()? It would avoid whitespace consumption... |
| #warning CONSIDER: Should INT_MAX be a valid width (%c/%C)? See __psfs_parse_spec(). |
| #endif /* __UCLIBC_MJN3_ONLY__ */ |
| |
| p = spec_chars; |
| do { |
| if (*psfs->fmt == *p) { |
| int p_m_spec_chars = p - spec_chars; |
| |
| #ifdef __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ |
| #error implement gnu a flag |
| if ((*p == 'a') |
| && ((psfs->fmt[1] == '[') || ((psfs->fmt[1]|0x20) == 's')) |
| ) { /* Assumes ascii for 's' and 'S' test. */ |
| psfs->flags |= FLAG_MALLOC; |
| ++psfs->fmt; |
| ++p; |
| continue; /* The related conversions follow 'a'. */ |
| } |
| #endif /* __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ */ |
| |
| for (p = spec_ranges; p_m_spec_chars > *p ; ++p) {} |
| if (((psfs->dataargtype >> 8) | psfs->flags) |
| & ~spec_allowed[(int)(p - spec_ranges)] |
| ) { |
| goto ERROR_EINVAL; |
| } |
| |
| if (p_m_spec_chars == CONV_p) { |
| /* a pointer has the same size as 'long int' */ |
| psfs->dataargtype = PA_FLAG_LONG; |
| } else if ((p_m_spec_chars >= CONV_c) |
| && (psfs->dataargtype & PA_FLAG_LONG)) { |
| p_m_spec_chars -= 3; /* lc -> C, ls -> S, l[ -> ?? */ |
| } |
| |
| psfs->conv_num = p_m_spec_chars; |
| return psfs->fmt - fmt0; |
| } |
| if (!*++p) { |
| ERROR_EINVAL: |
| __set_errno(EINVAL); |
| return -1; |
| } |
| } while(1); |
| |
| assert(0); |
| } |
| |
| #endif |
| /**********************************************************************/ |
| #if defined(L_vfscanf) || defined(L_vfwscanf) |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| #ifdef L_vfscanf |
| static int sc_getc(register struct scan_cookie *sc) |
| { |
| return (getc_unlocked)(sc->fp); /* Disable the macro. */ |
| } |
| |
| static int scan_getwc(register struct scan_cookie *sc) |
| { |
| size_t r; |
| int width; |
| wchar_t wc[1]; |
| char b[1]; |
| |
| if (--sc->width < 0) { |
| sc->ungot_flag |= 2; |
| return -1; |
| } |
| |
| width = sc->width; /* Preserve width. */ |
| sc->width = INT_MAX; /* MB_CUR_MAX can invoke a function. */ |
| |
| assert(!sc->mb_fail); |
| |
| r = (size_t)(-3); |
| while (__scan_getc(sc) >= 0) { |
| *b = sc->cc; |
| |
| r = mbrtowc(wc, b, 1, &sc->mbstate); |
| if (((ssize_t) r) >= 0) { /* Successful completion of a wc. */ |
| sc->wc = *wc; |
| goto SUCCESS; |
| } else if (r == ((size_t) -2)) { |
| /* Potentially valid but incomplete. */ |
| continue; |
| } |
| break; |
| } |
| |
| if (r == ((size_t)(-3))) { /* EOF or ERROR on first read */ |
| sc->wc = WEOF; |
| r = (size_t)(-1); |
| } else { |
| /* If we reach here, either r == ((size_t)-1) and |
| * mbrtowc set errno to EILSEQ, or r == ((size_t)-2) |
| * and stream is in an error state or at EOF with a |
| * partially complete wchar. */ |
| __set_errno(EILSEQ); /* In case of incomplete conversion. */ |
| sc->mb_fail = 1; |
| } |
| |
| SUCCESS: |
| sc->width = width; /* Restore width. */ |
| |
| return (int)((ssize_t) r); |
| } |
| |
| #endif /* L_vfscanf */ |
| |
| #ifdef L_vfwscanf |
| |
| /* This gets called by __scan_getc. __scan_getc is called by vfwscanf |
| * when the next wide char is expected to be valid ascii (digits). |
| */ |
| static int sc_getc(register struct scan_cookie *sc) |
| { |
| wint_t wc; |
| |
| if (__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp)) { |
| if (sc->fp->__bufpos < sc->fp->__bufend) { |
| wc = *((wchar_t *)(sc->fp->__bufpos)); |
| sc->fp->__bufpos += sizeof(wchar_t); |
| } else { |
| sc->fp->__modeflags |= __FLAG_EOF; |
| return EOF; |
| } |
| } else if ((wc = fgetwc_unlocked(sc->fp)) == WEOF) { |
| return EOF; |
| } |
| |
| sc->ungot_wflag = 1; |
| sc->ungot_wchar = wc; |
| sc->ungot_wchar_width = sc->fp->__ungot_width[0]; |
| |
| #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ |
| if (wc == sc->thousands_sep_wc) { |
| wc = ','; |
| } else |
| #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| if (wc == sc->decpt_wc) { |
| wc = '.'; |
| } else |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| sc->wc = sc->ungot_char = wc; |
| |
| return (int) wc; |
| } |
| |
| static int scan_getwc(register struct scan_cookie *sc) |
| { |
| wint_t wc; |
| |
| sc->wc = WEOF; |
| |
| if (--sc->width < 0) { |
| sc->ungot_flag |= 2; |
| return -1; |
| } |
| |
| if (sc->ungot_flag == 0) { |
| if (__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp)) { |
| if (sc->fp->__bufpos < sc->fp->__bufend) { |
| wc = *((wchar_t *)(sc->fp->__bufpos)); |
| sc->fp->__bufpos += sizeof(wchar_t); |
| } else { |
| sc->ungot_flag |= 2; |
| return -1; |
| } |
| } else if ((wc = fgetwc_unlocked(sc->fp)) == WEOF) { |
| sc->ungot_flag |= 2; |
| return -1; |
| } |
| sc->ungot_wflag = 1; |
| sc->ungot_char = wc; |
| sc->ungot_wchar_width = sc->fp->__ungot_width[0]; |
| } else { |
| assert(sc->ungot_flag == 1); |
| sc->ungot_flag = 0; |
| } |
| |
| ++sc->nread; |
| sc->wc = sc->ungot_char; |
| |
| return 0; |
| } |
| |
| |
| #endif /* L_vfwscanf */ |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| |
| static __inline void kill_scan_cookie(register struct scan_cookie *sc) |
| { |
| #ifdef L_vfscanf |
| |
| if (sc->ungot_flag & 1) { |
| #if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__) |
| if (!__STDIO_STREAM_IS_FAKE_VSSCANF_NB(sc->fp)) { |
| ungetc(sc->ungot_char, sc->fp); |
| } |
| #else |
| ungetc(sc->ungot_char, sc->fp); |
| #endif |
| /* Deal with distiction between user and scanf ungots. */ |
| if (sc->nread == 0) { /* Only one char was read... app ungot? */ |
| sc->fp->__ungot[1] = sc->app_ungot; /* restore ungot state. */ |
| } else { |
| sc->fp->__ungot[1] = 0; |
| } |
| } |
| |
| #else |
| |
| if ((sc->ungot_flag & 1) && (sc->ungot_wflag & 1) |
| && !__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp) |
| && (sc->fp->__state.__mask == 0) |
| ) { |
| ungetwc(sc->ungot_char, sc->fp); |
| /* Deal with distiction between user and scanf ungots. */ |
| if (sc->nread == 0) { /* Only one char was read... app ungot? */ |
| sc->fp->__ungot[1] = sc->app_ungot; /* restore ungot state. */ |
| } else { |
| sc->fp->__ungot[1] = 0; |
| } |
| sc->fp->__ungot_width[1] = sc->ungot_wchar_width; |
| } |
| |
| #endif |
| } |
| |
| |
| int VFSCANF (FILE *__restrict fp, const Wchar *__restrict format, va_list arg) |
| { |
| const Wuchar *fmt; |
| unsigned char *b; |
| |
| #ifdef L_vfwscanf |
| wchar_t wbuf[1]; |
| wchar_t *wb; |
| #endif /* L_vfwscanf */ |
| |
| #if defined(__UCLIBC_HAS_LOCALE__) && !defined(L_vfwscanf) || !defined(L_vfscanf) |
| mbstate_t mbstate; |
| #endif |
| |
| struct scan_cookie sc; |
| psfs_t psfs; |
| int i; |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning TODO: Fix MAX_DIGITS. We do not do binary, so...! |
| #endif |
| #define MAX_DIGITS 65 /* Allow one leading 0. */ |
| unsigned char buf[MAX_DIGITS+2]; |
| #ifdef L_vfscanf |
| unsigned char scanset[UCHAR_MAX + 1]; |
| unsigned char invert; /* Careful! Meaning changes. */ |
| #endif /* L_vfscanf */ |
| unsigned char fail; |
| unsigned char zero_conversions = 1; |
| __STDIO_AUTO_THREADLOCK_VAR; |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning TODO: Make checking of the format string in C locale an option. |
| #endif |
| /* To support old programs, don't check mb validity if in C locale. */ |
| #if defined(__UCLIBC_HAS_LOCALE__) && !defined(L_vfwscanf) |
| /* ANSI/ISO C99 requires format string to be a valid multibyte string |
| * beginning and ending in its initial shift state. */ |
| if (__UCLIBC_CURLOCALE->encoding != __ctype_encoding_7_bit) { |
| const char *p = format; |
| mbstate.__mask = 0; /* Initialize the mbstate. */ |
| if (mbsrtowcs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) { |
| __set_errno(EINVAL); /* Format string is invalid. */ |
| return 0; |
| } |
| } |
| #endif /* defined(__UCLIBC_HAS_LOCALE__) && !defined(L_vfwscanf) */ |
| |
| #if defined(NL_ARGMAX) && (NL_ARGMAX > 0) |
| psfs.num_pos_args = -1; /* Must start at -1. */ |
| /* Initialize positional arg ptrs to NULL. */ |
| memset(psfs.pos_args, 0, sizeof(psfs.pos_args)); |
| #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ |
| |
| __STDIO_AUTO_THREADLOCK(fp); |
| |
| __STDIO_STREAM_VALIDATE(fp); |
| |
| __init_scan_cookie(&sc,fp); |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| sc.sc_getc = sc_getc; |
| sc.ungot_wchar_width = sc.fp->__ungot_width[1]; |
| |
| #ifdef L_vfwscanf |
| |
| #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ |
| if (*sc.grouping) { |
| sc.thousands_sep = (const unsigned char *) ","; |
| sc.tslen = 1; |
| } |
| #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| sc.fake_decpt = (const unsigned char *) "."; |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| |
| #else /* L_vfwscanf */ |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| sc.fake_decpt = sc.decpt; |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| |
| #endif /* L_vfwscanf */ |
| |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| psfs.cnt = 0; |
| |
| /* Note: If we ever wanted to support non-nice codesets, we |
| * would really need to do a mb->wc conversion here in the |
| * vfscanf case. Related changes would have to be made in |
| * the code that follows... basicly wherever fmt appears. */ |
| for (fmt = (const Wuchar *) format ; *fmt ; /* ++fmt */) { |
| |
| psfs.store = 1; |
| psfs.flags = 0; |
| #ifndef NDEBUG |
| psfs.cur_ptr = NULL; /* Debugging aid. */ |
| #endif /* NDEBUG */ |
| |
| |
| sc.ungot_flag &= 1; /* Clear (possible fake) EOF. */ |
| sc.width = psfs.max_width = INT_MAX; |
| |
| /* Note: According to the standards, vfscanf does use isspace |
| * here. So, if we did a mb->wc conversion, we would have to do |
| * something like |
| * ((((__uwchar_t)wc) < UCHAR_MAX) && isspace(wc)) |
| * because wc might not be in the allowed domain. */ |
| if (ISSPACE(*fmt)) { |
| do { |
| ++fmt; |
| } while (ISSPACE(*fmt)); |
| --fmt; |
| psfs.conv_num = CONV_whitespace; |
| goto DO_WHITESPACE; |
| } |
| |
| if (*fmt == '%') { /* Conversion specification. */ |
| if (*++fmt == '%') { /* Remember, '%' eats whitespace too. */ |
| /* Note: The standard says no conversion occurs. |
| * So do not reset zero_conversions flag. */ |
| psfs.conv_num = CONV_percent; |
| goto DO_CONVERSION; |
| } |
| |
| |
| #ifdef L_vfscanf |
| psfs.fmt = fmt; |
| #else /* L_vfscanf */ |
| { |
| const __uwchar_t *wf = fmt; |
| psfs.fmt = b = buf; |
| |
| while (*wf && __isascii(*wf) && (b < buf + sizeof(buf) - 1)) { |
| *b++ = *wf++; |
| } |
| #ifdef __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ |
| #error this is wrong... we need to ched in __psfs_parse_spec instead since this checks last char in buffer and conversion my have stopped before it. |
| if ((*b == 'a') && ((*wf == '[') || ((*wf|0x20) == 's'))) { |
| goto DONE; /* Spec was excessively long. */ |
| } |
| #endif /* __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ */ |
| *b = 0; |
| if (b == buf) { /* Bad conversion specifier! */ |
| goto DONE; |
| } |
| } |
| #endif /* L_vfscanf */ |
| if ((i = __psfs_parse_spec(&psfs)) < 0) { /* Bad conversion specifier! */ |
| goto DONE; |
| } |
| fmt += i; |
| |
| if (psfs.store) { |
| #if defined(NL_ARGMAX) && (NL_ARGMAX > 0) |
| if (psfs.num_pos_args == -2) { |
| psfs.cur_ptr = va_arg(arg, void *); |
| } else { |
| while (psfs.cur_pos_arg > psfs.num_pos_args) { |
| psfs.pos_args[++psfs.num_pos_args] = va_arg(arg, void *); |
| } |
| psfs.cur_ptr = psfs.pos_args[psfs.cur_pos_arg]; |
| } |
| #else /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ |
| psfs.cur_ptr = va_arg(arg, void *); |
| #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ |
| } |
| |
| DO_CONVERSION: |
| /* First, consume white-space if not n, c, [, C, or l[. */ |
| if ((((1L << CONV_n)|(1L << CONV_C)|(1L << CONV_c) |
| |(1L << CONV_LEFTBRACKET)|(1L << CONV_leftbracket)) |
| & (1L << psfs.conv_num)) == 0 |
| ) { |
| DO_WHITESPACE: |
| while ((__scan_getc(&sc) >= 0) |
| #ifdef L_vfscanf |
| && isspace(sc.cc) |
| #else /* L_vfscanf */ |
| && iswspace(sc.wc) |
| #endif /* L_vfscanf */ |
| ) {} |
| __scan_ungetc(&sc); |
| if (psfs.conv_num == CONV_whitespace) { |
| goto NEXT_FMT; |
| } |
| } |
| |
| sc.width = psfs.max_width; /* Now limit the max width. */ |
| |
| if (sc.width == 0) { /* 0 width is forbidden. */ |
| goto DONE; |
| } |
| |
| |
| if (psfs.conv_num == CONV_percent) { |
| goto MATCH_CHAR; |
| } |
| |
| if (psfs.conv_num == CONV_n) { |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning CONSIDER: Should %n count as a conversion as far as EOF return value? |
| #endif |
| /* zero_conversions = 0; */ |
| if (psfs.store) { |
| _store_inttype(psfs.cur_ptr, psfs.dataargtype, |
| (uintmax_t) sc.nread); |
| } |
| goto NEXT_FMT; |
| } |
| |
| if (psfs.conv_num <= CONV_A) { /* pointer, integer, or float spec */ |
| int r = __psfs_do_numeric(&psfs, &sc); |
| #ifndef L_vfscanf |
| if (sc.ungot_wflag == 1) { /* fix up '?', '.', and ',' hacks */ |
| sc.cc = sc.ungot_char = sc.ungot_wchar; |
| } |
| #endif |
| if (r != -1) { /* Either success or a matching failure. */ |
| zero_conversions = 0; |
| } |
| if (r < 0) { |
| goto DONE; |
| } |
| goto NEXT_FMT; |
| } |
| |
| /* Do string conversions here since they are not common code. */ |
| |
| |
| #ifdef L_vfscanf |
| |
| if |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| (psfs.conv_num >= CONV_LEFTBRACKET) |
| #else /* __UCLIBC_HAS_WCHAR__ */ |
| (psfs.conv_num >= CONV_c) |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| { |
| b = (psfs.store ? ((unsigned char *) psfs.cur_ptr) : buf); |
| fail = 1; |
| |
| if (psfs.conv_num == CONV_c) { |
| if (sc.width == INT_MAX) { |
| sc.width = 1; |
| } |
| |
| while (__scan_getc(&sc) >= 0) { |
| zero_conversions = 0; |
| *b = sc.cc; |
| b += psfs.store; |
| } |
| __scan_ungetc(&sc); |
| if (sc.width > 0) { /* Failed to read all required. */ |
| goto DONE; |
| } |
| psfs.cnt += psfs.store; |
| goto NEXT_FMT; |
| } |
| |
| if (psfs.conv_num == CONV_s) { |
| /* Yes, believe it or not, a %s conversion can store nuls. */ |
| while ((__scan_getc(&sc) >= 0) && !isspace(sc.cc)) { |
| zero_conversions = 0; |
| *b = sc.cc; |
| b += psfs.store; |
| fail = 0; |
| } |
| } else { |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| assert((psfs.conv_num == CONV_LEFTBRACKET) || \ |
| (psfs.conv_num == CONV_leftbracket)); |
| #else /* __UCLIBC_HAS_WCHAR__ */ |
| assert((psfs.conv_num == CONV_leftbracket)); |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| |
| invert = 0; |
| |
| if (*++fmt == '^') { |
| ++fmt; |
| invert = 1; |
| } |
| memset(scanset, invert, sizeof(scanset)); |
| invert = 1-invert; |
| |
| if (*fmt == ']') { |
| scanset[(int)(']')] = invert; |
| ++fmt; |
| } |
| |
| while (*fmt != ']') { |
| if (!*fmt) { /* No closing ']'. */ |
| goto DONE; |
| } |
| if ((*fmt == '-') && (fmt[1] != ']') |
| && (fmt[-1] < fmt[1]) /* sorted? */ |
| ) { /* range */ |
| ++fmt; |
| i = fmt[-2]; |
| /* Note: scanset[i] should already have been done |
| * in the previous iteration. */ |
| do { |
| scanset[++i] = invert; |
| } while (i < *fmt); |
| /* Safe to fall through, and a bit smaller. */ |
| } |
| /* literal char */ |
| scanset[(int) *fmt] = invert; |
| ++fmt; |
| } |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| if (psfs.conv_num == CONV_LEFTBRACKET) { |
| goto DO_LEFTBRACKET; |
| } |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| |
| |
| while (__scan_getc(&sc) >= 0) { |
| zero_conversions = 0; |
| if (!scanset[sc.cc]) { |
| break; |
| } |
| *b = sc.cc; |
| b += psfs.store; |
| fail = 0; |
| } |
| } |
| /* Common tail for processing of %s and %[. */ |
| |
| __scan_ungetc(&sc); |
| if (fail) { /* nothing stored! */ |
| goto DONE; |
| } |
| *b = 0; /* Nul-terminate string. */ |
| psfs.cnt += psfs.store; |
| goto NEXT_FMT; |
| } |
| |
| #ifdef __UCLIBC_HAS_WCHAR__ |
| DO_LEFTBRACKET: /* Need to do common wide init. */ |
| if (psfs.conv_num >= CONV_C) { |
| wchar_t wbuf[1]; |
| wchar_t *wb; |
| |
| sc.mbstate.__mask = 0; |
| |
| wb = (psfs.store ? ((wchar_t *) psfs.cur_ptr) : wbuf); |
| fail = 1; |
| |
| if (psfs.conv_num == CONV_C) { |
| if (sc.width == INT_MAX) { |
| sc.width = 1; |
| } |
| |
| while (scan_getwc(&sc) >= 0) { |
| zero_conversions = 0; |
| assert(sc.width >= 0); |
| *wb = sc.wc; |
| wb += psfs.store; |
| } |
| |
| __scan_ungetc(&sc); |
| if (sc.width > 0) { /* Failed to read all required. */ |
| goto DONE; |
| } |
| psfs.cnt += psfs.store; |
| goto NEXT_FMT; |
| } |
| |
| |
| if (psfs.conv_num == CONV_S) { |
| /* Yes, believe it or not, a %s conversion can store nuls. */ |
| while (scan_getwc(&sc) >= 0) { |
| zero_conversions = 0; |
| if ((((__uwchar_t)(sc.wc)) <= UCHAR_MAX) && isspace(sc.wc)) { |
| break; |
| } |
| *wb = sc.wc; |
| wb += psfs.store; |
| fail = 0; |
| } |
| } else { |
| assert(psfs.conv_num == CONV_LEFTBRACKET); |
| |
| while (scan_getwc(&sc) >= 0) { |
| zero_conversions = 0; |
| if (((__uwchar_t) sc.wc) <= UCHAR_MAX) { |
| if (!scanset[sc.wc]) { |
| break; |
| } |
| } else if (invert) { |
| break; |
| } |
| *wb = sc.wc; |
| wb += psfs.store; |
| fail = 0; |
| } |
| } |
| /* Common tail for processing of %ls and %l[. */ |
| |
| __scan_ungetc(&sc); |
| if (fail || sc.mb_fail) { /* Nothing stored or mb error. */ |
| goto DONE; |
| } |
| *wb = 0; /* Nul-terminate string. */ |
| psfs.cnt += psfs.store; |
| goto NEXT_FMT; |
| |
| } |
| |
| #endif /* __UCLIBC_HAS_WCHAR__ */ |
| #else /* L_vfscanf */ |
| |
| if (psfs.conv_num >= CONV_C) { |
| b = buf; |
| wb = wbuf; |
| if (psfs.conv_num >= CONV_c) { |
| mbstate.__mask = 0; /* Initialize the mbstate. */ |
| if (psfs.store) { |
| b = (unsigned char *) psfs.cur_ptr; |
| } |
| } else { |
| if (psfs.store) { |
| wb = (wchar_t *) psfs.cur_ptr; |
| } |
| } |
| fail = 1; |
| |
| |
| if ((psfs.conv_num == CONV_C) || (psfs.conv_num == CONV_c)) { |
| if (sc.width == INT_MAX) { |
| sc.width = 1; |
| } |
| |
| while (scan_getwc(&sc) >= 0) { |
| zero_conversions = 0; |
| if (psfs.conv_num == CONV_C) { |
| *wb = sc.wc; |
| wb += psfs.store; |
| } else { |
| i = wcrtomb((char*) b, sc.wc, &mbstate); |
| if (i < 0) { /* Conversion failure. */ |
| goto DONE_DO_UNGET; |
| } |
| if (psfs.store) { |
| b += i; |
| } |
| } |
| } |
| __scan_ungetc(&sc); |
| if (sc.width > 0) { /* Failed to read all required. */ |
| goto DONE; |
| } |
| psfs.cnt += psfs.store; |
| goto NEXT_FMT; |
| } |
| |
| if ((psfs.conv_num == CONV_S) || (psfs.conv_num == CONV_s)) { |
| /* Yes, believe it or not, a %s conversion can store nuls. */ |
| while (scan_getwc(&sc) >= 0) { |
| zero_conversions = 0; |
| if (iswspace(sc.wc)) { |
| break; |
| } |
| if (psfs.conv_num == CONV_S) { |
| *wb = sc.wc; |
| wb += psfs.store; |
| } else { |
| i = wcrtomb((char*) b, sc.wc, &mbstate); |
| if (i < 0) { /* Conversion failure. */ |
| goto DONE_DO_UNGET; |
| } |
| if (psfs.store) { |
| b += i; |
| } |
| } |
| fail = 0; |
| } |
| } else { |
| const wchar_t *sss; |
| const wchar_t *ssp; |
| unsigned char invert = 0; |
| |
| assert((psfs.conv_num == CONV_LEFTBRACKET) |
| || (psfs.conv_num == CONV_leftbracket)); |
| |
| if (*++fmt == '^') { |
| ++fmt; |
| invert = 1; |
| } |
| sss = (const wchar_t *) fmt; |
| if (*fmt == ']') { |
| ++fmt; |
| } |
| while (*fmt != ']') { |
| if (!*fmt) { /* No closing ']'. */ |
| goto DONE; |
| } |
| if ((*fmt == '-') && (fmt[1] != ']') |
| && (fmt[-1] < fmt[1]) /* sorted? */ |
| ) { /* range */ |
| ++fmt; |
| } |
| ++fmt; |
| } |
| /* Ok... a valid scanset spec. */ |
| |
| while (scan_getwc(&sc) >= 0) { |
| zero_conversions = 0; |
| ssp = sss; |
| do { /* We know sss < fmt. */ |
| if (*ssp == '-') { /* possible range... */ |
| /* Note: We accept a-c-e (ordered) as |
| * equivalent to a-e. */ |
| if (ssp > sss) { |
| if ((++ssp < (const wchar_t *) fmt) |
| && (ssp[-2] < *ssp) /* sorted? */ |
| ) { /* yes */ |
| if ((sc.wc >= ssp[-2]) |
| && (sc.wc <= *ssp)) { |
| break; |
| } |
| continue; /* not in range */ |
| } |
| --ssp; /* oops... '-' at end, so back up */ |
| } |
| /* false alarm... a literal '-' */ |
| } |
| if (sc.wc == *ssp) { /* Matched literal char. */ |
| break; |
| } |
| } while (++ssp < (const wchar_t *) fmt); |
| |
| if ((ssp == (const wchar_t *) fmt) ^ invert) { |
| /* no match and not inverting |
| * or match and inverting */ |
| break; |
| } |
| if (psfs.conv_num == CONV_LEFTBRACKET) { |
| *wb = sc.wc; |
| wb += psfs.store; |
| } else { |
| i = wcrtomb((char*) b, sc.wc, &mbstate); |
| if (i < 0) { /* Conversion failure. */ |
| goto DONE_DO_UNGET; |
| } |
| if (psfs.store) { |
| b += i; |
| } |
| } |
| fail = 0; |
| } |
| } |
| /* Common tail for processing of %s and %[. */ |
| |
| __scan_ungetc(&sc); |
| if (fail) { /* nothing stored! */ |
| goto DONE; |
| } |
| *wb = 0; /* Nul-terminate string. */ |
| *b = 0; |
| psfs.cnt += psfs.store; |
| goto NEXT_FMT; |
| } |
| |
| #endif /* L_vfscanf */ |
| |
| assert(0); |
| goto DONE; |
| } /* conversion specification */ |
| |
| MATCH_CHAR: |
| if (__scan_getc(&sc) != *fmt) { |
| #ifdef L_vfwscanf |
| DONE_DO_UNGET: |
| #endif /* L_vfwscanf */ |
| __scan_ungetc(&sc); |
| goto DONE; |
| } |
| |
| NEXT_FMT: |
| ++fmt; |
| if (__FERROR_UNLOCKED(fp)) { |
| break; |
| } |
| } |
| |
| DONE: |
| if (__FERROR_UNLOCKED(fp) || (*fmt && zero_conversions && __FEOF_UNLOCKED(fp))) { |
| psfs.cnt = EOF; /* Yes, vfwscanf also returns EOF. */ |
| } |
| |
| kill_scan_cookie(&sc); |
| |
| __STDIO_STREAM_VALIDATE(fp); |
| |
| __STDIO_AUTO_THREADUNLOCK(fp); |
| |
| return psfs.cnt; |
| } |
| libc_hidden_def(VFSCANF) |
| #endif |
| /**********************************************************************/ |
| #ifdef L___psfs_do_numeric |
| |
| static const unsigned char spec_base[] = SPEC_BASE; |
| static const unsigned char nil_string[] = "(nil)"; |
| |
| int attribute_hidden __psfs_do_numeric(psfs_t *psfs, struct scan_cookie *sc) |
| { |
| unsigned char *b; |
| const unsigned char *p; |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| int exp_adjust = 0; |
| #endif |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning TODO: Fix MAX_DIGITS. We do not do binary, so...! |
| #warning TODO: Fix buf! |
| #endif |
| #define MAX_DIGITS 65 /* Allow one leading 0. */ |
| unsigned char buf[MAX_DIGITS+2+ 100]; |
| unsigned char usflag, base; |
| unsigned char nonzero = 0; |
| unsigned char seendigit = 0; |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning CONSIDER: What should be returned for an invalid conversion specifier? |
| #endif |
| #ifndef __UCLIBC_HAS_FLOATS__ |
| if (psfs->conv_num > CONV_i) { /* floating point */ |
| goto DONE; |
| } |
| #endif |
| |
| base = spec_base[psfs->conv_num - CONV_p]; |
| usflag = (psfs->conv_num <= CONV_u); /* (1)0 if (un)signed */ |
| b = buf; |
| |
| |
| if (psfs->conv_num == CONV_p) { /* Pointer */ |
| p = nil_string; |
| do { |
| if ((__scan_getc(sc) < 0) || (*p != sc->cc)) { |
| __scan_ungetc(sc); |
| if (p > nil_string) { |
| /* We matched at least the '(' so even if we |
| * are at eof, we can not match a pointer. */ |
| return -2; /* Matching failure */ |
| } |
| break; |
| } |
| if (!*++p) { /* Matched (nil), so no unget necessary. */ |
| if (psfs->store) { |
| ++psfs->cnt; |
| _store_inttype(psfs->cur_ptr, psfs->dataargtype, |
| (uintmax_t)0); |
| } |
| return 0; |
| } |
| } while (1); |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning CONSIDER: Should we require a 0x prefix and disallow +/- for pointer %p? |
| #endif /* __UCLIBC_MJN3_ONLY__ */ |
| } |
| |
| __scan_getc(sc); |
| if (sc->cc < 0) { |
| return -1; /* Input failure (nothing read yet). */ |
| } |
| |
| if ((sc->cc == '+') || (sc->cc == '-')) { /* Handle leading sign.*/ |
| *b++ = sc->cc; |
| __scan_getc(sc); |
| } |
| |
| if ((base & 0xef) == 0) { /* 0xef is ~16, so 16 or 0. */ |
| if (sc->cc == '0') { /* Possibly set base and handle prefix. */ |
| __scan_getc(sc); |
| if ((sc->cc|0x20) == 'x') { /* Assumes ascii.. x or X. */ |
| if (__scan_getc(sc) < 0) { |
| /* Either EOF or error (including wc outside char range). |
| * If EOF or error, this is a matching failure (we read 0x). |
| * If wc outside char range, this is also a matching failure. |
| * Hence, we do an unget (although not really necessary here |
| * and fail. */ |
| goto DONE_DO_UNGET; /* matching failure */ |
| } |
| base = 16; /* Base 16 for sure now. */ |
| #ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__ |
| /* The prefix is required for hexadecimal floats. */ |
| *b++ = '0'; |
| *b++ = 'x'; |
| #endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */ |
| } else { /* oops... back up */ |
| __scan_ungetc(sc); |
| sc->cc = '0'; /* NASTY HACK! */ |
| |
| base = (base >> 1) + 8; /* 0->8, 16->16. no 'if' */ |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| if (psfs->conv_num > CONV_i) { /* floating point */ |
| base = 10; |
| } |
| #endif |
| } |
| } else if (!base) { |
| base = 10; |
| } |
| } |
| |
| /***************** digit grouping **********************/ |
| #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ |
| |
| if ((psfs->flags & FLAG_THOUSANDS) && (base == 10) |
| && *(p = (const unsigned char *) sc->grouping) |
| ) { |
| |
| int nblk1, nblk2, nbmax, lastblock, pass, i; |
| |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning CONSIDER: Should we initalize the grouping blocks in __init_scan_cookie()? |
| #endif /* __UCLIBC_MJN3_ONLY__ */ |
| nbmax = nblk2 = nblk1 = *p; |
| if (*++p) { |
| nblk2 = *p; |
| if (nbmax < nblk2) { |
| nbmax = nblk2; |
| } |
| assert(!p[1]); |
| } |
| |
| /* Note: for printf, if 0 and \' flags appear then |
| * grouping is done before 0-padding. Should we |
| * strip leading 0's first? Or add a 0 flag? */ |
| |
| /* For vfwscanf, sc_getc translates, so the value of sc->cc is |
| * either EOF or a char. */ |
| |
| if (!__isdigit_char_or_EOF(sc->cc)) { /* No starting digit! */ |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| if (psfs->conv_num > CONV_i) { /* floating point */ |
| goto NO_STARTING_DIGIT; |
| } |
| #endif |
| goto DONE_DO_UNGET; |
| } |
| |
| if (sc->cc == '0') { |
| seendigit = 1; |
| *b++ = '0'; /* Store the first 0. */ |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning CONSIDER: Should leading 0s be skipped before digit grouping? (printf 0 pad) |
| #endif /* __UCLIBC_MJN3_ONLY__ */ |
| #if 0 |
| do { /* But ignore all subsequent 0s. */ |
| __scan_getc(sc); |
| } while (sc->cc == '0'); |
| #endif |
| } |
| pass = 0; |
| lastblock = 0; |
| do { |
| i = 0; |
| while (__isdigit_char_or_EOF(sc->cc)) { |
| seendigit = 1; |
| if (i == nbmax) { /* too many digits for a block */ |
| #ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ |
| if (!pass) { /* treat as nongrouped */ |
| if (nonzero) { |
| goto DO_NO_GROUP; |
| } |
| goto DO_TRIM_LEADING_ZEROS; |
| } |
| #endif |
| if (nbmax > nblk1) { |
| goto DONE_DO_UNGET; /* matching failure */ |
| } |
| goto DONE_GROUPING_DO_UNGET; /* nbmax == nblk1 */ |
| } |
| ++i; |
| |
| if (nonzero || (sc->cc != '0')) { |
| if (b < buf + MAX_DIGITS) { |
| *b++ = sc->cc; |
| nonzero = 1; |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| } else { |
| ++exp_adjust; |
| #endif |
| } |
| } |
| |
| __scan_getc(sc); |
| } |
| |
| if (i) { /* we saw digits digits */ |
| if ((i == nblk2) || ((i < nblk2) && !pass)) { |
| /* (possible) outer grp */ |
| p = sc->thousands_sep; |
| if (*p == sc->cc) { /* first byte matches... */ |
| /* so check if grouping mb char */ |
| /* Since 1st matched, either match or fail now |
| * unless EOF (yuk) */ |
| __scan_getc(sc); |
| MBG_LOOP: |
| if (!*++p) { /* is a grouping mb char */ |
| lastblock = i; |
| ++pass; |
| continue; |
| } |
| if (*p == sc->cc) { |
| __scan_getc(sc); |
| goto MBG_LOOP; |
| } |
| /* bad grouping mb char! */ |
| __scan_ungetc(sc); |
| if ((sc->cc >= 0) || (p > sc->thousands_sep + 1)) { |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| /* We failed to match a thousep mb char, and |
| * we've read too much to recover. But if |
| * this is a floating point conversion and |
| * the initial portion of the decpt mb char |
| * matches, then we may still be able to |
| * recover. */ |
| int k = p - sc->thousands_sep - 1; |
| |
| if ((psfs->conv_num > CONV_i) /* float conversion */ |
| && (!pass || (i == nblk1)) /* possible last */ |
| && !memcmp(sc->thousands_sep, sc->fake_decpt, k) |
| /* and prefix matched, so could be decpt */ |
| ) { |
| __scan_getc(sc); |
| p = sc->fake_decpt + k; |
| do { |
| if (!*++p) { |
| strcpy((char*) b, (char*) sc->decpt); |
| b += sc->decpt_len; |
| goto GOT_DECPT; |
| } |
| if (*p != sc->cc) { |
| __scan_ungetc(sc); |
| break; /* failed */ |
| } |
| __scan_getc(sc); |
| } while (1); |
| } |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| goto DONE; |
| } |
| /* was EOF and 1st, so recoverable. */ |
| } |
| } |
| if ((i == nblk1) || ((i < nblk1) && !pass)) { |
| /* got an inner group */ |
| goto DONE_GROUPING_DO_UNGET; |
| } |
| goto DONE_DO_UNGET; /* Matching failure. */ |
| } /* i != 0 */ |
| |
| assert(pass); |
| |
| goto DONE_DO_UNGET; |
| } while (1); |
| |
| assert(0); /* Should never get here. */ |
| } |
| |
| #endif /***************** digit grouping **********************/ |
| |
| /* Not grouping so first trim all but one leading 0. */ |
| #ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ |
| DO_TRIM_LEADING_ZEROS: |
| #endif /* __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ */ |
| if (sc->cc == '0') { |
| seendigit = 1; |
| *b++ = '0'; /* Store the first 0. */ |
| do { /* But ignore all subsequent 0s. */ |
| __scan_getc(sc); |
| } while (sc->cc == '0'); |
| } |
| |
| #ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ |
| DO_NO_GROUP: |
| #endif /* __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ */ |
| /* At this point, we're ready to start reading digits. */ |
| |
| #define valid_digit(cc,base) (isxdigit(cc) && ((base == 16) || (cc - '0' < base))) |
| |
| while (valid_digit(sc->cc,base)) { /* Now for significant digits.*/ |
| if (b - buf < MAX_DIGITS) { |
| nonzero = seendigit = 1; /* Set nonzero too 0s trimmed above. */ |
| *b++ = sc->cc; |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| } else { |
| ++exp_adjust; |
| #endif |
| } |
| __scan_getc(sc); |
| } |
| |
| #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ |
| DONE_GROUPING_DO_UNGET: |
| #endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ |
| if (psfs->conv_num <= CONV_i) { /* integer conversion */ |
| __scan_ungetc(sc); |
| *b = 0; /* null-terminate */ |
| if (!seendigit) { |
| goto DONE; /* No digits! */ |
| } |
| if (psfs->store) { |
| if (*buf == '-') { |
| usflag = 0; |
| } |
| ++psfs->cnt; |
| _store_inttype(psfs->cur_ptr, psfs->dataargtype, |
| (uintmax_t) STRTOUIM((char *) buf, NULL, base, 1-usflag)); |
| } |
| return 0; |
| } |
| |
| #ifdef __UCLIBC_HAS_FLOATS__ |
| |
| /* At this point, we have everything left of the decimal point or exponent. */ |
| #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ |
| NO_STARTING_DIGIT: |
| #endif |
| p = sc->fake_decpt; |
| do { |
| if (!*p) { |
| strcpy((char *) b, (char *) sc->decpt); |
| b += sc->decpt_len; |
| break; |
| } |
| if (*p != sc->cc) { |
| if (p > sc->fake_decpt) { |
| goto DONE_DO_UNGET; /* matching failure (read some of decpt) */ |
| } |
| goto DO_DIGIT_CHECK; |
| } |
| ++p; |
| __scan_getc(sc); |
| } while (1); |
| |
| #ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ |
| GOT_DECPT: |
| #endif |
| if (!nonzero) { |
| if (sc->cc == '0') { |
| assert(exp_adjust == 0); |
| *b++ = '0'; |
| ++exp_adjust; |
| seendigit = 1; |
| do { |
| --exp_adjust; |
| __scan_getc(sc); |
| } while (sc->cc == '0'); |
| } |
| } |
| |
| while (valid_digit(sc->cc,base)) { /* Process fractional digits.*/ |
| if (b - buf < MAX_DIGITS) { |
| seendigit = 1; |
| *b++ = sc->cc; |
| } |
| __scan_getc(sc); |
| } |
| |
| DO_DIGIT_CHECK: |
| /* Hmm... no decimal point. */ |
| if (!seendigit) { |
| static const unsigned char nan_inf_str[] = "an\0nfinity"; |
| |
| if (base == 16) { /* We had a prefix, but no digits! */ |
| goto DONE_DO_UNGET; /* matching failure */ |
| } |
| |
| /* Avoid tolower problems for INFINITY in the tr_TR locale. (yuk)*/ |
| #undef TOLOWER |
| #define TOLOWER(C) ((C)|0x20) |
| |
| switch (TOLOWER(sc->cc)) { |
| case 'i': |
| p = nan_inf_str + 3; |
| break; |
| case 'n': |
| p = nan_inf_str; |
| break; |
| default: |
| /* No digits and not inf or nan. */ |
| goto DONE_DO_UNGET; |
| } |
| |
| *b++ = sc->cc; |
| |
| do { |
| __scan_getc(sc); |
| if (TOLOWER(sc->cc) == *p) { |
| *b++ = sc->cc; |
| ++p; |
| continue; |
| } |
| if (!*p || (p == nan_inf_str + 5)) { /* match nan/infinity or inf */ |
| goto GOT_FLOAT; |
| } |
| /* Unrecoverable. Even if on 1st char, we had no digits. */ |
| goto DONE_DO_UNGET; |
| } while (1); |
| } |
| |
| /* If we get here, we had some digits. */ |
| |
| if ( |
| #ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__ |
| ((base == 16) && (((sc->cc)|0x20) == 'p')) || |
| #endif |
| (((sc->cc)|0x20) == 'e') |
| ) { /* Process an exponent. */ |
| *b++ = sc->cc; |
| |
| __scan_getc(sc); |
| if (sc->cc < 0) { |
| goto DONE_DO_UNGET; /* matching failure.. no exponent digits */ |
| } |
| |
| if ((sc->cc == '+') || (sc->cc == '-')) { /* Signed exponent? */ |
| *b++ = sc->cc; |
| __scan_getc(sc); |
| } |
| |
| #ifdef __UCLIBC_MJN3_ONLY__ |
| #warning TODO: Fix MAX_EXP_DIGITS! |
| #endif |
| #define MAX_EXP_DIGITS 20 |
| assert(seendigit); |
| seendigit = 0; |
| nonzero = 0; |
| |
| if (sc->cc == '0') { |
| seendigit = 1; |
| *b++ = '0'; |
| do { |
| __scan_getc(sc); |
| } while (sc->cc == '0'); |
| } |
| |
| while (__isdigit_char_or_EOF(sc->cc)) { /* Exponent digits (base 10).*/ |
| if (seendigit < MAX_EXP_DIGITS) { |
| ++seendigit; |
| *b++ = sc->cc; |
| } |
| __scan_getc(sc); |
| } |
| |
| if (!seendigit) { /* No digits. Unrecoverable. */ |
| goto DONE_DO_UNGET; |
| } |
| } |
| |
| |
| GOT_FLOAT: |
| *b = 0; |
| { |
| __fpmax_t x; |
| char *e; |
| x = __strtofpmax((char *) buf, &e, exp_adjust); |
| assert(!*e); |
| if (psfs->store) { |
| if (psfs->dataargtype & PA_FLAG_LONG_LONG) { |
| *((long double *)psfs->cur_ptr) = (long double) x; |
| } else if (psfs->dataargtype & PA_FLAG_LONG) { |
| *((double *)psfs->cur_ptr) = (double) x; |
| } else { |
| *((float *)psfs->cur_ptr) = (float) x; |
| } |
| ++psfs->cnt; |
| } |
| __scan_ungetc(sc); |
| return 0; |
| } |
| #endif /* __UCLIBC_HAS_FLOATS__ */ |
| |
| DONE_DO_UNGET: |
| __scan_ungetc(sc); |
| DONE: |
| return -2; /* Matching failure. */ |
| |
| } |
| #endif |
| /**********************************************************************/ |