/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1996, by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * System V.2 Emulation Stdio Library -- vfscanf
 *
 * Copyright 1985, 1992 by Mortice Kern Systems Inc.  All rights reserved.
 *
 */

#ifdef M_RCSID
#ifndef lint
static char rcsID[] = "$Id: vfscanf.c 1.27 1995/09/20 19:07:52 ant Exp $";
#endif
#endif

#include <mks.h>
#include <ctype.h>
#include <limits.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#ifdef __FLOAT__
#include <math.h>
#endif

#define	CONVTYPE	1
#define STAR		2
#define PERCENT		3
#define NUMBER		4
#define MODCONVL	5
#define NSCAN		6
#define	BRACKET		7
#define MODCONVH	8

#define BASE16	16
#define BASE10	10
#define BASE8	8
#define NOBASE	0
#define SIGNED	1
#define UNSIGNED 0

#define	CBUFSIZ	100	/* size of character buffer for input conversion */

struct lexlist {
	char	name;
	char	type;
};
static struct lexlist *lexp;
static struct lexlist lexlist[] ={
	'*',	STAR,
	'%',	PERCENT,
	'l',	MODCONVL,
	'h',	MODCONVH,
	'n',	NSCAN,
	'[',	BRACKET,
	'd',	CONVTYPE,
	'S',	CONVTYPE,	/* dummy entry (for multibyte characters) */
	's',	CONVTYPE,
	'u',	CONVTYPE,
	'c',	CONVTYPE,
	'x',	CONVTYPE,
	'o',	CONVTYPE,
	'0',	NUMBER,
	'1',	NUMBER,
	'2',	NUMBER,
	'3',	NUMBER,
	'4',	NUMBER,
	'5',	NUMBER,
	'6',	NUMBER,
	'7',	NUMBER,
	'8',	NUMBER,
	'9',	NUMBER,
	'i',	CONVTYPE,
	'f',	CONVTYPE,
	'e',	CONVTYPE,
	'g',	CONVTYPE,
	0,	0
};

static int	scan(int, const char *, const char *);
static	int	gettoken(void);
static	void	whitespace(void);
static	int	match(const char *, char *);
static	long	unsigned	getnum(int, int, int);
static	int	getin(void);
static	void	unget(int);
#ifdef	__FLOAT__
static	double	lstrtod(void);
#endif

static	int	ungot;		/* getin/unget char */
static	FILE	*fpin;		/* input file pointer */
static	int	pflag;		/*indicator of conversion description present */
static	int	width;		/* field width value */
static	const	char	*fmtptr;	/* format string pointer */
static	int	charcnt;	/* number of characters scanned (for %n) */
static	int	from;		/* token type we've come from */
static	int	gfail;		/* getnum() fail flag, non-zero for fail */
 
/*
 * Convert formatted input from given input.
 * This is the workhorse for scanf, sscanf, and fscanf.
 * Returns the number of matched and assigned input items.
 */
