/* VFSCANF.C

  * 

  * Portions Copyright (c) 1990-2004 Nokia Corporation and/or its subsidiary(-ies).

  * All rights reserved.

  */

 /* No user fns here. Pesch 15apr92. */

 /*

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

 #include "LOCAL.H"

 #include "FLOATIO.H"

 #define	BUF	(MAXEXP+MAXFRACT+3)	/* 3 = sign + decimal point + NUL */

 /*

  * Flags used during conversion.

  */

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

 #define	LONGDBL		0x02	/* L: long double; unimplemented */

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

 #define u_char char

 #define u_long unsigned long

 /*static*/ u_char *__sccl (register char *tab,register u_char *fmt);

 /*

  * vfscanf

  */

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

 int

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

   u_long (*ccfn) (const char *_n, char **_end_PTR, int _base) = 0;	/* conversion function (strtol/strtoul) */

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

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

   short *sp;

   int *ip;

   float *flp;

   double *dp;

   long *lp;

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

     {

       c = *fmt++;

       if (c == 0)

 	return nassigned;

       if (isspace (c))

 	{

 	  for (;;)

 	    {

 	      if (BufferEmpty)

 		return nassigned;

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

 		break;

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

 	    }

 	  continue;

 	}

       if (c != '%')

 	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:

 	  if (BufferEmpty)

 	    goto input_failure;

 	  if (*fp->_p != c)

 	    goto match_failure;

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

 	  nread++;

 	  continue;

 	case '*':

 	  flags |= SUPPRESS;

 	  goto again;

 	case 'l':

 	  flags |= LONG;

 	  goto again;

 	case 'L':

 	  /* not supported 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 (*)(const char *_n, char **_end_PTR, int _base))strtol;

 	  base = 10;

 	  break;

 	case 'i':

 	  c = CT_INT;

 	  ccfn = (u_long (*)(const char *_n, char **_end_PTR, int _base))strtol;

 	  base = 0;

 	  break;

 	case 'O':		/* compat */

 	  flags |= LONG;

 	  /* FALLTHROUGH */

 	case 'o':

 	  c = CT_INT;

 	  ccfn = (u_long (*)(const char *_n, char **_end_PTR, int _base))strtoul;

 	  base = 8;

 	  break;

 	case 'u':

 	  c = CT_INT;

 	  ccfn = (u_long (*)(const char *_n, char **_end_PTR, int _base))strtoul;

 	  base = 10;

 	  break;

 	case 'X':		/* compat   XXX */

 	case 'x':

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

 	  c = CT_INT;

 	  ccfn = (u_long (*)(const char *_n, char **_end_PTR, int _base))strtoul;

 	  base = 16;

 	  break;

 	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;

 	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 = (u_long (*)(const char *_n, char **_end_PTR, int _base))strtoul;

 	  base = 16;

 	  break;

 	case 'n':

 	  if (flags & SUPPRESS)	/* ??? */

 	    continue;

 	  if (flags & SHORT)

 	    {

 	      sp = va_arg (ap, short *);

 	      *sp = (short)nread;

 	    }

 	  else if (flags & LONG)

 	    {

 	      lp = va_arg (ap, long *);

 	      *lp = nread;

 	    }

 	  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 (*)(const char *_n, char **_end_PTR, int _base))strtol;

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

 	    {

 	      size_t sum = 0;

 	      for (;;)

 		{

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

 		    {

 		      sum += n;

 		      width -= n;

 		      fp->_p += n;

 		      if (__srefill (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 ((void*) va_arg (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 = (unsigned long)(~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 = (unsigned long)(~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':

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

 		  goto ok;

 		  /* sign ok only as first character */

 		case '+':

 		case '-':

 		  if (flags & SIGNOK)

 		    {

 		      flags &= ~SIGNOK;

 		      goto ok;

 		    }

 		  break;

 		  /* x ok iff flag still set & 2nd char */

 		case 'x':

 		case 'X':

 		  if (flags & PFXOK && p == buf + 1)

 		    {

 		      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.

 	       */

 	      break;

 	    ok:

 	      /*

 	       * c is legal: store it and look at the next.

 	       */

 	      *p++ = (char)c;

 	      if (--fp->_r > 0)

 		fp->_p++;

 	      else

 	      if (__srefill (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'.

 	   */

 	  if (flags & NDIGITS)

 	    {

 	      if (p > buf)

 		(void) ungetc (*(u_char *)-- p, fp);

 	      goto match_failure;

 	    }

 	  c = ((u_char *) p)[-1];

 	  if (c == 'x' || c == 'X')

 	    {

 	      --p;

 	      /*(void)*/ ungetc (c, fp);

 	    }

 	  if ((flags & SUPPRESS) == 0)

 	    {

 	      u_long res;

 	      *p = 0;

 	      res = (*ccfn) (buf, (char **) NULL, base);

 	      if (flags & POINTER)

 		*(va_arg (ap, void* *)) = (void*) res;

 	      else if (flags & SHORT)

 		{

 		  sp = va_arg (ap, short *);

 		  *sp = (short)res;

 		}

 	      else if (flags & LONG)

 		{

 		  lp = va_arg (ap, long *);

 		  *lp = res;

 		}

 	      else

 		{

 		  ip = va_arg (ap, int *);

 		  *ip = res;

 		}

 	      nassigned++;

 	    }

 	  nread += p - buf;

 	  break;

 	case CT_FLOAT:

 	  /* scan a floating point number as if by strtod */

 #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 | DPTOK | EXPOK;

 	  for (p = buf; width; width--)

 	    {

 	      c = *fp->_p;

 	      /*

 	       * This code mimicks the integer conversion

 	       * code, but is much simpler.

 	       */

 	      switch (c)

 		{

 		case '0':

 		case '1':

 		case '2':

 		case '3':

 		case '4':

 		case '5':

 		case '6':

 		case '7':

 		case '8':

 		case '9':

 		  flags &= ~(SIGNOK | NDIGITS);

 		  goto fok;

 		case '+':

 		case '-':

 		  if (flags & SIGNOK)

 		    {

 		      flags &= ~SIGNOK;

 		      goto fok;

 		    }

 		  break;

 		case '.':

 		  if (flags & DPTOK)

 		    {

 		      flags &= ~(SIGNOK | DPTOK);

 		      goto fok;

 		    }

 		  break;

 		case 'e':

 		case 'E':

 		  /* no exponent without some digits */

 		  if ((flags & (NDIGITS | EXPOK)) == EXPOK)

 		    {

 		      flags =

 			(flags & ~(EXPOK | DPTOK)) |

 			SIGNOK | NDIGITS;

 		      goto fok;

 		    }

 		  break;

 		}

 	      break;

 	    fok:

 	      *p++ = (char)c;

 	      if (--fp->_r > 0)

 		fp->_p++;

 	      else

 	      if (__srefill (fp))

 		break;		/* EOF */

 	    }

 	  /*

 	   * 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 (*(u_char *)-- p, fp);

 		  goto match_failure;

 		}

 	      /* just a bad exponent (e and maybe sign) */

 	      c = *(u_char *)-- p;

 	      if (c != 'e' && c != 'E')

 		{

 		  (void) ungetc (c, fp);	/* sign */

 		  c = *(u_char *)-- p;

 		}

 	      (void) ungetc (c, fp);

 	    }

 	  if ((flags & SUPPRESS) == 0)

 	    {

 	      double res;

 	      *p = 0;

 	      res = atof (buf);

 	      if (flags & LONG)

 		{

 		  dp = va_arg (ap, double *);

 		  *dp = res;

 		}

 	      else

 		{

 		  flp = va_arg (ap, float *);

 		  *flp = (float)res;

 		}

 	      nassigned++;

 	    }

 	  nread += p - buf;

 	  break;

 	}

     }

 input_failure:

   return nassigned ? nassigned : -1;

 match_failure:

   return nassigned;

 }

 /*

  * Fill in the given table from the scanset at the given format

  * (just after `[').  Return a pointer to the character past the

  * closing `]'.  The table has a 1 wherever characters should be

  * considered part of the scanset.

  */

 /*static*/

 u_char *

 __sccl (register char *tab,register u_char *fmt)

 {

   register int c, n, v;

   /* first `clear' the whole table */

   c = *fmt++;			/* first char hat => negated scanset */

   if (c == '^')

     {

       v = 1;			/* default => accept */

       c = *fmt++;		/* get new first char */

     }

   else

     v = 0;			/* default => reject */

   /* should probably use memset here */

   for (n = 0; n < 256; n++)

     tab[n] = (char)v;

   if (c == 0)

     return fmt - 1;		/* format ended before closing ] */

   /*

    * Now set the entries corresponding to the actual scanset to the

    * opposite of the above.

    *

    * The first character may be ']' (or '-') without being special; the

    * last character may be '-'.

    */

   v = 1 - v;

   for (;;)

     {

       tab[c] = (char)v;		/* take character c */

     doswitch:

       n = *fmt++;		/* and examine the next */

       switch (n)

 	{

 	case 0:		/* format ended too soon */

 	  return fmt - 1;

 	case '-':

 	  /*

 	   * A scanset of the form [01+-] is defined as `the digit 0, the

 	   * digit 1, the character +, the character -', but the effect of a

 	   * scanset such as [a-zA-Z0-9] is implementation defined.  The V7

 	   * Unix scanf treats `a-z' as `the letters a through z', but treats

 	   * `a-a' as `the letter a, the character -, and the letter a'.

 	   *

 	   * For compatibility, the `-' is not considerd to define a range if

 	   * the character following it is either a close bracket (required by

 	   * ANSI) or is not numerically greater than the character we just

 	   * stored in the table (c).

 	   */

 	  n = *fmt;

 	  if (n == ']' || n < c)

 	    {

 	      c = '-';

 	      break;		/* resume the for(;;) */

 	    }

 	  fmt++;

 	  do

 	    {			/* fill in the range */

 	      tab[++c] = (char)v;

 	    }

 	  while (c < n);

 #if 1			/* XXX another disgusting compatibility hack */

 	  /*

 	   * Alas, the V7 Unix scanf also treats formats such

 	   * as [a-c-e] as `the letters a through e'. This too

 	   * is permitted by the standard....

 	   */

 	  goto doswitch;

 #else

 	  c = *fmt++;

 	  if (c == 0)

 	    return fmt - 1;

 	  if (c == ']')

 	    return fmt;

 	  break;

 #endif

 	case ']':		/* end of scanset */

 	  return fmt;

 	default:		/* just another character */

 	  c = n;

 	  break;

 	}

     }

   /* NOTREACHED */

 }