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