Subversion Repositories or1k

/*

FUNCTION

<<vscanf>>, <<vfscanf>>, <<vsscanf>>---format argument list

INDEX

        vscanf

INDEX

        vfscanf

INDEX

        vsscanf

ANSI_SYNOPSIS

        #include <stdio.h>

        #include <stdarg.h>

        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(void *<[reent]>, const char *<[fmt]>,

                       va_list <[list]>);

        int _vfscanf_r(void *<[reent]>, FILE *<[fp]>, const char *<[fmt]>,

                       va_list <[list]>);

        int _vsscanf_r(void *<[reent]>, const char *<[str]>, const char *<[fmt]>,

                       va_list <[list]>);

TRAD_SYNOPSIS

        #include <stdio.h>

        #include <varargs.h>

        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]>)

        char *<[reent]>;

        char *<[fmt]>;

        va_list <[list]>;

        int _vfscanf_r( <[reent]>, <[fp]>, <[fmt]>, <[list]>)

        char *<[reent]>;

        FILE *<[fp]>;

        char *<[fmt]>;

        va_list <[list]>;

        int _vsscanf_r( <[reent]>, <[str]>, <[fmt]>, <[list]>)

        char *<[reent]>;

        char *<[str]>;

        char *<[fmt]>;

        va_list <[list]>;

DESCRIPTION

<<vscanf>>, <<vfscanf>>, and <<vsscanf>> are (respectively) variants

of <<scanf>>, <<fscanf>>, and <<sscanf>>.  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:

<<vscanf>> returns the number of input fields successfully scanned,

converted, and stored; the return value does not include scanned

fields which were not stored.

If <<vscanf>> attempts to read at end-of-file, the return value

is <<EOF>>.

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:

*/

/*-

 * 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.

 */

#include <_ansi.h>

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

#ifdef _HAVE_STDC

#include <stdarg.h>

#else

#include <varargs.h>

#endif

#include "local.h"

#ifndef NO_FLOATING_POINT

#define FLOATING_POINT

#endif

#ifdef FLOATING_POINT

#include <float.h>

/* 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_DBL && (LDBL_MANT_DIG > DBL_MANT_DIG)

#undef _NO_LONGDBL

extern _LONG_DOUBLE _strtold _PARAMS((char *s, char **sptr));

#endif

#define _NO_LONGLONG

#if defined WANT_PRINTF_LONG_LONG && defined __GNUC__

# undef _NO_LONGLONG

#endif

#include "floatio.h"

#define BUF     (MAXEXP+MAXFRACT+3)     /* 3 = sign + decimal point + 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

/*

 * Flags used during conversion.

 */

#define LONG            0x01    /* l: long or double */

#define LONGDBL         0x02    /* L: long double or long long */

#define SHORT           0x04    /* h: short */

#define SUPPRESS        0x08    /* suppress assignment */

#define POINTER         0x10    /* weird %p pointer (`fake hex') */

#define NOSKIP          0x20    /* 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          0x40    /* +/- is (still) legal */

#define NDIGITS         0x80    /* no digits detected */

#define DPTOK           0x100   /* (float) decimal point is still legal */

#define EXPOK           0x200   /* (float) exponent (e+3, etc) still legal */

#define PFXOK           0x100   /* 0x prefix is (still) legal */

#define NZDIGITS        0x200   /* no 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 */

#if 0

#define u_char unsigned char

#endif

#define u_char char

#define u_long unsigned long

#ifndef _NO_LONGLONG

typedef unsigned long long u_long_long;

#endif

/*static*/ u_char *__sccl ();

/*

 * vfscanf

 */

#define BufferEmpty (fp->_r <= 0 && __srefill(fp))

#ifndef _REENT_ONLY

int

_DEFUN (vfscanf, (fp, fmt, ap),

    register FILE *fp _AND

    _CONST char *fmt _AND

    va_list ap)

{

  CHECK_INIT(fp);

  return __svfscanf_r (fp->_data, fp, fmt, ap);

}

int

__svfscanf (fp, fmt0, ap)

     register FILE *fp;

     char _CONST *fmt0;

     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)

{

  return __svfscanf_r (data, fp, fmt, ap);

}

int

__svfscanf_r (rptr, fp, fmt0, ap)

     struct _reent *rptr;

     register FILE *fp;

     char _CONST *fmt0;

     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 */

  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 */

  u_long (*ccfn) () = 0; /* conversion function (strtol/strtoul) */

  char ccltab[256];             /* character class table for %[...] */

  char buf[BUF];                /* buffer for numeric conversions */

  char *lptr;                   /* literal pointer */

#ifdef MB_CAPABLE

  int state = 0;                /* value to keep track of multibyte state */