int
mks_vfscanf(FILE *pfin, const char *fmt, va_list ap)
{
	int	nitems;
	int	ltoken;
	int	c;
	int	modconv;	/* flag indicating conversion modifier */
	int	suppression;	/* flag to suppress conversion */

	long unsigned number;	/* return value from getnumber */

	ungot = EOF;
	fpin = pfin;
	fmtptr = fmt;
	from = 'X';
	nitems = 0;
	charcnt = 0;

	for (;;) {
		if (from == 'X') {
			pflag = 0;
			modconv = 0;
			suppression = 0;
			width = 0;
		}
		ltoken = gettoken();

		switch (ltoken) {

		case 0:
			goto retitems;
	
		case MODCONVL:
		case MODCONVH:
			switch (from) {
	
			case 'A':
			case 'D':
			case 'P':
				from = 'E';
				modconv = ltoken;
				break;
			default:
				from = 'X';
				break;
			}
			break;
	
		case CONVTYPE:
			switch (from) {

			int	intassign;

			case 'E':
			case 'P':
			case 'D':
			case 'A':
				from = 'X';
				intassign = 1;
				pflag = 0;

				switch (lexp->name) {

				case 'd':
					number = getnum(BASE10, width, SIGNED);
					if (gfail)
						goto retitems;
					break;
				case 'u':
					number = getnum(BASE10, width, UNSIGNED);
					if (gfail)
						goto retitems;
					break;
				case 'x':
					number = getnum(BASE16, width, SIGNED);
					if (gfail)
						goto retitems;
					break;
				case 'o':
					number = getnum(BASE8, width, SIGNED);
					if (gfail)
						goto retitems;
					break;
				case 'i':
					number = getnum(NOBASE, width, SIGNED);
					if (gfail)
						goto retitems;
					break;
				case 'c':
				/* 'S' dummy entry (for multibyte characters) */
				case 'S':
				case 's': {
					int gotitem = 0;
					char	*str;

					if (!suppression)
						str = va_arg(ap, char *);

					/* Input whitespace is not skipped
					 * for %c, which implies that %c
					 * can return whitespace.
					 */
					if (lexp->name != 'c')
						whitespace();
					for (;;) {
						c = getin();

						/* Only %s and %S stop on 
						 * whitespace. 
						 */
						if (lexp->name != 'c' && isspace(c)) {
							unget(c);
							break;
						}
						if (c == EOF) {
							if(!gotitem)
								goto retitems;
							break;
						}

						gotitem = 1;
						if (!suppression)
							*str++ = c;

						if (width) {
							if (--width == 0)
								break;
						}
					}

					/*
					 * ANSI C states that %c does not 
					 * terminate with a null character.
					 */
					if (!suppression && lexp->name != 'c')
						*str = '\0';
					intassign = 0;
					break;
				}
#ifdef	__FLOAT__
				case 'f':
				case 'g':
				case 'e': {
					double	fresult;

					fresult = lstrtod();
					if(gfail)
						goto retitems;
					if(suppression)
						break;
					if (modconv == MODCONVL)
						*(double *)va_arg(ap, double *) = fresult;
					else
						*(float *)va_arg(ap, float *) = (float)fresult;
					/*FALLTHROUGH*/
				}
#else	/* !__FLOAT__ */
				case 'f':
				case 'g':
				case 'e':
#endif	/* __FLOAT__ */
				default:
					intassign = 0;
					break;
				}

				if (suppression)
					break;
				else
					nitems++;

				if (intassign == 0)
					break;

				switch (modconv) {

				case MODCONVH:
					*(short *)va_arg(ap, short *) = (short)number;
					break;
				case MODCONVL:
					*(long *)va_arg(ap, long *) = (long)number;
					break;
				default:
					*(int *)va_arg(ap, int *) = (int)number;
					break;
				}
				break;
			default:
				from = 'X';
				break;
			}
			break;
	
		case STAR:
			if (from == 'P') {
				from = 'A';
				suppression = 1;
			} else {
				from = 'X';
			}
			break;
	
		case PERCENT:
			if (from == 'P') {
				from = 'X';
				pflag = 0;
				c = getin();
				if (c != '%')
					goto retitems;
			} else {
				from = 'X';
			}
			break;
	
		case NUMBER:
			if (from == 'P' || from == 'A') {
				from = 'D';
			} else {
				from = 'X';
			}
			break;
	
		case NSCAN:
			if (from == 'P') {
				pflag = 0;
				if (!suppression) {
					*(int *)va_arg(ap, int *) = charcnt;
				}
			}
			from = 'X';
			break;
	
		case BRACKET:
			switch (from) {

			case 'A':
			case 'D':
			case 'P': {
				char *ptr;

				pflag = 0;
				if (width == 0)
					width = INT_MAX;
				ptr = suppression ? NULL : va_arg(ap, char *);
				if (match(fmtptr, ptr) && !feof(fpin) 
				&& !suppression)
					nitems++;
				while (*fmtptr++ != ']')
					;
				break;
			}
			default:
				break;
			}
			from = 'X';
			break;
	
		default:
			c = *(fmtptr-1);
			if (c == ' ' || c == '\t' || c == '\n' || c == '\f')
				whitespace();
			else {
				c = getin();

				if (c != *(fmtptr-1))
					goto retitems;
			}
			from = 'X';
			break;
		}
	}
retitems:
	if (ungot != EOF) {
		ungetc(ungot, fpin);
		ungot = EOF;
	}
	return nitems==0 ? EOF : nitems;
}

