WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/newlib/libc/stdio/vfscanf.c


/*-
 * 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
<>, <>, <>---format argument list
 
INDEX
	vfscanf
INDEX
	_vfscanf_r
INDEX
	vscanf
INDEX
	_vscanf_r
INDEX
	vsscanf
INDEX
	_vsscanf_r
 
ANSI_SYNOPSIS
	#include 
	#include 
	int vscanf(const char *<[fmt]>, va_list <[list]>);
	int vfscanf(FILE *<[fp]>, const char *<[fmt]>, va_list <[list]>);
	int vsscanf(const char *<[str]>, const char *<[fmt]>, va_list <[list]>);
 
	int _vscanf_r(struct _reent *<[reent]>, const char *<[fmt]>,
                       va_list <[list]>);
	int _vfscanf_r(struct _reent *<[reent]>, FILE *<[fp]>, const char *<[fmt]>,
                       va_list <[list]>);
	int _vsscanf_r(struct _reent *<[reent]>, const char *<[str]>,
                       const char *<[fmt]>, va_list <[list]>);
 
TRAD_SYNOPSIS
	#include 
	#include 
	int vscanf( <[fmt]>, <[ist]>)
	char *<[fmt]>;
	va_list <[list]>;
 
	int vfscanf( <[fp]>, <[fmt]>, <[list]>)
	FILE *<[fp]>;
	char *<[fmt]>;
	va_list <[list]>;
 
	int vsscanf( <[str]>, <[fmt]>, <[list]>)
	char *<[str]>;
	char *<[fmt]>;
	va_list <[list]>;
 
	int _vscanf_r( <[reent]>, <[fmt]>, <[ist]>)
	struct _reent *<[reent]>;
	char *<[fmt]>;
	va_list <[list]>;
 
	int _vfscanf_r( <[reent]>, <[fp]>, <[fmt]>, <[list]>)
	struct _reent *<[reent]>;
	FILE *<[fp]>;
	char *<[fmt]>;
	va_list <[list]>;
 
	int _vsscanf_r( <[reent]>, <[str]>, <[fmt]>, <[list]>)
	struct _reent *<[reent]>;
	char *<[str]>;
	char *<[fmt]>;
	va_list <[list]>;
 
DESCRIPTION
<>, <>, and <> are (respectively) variants
of <>, <>, and <>.  They differ only in
allowing their caller to pass the variable argument list as a
<> object (initialized by <>) rather than
directly accepting a variable number of arguments.
 
RETURNS
The return values are consistent with the corresponding functions:
<> returns the number of input fields successfully scanned,
converted, and stored; the return value does not include scanned
fields which were not stored.
 
If <> attempts to read at end-of-file, the return value
is <>.
 
If no fields were stored, the return value is <<0>>.
 
The routines <<_vscanf_r>>, <<_vfscanf_f>>, and <<_vsscanf_r>> are
reentrant versions which take an additional first parameter which points to the
reentrancy structure.
 
PORTABILITY
These are GNU extensions.
 
Supporting OS subroutines required:
*/
 
#include <_ansi.h>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "local.h"
#include "../stdlib/local.h"
 
#ifdef INTEGER_ONLY
#define VFSCANF vfiscanf
#define _VFSCANF_R _vfiscanf_r
#define __SVFSCANF __svfiscanf
#ifdef STRING_ONLY
#  define __SVFSCANF_R __ssvfiscanf_r
#else
#  define __SVFSCANF_R __svfiscanf_r
#endif
#else
#define VFSCANF vfscanf
#define _VFSCANF_R _vfscanf_r
#define __SVFSCANF __svfscanf
#ifdef STRING_ONLY
#  define __SVFSCANF_R __ssvfscanf_r
#else
#  define __SVFSCANF_R __svfscanf_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 _ungetc_r _sungetc_r
#define __srefill_r __ssrefill_r
#define _fread_r _sfread_r
#endif
 
#ifdef FLOATING_POINT
#include 
#include 
#include 
 
/* 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
 
#endif
 
#include "floatio.h"
 
#define BUF (MAXEXP+MAXFRACT+MB_LEN_MAX+2) /* decimal point + sign + NUL */
 
/* 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 */
 
/*
 * 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	NNZDIGITS	0x800	/* no non-zero digits 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., strtol or strtoul */
#define	CT_FLOAT	4	/* floating, i.e., strtod */
 
#define u_char unsigned char
#define u_long unsigned long
 
#ifndef _NO_LONGLONG
typedef unsigned long long u_long_long;
#endif
 
/*
 * vfscanf
 */
 
#define BufferEmpty (fp->_r <= 0 && __srefill_r(rptr, fp))
 
#ifndef STRING_ONLY
 
#ifndef _REENT_ONLY
 
int
_DEFUN(VFSCANF, (fp, fmt, ap),
       register FILE *fp _AND
       _CONST char *fmt _AND
       va_list ap)
{
  struct _reent *reent = _REENT;
 
  CHECK_INIT(reent, fp);
  return __SVFSCANF_R (reent, fp, fmt, ap);
}
 
int
_DEFUN(__SVFSCANF, (fp, fmt0, ap),
       register FILE *fp _AND
       char _CONST *fmt0 _AND
       va_list ap)
{
  return __SVFSCANF_R (_REENT, fp, fmt0, ap);
}
 
#endif /* !_REENT_ONLY */
 
int
_DEFUN(_VFSCANF_R, (data, fp, fmt, ap),
       struct _reent *data _AND
       register FILE *fp   _AND
       _CONST char *fmt    _AND
       va_list ap)
{
  CHECK_INIT(data, fp);
  return __SVFSCANF_R (data, fp, fmt, ap);
}
#endif /* !STRING_ONLY */
 
#if defined (STRING_ONLY) && defined (INTEGER_ONLY)
/* When dealing with the sscanf family, we don't want to use the
 * regular ungetc which will drag in file I/O items we don't need.
 * So, we create our own trimmed-down version.  */
int
_DEFUN(_sungetc_r, (data, fp, ch),
	struct _reent *data _AND
	int c               _AND
	register FILE *fp)
{
  if (c == EOF)
    return (EOF);
 
  /* After ungetc, we won't be at eof anymore */
  fp->_flags &= ~__SEOF;
  c = (unsigned char) c;
 
  /*
   * If we are in the middle of ungetc'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 = c;
      fp->_r++;
      return c;
    }
 
  /*
   * If we can handle this by simply backing up, do so,
   * but never replace the original character.
   * (This makes sscanf() work when scanning `const' data.)
   */
 
  if (fp->_bf._base != NULL && fp->_p > fp->_bf._base && fp->_p[-1] == c)
    {
      fp->_p--;
      fp->_r++;
      return c;
    }
 
  /*
   * 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->_ubuf[sizeof (fp->_ubuf) - 1] = c;
  fp->_p = &fp->_ubuf[sizeof (fp->_ubuf) - 1];
  fp->_r = 1;
  return c;
}
 
/* String only version of __srefill_r for sscanf family.  */
int
_DEFUN(__ssrefill_r, (ptr, fp),
       struct _reent * ptr _AND
       register FILE * fp)
{
  /*
   * Our only hope of further input is the ungetc buffer.
   * If there is anything in that buffer to read, return.
   */
  if (HASUB (fp))
    {
      FREEUB (ptr, fp);
      if ((fp->_r = fp->_ur) != 0)
        {
          fp->_p = fp->_up;
	  return 0;
        }
    }
 
  /* Otherwise we are out of character input.  */
  fp->_p = fp->_bf._base;
  fp->_r = 0;
  fp->_flags |= __SEOF;
  return EOF;
}
 
size_t
_DEFUN(_sfread_r, (ptr, buf, size, count, fp),
       struct _reent * ptr _AND
       _PTR buf _AND
       size_t size _AND
       size_t count _AND
       FILE * fp)
{
  register size_t resid;
  register char *p;
  register int r;
  size_t total;
 
  if ((resid = count * size) == 0)
    return 0;
 
  total = resid;
  p = buf;
 
  while (resid > (r = fp->_r))
    {
      _CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, (size_t) r);
      fp->_p += r;
      fp->_r = 0;
      p += r;
      resid -= r;
      if (__ssrefill_r (ptr, fp))
        {
          /* no more input: return partial result */
          return (total - resid) / size;
        }
    }
  _CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, resid);
  fp->_r -= resid;
  fp->_p += resid;
  return count;
}
#else /* !STRING_ONLY || !INTEGER_ONLY */
int _EXFUN (_sungetc_r, (struct _reent *, int, register FILE *));
int _EXFUN (__ssrefill_r, (struct _reent *, register FILE *));
size_t _EXFUN (_sfread_r, (struct _reent *, _PTR buf, size_t, size_t, FILE *));
#endif /* !STRING_ONLY || !INTEGER_ONLY */
 
