Macintosh-Tools/Retro68
1
0
Fork 0
mirror of https://github.com/autc04/Retro68.git synced 2024-12-11 19:49:32 +00:00
Code Issues Projects Releases Wiki Activity
89d4565f0d
Retro68/gcc/newlib/libc/stdio/vfwscanf.c
Wolfgang Thaller ec13cc9ce7 fix newlib
2018-12-29 09:59:36 +01:00

1680 lines
40 KiB
C
Raw Blame History

/*-
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
/*
FUNCTION
<<vfwscanf>>, <<vwscanf>>, <<vswscanf>>---scan and format argument list from wide character input
INDEX
vfwscanf
INDEX
_vfwscanf
INDEX
vwscanf
INDEX
_vwscanf
INDEX
vswscanf
INDEX
_vswscanf
SYNOPSIS
#include <stdio.h>
#include <stdarg.h>
int vwscanf(const wchar_t *__restrict <[fmt]>, va_list <[list]>);
int vfwscanf(FILE *__restrict <[fp]>,
const wchar_t *__restrict <[fmt]>, va_list <[list]>);
int vswscanf(const wchar_t *__restrict <[str]>,
const wchar_t *__restrict <[fmt]>, va_list <[list]>);
int _vwscanf(struct _reent *<[reent]>, const wchar_t *<[fmt]>,
va_list <[list]>);
int _vfwscanf(struct _reent *<[reent]>, FILE *<[fp]>,
const wchar_t *<[fmt]>, va_list <[list]>);
int _vswscanf(struct _reent *<[reent]>, const wchar_t *<[str]>,
const wchar_t *<[fmt]>, va_list <[list]>);
DESCRIPTION
<<vwscanf>>, <<vfwscanf>>, and <<vswscanf>> are (respectively) variants
of <<wscanf>>, <<fwscanf>>, and <<swscanf>>. They differ only in
allowing their caller to pass the variable argument list as a
<<va_list>> object (initialized by <<va_start>>) rather than
directly accepting a variable number of arguments.
RETURNS
The return values are consistent with the corresponding functions:
<<vwscanf>> returns the number of input fields successfully scanned,
converted, and stored; the return value does not include scanned
fields which were not stored.
If <<vwscanf>> attempts to read at end-of-file, the return value
is <<EOF>>.
If no fields were stored, the return value is <<0>>.
The routines <<_vwscanf>>, <<_vfwscanf>>, and <<_vswscanf>> are
reentrant versions which take an additional first parameter which points
to the reentrancy structure.
PORTABILITY
C99, POSIX-1.2008
*/
#include <_ansi.h>
#include <reent.h>
#include <newlib.h>
#include <ctype.h>
#include <wctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>
#include <wchar.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include "local.h"
#ifdef INTEGER_ONLY
#define VFWSCANF vfiwscanf
#define _VFWSCANF_R _vfiwscanf_r
#define __SVFWSCANF __svfiwscanf
#ifdef STRING_ONLY
# define __SVFWSCANF_R __ssvfiwscanf_r
#else
# define __SVFWSCANF_R __svfiwscanf_r
#endif
#else
#define VFWSCANF vfwscanf
#define _VFWSCANF_R _vfwscanf_r
#define __SVFWSCANF __svfwscanf
#ifdef STRING_ONLY
# define __SVFWSCANF_R __ssvfwscanf_r
#else
# define __SVFWSCANF_R __svfwscanf_r
#endif
#ifndef NO_FLOATING_POINT
#define FLOATING_POINT
#endif
#endif
#ifdef STRING_ONLY
#undef _newlib_flockfile_start
#undef _newlib_flockfile_exit
#undef _newlib_flockfile_end
#define _newlib_flockfile_start(x) {}
#define _newlib_flockfile_exit(x) {}
#define _newlib_flockfile_end(x) {}
#define _ungetwc_r _sungetwc_r
#define __srefill_r __ssrefill_r
#define _fgetwc_r _sfgetwc_r
#endif
#ifdef FLOATING_POINT
#include <math.h>
#include <float.h>
#include <locale.h>
#ifdef __HAVE_LOCALE_INFO_EXTENDED__
#include "../locale/setlocale.h"
#endif
/* Currently a test is made to see if long double processing is warranted.
This could be changed in the future should the _ldtoa_r code be
preferred over _dtoa_r. */
#define _NO_LONGDBL
#if defined _WANT_IO_LONG_DOUBLE && (LDBL_MANT_DIG > DBL_MANT_DIG)
#undef _NO_LONGDBL
extern _LONG_DOUBLE _wcstold_r (wchar_t *s, wchar_t **sptr);
#endif
#include "floatio.h"
#if ((MAXEXP+MAXFRACT+3) > MB_LEN_MAX)
# define BUF (MAXEXP+MAXFRACT+3) /* 3 = sign + decimal point + NUL */
#else
# define BUF MB_LEN_MAX
#endif
/* An upper bound for how long a long prints in decimal. 4 / 13 approximates
log (2). Add one char for roundoff compensation and one for the sign. */
#define MAX_LONG_LEN ((CHAR_BIT * sizeof (long) - 1) * 4 / 13 + 2)
#else
#define BUF 40
#endif
#define _NO_LONGLONG
#if defined _WANT_IO_LONG_LONG \
&& (defined __GNUC__ || __STDC_VERSION__ >= 199901L)
# undef _NO_LONGLONG
#endif
#define _NO_POS_ARGS
#ifdef _WANT_IO_POS_ARGS
# undef _NO_POS_ARGS
# ifdef NL_ARGMAX
# define MAX_POS_ARGS NL_ARGMAX
# else
# define MAX_POS_ARGS 32
# endif
static void * get_arg (int, va_list *, int *, void **);
#endif /* _WANT_IO_POS_ARGS */
/*
* Flags used during conversion.
*/
#define LONG 0x01 /* l: long or double */
#define LONGDBL 0x02 /* L/ll: long double or long long */
#define SHORT 0x04 /* h: short */
#define CHAR 0x08 /* hh: 8 bit integer */
#define SUPPRESS 0x10 /* suppress assignment */
#define POINTER 0x20 /* weird %p pointer (`fake hex') */
#define NOSKIP 0x40 /* do not skip blanks */
#define MALLOC 0x80 /* handle 'm' modifier */
/*
* The following are used in numeric conversions only:
* SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
* SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
*/
#define SIGNOK 0x80 /* +/- is (still) legal */
#define NDIGITS 0x100 /* no digits detected */
#define DPTOK 0x200 /* (float) decimal point is still legal */
#define EXPOK 0x400 /* (float) exponent (e+3, etc) still legal */
#define PFXOK 0x200 /* 0x prefix is (still) legal */
#define NZDIGITS 0x400 /* no zero digits detected */
#define HAVESIGN 0x10000 /* sign detected */
/*
* Conversion types.
*/
#define CT_CHAR 0 /* %c conversion */
#define CT_CCL 1 /* %[...] conversion */
#define CT_STRING 2 /* %s conversion */
#define CT_INT 3 /* integer, i.e., wcstol or wcstoul */
#define CT_FLOAT 4 /* floating, i.e., wcstod */
#define INCCL(_c) \
(cclcompl ? (wmemchr(ccls, (_c), ccle - ccls) == NULL) : \
(wmemchr(ccls, (_c), ccle - ccls) != NULL))
/*
* vfwscanf
*/
#ifndef STRING_ONLY
#ifndef _REENT_ONLY
int
VFWSCANF (register FILE *__restrict fp,
const wchar_t *__restrict fmt,
va_list ap)
{
struct _reent *reent = _REENT;
CHECK_INIT(reent, fp);
return __SVFWSCANF_R (reent, fp, fmt, ap);
}
int
__SVFWSCANF (register FILE *fp,
wchar_t const *fmt0,
va_list ap)
{
return __SVFWSCANF_R (_REENT, fp, fmt0, ap);
}
#endif /* !_REENT_ONLY */
int
_VFWSCANF_R (struct _reent *data,
register FILE *fp,
const wchar_t *fmt,
va_list ap)
{
CHECK_INIT(data, fp);
return __SVFWSCANF_R (data, fp, fmt, ap);
}
#endif /* !STRING_ONLY */
#ifdef STRING_ONLY
/* When dealing with the swscanf family, we don't want to use the
* regular ungetwc which will drag in file I/O items we don't need.
* So, we create our own trimmed-down version. */
static wint_t
_sungetwc_r (struct _reent *data,
wint_t wc,
register FILE *fp)
{
if (wc == WEOF)
return (WEOF);
/* After ungetc, we won't be at eof anymore */
fp->_flags &= ~__SEOF;
/*
* If we are in the middle of ungetwc'ing, just continue.
* This may require expanding the current ungetc buffer.
*/
if (HASUB (fp))
{
if (fp->_r >= fp->_ub._size && __submore (data, fp))
{
return EOF;
}
fp->_p -= sizeof (wchar_t);
*fp->_p = (wchar_t) wc;
fp->_r += sizeof (wchar_t);
return wc;
}
/*
* If we can handle this by simply backing up, do so,
* but never replace the original character.
* (This makes swscanf() work when scanning `const' data.)
*/
if (fp->_bf._base != NULL && fp->_p > fp->_bf._base
&& ((wchar_t *)fp->_p)[-1] == wc)
{
fp->_p -= sizeof (wchar_t);
fp->_r += sizeof (wchar_t);
return wc;
}
/*
* Create an ungetc buffer.
* Initially, we will use the `reserve' buffer.
*/
fp->_ur = fp->_r;
fp->_up = fp->_p;
fp->_ub._base = fp->_ubuf;
fp->_ub._size = sizeof (fp->_ubuf);
fp->_p = &fp->_ubuf[sizeof (fp->_ubuf) - sizeof (wchar_t)];
*(wchar_t *) fp->_p = wc;
fp->_r = 2;
return wc;
}
extern int __ssrefill_r (struct _reent *ptr, register FILE * fp);
static size_t
_sfgetwc_r (struct _reent * ptr,
FILE * fp)
{
wchar_t wc;
if (fp->_r <= 0 && __ssrefill_r (ptr, fp))
return (WEOF);
wc = *(wchar_t *) fp->_p;
fp->_p += sizeof (wchar_t);
fp->_r -= sizeof (wchar_t);
return (wc);
}
#endif /* STRING_ONLY */
int
__SVFWSCANF_R (struct _reent *rptr,
register FILE *fp,
wchar_t const *fmt0,
va_list ap)
{
register wchar_t *fmt = (wchar_t *) fmt0;
register wint_t c; /* character from format, or conversion */
register size_t width; /* field width, or 0 */
register wchar_t *p = NULL; /* points into all kinds of strings */
register int n; /* handy integer */
register int flags; /* flags as defined above */
register wchar_t *p0; /* saves original value of p when necessary */
int nassigned; /* number of fields assigned */
int nread; /* number of characters consumed from fp */
#ifndef _NO_POS_ARGS
int N; /* arg number */
int arg_index = 0; /* index into args processed directly */
int numargs = 0; /* number of varargs read */
void *args[MAX_POS_ARGS]; /* positional args read */
int is_pos_arg; /* is current format positional? */
#endif
int base = 0; /* base argument to wcstol/wcstoul */
mbstate_t mbs; /* value to keep track of multibyte state */
#define CCFN_PARAMS (struct _reent *, const wchar_t *, wchar_t **, int)
unsigned long (*ccfn)CCFN_PARAMS=0; /* conversion function (wcstol/wcstoul) */
wchar_t buf[BUF]; /* buffer for numeric conversions */
const wchar_t *ccls; /* character class start */
const wchar_t *ccle; /* character class end */
int cclcompl = 0; /* ccl is complemented? */
wint_t wi; /* handy wint_t */
char *mbp = NULL; /* multibyte string pointer for %c %s %[ */
size_t nconv; /* number of bytes in mb. conversion */
char mbbuf[MB_LEN_MAX]; /* temporary mb. character buffer */
char *cp;
short *sp;
int *ip;
#ifdef FLOATING_POINT
float *flp;
_LONG_DOUBLE *ldp;
double *dp;
wchar_t decpt;
#endif
long *lp;
#ifndef _NO_LONGLONG
long long *llp;
#endif
#ifdef _WANT_IO_C99_FORMATS
#define _WANT_IO_POSIX_EXTENSIONS
#endif
#ifdef _WANT_IO_POSIX_EXTENSIONS
/* POSIX requires that fwscanf frees all allocated strings from 'm'
conversions in case it returns EOF. m_ptr is used to keep track.
It will be allocated on the stack the first time an 'm' conversion
takes place, and it will be free'd on return from the function.
This implementation tries to save space by only allocating 8
pointer slots at a time. Most scenarios should never have to call
realloc again. This implementation allows only up to 65528 'm'
conversions per fwscanf invocation for now. That should be enough
for almost all scenarios, right? */
struct m_ptrs {
void ***m_arr; /* Array of pointer args to 'm' conversion */
uint16_t m_siz; /* Number of slots in m_arr */
uint16_t m_cnt; /* Number of valid entries in m_arr */
} *m_ptr = NULL;
#define init_m_ptr() \
do \
{ \
if (!m_ptr) \
{ \
m_ptr = (struct m_ptrs *) alloca (sizeof *m_ptr); \
m_ptr->m_arr = NULL; \
m_ptr->m_siz = 0; \
m_ptr->m_cnt = 0; \
} \
} \
while (0)
#define push_m_ptr(arg) \
do \
{ \
if (m_ptr->m_cnt >= m_ptr->m_siz) \
{ \
void ***n = NULL; \
\
if (m_ptr->m_siz + 8 > 0 && m_ptr->m_siz + 8 < UINT16_MAX) \
n = (void ***) realloc (m_ptr->m_arr, \
(m_ptr->m_siz + 8) * \
sizeof (void **)); \
if (!n) \
{ \
nassigned = EOF; \
goto match_failure; \
} \
m_ptr->m_arr = n; \
m_ptr->m_siz += 8; \
} \
m_ptr->m_arr[m_ptr->m_cnt++] = (void **) (arg); \
} \
while (0)
#define alloc_m_ptr(_type, _p, _p0, _p_p, _w) \
({ \
_p_p = GET_ARG (N, ap, _type **); \
if (!_p_p) \
goto match_failure; \
_p0 = (_type *) malloc ((_w) * sizeof (_type)); \
if (!_p0) \
{ \
nassigned = EOF; \
goto match_failure; \
} \
*_p_p = _p0; \
push_m_ptr (_p_p); \
_p = _p0; \
_w; \
})
/* For char output, check if there's room for at least MB_CUR_MAX
characters. */
#define realloc_m_ptr(_type, _p, _p0, _p_p, _w) \
({ \
size_t _nw = (_w); \
ptrdiff_t _dif = _p - _p0; \
if (_p_p && \
((sizeof (_type) == 1 && _dif >= _nw - MB_CUR_MAX) \
|| _dif >= _nw)) \
{ \
_p0 = (_type *) realloc (_p0, (_nw << 1) * sizeof (_type)); \
if (!_p0) \
{ \
nassigned = EOF; \
goto match_failure; \
} \
_p = _p0 + _dif; \
*_p_p = _p0; \
_nw <<= 1; \
} \
_nw; \
})
#define shrink_m_ptr(_type, _p_p, _w, _cw) \
({ \
size_t _nw = (_w); \
if (_p_p && _nw < _cw) \
{ \
_type *_np_p = (_type *) \
realloc (*_p_p, _nw * sizeof (_type)); \
if (_np_p) \
*_p_p = _np_p; \
} \
})
#define free_m_ptr() \
do \
{ \
if (m_ptr) \
{ \
if (nassigned == EOF) \
{ \
int i; \
for (i = 0; i < m_ptr->m_cnt; ++i) \
{ \
free (*m_ptr->m_arr[i]); \
*m_ptr->m_arr[i] = NULL; \
} \
} \
if (m_ptr->m_arr) \
free (m_ptr->m_arr); \
} \
} \
while (0)
#endif
/* `basefix' is used to avoid `if' tests in the integer scanner */
static const short basefix[17] =
{10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
/* Macro to support positional arguments */
#ifndef _NO_POS_ARGS
# define GET_ARG(n, ap, type) \
((type) (is_pos_arg \
? (n < numargs \
? args[n] \
: get_arg (n, &ap, &numargs, args)) \
: (arg_index++ < numargs \
? args[n] \
: (numargs < MAX_POS_ARGS \
? args[numargs++] = va_arg (ap, void *) \
: va_arg (ap, void *)))))
#else
# define GET_ARG(n, ap, type) (va_arg (ap, type))
#endif
#ifdef FLOATING_POINT
#ifdef _MB_CAPABLE
#ifdef __HAVE_LOCALE_INFO_EXTENDED__
decpt = *__get_current_numeric_locale ()->wdecimal_point;
#else
{
size_t nconv;
memset (&mbs, '\0', sizeof (mbs));
nconv = _mbrtowc_r (rptr, &decpt,
_localeconv_r (rptr)->decimal_point,
MB_CUR_MAX, &mbs);
if (nconv == (size_t) -1 || nconv == (size_t) -2)
decpt = L'.';
}
#endif /* !__HAVE_LOCALE_INFO_EXTENDED__ */
#else
decpt = (wchar_t) *_localeconv_r (rptr)->decimal_point;
#endif /* !_MB_CAPABLE */
#endif /* FLOATING_POINT */
_newlib_flockfile_start (fp);
ORIENT (fp, 1);
nassigned = 0;
nread = 0;
ccls = ccle = NULL;
for (;;)
{
c = *fmt++;
if (c == L'\0')
goto all_done;
if (iswspace (c))
{
while ((c = _fgetwc_r (rptr, fp)) != WEOF && iswspace(c))
;
if (c != WEOF)
_ungetwc_r (rptr, c, fp);
continue;
}
if (c != L'%')
goto literal;
width = 0;
flags = 0;
#ifndef _NO_POS_ARGS
N = arg_index;
is_pos_arg = 0;
#endif
/*
* switch on the format. continue if done; break once format
* type is derived.
*/
again:
c = *fmt++;
switch (c)
{
case L'%':
literal:
if ((wi = _fgetwc_r (rptr, fp)) == WEOF)
goto input_failure;
if (wi != c)
{
_ungetwc_r (rptr, wi, fp);
goto input_failure;
}
nread++;
continue;
case L'*':
if ((flags & (CHAR | SHORT | LONG | LONGDBL | SUPPRESS | MALLOC))
|| width)
flags |= SUPPRESS;
goto again;
case L'l':
if (flags & (CHAR | SHORT | LONG | LONGDBL))
goto match_failure;
#if defined _WANT_IO_C99_FORMATS || !defined _NO_LONGLONG
if (*fmt == L'l') /* Check for 'll' = long long (SUSv3) */
{
++fmt;
flags |= LONGDBL;
}
else
#endif
flags |= LONG;
goto again;
case L'L':
if (flags & (CHAR | SHORT | LONG | LONGDBL))
goto match_failure;
flags |= LONGDBL;
goto again;
case L'h':
#ifdef _WANT_IO_C99_FORMATS
if (flags & (CHAR | SHORT | LONG | LONGDBL))
goto match_failure;
if (*fmt == 'h') /* Check for 'hh' = char int (SUSv3) */
{
++fmt;
flags |= CHAR;
}
else
#endif
flags |= SHORT;
goto again;
#ifdef _WANT_IO_C99_FORMATS
case L'j': /* intmax_t */
if (flags & (CHAR | SHORT | LONG | LONGDBL))
goto match_failure;
if (sizeof (intmax_t) == sizeof (long))
flags |= LONG;
else
flags |= LONGDBL;
goto again;
case L't': /* ptrdiff_t */
if (flags & (CHAR | SHORT | LONG | LONGDBL))
goto match_failure;
if (sizeof (ptrdiff_t) < sizeof (int))
/* POSIX states ptrdiff_t is 16 or more bits, as
is short. */
flags |= SHORT;
else if (sizeof (ptrdiff_t) == sizeof (int))
/* no flag needed */;
else if (sizeof (ptrdiff_t) <= sizeof (long))
flags |= LONG;
else
/* POSIX states that at least one programming
environment must support ptrdiff_t no wider than
long, but that means other environments can
have ptrdiff_t as wide as long long. */
flags |= LONGDBL;
goto again;
case L'z': /* size_t */
if (flags & (CHAR | SHORT | LONG | LONGDBL))
goto match_failure;
if (sizeof (size_t) < sizeof (int))
/* POSIX states size_t is 16 or more bits, as is short. */
flags |= SHORT;
else if (sizeof (size_t) == sizeof (int))
/* no flag needed */;
else if (sizeof (size_t) <= sizeof (long))
flags |= LONG;
else
/* POSIX states that at least one programming
environment must support size_t no wider than
long, but that means other environments can
have size_t as wide as long long. */
flags |= LONGDBL;
goto again;
#endif /* _WANT_IO_C99_FORMATS */
#ifdef _WANT_IO_POSIX_EXTENSIONS
case 'm':
if (flags & (CHAR | SHORT | LONG | LONGDBL | MALLOC))
goto match_failure;
init_m_ptr ();
flags |= MALLOC;
goto again;
#endif
case L'0':
case L'1':
case L'2':
case L'3':
case L'4':
case L'5':
case L'6':
case L'7':
case L'8':
case L'9':
if (flags & (CHAR | SHORT | LONG | LONGDBL | MALLOC))
goto match_failure;
width = width * 10 + c - L'0';
goto again;
#ifndef _NO_POS_ARGS
case L'$':
if (flags & (CHAR | SHORT | LONG | LONGDBL | SUPPRESS | MALLOC))
goto match_failure;
if (width <= MAX_POS_ARGS)
{
N = width - 1;
is_pos_arg = 1;
width = 0;
goto again;
}
rptr->_errno = EINVAL;
goto input_failure;
#endif /* !_NO_POS_ARGS */
case L'd':
c = CT_INT;
ccfn = (unsigned long (*)CCFN_PARAMS)_wcstol_r;
base = 10;
break;
case L'i':
c = CT_INT;
ccfn = (unsigned long (*)CCFN_PARAMS)_wcstol_r;
base = 0;
break;
case L'o':
c = CT_INT;
ccfn = _wcstoul_r;
base = 8;
break;
case L'u':
c = CT_INT;
ccfn = _wcstoul_r;
base = 10;
break;
case L'X':
case L'x':
flags |= PFXOK; /* enable 0x prefixing */
c = CT_INT;
ccfn = _wcstoul_r;
base = 16;
break;
#ifdef FLOATING_POINT
# ifdef _WANT_IO_C99_FORMATS
case L'A':
case L'a':
case L'F':
# endif
case L'E':
case L'G':
case L'e':
case L'f':
case L'g':
c = CT_FLOAT;
break;
#endif
#ifdef _WANT_IO_C99_FORMATS
case L'S':
flags |= LONG;
/* FALLTHROUGH */
#endif
case L's':
c = CT_STRING;
break;
case L'[':
if (*fmt == '^')
{
cclcompl = 1;
++fmt;
}
else
cclcompl = 0;
ccls = fmt;
if (*fmt == ']')
fmt++;
while (*fmt != '\0' && *fmt != ']')
fmt++;
ccle = fmt;
fmt++;
flags |= NOSKIP;
c = CT_CCL;
break;
#ifdef _WANT_IO_C99_FORMATS
case 'C':
flags |= LONG;
/* FALLTHROUGH */
#endif
case 'c':
flags |= NOSKIP;
c = CT_CHAR;
break;
case 'p': /* pointer format is like hex */
flags |= POINTER | PFXOK;
c = CT_INT;
ccfn = _wcstoul_r;
base = 16;
break;
case 'n':
if (flags & SUPPRESS) /* ??? */
continue;
#ifdef _WANT_IO_C99_FORMATS
if (flags & CHAR)
{
cp = GET_ARG (N, ap, char *);
*cp = nread;
}
else
#endif
if (flags & SHORT)
{
sp = GET_ARG (N, ap, short *);
*sp = nread;
}
else if (flags & LONG)
{
lp = GET_ARG (N, ap, long *);
*lp = nread;
}
#ifndef _NO_LONGLONG
else if (flags & LONGDBL)
{
llp = GET_ARG (N, ap, long long*);
*llp = nread;
}
#endif
else
{
ip = GET_ARG (N, ap, int *);
*ip = nread;
}
continue;
default:
goto match_failure;
}
/*
* Consume leading white space, except for formats that
* suppress this.
*/
if ((flags & NOSKIP) == 0)
{
while ((wi = _fgetwc_r (rptr, fp)) != WEOF && iswspace (wi))
nread++;
if (wi == WEOF)
goto input_failure;
_ungetwc_r (rptr, wi, fp);
}
/*
* Do the conversion.
*/
switch (c)
{
case CT_CHAR:
/* scan arbitrary characters (sets NOSKIP) */
if (width == 0)
width = 1;
if (flags & LONG)
{
#ifdef _WANT_IO_POSIX_EXTENSIONS
wchar_t **p_p = NULL;
wchar_t *p0 = NULL;
size_t p_siz = 0;
#endif
if (flags & SUPPRESS)
;
#ifdef _WANT_IO_POSIX_EXTENSIONS
else if (flags & MALLOC)
p_siz = alloc_m_ptr (wchar_t, p, p0, p_p, 32);
#endif
else
p = GET_ARG(N, ap, wchar_t *);
n = 0;
while (width-- != 0 && (wi = _fgetwc_r (rptr, fp)) != WEOF)
{
if (!(flags & SUPPRESS))
{
#ifdef _WANT_IO_POSIX_EXTENSIONS
/* Check before ++ because we never add a \0 */
p_siz = realloc_m_ptr (wchar_t, p, p0, p_p, p_siz);
#endif
*p++ = (wchar_t) wi;
}
n++;
}
if (n == 0)
goto input_failure;
nread += n;
#ifdef _WANT_IO_POSIX_EXTENSIONS
shrink_m_ptr (wchar_t, p_p, p - p0, p_siz);
#endif
if (!(flags & SUPPRESS))
nassigned++;
}
else
{
#ifdef _WANT_IO_POSIX_EXTENSIONS
char **mbp_p = NULL;
char *mbp0 = NULL;
size_t mbp_siz = 0;
#endif
if (flags & SUPPRESS)
mbp = mbbuf;
#ifdef _WANT_IO_POSIX_EXTENSIONS
else if (flags & MALLOC)
mbp_siz = alloc_m_ptr (char, mbp, mbp0, mbp_p, 32);
#endif
else
mbp = GET_ARG(N, ap, char *);
n = 0;
memset ((void *)&mbs, '\0', sizeof (mbstate_t));
while (width != 0 && (wi = _fgetwc_r (rptr, fp)) != WEOF)
{
nconv = _wcrtomb_r (rptr, mbp, wi, &mbs);
if (nconv == (size_t) -1)
goto input_failure;
/* Ignore high surrogate in width counting */
if (nconv != 0 || mbs.__count != -4)
width--;
if (!(flags & SUPPRESS))
{
#ifdef _WANT_IO_POSIX_EXTENSIONS
mbp_siz = realloc_m_ptr (char, mbp, mbp0, mbp_p, mbp_siz);
#endif
mbp += nconv;
}
n++;
}
if (n == 0)
goto input_failure;
nread += n;
#ifdef _WANT_IO_POSIX_EXTENSIONS
shrink_m_ptr (char, mbp_p, mbp - mbp0, mbp_siz);
#endif
if (!(flags & SUPPRESS))
nassigned++;
}
break;
case CT_CCL:
/* scan a (nonempty) character class (sets NOSKIP) */
if (width == 0)
width = SIZE_MAX; /* `infinity' */
/* take only those things in the class */
if ((flags & SUPPRESS) && (flags & LONG))
{
n = 0;
while ((wi = _fgetwc_r (rptr, fp)) != WEOF
&& width-- != 0 && INCCL (wi))
n++;
if (wi != WEOF)
_ungetwc_r (rptr, wi, fp);
if (n == 0)
goto match_failure;
}
else if (flags & LONG)
{
#ifdef _WANT_IO_POSIX_EXTENSIONS
wchar_t **p_p = NULL;
size_t p_siz = 0;
if (flags & MALLOC)
p_siz = alloc_m_ptr (wchar_t, p, p0, p_p, 32);
else
#endif
p0 = p = GET_ARG(N, ap, wchar_t *);
while ((wi = _fgetwc_r (rptr, fp)) != WEOF
&& width-- != 0 && INCCL (wi))
{
*p++ = (wchar_t) wi;
#ifdef _WANT_IO_POSIX_EXTENSIONS
p_siz = realloc_m_ptr (wchar_t, p, p0, p_p, p_siz);
#endif
}
if (wi != WEOF)
_ungetwc_r (rptr, wi, fp);
n = p - p0;
if (n == 0)
goto match_failure;
*p = L'\0';
#ifdef _WANT_IO_POSIX_EXTENSIONS
shrink_m_ptr (wchar_t, p_p, n + 1, p_siz);
#endif
nassigned++;
}
else
{
#ifdef _WANT_IO_POSIX_EXTENSIONS
char **mbp_p = NULL;
char *mbp0 = NULL;
size_t mbp_siz = 0;
#endif
if (flags & SUPPRESS)
mbp = mbbuf;
#ifdef _WANT_IO_POSIX_EXTENSIONS
else if (flags & MALLOC)
mbp_siz = alloc_m_ptr (char, mbp, mbp0, mbp_p, 32);
#endif
else
mbp = GET_ARG(N, ap, char *);
n = 0;
memset ((void *) &mbs, '\0', sizeof (mbstate_t));
while ((wi = _fgetwc_r (rptr, fp)) != WEOF
&& width != 0 && INCCL (wi))
{
nconv = _wcrtomb_r (rptr, mbp, wi, &mbs);
if (nconv == (size_t) -1)
goto input_failure;
/* Ignore high surrogate in width counting */
if (nconv != 0 || mbs.__count != -4)
width--;
if (!(flags & SUPPRESS))
{
mbp += nconv;
#ifdef _WANT_IO_POSIX_EXTENSIONS
mbp_siz = realloc_m_ptr (char, mbp, mbp0, mbp_p, mbp_siz);
#endif
}
n++;
}
if (wi != WEOF)
_ungetwc_r (rptr, wi, fp);
if (!(flags & SUPPRESS))
{
*mbp = 0;
#ifdef _WANT_IO_POSIX_EXTENSIONS
shrink_m_ptr (char, mbp_p, mbp - mbp0 + 1, mbp_siz);
#endif
nassigned++;
}
}
nread += n;
break;
case CT_STRING:
/* like CCL, but zero-length string OK, & no NOSKIP */
if (width == 0)
width = SIZE_MAX;
if ((flags & SUPPRESS) && (flags & LONG))
{
while ((wi = _fgetwc_r (rptr, fp)) != WEOF
&& width-- != 0 && !iswspace (wi))
nread++;
if (wi != WEOF)
_ungetwc_r (rptr, wi, fp);
}
else if (flags & LONG)
{
#ifdef _WANT_IO_POSIX_EXTENSIONS
wchar_t **p_p = NULL;
size_t p_siz = 0;
if (flags & MALLOC)
p_siz = alloc_m_ptr (wchar_t, p, p0, p_p, 32);
else
#endif
p0 = p = GET_ARG(N, ap, wchar_t *);
while ((wi = _fgetwc_r (rptr, fp)) != WEOF
&& width-- != 0 && !iswspace (wi))
{
*p++ = (wchar_t) wi;
#ifdef _WANT_IO_POSIX_EXTENSIONS
p_siz = realloc_m_ptr (wchar_t, p, p0, p_p, p_siz);
#endif
nread++;
}
if (wi != WEOF)
_ungetwc_r (rptr, wi, fp);
*p = L'\0';
#ifdef _WANT_IO_POSIX_EXTENSIONS
shrink_m_ptr (wchar_t, p_p, p - p0 + 1, p_siz);
#endif
nassigned++;
}
else
{
#ifdef _WANT_IO_POSIX_EXTENSIONS
char **mbp_p = NULL;
char *mbp0 = NULL;
size_t mbp_siz = 0;
#endif
if (flags & SUPPRESS)
mbp = mbbuf;
#ifdef _WANT_IO_POSIX_EXTENSIONS
else if (flags & MALLOC)
mbp_siz = alloc_m_ptr (char, mbp, mbp0, mbp_p, 32);
#endif
else
mbp = GET_ARG(N, ap, char *);
memset ((void *) &mbs, '\0', sizeof (mbstate_t));
while ((wi = _fgetwc_r (rptr, fp)) != WEOF
&& width != 0 && !iswspace (wi))
{
nconv = wcrtomb(mbp, wi, &mbs);
if (nconv == (size_t)-1)
goto input_failure;
/* Ignore high surrogate in width counting */
if (nconv != 0 || mbs.__count != -4)
width--;
if (!(flags & SUPPRESS))
{
mbp += nconv;
#ifdef _WANT_IO_POSIX_EXTENSIONS
mbp_siz = realloc_m_ptr (char, mbp, mbp0, mbp_p, mbp_siz);
#endif
}
nread++;
}
if (wi != WEOF)
_ungetwc_r (rptr, wi, fp);
if (!(flags & SUPPRESS))
{
*mbp = 0;
#ifdef _WANT_IO_POSIX_EXTENSIONS
shrink_m_ptr (char, mbp_p, mbp - mbp0 + 1, mbp_siz);
#endif
nassigned++;
}
}
continue;
case CT_INT:
{
/* scan an integer as if by wcstol/wcstoul */
if (width == 0 || width > sizeof (buf) / sizeof (*buf) - 1)
width = sizeof(buf) / sizeof (*buf) - 1;
flags |= SIGNOK | NDIGITS | NZDIGITS;
for (p = buf; width; width--)
{
c = _fgetwc_r (rptr, fp);
/*
* Switch on the character; `goto ok' if we
* accept it as a part of number.
*/
switch (c)
{
/*
* The digit 0 is always legal, but is special.
* For %i conversions, if no digits (zero or nonzero)
* have been scanned (only signs), we will have base==0.
* In that case, we should set it to 8 and enable 0x
* prefixing. Also, if we have not scanned zero digits
* before this, do not turn off prefixing (someone else
* will turn it off if we have scanned any nonzero digits).
*/
case L'0':
if (base == 0)
{
base = 8;
flags |= PFXOK;
}
if (flags & NZDIGITS)
flags &= ~(SIGNOK | NZDIGITS | NDIGITS);
else
flags &= ~(SIGNOK | PFXOK | NDIGITS);
goto ok;
/* 1 through 7 always legal */
case L'1':
case L'2':
case L'3':
case L'4':
case L'5':
case L'6':
case L'7':
base = basefix[base];
flags &= ~(SIGNOK | PFXOK | NDIGITS);
goto ok;
/* digits 8 and 9 ok iff decimal or hex */
case L'8':
case L'9':
base = basefix[base];
if (base <= 8)
break; /* not legal here */
flags &= ~(SIGNOK | PFXOK | NDIGITS);
goto ok;
/* letters ok iff hex */
case L'A':
case L'B':
case L'C':
case L'D':
case L'E':
case L'F':
case L'a':
case L'b':
case L'c':
case L'd':
case L'e':
case L'f':
/* no need to fix base here */
if (base <= 10)
break; /* not legal here */
flags &= ~(SIGNOK | PFXOK | NDIGITS);
goto ok;
/* sign ok only as first character */
case L'+':
case L'-':
if (flags & SIGNOK)
{
flags &= ~SIGNOK;
flags |= HAVESIGN;
goto ok;
}
break;
/* x ok iff flag still set & single 0 seen */
case L'x':
case L'X':
if ((flags & PFXOK) && p == buf + 1 + !!(flags & HAVESIGN))
{
base = 16;/* if %i */
flags &= ~PFXOK;
goto ok;
}
break;
}
/*
* If we got here, c is not a legal character
* for a number. Stop accumulating digits.
*/
if (c != WEOF)
_ungetwc_r (rptr, c, fp);
break;
ok:
/*
* c is legal: store it and look at the next.
*/
*p++ = (wchar_t) c;
}
/*
* If we had only a sign, it is no good; push back the sign.
* If the number ends in `x', it was [sign] '0' 'x', so push back
* the x and treat it as [sign] '0'.
* Use of ungetc here and below assumes ASCII encoding; we are only
* pushing back 7-bit characters, so casting to unsigned char is
* not necessary.
*/
if (flags & NDIGITS)
{
if (p > buf)
_ungetwc_r (rptr, *--p, fp); /* [-+xX] */
goto match_failure;
}
c = p[-1];
if (c == L'x' || c == L'X')
{
--p;
_ungetwc_r (rptr, c, fp);
}
if ((flags & SUPPRESS) == 0)
{
unsigned long res;
*p = 0;
res = (*ccfn) (rptr, buf, (wchar_t **) NULL, base);
if (flags & POINTER)
{
void **vp = GET_ARG (N, ap, void **);
#ifndef _NO_LONGLONG
if (sizeof (uintptr_t) > sizeof (unsigned long))
{
unsigned long long resll;
resll = _wcstoull_r (rptr, buf, (wchar_t **) NULL, base);
*vp = (void *) (uintptr_t) resll;
}
else
#endif /* !_NO_LONGLONG */
*vp = (void *) (uintptr_t) res;
}
#ifdef _WANT_IO_C99_FORMATS
else if (flags & CHAR)
{
cp = GET_ARG (N, ap, char *);
*cp = res;
}
#endif
else if (flags & SHORT)
{
sp = GET_ARG (N, ap, short *);
*sp = res;
}
else if (flags & LONG)
{
lp = GET_ARG (N, ap, long *);
*lp = res;
}
#ifndef _NO_LONGLONG
else if (flags & LONGDBL)
{
unsigned long long resll;
if (ccfn == _wcstoul_r)
resll = _wcstoull_r (rptr, buf, (wchar_t **) NULL, base);
else
resll = _wcstoll_r (rptr, buf, (wchar_t **) NULL, base);
llp = GET_ARG (N, ap, long long*);
*llp = resll;
}
#endif
else
{
ip = GET_ARG (N, ap, int *);
*ip = res;
}
nassigned++;
}
nread += p - buf;
break;
}
#ifdef FLOATING_POINT
case CT_FLOAT:
{
/* scan a floating point number as if by wcstod */
/* This code used to assume that the number of digits is reasonable.
However, ANSI / ISO C makes no such stipulation; we have to get
exact results even when there is an unreasonable amount of
leading zeroes. */
long leading_zeroes = 0;
long zeroes, exp_adjust;
wchar_t *exp_start = NULL;
unsigned width_left = 0;
char nancount = 0;
char infcount = 0;
#ifdef hardway
if (width == 0 || width > sizeof (buf) / sizeof (*buf) - 1)
#else
/* size_t is unsigned, hence this optimisation */
if (width - 1 > sizeof (buf) / sizeof (*buf) - 2)
#endif
{
width_left = width - (sizeof (buf) / sizeof (*buf) - 1);
width = sizeof (buf) / sizeof (*buf) - 1;
}
flags |= SIGNOK | NDIGITS | DPTOK | EXPOK;
zeroes = 0;
exp_adjust = 0;
for (p = buf; width; )
{
c = _fgetwc_r (rptr, fp);
/*
* This code mimicks the integer conversion
* code, but is much simpler.
*/
switch (c)
{
case L'0':
if (flags & NDIGITS)
{
flags &= ~SIGNOK;
zeroes++;
if (width_left)
{
width_left--;
width++;
}
goto fskip;
}
/* Fall through. */
case L'1':
case L'2':
case L'3':
case L'4':
case L'5':
case L'6':
case L'7':
case L'8':
case L'9':
if (nancount + infcount == 0)
{
flags &= ~(SIGNOK | NDIGITS);
goto fok;
}
break;
case L'+':
case L'-':
if (flags & SIGNOK)
{
flags &= ~SIGNOK;
goto fok;
}
break;
case L'n':
case L'N':
if (nancount == 0 && zeroes == 0
&& (flags & (NDIGITS | DPTOK | EXPOK)) ==
(NDIGITS | DPTOK | EXPOK))
{
flags &= ~(SIGNOK | DPTOK | EXPOK | NDIGITS);
nancount = 1;
goto fok;
}
if (nancount == 2)
{
nancount = 3;
goto fok;
}
if (infcount == 1 || infcount == 4)
{
infcount++;
goto fok;
}
break;
case L'a':
case L'A':
if (nancount == 1)
{
nancount = 2;
goto fok;
}
break;
case L'i':
if (infcount == 0 && zeroes == 0
&& (flags & (NDIGITS | DPTOK | EXPOK)) ==
(NDIGITS | DPTOK | EXPOK))
{
flags &= ~(SIGNOK | DPTOK | EXPOK | NDIGITS);
infcount = 1;
goto fok;
}
if (infcount == 3 || infcount == 5)
{
infcount++;
goto fok;
}
break;
case L'f':
case L'F':
if (infcount == 2)
{
infcount = 3;
goto fok;
}
break;
case L't':
case L'T':
if (infcount == 6)
{
infcount = 7;
goto fok;
}
break;
case L'y':
case L'Y':
if (infcount == 7)
{
infcount = 8;
goto fok;
}
break;
case L'e':
case L'E':
/* no exponent without some digits */
if ((flags & (NDIGITS | EXPOK)) == EXPOK
|| ((flags & EXPOK) && zeroes))
{
if (! (flags & DPTOK))
{
exp_adjust = zeroes - leading_zeroes;
exp_start = p;
}
flags =
(flags & ~(EXPOK | DPTOK)) |
SIGNOK | NDIGITS;
zeroes = 0;
goto fok;
}
break;
default:
if ((wchar_t) c == decpt && (flags & DPTOK))
{
flags &= ~(SIGNOK | DPTOK);
leading_zeroes = zeroes;
goto fok;
}
break;
}
if (c != WEOF)
_ungetwc_r (rptr, c, fp);
break;
fok:
*p++ = c;
fskip:
width--;
++nread;
}
if (zeroes)
flags &= ~NDIGITS;
/* We may have a 'N' or possibly even [sign] 'N' 'a' as the
start of 'NaN', only to run out of chars before it was
complete (or having encountered a non-matching char). So
check here if we have an outstanding nancount, and if so
put back the chars we did swallow and treat as a failed
match.
FIXME - we still don't handle NAN([0xdigits]). */
if (nancount - 1U < 2U) /* nancount && nancount < 3 */
{
/* Newlib's ungetc works even if we called __srefill in
the middle of a partial parse, but POSIX does not
guarantee that in all implementations of ungetc. */
while (p > buf)
{
_ungetwc_r (rptr, *--p, fp); /* [-+nNaA] */
--nread;
}
goto match_failure;
}
/* Likewise for 'inf' and 'infinity'. But be careful that
'infinite' consumes only 3 characters, leaving the stream
at the second 'i'. */
if (infcount - 1U < 7U) /* infcount && infcount < 8 */
{
if (infcount >= 3) /* valid 'inf', but short of 'infinity' */
while (infcount-- > 3)
{
_ungetwc_r (rptr, *--p, fp); /* [iInNtT] */
--nread;
}
else
{
while (p > buf)
{
_ungetwc_r (rptr, *--p, fp); /* [-+iInN] */
--nread;
}
goto match_failure;
}
}
/*
* If no digits, might be missing exponent digits
* (just give back the exponent) or might be missing
* regular digits, but had sign and/or decimal point.
*/
if (flags & NDIGITS)
{
if (flags & EXPOK)
{
/* no digits at all */
while (p > buf)
{
_ungetwc_r (rptr, *--p, fp); /* [-+.] */
--nread;
}
goto match_failure;
}
/* just a bad exponent (e and maybe sign) */
c = *--p;
--nread;
if (c != L'e' && c != L'E')
{
_ungetwc_r (rptr, c, fp); /* [-+] */
c = *--p;
--nread;
}
_ungetwc_r (rptr, c, fp); /* [eE] */
}
if ((flags & SUPPRESS) == 0)
{
double res = 0;
#ifdef _NO_LONGDBL
#define QUAD_RES res;
#else /* !_NO_LONG_DBL */
long double qres = 0;
#define QUAD_RES qres;
#endif /* !_NO_LONG_DBL */
long new_exp = 0;
*p = 0;
if ((flags & (DPTOK | EXPOK)) == EXPOK)
{
exp_adjust = zeroes - leading_zeroes;
new_exp = -exp_adjust;
exp_start = p;
}
else if (exp_adjust)
new_exp = _wcstol_r (rptr, (exp_start + 1), NULL, 10) - exp_adjust;
if (exp_adjust)
{
/* If there might not be enough space for the new exponent,
truncate some trailing digits to make room. */
if (exp_start >= buf + sizeof (buf) / sizeof (*buf)
- MAX_LONG_LEN)
exp_start = buf + sizeof (buf) / sizeof (*buf)
- MAX_LONG_LEN - 1;
swprintf (exp_start, MAX_LONG_LEN, L"e%ld", new_exp);
}
/* FIXME: We don't have wcstold yet. */
#if 0//ndef _NO_LONGDBL /* !_NO_LONGDBL */
if (flags & LONGDBL)
qres = _wcstold_r (rptr, buf, NULL);
else
#endif
res = _wcstod_r (rptr, buf, NULL);
if (flags & LONG)
{
dp = GET_ARG (N, ap, double *);
*dp = res;
}
else if (flags & LONGDBL)
{
ldp = GET_ARG (N, ap, _LONG_DOUBLE *);
*ldp = QUAD_RES;
}
else
{
flp = GET_ARG (N, ap, float *);
if (isnan (res))
*flp = nanf (NULL);
else
*flp = res;
}
nassigned++;
}
break;
}
#endif /* FLOATING_POINT */
}
}
input_failure:
/* On read failure, return EOF failure regardless of matches; errno
should have been set prior to here. On EOF failure (including
invalid format string), return EOF if no matches yet, else number
of matches made prior to failure. */
nassigned = nassigned && !(fp->_flags & __SERR) ? nassigned : EOF;
match_failure:
all_done:
/* Return number of matches, which can be 0 on match failure. */
_newlib_flockfile_end (fp);
#ifdef _WANT_IO_POSIX_EXTENSIONS
free_m_ptr ();
#endif
return nassigned;
}
#ifndef _NO_POS_ARGS
/* Process all intermediate arguments. Fortunately, with wscanf, all
intermediate arguments are sizeof(void*), so we don't need to scan
ahead in the format string. */
static void *
get_arg (int n, va_list *ap, int *numargs_p, void **args)
{
int numargs = *numargs_p;
while (n >= numargs)
args[numargs++] = va_arg (*ap, void *);
*numargs_p = numargs;
return args[n];
}
#endif /* !_NO_POS_ARGS */
Reference in New Issue View Git Blame Copy Permalink