static int
gettoken()
{
	char	c;

	if (*fmtptr == 0)
		return 0;	/* return 0 for end of string */

	c = *fmtptr++;

	if (pflag) {
		for(lexp=lexlist; lexp->name != 0; lexp++) {
			if (c == lexp->name) {
				if (lexp->type == NUMBER) {
					width = (int) strtol(fmtptr-1, (char **)0, BASE10);
					while (*fmtptr >= '0' && *fmtptr <= '9')
						fmtptr++;
				} else if (c == 'c') {
					/* No width specified for %c, default
					 * is one.
					 */
					width = 1;
				}
				return lexp->type;
			}
		}
		return -1;
	}

	if (c == '%') {
		pflag = 1;
		from = 'P';
		return gettoken();
	}
	return -1;
}

static void
whitespace()
{
	register int	c;

	do {
		c = getin();
	} while (isspace(c));

	unget(c);
}

static int
scan(int ch, const char *str, const char *estr)
{
	for (; str < estr; ++str)
		if (*str == ch)
			return 1;

	return 0;
}

static int
match(const char *str, char *outstr)
{
	int	complement;
	int	i;
	char	start, end;
	int	c;
	const	char	*bscan, *escan;

	if (*str == '^') {
		complement = 1;
		str++;
	} else
		complement = 0;

	start = *str++;
	end = 0;
	if (*str == '-') {
		if (str[2] == ']')
			end = str[1];
	}
	if (start > end) {
		bscan = str - 1;
		while (*str++ != ']')
			;
		escan = str - 1;

		for (i=0; i<width; i++) {
			if ((c = getin()) == EOF)
				return 0;
			if (!scan(c, bscan, escan) ^ complement)
				break;
			if (outstr != NULL)
				*outstr++ = c;
		}
	} else {
		for (i=0; i<width; i++) {
			c = getin();
			if (complement) {
				if (c >= start && c <= end)
					break;
				else if (outstr != NULL)
					*outstr++ = c;
			} else {
				if (c < start || c > end)
					break;
				else if (outstr != NULL)
					*outstr++ = c;
			}
		}
	}

	if (i < width)
		unget(c);

	if (outstr != NULL)
		*outstr = '\0';
	return (i > 1);
}

/*
 * Get a number from the input stream.
 * The base, if zero, will be determined by the nature of the number.
 * A leading 0x means hexadecimal, a leading 0 for octal, otherwise decimal.
 * 
 * if the width is 0 then the max input string length of number is used.
 *
 * The sign tell us that a signed number is expected (rather than the
 *	'u' conversion type which is unsigned).
 */