#endif

  short *sp;

  int *ip;

  float *flp;

  _LONG_DOUBLE *ldp;

  double *dp;

  long *lp;

#ifndef _NO_LONGLONG

  long long *llp;

#else

        u_long _uquad;

#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};

  nassigned = 0;

  nread = 0;

  for (;;)

    {

#ifndef MB_CAPABLE

      wc = *fmt;

#else

      nbytes = _mbtowc_r (rptr, &wc, fmt, MB_CUR_MAX, &state);

#endif

      fmt += nbytes;

      if (wc == 0)

        return nassigned;

      if (nbytes == 1 && isspace (wc))

        {

          for (;;)

            {

              if (BufferEmpty)

                return nassigned;

              if (!isspace (*fp->_p))

                break;

              nread++, fp->_r--, fp->_p++;

            }

          continue;

        }

      if (wc != '%')

        goto literal;

      width = 0;

      flags = 0;

      /*

       * 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':

          flags |= LONG;

          goto again;

        case 'L':

          flags |= LONGDBL;

          goto again;

        case 'h':

          flags |= SHORT;

          goto again;

        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;

          /*

           * 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 (*)())_strtol_r;

          base = 10;

          break;

        case 'i':

          c = CT_INT;

          ccfn = (u_long (*)())_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':               /* compat   XXX */

        case 'x':

          flags |= PFXOK;       /* enable 0x prefixing */

          c = CT_INT;

          ccfn = _strtoul_r;

          base = 16;

          break;

#ifdef FLOATING_POINT

        case 'E':               /* compat   XXX */

        case 'G':               /* compat   XXX */

/* ANSI says that E,G and X behave the same way as e,g,x */

          /* FALLTHROUGH */

        case 'e':

        case 'f':

        case 'g':

          c = CT_FLOAT;

          break;

#endif

        case 's':

          c = CT_STRING;

          break;

        case '[':

          fmt = __sccl (ccltab, fmt);

          flags |= NOSKIP;

          c = CT_CCL;

          break;

        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;

          if (flags & SHORT)

            {

              sp = va_arg (ap, short *);

              *sp = nread;

            }

          else if (flags & LONG)

            {

              lp = va_arg (ap, long *);

              *lp = nread;

            }

#ifndef _NO_LONGLONG

          else if (flags & LONGDBL)

            {

              llp = va_arg (ap, long long*);

              *llp = nread;

            }

#endif

          else

            {

              ip = va_arg (ap, int *);

              *ip = nread;

            }

          continue;

          /*

           * Disgusting backwards compatibility hacks.  XXX

           */

        case '\0':              /* compat */

          return EOF;

        default:                /* compat */

          if (isupper (c))

            flags |= LONG;

          c = CT_INT;

          ccfn = (u_long (*)())_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

#ifndef CYGNUS_NEC

              if (__srefill (fp))

#endif

                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 (flags & SUPPRESS)

            {

              size_t sum = 0;

              for (;;)

                {

                  if ((n = fp->_r) < (int)width)

                    {

                      sum += n;

                      width -= n;

                      fp->_p += n;

#ifndef CYGNUS_NEC

                      if (__srefill (fp))

                        {

#endif

                          if (sum == 0)

                            goto input_failure;

                          break;

#ifndef CYGNUS_NEC

                        }

#endif

                    }

                  else

                    {

                      sum += width;

                      fp->_r -= width;

                      fp->_p += width;

                      break;

                    }

                }

              nread += sum;

            }

          else

            {

#ifdef CYGNUS_NEC

              /* Kludge city for the moment */

              char *dest = va_arg (ap, char *);

              int n = width;

              if (fp->_r == 0)

                goto input_failure;

              while (n && fp->_r)

                {

                  *dest++ = *(fp->_p++);

                  n--;

                  fp->_r--;

                  nread++;

                }

#else

              size_t r = fread ((_PTR) va_arg (ap, char *), 1, width, fp);

              if (r == 0)

                goto input_failure;

              nread += r;

#endif

              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 = va_arg (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 = ~0;

          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 = va_arg (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 */

#ifdef hardway

          if (width == 0 || width > sizeof (buf) - 1)

            width = sizeof (buf) - 1;

#else

          /* size_t is unsigned, hence this optimisation */

          if (--width > sizeof (buf) - 2)

            width = sizeof (buf) - 2;

          width++;

#endif

          flags |= SIGNOK | NDIGITS | NZDIGITS;

          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 (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 '1':

                case '2':

                case '3':

                case '4':

                case '5':

                case '6':

                case '7':

                  base = basefix[base];

                  flags &= ~(SIGNOK | PFXOK | NDIGITS);

                  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);

                  goto ok;

                  /* letters ok iff hex */

                case 'A':

                case 'B':

                case 'C':

                case 'D':

                case 'E':

                case 'F':

                case 'a':