int
_DEFUN(__SVFSCANF_R, (rptr, fp, fmt0, ap),
       struct _reent *rptr _AND
       register FILE *fp   _AND
       char _CONST *fmt0   _AND
       va_list ap)
{
  register u_char *fmt = (u_char *) fmt0;
  register int c;		/* character from format, or conversion */
  register size_t width;	/* field width, or 0 */
  register char *p;		/* points into all kinds of strings */
  register int n;		/* handy integer */
  register int flags;		/* flags as defined above */
  register char *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 strtol/strtoul */
  int nbytes = 1;               /* number of bytes read from fmt string */
  wchar_t wc;                   /* wchar to use to read format string */
  wchar_t *wcp;                 /* handy wide character pointer */
  size_t mbslen;                /* length of converted multibyte sequence */
#ifdef _MB_CAPABLE
  mbstate_t state;              /* value to keep track of multibyte state */
#endif
 
  #define CCFN_PARAMS	_PARAMS((struct _reent *, const char *, char **, int))
  u_long (*ccfn)CCFN_PARAMS=0;	/* conversion function (strtol/strtoul) */
  char ccltab[256];		/* character class table for %[...] */
  char buf[BUF];		/* buffer for numeric conversions */
  unsigned char *lptr;          /* literal pointer */
 
  char *cp;
  short *sp;
  int *ip;
#ifdef FLOATING_POINT
  float *flp;
  _LONG_DOUBLE *ldp;
  double *dp;
#endif
  long *lp;
#ifndef _NO_LONGLONG
  long long *llp;
#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
 
  _newlib_flockfile_start (fp);
 
  ORIENT (fp, -1);
 
  nassigned = 0;
  nread = 0;
#ifdef _MB_CAPABLE
  memset (&state, 0, sizeof (state));
#endif
 
  for (;;)
    {
#ifndef _MB_CAPABLE
      wc = *fmt;
#else
      nbytes = __mbtowc (rptr, &wc, (char *) fmt, MB_CUR_MAX,
			 __locale_charset (), &state);
      if (nbytes < 0) {
	wc = 0xFFFD; /* Unicode replacement character */
	nbytes = 1;
	memset (&state, 0, sizeof (state));
      }
#endif
      fmt += nbytes;
 
      if (wc == 0)
	goto all_done;
      if (nbytes == 1 && isspace (wc))
	{
	  for (;;)
	    {
	      if (BufferEmpty || !isspace (*fp->_p))
		break;
	      nread++, fp->_r--, fp->_p++;
	    }
	  continue;
	}
      if (wc != '%')
	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 '%':
	literal:
          lptr = fmt - nbytes;
          for (n = 0; n < nbytes; ++n)
            {
	      if (BufferEmpty)
	        goto input_failure;
	      if (*fp->_p != *lptr)
	        goto match_failure;
	      fp->_r--, fp->_p++;
	      nread++;
              ++lptr;
            }
	  continue;
 
	case '*':
	  flags |= SUPPRESS;
	  goto again;
	case 'l':
#if defined _WANT_IO_C99_FORMATS || !defined _NO_LONGLONG
	  if (*fmt == 'l')	/* Check for 'll' = long long (SUSv3) */
	    {
	      ++fmt;
	      flags |= LONGDBL;
	    }
	  else
#endif
	    flags |= LONG;
	  goto again;
	case 'L':
	  flags |= LONGDBL;
	  goto again;
	case 'h':
#ifdef _WANT_IO_C99_FORMATS
	  if (*fmt == 'h')	/* Check for 'hh' = char int (SUSv3) */
	    {
	      ++fmt;
	      flags |= CHAR;
	    }
	  else
#endif
	    flags |= SHORT;
	  goto again;
#ifdef _WANT_IO_C99_FORMATS
	case 'j': /* intmax_t */
	  if (sizeof (intmax_t) == sizeof (long))
	    flags |= LONG;
	  else
	    flags |= LONGDBL;
	  goto again;
	case 't': /* ptrdiff_t */
	  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 'z': /* size_t */
	  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 */
 
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	  width = width * 10 + c - '0';
	  goto again;
 
#ifndef _NO_POS_ARGS
	case '$':
	  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 */
 
	  /*
	   * Conversions. Those marked `compat' are for
	   * 4.[123]BSD compatibility.
	   *
	   * (According to ANSI, E and X formats are supposed to
	   * the same as e and x.  Sorry about that.)
	   */
 
	case 'D':		/* compat */
	  flags |= LONG;
	  /* FALLTHROUGH */
	case 'd':
	  c = CT_INT;
	  ccfn = (u_long (*)CCFN_PARAMS)_strtol_r;
	  base = 10;
	  break;
 
	case 'i':
	  c = CT_INT;
	  ccfn = (u_long (*)CCFN_PARAMS)_strtol_r;
	  base = 0;
	  break;
 
	case 'O':		/* compat */
	  flags |= LONG;
	  /* FALLTHROUGH */
	case 'o':
	  c = CT_INT;
	  ccfn = _strtoul_r;
	  base = 8;
	  break;
 
	case 'u':
	  c = CT_INT;
	  ccfn = _strtoul_r;
	  base = 10;
	  break;
 
	case 'X':
	case 'x':
	  flags |= PFXOK;	/* enable 0x prefixing */
	  c = CT_INT;
	  ccfn = _strtoul_r;
	  base = 16;
	  break;
 
#ifdef FLOATING_POINT
# ifdef _WANT_IO_C99_FORMATS
	case 'a':
	case 'A':
	case 'F':
# endif
	case 'E':
	case 'G':
	case 'e':
	case 'f':
	case 'g':
	  c = CT_FLOAT;
	  break;
#endif
 
#ifdef _WANT_IO_C99_FORMATS
	case 'S':
	  flags |= LONG;
	  /* FALLTHROUGH */
#endif
 
	case 's':
	  c = CT_STRING;
	  break;
 
	case '[':
	  fmt = (u_char *) __sccl (ccltab, (unsigned char *) 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 = _strtoul_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;
 
	  /*
	   * Disgusting backwards compatibility hacks.	XXX
	   */
	case '\0':		/* compat */
	  _newlib_flockfile_exit (fp);
	  return EOF;
 
	default:		/* compat */
	  if (isupper (c))
	    flags |= LONG;
	  c = CT_INT;
	  ccfn = (u_long (*)CCFN_PARAMS)_strtol_r;
	  base = 10;
	  break;
	}
 
      /*
       * We have a conversion that requires input.
       */
      if (BufferEmpty)
	goto input_failure;
 
      /*
       * Consume leading white space, except for formats that
       * suppress this.
       */
      if ((flags & NOSKIP) == 0)
	{
	  while (isspace (*fp->_p))
	    {
	      nread++;
	      if (--fp->_r > 0)
		fp->_p++;
	      else
	      if (__srefill_r (rptr, fp))
		goto input_failure;
	    }
	  /*
	   * Note that there is at least one character in the
	   * buffer, so conversions that do not set NOSKIP ca
	   * no longer result in an input failure.
	   */
	}
 
      /*
       * Do the conversion.
       */
      switch (c)
	{
 
	case CT_CHAR:
	  /* scan arbitrary characters (sets NOSKIP) */
	  if (width == 0)
	    width = 1;
#if !defined(_ELIX_LEVEL) || _ELIX_LEVEL >= 2
          if (flags & LONG)
            {
              mbstate_t state;
              memset (&state, 0, sizeof (mbstate_t));
              if ((flags & SUPPRESS) == 0)
                wcp = GET_ARG (N, ap, wchar_t *);
              else
                wcp = NULL;
              n = 0;
              while (width != 0)
                {
                  if (n == MB_CUR_MAX)
                    goto input_failure;
                  buf[n++] = *fp->_p;
                  fp->_r -= 1;
                  fp->_p += 1;
                  if ((mbslen = _mbrtowc_r (rptr, wcp, buf, n, &state))
                                                         == (size_t)-1)
                    goto input_failure; /* Invalid sequence */
                  if (mbslen == 0 && !(flags & SUPPRESS))
                    *wcp = L'\0';
                  if (mbslen != (size_t)-2) /* Incomplete sequence */
                    {
                      nread += n;
                      width -= 1;
                      if (!(flags & SUPPRESS))
                        wcp += 1;
                      n = 0;
                    }
                  if (BufferEmpty)
	            {
                      if (n != 0)
                        goto input_failure;
                      break;
                    }
                }
              if (!(flags & SUPPRESS))
                nassigned++;
            }
          else
#endif
        	  if (flags & SUPPRESS)
	    {
	      size_t sum = 0;
	      for (;;)
		{
		  if ((n = fp->_r) < (int)width)
		    {
		      sum += n;
		      width -= n;
		      fp->_p += n;
		      if (__srefill_r (rptr, fp))
			{
			  if (sum == 0)
			    goto input_failure;
			  break;
			}
		    }
		  else
		    {
		      sum += width;
		      fp->_r -= width;
		      fp->_p += width;
		      break;
		    }
		}
	      nread += sum;
	    }
	  else
	    {
	      size_t r = _fread_r (rptr, (_PTR) GET_ARG (N, ap, char *), 1, width, fp);
 
	      if (r == 0)
		goto input_failure;
	      nread += r;
	      nassigned++;
	    }
	  break;
 
	case CT_CCL:
	  /* scan a (nonempty) character class (sets NOSKIP) */
	  if (width == 0)
	    width = ~0;		/* `infinity' */
	  /* take only those things in the class */
	  if (flags & SUPPRESS)
	    {
	      n = 0;
	      while (ccltab[*fp->_p])
		{
		  n++, fp->_r--, fp->_p++;
		  if (--width == 0)
		    break;
		  if (BufferEmpty)
		    {
		      if (n == 0)
			goto input_failure;
		      break;
		    }
		}
	      if (n == 0)
		goto match_failure;
	    }
	  else
	    {
	      p0 = p = GET_ARG (N, ap, char *);
	      while (ccltab[*fp->_p])
		{
		  fp->_r--;
		  *p++ = *fp->_p++;
		  if (--width == 0)
		    break;
		  if (BufferEmpty)
		    {
		      if (p == p0)
			goto input_failure;
		      break;
		    }
		}
	      n = p - p0;
	      if (n == 0)
		goto match_failure;
	      *p = 0;
	      nassigned++;
	    }
	  nread += n;
	  break;
 
	case CT_STRING:
	  /* like CCL, but zero-length string OK, & no NOSKIP */
	  if (width == 0)
            width = (size_t)~0;
#if !defined(_ELIX_LEVEL) || _ELIX_LEVEL >= 2
          if (flags & LONG)
            {
              /* Process %S and %ls placeholders */
              mbstate_t state;
              memset (&state, 0, sizeof (mbstate_t));
              if ((flags & SUPPRESS) == 0)
                wcp = GET_ARG (N, ap, wchar_t *);
              else
                wcp = &wc;
              n = 0;
              while (!isspace (*fp->_p) && width != 0)
                {
                  if (n == MB_CUR_MAX)
                    goto input_failure;
                  buf[n++] = *fp->_p;
                  fp->_r -= 1;
                  fp->_p += 1;
                  if ((mbslen = _mbrtowc_r (rptr, wcp, buf, n, &state))
                                                        == (size_t)-1)
                    goto input_failure;
                  if (mbslen == 0)
                    *wcp = L'\0';
                  if (mbslen != (size_t)-2) /* Incomplete sequence */
                    {
                      if (iswspace(*wcp))
                        {
                          while (n != 0)
                            _ungetc_r (rptr, (unsigned char) buf[--n], fp);
                          break;
                        }
                      nread += n;
                      width -= 1;
                      if ((flags & SUPPRESS) == 0)
                        wcp += 1;
                      n = 0;
                    }
                  if (BufferEmpty)
                    {
                      if (n != 0)
                        goto input_failure;
                      break;
                    }
                }
              if (!(flags & SUPPRESS))
                {
                  *wcp = L'\0';
                  nassigned++;
                }
            }
          else
#endif
        	  if (flags & SUPPRESS)
	    {
	      n = 0;
	      while (!isspace (*fp->_p))
		{
		  n++, fp->_r--, fp->_p++;
		  if (--width == 0)
		    break;
		  if (BufferEmpty)
		    break;
		}
	      nread += n;
	    }
	  else
	    {
	      p0 = p = GET_ARG (N, ap, char *);
	      while (!isspace (*fp->_p))
		{
		  fp->_r--;
		  *p++ = *fp->_p++;
		  if (--width == 0)
		    break;
		  if (BufferEmpty)
		    break;
		}
	      *p = 0;
	      nread += p - p0;
	      nassigned++;
	    }
	  continue;
 
	case CT_INT:
	{
	  /* scan an integer as if by strtol/strtoul */
	  unsigned width_left = 0;
	  int skips = 0;
#ifdef hardway
	  if (width == 0 || width > sizeof (buf) - 1)
#else
	  /* size_t is unsigned, hence this optimisation */
	  if (width - 1 > sizeof (buf) - 2)
#endif
	    {
	      width_left = width - (sizeof (buf) - 1);
	      width = sizeof (buf) - 1;
	    }
	  flags |= SIGNOK | NDIGITS | NZDIGITS | NNZDIGITS;
	  for (p = buf; width; width--)
	    {
	      c = *fp->_p;
	      /*
	       * 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 '0':
		  if (! (flags & NNZDIGITS))
		    goto ok;
		  if (base == 0)
		    {
		      base = 8;
		      flags |= PFXOK;
		    }
		  if (flags & NZDIGITS)
		    {
		      flags &= ~(SIGNOK | NZDIGITS | NDIGITS);
		      goto ok;
		    }
		  flags &= ~(SIGNOK | PFXOK | NDIGITS);
		  if (width_left)
		    {
		      width_left--;
		      width++;
		    }
		  ++skips;
		  goto skip;
 
		  /* 1 through 7 always legal */
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		  base = basefix[base];
		  flags &= ~(SIGNOK | PFXOK | NDIGITS | NNZDIGITS);
		  goto ok;
 
		  /* digits 8 and 9 ok iff decimal or hex */
		case '8':
		case '9':
		  base = basefix[base];
		  if (base <= 8)
		    break;	/* not legal here */
		  flags &= ~(SIGNOK | PFXOK | NDIGITS | NNZDIGITS);
		  goto ok;
 
		  /* letters ok iff hex */
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		  /* no need to fix base here */
		  if (base <= 10)
		    break;	/* not legal here */
		  flags &= ~(SIGNOK | PFXOK | NDIGITS | NNZDIGITS);
		  goto ok;
 
		  /* sign ok only as first character */
		case '+':
		case '-':
		  if (flags & SIGNOK)
		    {
		      flags &= ~SIGNOK;
		      goto ok;
		    }
		  break;
 
		  /* x ok iff flag still set & single 0 seen */
		case 'x':
		case 'X':
		  if ((flags & (PFXOK | NZDIGITS)) == PFXOK)
		    {
		      base = 16;/* if %i */
		      flags &= ~PFXOK;
		      /* We must reset the NZDIGITS and NDIGITS
			 flags that would have been unset by seeing
			 the zero that preceded the X or x.  */
		      flags |= NZDIGITS | NDIGITS;
		      goto ok;
		    }
		  break;
		}
 
	      /*
	       * If we got here, c is not a legal character
	       * for a number.  Stop accumulating digits.
	       */
	      break;
	    ok:
	      /*
	       * c is legal: store it and look at the next.
	       */
	      *p++ = c;
	    skip:
	      if (--fp->_r > 0)
		fp->_p++;
	      else
	      if (__srefill_r (rptr, fp))
		break;		/* EOF */
	    }
	  /*
	   * 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)
		_ungetc_r (rptr, *--p, fp); /* [-+xX] */
	      if (p == buf)
		goto match_failure;
	    }
	  if ((flags & SUPPRESS) == 0)
	    {
	      u_long res;
 
	      *p = 0;
	      res = (*ccfn) (rptr, buf, (char **) NULL, base);
	      if (flags & POINTER)
		{
		  void **vp = GET_ARG (N, ap, void **);
#ifndef _NO_LONGLONG
		  if (sizeof (uintptr_t) > sizeof (u_long))
		    {
		      u_long_long resll;
		      resll = _strtoull_r (rptr, buf, (char **) 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)
		{
		  u_long_long resll;
		  if (ccfn == _strtoul_r)
		    resll = _strtoull_r (rptr, buf, (char **) NULL, base);
		  else
		    resll = _strtoll_r (rptr, buf, (char **) 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 + skips;
	  break;
	}
#ifdef FLOATING_POINT
	case CT_FLOAT:
	{
	  /* scan a floating point number as if by strtod */
	  /* 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;
	  char *exp_start = NULL;
	  unsigned width_left = 0;
	  char nancount = 0;
	  char infcount = 0;
	  const char *decpt = _localeconv_r (rptr)->decimal_point;
#ifdef _MB_CAPABLE
	  int decptpos = 0;
#endif
#ifdef hardway
	  if (width == 0 || width > sizeof (buf) - 1)
#else
	  /* size_t is unsigned, hence this optimisation */
	  if (width - 1 > sizeof (buf) - 2)
#endif
	    {
	      width_left = width - (sizeof (buf) - 1);
	      width = sizeof (buf) - 1;
	    }
	  flags |= SIGNOK | NDIGITS | DPTOK | EXPOK;
	  zeroes = 0;
	  exp_adjust = 0;
	  for (p = buf; width; )
	    {
	      c = *fp->_p;
	      /*
	       * This code mimicks the integer conversion
	       * code, but is much simpler.
	       */
	      switch (c)
		{
		case '0':
		  if (flags & NDIGITS)
		    {
		      flags &= ~SIGNOK;
		      zeroes++;
		      if (width_left)
			{
			  width_left--;
			  width++;
			}
		      goto fskip;
		    }
		  /* Fall through.  */
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		  if (nancount + infcount == 0)
		    {
		      flags &= ~(SIGNOK | NDIGITS);
		      goto fok;
		    }
		  break;
 
		case '+':
		case '-':
		  if (flags & SIGNOK)
		    {
		      flags &= ~SIGNOK;
		      goto fok;
		    }
		  break;
		case 'n':
		case '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 'a':
		case 'A':
		  if (nancount == 1)
		    {
		      nancount = 2;
		      goto fok;
		    }
		  break;
		case 'i':
		case '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 'f':
		case 'F':
		  if (infcount == 2)
		    {
		      infcount = 3;
		      goto fok;
		    }
		  break;
		case 't':
		case 'T':
		  if (infcount == 6)
		    {
		      infcount = 7;
		      goto fok;
		    }
		  break;
		case 'y':
		case 'Y':
		  if (infcount == 7)
		    {
		      infcount = 8;
		      goto fok;
		    }
		  break;
		case 'e':
		case '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:
#ifndef _MB_CAPABLE
		  if ((unsigned char) c == (unsigned char) decpt[0]
		      && (flags & DPTOK))
		    {
		      flags &= ~(SIGNOK | DPTOK);
		      leading_zeroes = zeroes;
		      goto fok;
		    }
		  break;
#else
		  if (flags & DPTOK)
		    {
		      while ((unsigned char) c
			     == (unsigned char) decpt[decptpos])
			{
			  if (decpt[++decptpos] == '\0')
			    {
			      /* We read the complete decpt seq. */
			      flags &= ~(SIGNOK | DPTOK);
			      leading_zeroes = zeroes;
			      p = stpncpy (p, decpt, decptpos);
			      decptpos = 0;
			      goto fskip;
			    }
			  ++nread;
			  if (--fp->_r > 0)
			    fp->_p++;
			  else if (__srefill_r (rptr, fp))
			    break;		/* EOF */
			  c = *fp->_p;
			}
		      if (decptpos > 0)
			{
			  /* We read part of a multibyte decimal point,
			     but the rest is invalid or we're at EOF,
			     so back off. */
			  while (decptpos-- > 0)
			    {
			      _ungetc_r (rptr, (unsigned char) decpt[decptpos],
					 fp);
			      --nread;
			    }
			}
		    }
		  break;
#endif
		}
	      break;
	    fok:
	      *p++ = c;
	    fskip:
	      width--;
	      ++nread;
	      if (--fp->_r > 0)
		fp->_p++;
	      else
	      if (__srefill_r (rptr, fp))
		break;		/* EOF */
	    }
	  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)
		{
		  _ungetc_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)
		  {
		    _ungetc_r (rptr, *--p, fp); /* [iInNtT] */
		    --nread;
		  }
	      else
		{
		  while (p > buf)
		    {
		      _ungetc_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)
		    {
		      _ungetc_r (rptr, *--p, fp); /* [-+.] */
		      --nread;
		    }
		  goto match_failure;
		}
	      /* just a bad exponent (e and maybe sign) */
	      c = *--p;
	      --nread;
	      if (c != 'e' && c != 'E')
		{
		  _ungetc_r (rptr, c, fp); /* [-+] */
		  c = *--p;
		  --nread;
		}
	      _ungetc_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 = _strtol_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) - MAX_LONG_LEN)
		    exp_start = buf + sizeof (buf) - MAX_LONG_LEN - 1;
                 sprintf (exp_start, "e%ld", new_exp);
		}
 
	      /* FIXME: Is that still true?
	         Current _strtold routine is markedly slower than
	         _strtod_r.  Only use it if we have a long double
	         result.  */
#ifndef _NO_LONGDBL /* !_NO_LONGDBL */
	      if (flags & LONGDBL)
		qres = _strtold_r (rptr, buf, NULL);
	      else
#endif
	        res = _strtod_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.  */
  _newlib_flockfile_exit (fp);
  return 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);
  return nassigned;
}
 
#ifndef _NO_POS_ARGS
/* Process all intermediate arguments.  Fortunately, with scanf, 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 */

Rev 4921	Rev 6099
1	/*-	1	/*-
2	* Copyright (c) 1990 The Regents of the University of California.	2	* Copyright (c) 1990 The Regents of the University of California.
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms are permitted	5	* Redistribution and use in source and binary forms are permitted
6	* provided that the above copyright notice and this paragraph are	6	* provided that the above copyright notice and this paragraph are
7	* duplicated in all such forms and that any documentation,	7	* duplicated in all such forms and that any documentation,
8	* advertising materials, and other materials related to such	8	* advertising materials, and other materials related to such
9	* distribution and use acknowledge that the software was developed	9	* distribution and use acknowledge that the software was developed
10	* by the University of California, Berkeley. The name of the	10	* by the University of California, Berkeley. The name of the
11	* University may not be used to endorse or promote products derived	11	* University may not be used to endorse or promote products derived
12	* from this software without specific prior written permission.	12	* from this software without specific prior written permission.
13	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR	13	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED	14	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.	15	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16	*/	16	*/
17		17
18	/*	18	/*
19	FUNCTION	19	FUNCTION
20	<>, <>, <>---format argument list	20	<>, <>, <>---format argument list
21		21
22	INDEX	22	INDEX
23	vfscanf	23	vfscanf
24	INDEX	24	INDEX
25	_vfscanf_r	25	_vfscanf_r
26	INDEX	26	INDEX
27	vscanf	27	vscanf
28	INDEX	28	INDEX
29	_vscanf_r	29	_vscanf_r
30	INDEX	30	INDEX
31	vsscanf	31	vsscanf
32	INDEX	32	INDEX
33	_vsscanf_r	33	_vsscanf_r
34		34
35	ANSI_SYNOPSIS	35	ANSI_SYNOPSIS
36	#include	36	#include
37	#include	37	#include
38	int vscanf(const char *<[fmt]>, va_list <[list]>);	38	int vscanf(const char *<[fmt]>, va_list <[list]>);
39	int vfscanf(FILE <[fp]>, const char <[fmt]>, va_list <[list]>);	39	int vfscanf(FILE <[fp]>, const char <[fmt]>, va_list <[list]>);
40	int vsscanf(const char <[str]>, const char <[fmt]>, va_list <[list]>);	40	int vsscanf(const char <[str]>, const char <[fmt]>, va_list <[list]>);
41		41
42	int _vscanf_r(struct _reent <[reent]>, const char <[fmt]>,	42	int _vscanf_r(struct _reent <[reent]>, const char <[fmt]>,
43	va_list <[list]>);	43	va_list <[list]>);
44	int _vfscanf_r(struct _reent <[reent]>, FILE <[fp]>, const char *<[fmt]>,	44	int _vfscanf_r(struct _reent <[reent]>, FILE <[fp]>, const char *<[fmt]>,
45	va_list <[list]>);	45	va_list <[list]>);
46	int _vsscanf_r(struct _reent <[reent]>, const char <[str]>,	46	int _vsscanf_r(struct _reent <[reent]>, const char <[str]>,
47	const char *<[fmt]>, va_list <[list]>);	47	const char *<[fmt]>, va_list <[list]>);
48		48
49	TRAD_SYNOPSIS	49	TRAD_SYNOPSIS
50	#include	50	#include
51	#include	51	#include
52	int vscanf( <[fmt]>, <[ist]>)	52	int vscanf( <[fmt]>, <[ist]>)
53	char *<[fmt]>;	53	char *<[fmt]>;
54	va_list <[list]>;	54	va_list <[list]>;
55		55
56	int vfscanf( <[fp]>, <[fmt]>, <[list]>)	56	int vfscanf( <[fp]>, <[fmt]>, <[list]>)
57	FILE *<[fp]>;	57	FILE *<[fp]>;
58	char *<[fmt]>;	58	char *<[fmt]>;
59	va_list <[list]>;	59	va_list <[list]>;
60		60
61	int vsscanf( <[str]>, <[fmt]>, <[list]>)	61	int vsscanf( <[str]>, <[fmt]>, <[list]>)
62	char *<[str]>;	62	char *<[str]>;
63	char *<[fmt]>;	63	char *<[fmt]>;
64	va_list <[list]>;	64	va_list <[list]>;
65		65
66	int _vscanf_r( <[reent]>, <[fmt]>, <[ist]>)	66	int _vscanf_r( <[reent]>, <[fmt]>, <[ist]>)
67	struct _reent *<[reent]>;	67	struct _reent *<[reent]>;
68	char *<[fmt]>;	68	char *<[fmt]>;
69	va_list <[list]>;	69	va_list <[list]>;
70		70
71	int _vfscanf_r( <[reent]>, <[fp]>, <[fmt]>, <[list]>)	71	int _vfscanf_r( <[reent]>, <[fp]>, <[fmt]>, <[list]>)
72	struct _reent *<[reent]>;	72	struct _reent *<[reent]>;
73	FILE *<[fp]>;	73	FILE *<[fp]>;
74	char *<[fmt]>;	74	char *<[fmt]>;
75	va_list <[list]>;	75	va_list <[list]>;
76		76
77	int _vsscanf_r( <[reent]>, <[str]>, <[fmt]>, <[list]>)	77	int _vsscanf_r( <[reent]>, <[str]>, <[fmt]>, <[list]>)
78	struct _reent *<[reent]>;	78	struct _reent *<[reent]>;
79	char *<[str]>;	79	char *<[str]>;
80	char *<[fmt]>;	80	char *<[fmt]>;
81	va_list <[list]>;	81	va_list <[list]>;
82		82
83	DESCRIPTION	83	DESCRIPTION
84	<>, <>, and <> are (respectively) variants	84	<>, <>, and <> are (respectively) variants
85	of <>, <>, and <>. They differ only in	85	of <>, <>, and <>. They differ only in
86	allowing their caller to pass the variable argument list as a	86	allowing their caller to pass the variable argument list as a
87	<> object (initialized by <>) rather than	87	<> object (initialized by <>) rather than
88	directly accepting a variable number of arguments.	88	directly accepting a variable number of arguments.
89		89
90	RETURNS	90	RETURNS
91	The return values are consistent with the corresponding functions:	91	The return values are consistent with the corresponding functions:
92	<> returns the number of input fields successfully scanned,	92	<> returns the number of input fields successfully scanned,
93	converted, and stored; the return value does not include scanned	93	converted, and stored; the return value does not include scanned
94	fields which were not stored.	94	fields which were not stored.
95		95
96	If <> attempts to read at end-of-file, the return value	96	If <> attempts to read at end-of-file, the return value
97	is <>.	97	is <>.
98		98
99	If no fields were stored, the return value is <<0>>.	99	If no fields were stored, the return value is <<0>>.
100		100
101	The routines <<_vscanf_r>>, <<_vfscanf_f>>, and <<_vsscanf_r>> are	101	The routines <<_vscanf_r>>, <<_vfscanf_f>>, and <<_vsscanf_r>> are
102	reentrant versions which take an additional first parameter which points to the	102	reentrant versions which take an additional first parameter which points to the
103	reentrancy structure.	103	reentrancy structure.
104		104
105	PORTABILITY	105	PORTABILITY
106	These are GNU extensions.	106	These are GNU extensions.
107		107
108	Supporting OS subroutines required:	108	Supporting OS subroutines required:
109	*/	109	*/
110		110
111	#include <_ansi.h>	111	#include <_ansi.h>
112	#include	112	#include
113	#include	113	#include
114	#include	114	#include
115	#include	115	#include
116	#include	116	#include
117	#include	117	#include
118	#include	118	#include
119	#include	119	#include
120	#include	120	#include
121	#include	121	#include
122	#include	122	#include
123	#include	123	#include
124	#include "local.h"	124	#include "local.h"
125	#include "../stdlib/local.h"	125	#include "../stdlib/local.h"
126		126
127	#ifdef INTEGER_ONLY	127	#ifdef INTEGER_ONLY
128	#define VFSCANF vfiscanf	128	#define VFSCANF vfiscanf
129	#define _VFSCANF_R _vfiscanf_r	129	#define _VFSCANF_R _vfiscanf_r
130	#define __SVFSCANF __svfiscanf	130	#define __SVFSCANF __svfiscanf
131	#ifdef STRING_ONLY	131	#ifdef STRING_ONLY
132	# define __SVFSCANF_R __ssvfiscanf_r	132	# define __SVFSCANF_R __ssvfiscanf_r
133	#else	133	#else
134	# define __SVFSCANF_R __svfiscanf_r	134	# define __SVFSCANF_R __svfiscanf_r
135	#endif	135	#endif
136	#else	136	#else
137	#define VFSCANF vfscanf	137	#define VFSCANF vfscanf
138	#define _VFSCANF_R _vfscanf_r	138	#define _VFSCANF_R _vfscanf_r
139	#define __SVFSCANF __svfscanf	139	#define __SVFSCANF __svfscanf
140	#ifdef STRING_ONLY	140	#ifdef STRING_ONLY
141	# define __SVFSCANF_R __ssvfscanf_r	141	# define __SVFSCANF_R __ssvfscanf_r
142	#else	142	#else
143	# define __SVFSCANF_R __svfscanf_r	143	# define __SVFSCANF_R __svfscanf_r
144	#endif	144	#endif
145	#ifndef NO_FLOATING_POINT	145	#ifndef NO_FLOATING_POINT
146	#define FLOATING_POINT	146	#define FLOATING_POINT
147	#endif	147	#endif
148	#endif	148	#endif
149		149
150	#ifdef STRING_ONLY	150	#ifdef STRING_ONLY
151	#undef _newlib_flockfile_start	151	#undef _newlib_flockfile_start
152	#undef _newlib_flockfile_exit	152	#undef _newlib_flockfile_exit
153	#undef _newlib_flockfile_end	153	#undef _newlib_flockfile_end
154	#define _newlib_flockfile_start(x) {}	154	#define _newlib_flockfile_start(x) {}
155	#define _newlib_flockfile_exit(x) {}	155	#define _newlib_flockfile_exit(x) {}
156	#define _newlib_flockfile_end(x) {}	156	#define _newlib_flockfile_end(x) {}
157	#define _ungetc_r _sungetc_r	157	#define _ungetc_r _sungetc_r
158	#define __srefill_r __ssrefill_r	158	#define __srefill_r __ssrefill_r
159	#define _fread_r _sfread_r	159	#define _fread_r _sfread_r
160	#endif	160	#endif
161		161
162	#ifdef FLOATING_POINT	162	#ifdef FLOATING_POINT
163	#include	163	#include
164	#include	164	#include
165	#include	165	#include
166		166
167	/* Currently a test is made to see if long double processing is warranted.	167	/* Currently a test is made to see if long double processing is warranted.
168	This could be changed in the future should the _ldtoa_r code be	168	This could be changed in the future should the _ldtoa_r code be
169	preferred over _dtoa_r. */	169	preferred over _dtoa_r. */
170	#define _NO_LONGDBL	170	#define _NO_LONGDBL
171	#if defined _WANT_IO_LONG_DOUBLE && (LDBL_MANT_DIG > DBL_MANT_DIG)	171	#if defined _WANT_IO_LONG_DOUBLE && (LDBL_MANT_DIG > DBL_MANT_DIG)
172	#undef _NO_LONGDBL	172	#undef _NO_LONGDBL
173	extern _LONG_DOUBLE _strtold _PARAMS((char s, char *sptr));	-
174	#endif	173	#endif
175		174
176	#include "floatio.h"	175	#include "floatio.h"
177		176
178	#define BUF (MAXEXP+MAXFRACT+MB_LEN_MAX+2) /* decimal point + sign + NUL */	177	#define BUF (MAXEXP+MAXFRACT+MB_LEN_MAX+2) /* decimal point + sign + NUL */
179		178
180	/* An upper bound for how long a long prints in decimal. 4 / 13 approximates	179	/* An upper bound for how long a long prints in decimal. 4 / 13 approximates
181	log (2). Add one char for roundoff compensation and one for the sign. */	180	log (2). Add one char for roundoff compensation and one for the sign. */
182	#define MAX_LONG_LEN ((CHAR_BIT * sizeof (long) - 1) * 4 / 13 + 2)	181	#define MAX_LONG_LEN ((CHAR_BIT * sizeof (long) - 1) * 4 / 13 + 2)
183	#else	182	#else
184	#define BUF 40	183	#define BUF 40
185	#endif	184	#endif
186		185
187	#define _NO_LONGLONG	186	#define _NO_LONGLONG
188	#if defined _WANT_IO_LONG_LONG \	187	#if defined _WANT_IO_LONG_LONG \
189	&& (defined __GNUC__ \|\| __STDC_VERSION__ >= 199901L)	188	&& (defined __GNUC__ \|\| __STDC_VERSION__ >= 199901L)
190	# undef _NO_LONGLONG	189	# undef _NO_LONGLONG
191	#endif	190	#endif
192		191
193	#define _NO_POS_ARGS	192	#define _NO_POS_ARGS
194	#ifdef _WANT_IO_POS_ARGS	193	#ifdef _WANT_IO_POS_ARGS
195	# undef _NO_POS_ARGS	194	# undef _NO_POS_ARGS
196	# ifdef NL_ARGMAX	195	# ifdef NL_ARGMAX
197	# define MAX_POS_ARGS NL_ARGMAX	196	# define MAX_POS_ARGS NL_ARGMAX
198	# else	197	# else
199	# define MAX_POS_ARGS 32	198	# define MAX_POS_ARGS 32
200	# endif	199	# endif
201		200
202	static void * get_arg (int, va_list , int , void **);	201	static void * get_arg (int, va_list , int , void **);
203	#endif /* _WANT_IO_POS_ARGS */	202	#endif /* _WANT_IO_POS_ARGS */
204		203
205	/*	204	/*
206	* Flags used during conversion.	205	* Flags used during conversion.
207	*/	206	*/
208		207
209	#define LONG 0x01 /* l: long or double */	208	#define LONG 0x01 /* l: long or double */
210	#define LONGDBL 0x02 /* L/ll: long double or long long */	209	#define LONGDBL 0x02 /* L/ll: long double or long long */
211	#define SHORT 0x04 /* h: short */	210	#define SHORT 0x04 /* h: short */
212	#define CHAR 0x08 /* hh: 8 bit integer */	211	#define CHAR 0x08 /* hh: 8 bit integer */
213	#define SUPPRESS 0x10 /* suppress assignment */	212	#define SUPPRESS 0x10 /* suppress assignment */
214	#define POINTER 0x20 /* weird %p pointer (`fake hex') */	213	#define POINTER 0x20 /* weird %p pointer (`fake hex') */
215	#define NOSKIP 0x40 /* do not skip blanks */	214	#define NOSKIP 0x40 /* do not skip blanks */
216		215
217	/*	216	/*
218	* The following are used in numeric conversions only:	217	* The following are used in numeric conversions only:
219	* SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;	218	* SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
220	* SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.	219	* SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
221	*/	220	*/
222		221
223	#define SIGNOK 0x80 /* +/- is (still) legal */	222	#define SIGNOK 0x80 /* +/- is (still) legal */
224	#define NDIGITS 0x100 /* no digits detected */	223	#define NDIGITS 0x100 /* no digits detected */
225		224
226	#define DPTOK 0x200 /* (float) decimal point is still legal */	225	#define DPTOK 0x200 /* (float) decimal point is still legal */
227	#define EXPOK 0x400 /* (float) exponent (e+3, etc) still legal */	226	#define EXPOK 0x400 /* (float) exponent (e+3, etc) still legal */
228		227
229	#define PFXOK 0x200 /* 0x prefix is (still) legal */	228	#define PFXOK 0x200 /* 0x prefix is (still) legal */
230	#define NZDIGITS 0x400 /* no zero digits detected */	229	#define NZDIGITS 0x400 /* no zero digits detected */
231	#define NNZDIGITS 0x800 /* no non-zero digits detected */	230	#define NNZDIGITS 0x800 /* no non-zero digits detected */
232		231
233	/*	232	/*
234	* Conversion types.	233	* Conversion types.
235	*/	234	*/
236		235
237	#define CT_CHAR 0 /* %c conversion */	236	#define CT_CHAR 0 /* %c conversion */
238	#define CT_CCL 1 /* %[...] conversion */	237	#define CT_CCL 1 /* %[...] conversion */
239	#define CT_STRING 2 /* %s conversion */	238	#define CT_STRING 2 /* %s conversion */
240	#define CT_INT 3 /* integer, i.e., strtol or strtoul */	239	#define CT_INT 3 /* integer, i.e., strtol or strtoul */
241	#define CT_FLOAT 4 /* floating, i.e., strtod */	240	#define CT_FLOAT 4 /* floating, i.e., strtod */
242		241
243	#define u_char unsigned char	242	#define u_char unsigned char
244	#define u_long unsigned long	243	#define u_long unsigned long
245		244
246	#ifndef _NO_LONGLONG	245	#ifndef _NO_LONGLONG
247	typedef unsigned long long u_long_long;	246	typedef unsigned long long u_long_long;
248	#endif	247	#endif
249		248
250	/*	249	/*
251	* vfscanf	250	* vfscanf
252	*/	251	*/
253		252
254	#define BufferEmpty (fp->_r <= 0 && __srefill_r(rptr, fp))	253	#define BufferEmpty (fp->_r <= 0 && __srefill_r(rptr, fp))
255		254
256	#ifndef STRING_ONLY	255	#ifndef STRING_ONLY
257		256
258	#ifndef _REENT_ONLY	257	#ifndef _REENT_ONLY
259		258
260	int	259	int
261	_DEFUN(VFSCANF, (fp, fmt, ap),	260	_DEFUN(VFSCANF, (fp, fmt, ap),
262	register FILE *fp _AND	261	register FILE *fp _AND
263	_CONST char *fmt _AND	262	_CONST char *fmt _AND
264	va_list ap)	263	va_list ap)
265	{	264	{
266	struct _reent *reent = _REENT;	265	struct _reent *reent = _REENT;
267		266
268	CHECK_INIT(reent, fp);	267	CHECK_INIT(reent, fp);
269	return __SVFSCANF_R (reent, fp, fmt, ap);	268	return __SVFSCANF_R (reent, fp, fmt, ap);
270	}	269	}
271		270
272	int	271	int
273	_DEFUN(__SVFSCANF, (fp, fmt0, ap),	272	_DEFUN(__SVFSCANF, (fp, fmt0, ap),
274	register FILE *fp _AND	273	register FILE *fp _AND
275	char _CONST *fmt0 _AND	274	char _CONST *fmt0 _AND
276	va_list ap)	275	va_list ap)
277	{	276	{
278	return __SVFSCANF_R (_REENT, fp, fmt0, ap);	277	return __SVFSCANF_R (_REENT, fp, fmt0, ap);
279	}	278	}
280		279
281	#endif /* !_REENT_ONLY */	280	#endif /* !_REENT_ONLY */
282		281
283	int	282	int
284	_DEFUN(_VFSCANF_R, (data, fp, fmt, ap),	283	_DEFUN(_VFSCANF_R, (data, fp, fmt, ap),
285	struct _reent *data _AND	284	struct _reent *data _AND
286	register FILE *fp _AND	285	register FILE *fp _AND
287	_CONST char *fmt _AND	286	_CONST char *fmt _AND
288	va_list ap)	287	va_list ap)
289	{	288	{
290	CHECK_INIT(data, fp);	289	CHECK_INIT(data, fp);
291	return __SVFSCANF_R (data, fp, fmt, ap);	290	return __SVFSCANF_R (data, fp, fmt, ap);
292	}	291	}
293	#endif /* !STRING_ONLY */	292	#endif /* !STRING_ONLY */
294		293
295	#if defined (STRING_ONLY) && defined (INTEGER_ONLY)	294	#if defined (STRING_ONLY) && defined (INTEGER_ONLY)
296	/* When dealing with the sscanf family, we don't want to use the	295	/* When dealing with the sscanf family, we don't want to use the
297	* regular ungetc which will drag in file I/O items we don't need.	296	* regular ungetc which will drag in file I/O items we don't need.
298	* So, we create our own trimmed-down version. */	297	* So, we create our own trimmed-down version. */
299	int	298	int
300	_DEFUN(_sungetc_r, (data, fp, ch),	299	_DEFUN(_sungetc_r, (data, fp, ch),
301	struct _reent *data _AND	300	struct _reent *data _AND
302	int c _AND	301	int c _AND
303	register FILE *fp)	302	register FILE *fp)
304	{	303	{
305	if (c == EOF)	304	if (c == EOF)
306	return (EOF);	305	return (EOF);
307		306
308	/* After ungetc, we won't be at eof anymore */	307	/* After ungetc, we won't be at eof anymore */
309	fp->_flags &= ~__SEOF;	308	fp->_flags &= ~__SEOF;
310	c = (unsigned char) c;	309	c = (unsigned char) c;
311		310
312	/*	311	/*
313	* If we are in the middle of ungetc'ing, just continue.	312	* If we are in the middle of ungetc'ing, just continue.
314	* This may require expanding the current ungetc buffer.	313	* This may require expanding the current ungetc buffer.
315	*/	314	*/
316		315
317	if (HASUB (fp))	316	if (HASUB (fp))
318	{	317	{
319	if (fp->_r >= fp->_ub._size && __submore (data, fp))	318	if (fp->_r >= fp->_ub._size && __submore (data, fp))
320	{	319	{
321	return EOF;	320	return EOF;
322	}	321	}
323	*--fp->_p = c;	322	*--fp->_p = c;
324	fp->_r++;	323	fp->_r++;
325	return c;	324	return c;
326	}	325	}
327		326
328	/*	327	/*
329	* If we can handle this by simply backing up, do so,	328	* If we can handle this by simply backing up, do so,
330	* but never replace the original character.	329	* but never replace the original character.
331	* (This makes sscanf() work when scanning `const' data.)	330	* (This makes sscanf() work when scanning `const' data.)
332	*/	331	*/
333		332
334	if (fp->_bf._base != NULL && fp->_p > fp->_bf._base && fp->_p[-1] == c)	333	if (fp->_bf._base != NULL && fp->_p > fp->_bf._base && fp->_p[-1] == c)
335	{	334	{
336	fp->_p--;	335	fp->_p--;
337	fp->_r++;	336	fp->_r++;
338	return c;	337	return c;
339	}	338	}
340		339
341	/*	340	/*
342	* Create an ungetc buffer.	341	* Create an ungetc buffer.
343	* Initially, we will use the `reserve' buffer.	342	* Initially, we will use the `reserve' buffer.
344	*/	343	*/
345		344
346	fp->_ur = fp->_r;	345	fp->_ur = fp->_r;
347	fp->_up = fp->_p;	346	fp->_up = fp->_p;
348	fp->_ub._base = fp->_ubuf;	347	fp->_ub._base = fp->_ubuf;
349	fp->_ub._size = sizeof (fp->_ubuf);	348	fp->_ub._size = sizeof (fp->_ubuf);
350	fp->_ubuf[sizeof (fp->_ubuf) - 1] = c;	349	fp->_ubuf[sizeof (fp->_ubuf) - 1] = c;
351	fp->_p = &fp->_ubuf[sizeof (fp->_ubuf) - 1];	350	fp->_p = &fp->_ubuf[sizeof (fp->_ubuf) - 1];
352	fp->_r = 1;	351	fp->_r = 1;
353	return c;	352	return c;
354	}	353	}
355		354
356	/* String only version of __srefill_r for sscanf family. */	355	/* String only version of __srefill_r for sscanf family. */
357	int	356	int
358	_DEFUN(__ssrefill_r, (ptr, fp),	357	_DEFUN(__ssrefill_r, (ptr, fp),
359	struct _reent * ptr _AND	358	struct _reent * ptr _AND
360	register FILE * fp)	359	register FILE * fp)
361	{	360	{
362	/*	361	/*
363	* Our only hope of further input is the ungetc buffer.	362	* Our only hope of further input is the ungetc buffer.
364	* If there is anything in that buffer to read, return.	363	* If there is anything in that buffer to read, return.
365	*/	364	*/
366	if (HASUB (fp))	365	if (HASUB (fp))
367	{	366	{
368	FREEUB (ptr, fp);	367	FREEUB (ptr, fp);
369	if ((fp->_r = fp->_ur) != 0)	368	if ((fp->_r = fp->_ur) != 0)
370	{	369	{
371	fp->_p = fp->_up;	370	fp->_p = fp->_up;
372	return 0;	371	return 0;
373	}	372	}
374	}	373	}
375		374
376	/* Otherwise we are out of character input. */	375	/* Otherwise we are out of character input. */
377	fp->_p = fp->_bf._base;	376	fp->_p = fp->_bf._base;
378	fp->_r = 0;	377	fp->_r = 0;
379	fp->_flags \|= __SEOF;	378	fp->_flags \|= __SEOF;
380	return EOF;	379	return EOF;
381	}	380	}
382		381
383	size_t	382	size_t
384	_DEFUN(_sfread_r, (ptr, buf, size, count, fp),	383	_DEFUN(_sfread_r, (ptr, buf, size, count, fp),
385	struct _reent * ptr _AND	384	struct _reent * ptr _AND
386	_PTR buf _AND	385	_PTR buf _AND
387	size_t size _AND	386	size_t size _AND
388	size_t count _AND	387	size_t count _AND
389	FILE * fp)	388	FILE * fp)
390	{	389	{
391	register size_t resid;	390	register size_t resid;
392	register char *p;	391	register char *p;
393	register int r;	392	register int r;
394	size_t total;	393	size_t total;
395		394
396	if ((resid = count * size) == 0)	395	if ((resid = count * size) == 0)
397	return 0;	396	return 0;
398		397
399	total = resid;	398	total = resid;
400	p = buf;	399	p = buf;
401		400
402	while (resid > (r = fp->_r))	401	while (resid > (r = fp->_r))
403	{	402	{
404	_CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, (size_t) r);	403	_CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, (size_t) r);
405	fp->_p += r;	404	fp->_p += r;
406	fp->_r = 0;	405	fp->_r = 0;
407	p += r;	406	p += r;
408	resid -= r;	407	resid -= r;
409	if (__ssrefill_r (ptr, fp))	408	if (__ssrefill_r (ptr, fp))
410	{	409	{
411	/* no more input: return partial result */	410	/* no more input: return partial result */
412	return (total - resid) / size;	411	return (total - resid) / size;
413	}	412	}
414	}	413	}
415	_CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, resid);	414	_CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, resid);
416	fp->_r -= resid;	415	fp->_r -= resid;
417	fp->_p += resid;	416	fp->_p += resid;
418	return count;	417	return count;
419	}	418	}
420	#else /* !STRING_ONLY \|\| !INTEGER_ONLY */	419	#else /* !STRING_ONLY \|\| !INTEGER_ONLY */
421	int _EXFUN (_sungetc_r, (struct _reent , int, register FILE ));	420	int _EXFUN (_sungetc_r, (struct _reent , int, register FILE ));
422	int _EXFUN (__ssrefill_r, (struct _reent , register FILE ));	421	int _EXFUN (__ssrefill_r, (struct _reent , register FILE ));
423	size_t _EXFUN (_sfread_r, (struct _reent , _PTR buf, size_t, size_t, FILE ));	422	size_t _EXFUN (_sfread_r, (struct _reent , _PTR buf, size_t, size_t, FILE ));
424	#endif /* !STRING_ONLY \|\| !INTEGER_ONLY */	423	#endif /* !STRING_ONLY \|\| !INTEGER_ONLY */
425		424
426	int	425	int
427	_DEFUN(__SVFSCANF_R, (rptr, fp, fmt0, ap),	426	_DEFUN(__SVFSCANF_R, (rptr, fp, fmt0, ap),
428	struct _reent *rptr _AND	427	struct _reent *rptr _AND
429	register FILE *fp _AND	428	register FILE *fp _AND
430	char _CONST *fmt0 _AND	429	char _CONST *fmt0 _AND
431	va_list ap)	430	va_list ap)
432	{	431	{
433	register u_char fmt = (u_char ) fmt0;	432	register u_char fmt = (u_char ) fmt0;
434	register int c; /* character from format, or conversion */	433	register int c; /* character from format, or conversion */
435	register size_t width; /* field width, or 0 */	434	register size_t width; /* field width, or 0 */
436	register char p; / points into all kinds of strings */	435	register char p; / points into all kinds of strings */
437	register int n; /* handy integer */	436	register int n; /* handy integer */
438	register int flags; /* flags as defined above */	437	register int flags; /* flags as defined above */
439	register char p0; / saves original value of p when necessary */	438	register char p0; / saves original value of p when necessary */
440	int nassigned; /* number of fields assigned */	439	int nassigned; /* number of fields assigned */
441	int nread; /* number of characters consumed from fp */	440	int nread; /* number of characters consumed from fp */
442	#ifndef _NO_POS_ARGS	441	#ifndef _NO_POS_ARGS
443	int N; /* arg number */	442	int N; /* arg number */
444	int arg_index = 0; /* index into args processed directly */	443	int arg_index = 0; /* index into args processed directly */
445	int numargs = 0; /* number of varargs read */	444	int numargs = 0; /* number of varargs read */
446	void args[MAX_POS_ARGS]; / positional args read */	445	void args[MAX_POS_ARGS]; / positional args read */
447	int is_pos_arg; /* is current format positional? */	446	int is_pos_arg; /* is current format positional? */
448	#endif	447	#endif
449	int base = 0; /* base argument to strtol/strtoul */	448	int base = 0; /* base argument to strtol/strtoul */
450	int nbytes = 1; /* number of bytes read from fmt string */	449	int nbytes = 1; /* number of bytes read from fmt string */
451	wchar_t wc; /* wchar to use to read format string */	450	wchar_t wc; /* wchar to use to read format string */
452	wchar_t wcp; / handy wide character pointer */	451	wchar_t wcp; / handy wide character pointer */
453	size_t mbslen; /* length of converted multibyte sequence */	452	size_t mbslen; /* length of converted multibyte sequence */
454	#ifdef _MB_CAPABLE	453	#ifdef _MB_CAPABLE
455	mbstate_t state; /* value to keep track of multibyte state */	454	mbstate_t state; /* value to keep track of multibyte state */
456	#endif	455	#endif
457		456
458	#define CCFN_PARAMS _PARAMS((struct _reent , const char , char **, int))	457	#define CCFN_PARAMS _PARAMS((struct _reent , const char , char **, int))
459	u_long (ccfn)CCFN_PARAMS=0; / conversion function (strtol/strtoul) */	458	u_long (ccfn)CCFN_PARAMS=0; / conversion function (strtol/strtoul) */
460	char ccltab[256]; /* character class table for %[...] */	459	char ccltab[256]; /* character class table for %[...] */
461	char buf[BUF]; /* buffer for numeric conversions */	460	char buf[BUF]; /* buffer for numeric conversions */
462	unsigned char lptr; / literal pointer */	461	unsigned char lptr; / literal pointer */
463		462
464	char *cp;	463	char *cp;
465	short *sp;	464	short *sp;
466	int *ip;	465	int *ip;
467	#ifdef FLOATING_POINT	466	#ifdef FLOATING_POINT
468	float *flp;	467	float *flp;
469	_LONG_DOUBLE *ldp;	468	_LONG_DOUBLE *ldp;
470	double *dp;	469	double *dp;
471	#endif	470	#endif
472	long *lp;	471	long *lp;
473	#ifndef _NO_LONGLONG	472	#ifndef _NO_LONGLONG
474	long long *llp;	473	long long *llp;
475	#endif	474	#endif
476		475
477	/* `basefix' is used to avoid `if' tests in the integer scanner */	476	/* `basefix' is used to avoid `if' tests in the integer scanner */
478	static _CONST short basefix[17] =	477	static _CONST short basefix[17] =
479	{10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};	478	{10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
480		479
481	/* Macro to support positional arguments */	480	/* Macro to support positional arguments */
482	#ifndef _NO_POS_ARGS	481	#ifndef _NO_POS_ARGS
483	# define GET_ARG(n, ap, type) \	482	# define GET_ARG(n, ap, type) \
484	((type) (is_pos_arg \	483	((type) (is_pos_arg \
485	? (n < numargs \	484	? (n < numargs \
486	? args[n] \	485	? args[n] \
487	: get_arg (n, &ap, &numargs, args)) \	486	: get_arg (n, &ap, &numargs, args)) \
488	: (arg_index++ < numargs \	487	: (arg_index++ < numargs \
489	? args[n] \	488	? args[n] \
490	: (numargs < MAX_POS_ARGS \	489	: (numargs < MAX_POS_ARGS \
491	? args[numargs++] = va_arg (ap, void *) \	490	? args[numargs++] = va_arg (ap, void *) \
492	: va_arg (ap, void *)))))	491	: va_arg (ap, void *)))))
493	#else	492	#else
494	# define GET_ARG(n, ap, type) (va_arg (ap, type))	493	# define GET_ARG(n, ap, type) (va_arg (ap, type))
495	#endif	494	#endif
496		495
497	_newlib_flockfile_start (fp);	496	_newlib_flockfile_start (fp);
498		497
499	ORIENT (fp, -1);	498	ORIENT (fp, -1);
500		499

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/newlib/libc/stdio/vfscanf.c – Rev 4921 → 6099