static long unsigned
getnum(int base, int width, int sign)
{
	char	*s;
	char	cbuf[CBUFSIZ];			/* char buffer for number */
	int	w;
	register int	c;
	int	neg;
	long	ret;

	gfail = 0;
	whitespace();

	if (width == 0)
		width = sizeof cbuf;

	neg = 0;
	if (sign) {
		c = getin();
		if (c == '+' || c == '-')
			neg = c=='-' ? 1 : 0;
		else
			unget(c);
	}

	if (base == 0) {
		base = 10;
		c = getin();
		if (c == '0') {
			base = 8;
			c = getin();
			if (c == 'X' || c == 'x')
				base = 16;
			else
				unget(c);
		} else
			unget(c);
	}
	if (base == 10) {
		w = 0;
		s = cbuf;
		while (w < width && w < sizeof cbuf) {
			c = getin();
			switch (c) {
	
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				*s++ = c;
				w++;
				continue;
			default:
				unget(c);
				w = width;	/* force end of loop */
				break;
			}
		}
		*s = '\0';
		ret = strtol(cbuf, (char **)0, 10);
		goto retn;
	}
	if (base == 8) {
		w = 0;
		s = cbuf;
		while (w < width && w < sizeof cbuf) {
			c = getin();
			switch (c) {
	
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
				*s++ = c;
				w++;
				continue;
			default:
				unget(c);
				w = width;	/* force end of loop */
				break;
			}
		}
		*s = '\0';
		ret = strtol(cbuf, (char **)0, 8);
		goto retn;
	}
	if (base == 16) {
		w = 0;
		s = cbuf;
		while (w < width && w < sizeof cbuf) {
			c = getin();
			c = toupper(c);
			switch (c) {
	
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
				*s++ = c;
				w++;
				continue;
			default:
				unget(c);
				w = width;	/* force end of loop */
				break;
			}
		}
		*s = '\0';
		ret = strtol(cbuf, (char **)0, 16);
		goto retn;
	}

/*
 * if we get this far then a bad base was passed.
 */
	gfail = -1;

retn:
	if (*cbuf == '\0')	/* No number at all?? */
		gfail = -1;
	if (neg)
		ret = -ret;
	return ret;
}

#ifdef	__FLOAT__
static double
lstrtod()
{
	int	slen;
	int	neg, eneg;
	char	cbuf[CBUFSIZ];
	register int	c;
	register char	*sp, *s1, *s2, *s3;
	double	total, exp, tens;

	neg = eneg = 1;
	gfail = 0;

	whitespace();

	c = getin();

	if (c == '-' || c == '+')
		if (c == '-') {
			neg = -1;
			c = getin();
		}

	sp = s1 = cbuf;
	while (c >= '0' && c <= '9') {
		*sp++ = c;
		c = getin();
	}

	s2 = sp;
	if (c == '.') {
		c = getin();
		while (c >= '0' && c <= '9') {
			*sp++ = c;
			c = getin();
		}
	}

	s3 = sp;
	if (c == 'e' || c == 'E') {
		c = getin();
		if (c == '-' || c == '+')
			if (c == '-') {
				eneg = -1;
				c = getin();
			}
		while (c >= '0' && c <= '9') {
			*sp++ = c;
			c = getin();
		}
	}
	*sp = '\0';

	if (s1 == s2 && s2 == s3) {
		gfail = -1;
		return 0.0;
	}
	unget(c);

	/*
	 * convert the three strings (integer, fraction, and exponent)
	 * into a floating point number.
	 */

	total = 0.0;
	tens = 1.0;
	for (sp=s2-1; sp >= s1; sp--) {
		total += (*sp -'0') * tens;
		tens *= 10.0;
	}

	tens = .1;
	for (sp=s2; sp < s3; sp++) {
		total += (*sp - '0') * tens;
		tens /= 10.0;
	}
	total *= (double)neg;

	exp = 0.0;
	tens = 1.0;
	if ((slen = strlen(s3)) > 0) {
		sp = s3 + slen - 1;
		for ( ; sp >= s3; sp--) {
			exp += (*sp - '0') * tens;
			tens *= 10.0;
		}
	}
	*sp = '\0';

	exp *= (double)eneg;

	total *= pow(10.0, exp);

	return total;
}
#endif	/* __FLOAT__ */

static	int
getin()
{
	int	c;

	if (ungot != EOF) {
		c = ungot;
		ungot = EOF;
	} else
		c = getc(fpin);
	charcnt++;
	return c;
}

static void
unget(int c)
{
	/* Dont' use ungetc because it doesn't work with m_fsopen */
	ungot = c;
	charcnt--;
}