/*

 * This file and its contents are supplied under the terms of the

 * Common Development and Distribution License ("CDDL"), version 1.0.

 * You may only use this file in accordance with the terms of version

 * 1.0 of the CDDL.

 *

 * A full copy of the text of the CDDL should have accompanied this

 * source.  A copy of the CDDL is also available via the Internet at

 * http://www.illumos.org/license/CDDL.

 */

/*

 * Copyright 2010 Nexenta Systems, Inc.  All rights reserved.

 */

/*

 * This file contains the "scanner", which tokenizes the input files

 * for localedef for processing by the higher level grammar processor.

 */

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <limits.h>

#include <string.h>

#include <widec.h>

#include <sys/types.h>

#include <assert.h>

#include "localedef.h"

#include "parser.tab.h"

int			com_char = '#';

int			esc_char = '\\';

int			mb_cur_min = 1;

int			mb_cur_max = 1;

int			lineno = 1;

int			warnings = 0;

static int		nextline;

static FILE		*input = stdin;

static const char	*filename = "<stdin>";

static int		instring = 0;

static int		escaped = 0;

/*

 * Token space ... grows on demand.

 */

static char *token = NULL;

static int tokidx;

static int toksz = 0;

static int hadtok = 0;

/*

 * Wide string space ... grows on demand.

 */

static wchar_t *widestr = NULL;

static int wideidx = 0;

static int widesz = 0;

/*

 * The last keyword seen.  This is useful to trigger the special lexer rules

 * for "copy" and also collating symbols and elements.

 */

int	last_kw = 0;

static int	category = T_END;

static struct token {

	int id;

	const char *name;

} keywords[] = {

	{ T_COM_CHAR,		"comment_char" },

	{ T_ESC_CHAR,		"escape_char" },

	{ T_END,		"END" },

	{ T_COPY,		"copy" },

	{ T_MESSAGES,		"LC_MESSAGES" },

	{ T_YESSTR,		"yesstr" },

	{ T_YESEXPR,		"yesexpr" },

	{ T_NOSTR,		"nostr" },

	{ T_NOEXPR,		"noexpr" },

	{ T_MONETARY,		"LC_MONETARY" },

	{ T_INT_CURR_SYMBOL,	"int_curr_symbol" },

	{ T_CURRENCY_SYMBOL,	"currency_symbol" },

	{ T_MON_DECIMAL_POINT,	"mon_decimal_point" },

	{ T_MON_THOUSANDS_SEP,	"mon_thousands_sep" },

	{ T_POSITIVE_SIGN,	"positive_sign" },

	{ T_NEGATIVE_SIGN,	"negative_sign" },

	{ T_MON_GROUPING,	"mon_grouping" },

	{ T_INT_FRAC_DIGITS,	"int_frac_digits" },

	{ T_FRAC_DIGITS,	"frac_digits" },

	{ T_P_CS_PRECEDES,	"p_cs_precedes" },

	{ T_P_SEP_BY_SPACE,	"p_sep_by_space" },

	{ T_N_CS_PRECEDES,	"n_cs_precedes" },

	{ T_N_SEP_BY_SPACE,	"n_sep_by_space" },

	{ T_P_SIGN_POSN,	"p_sign_posn" },

	{ T_N_SIGN_POSN,	"n_sign_posn" },

	{ T_INT_P_CS_PRECEDES,	"int_p_cs_precedes" },

	{ T_INT_N_CS_PRECEDES,	"int_n_cs_precedes" },

	{ T_INT_P_SEP_BY_SPACE,	"int_p_sep_by_space" },

	{ T_INT_N_SEP_BY_SPACE,	"int_n_sep_by_space" },

	{ T_INT_P_SIGN_POSN,	"int_p_sign_posn" },

	{ T_INT_N_SIGN_POSN,	"int_n_sign_posn" },

	{ T_COLLATE,		"LC_COLLATE" },

	{ T_COLLATING_SYMBOL,	"collating-symbol" },

	{ T_COLLATING_ELEMENT,	"collating-element" },

	{ T_FROM,		"from" },

	{ T_ORDER_START,	"order_start" },

	{ T_ORDER_END,		"order_end" },

	{ T_FORWARD,		"forward" },

	{ T_BACKWARD,		"backward" },

	{ T_POSITION,		"position" },

	{ T_IGNORE,		"IGNORE" },

	{ T_UNDEFINED,		"UNDEFINED" },

	{ T_NUMERIC,		"LC_NUMERIC" },

	{ T_DECIMAL_POINT,	"decimal_point" },

	{ T_THOUSANDS_SEP,	"thousands_sep" },

	{ T_GROUPING,		"grouping" },

	{ T_TIME,		"LC_TIME" },

	{ T_ABDAY,		"abday" },

	{ T_DAY,		"day" },

	{ T_ABMON,		"abmon" },

	{ T_MON,		"mon" },

	{ T_D_T_FMT,		"d_t_fmt" },

	{ T_D_FMT,		"d_fmt" },

	{ T_T_FMT,		"t_fmt" },

	{ T_AM_PM,		"am_pm" },

	{ T_T_FMT_AMPM,		"t_fmt_ampm" },

	{ T_ERA,		"era" },

	{ T_ERA_D_FMT,		"era_d_fmt" },

	{ T_ERA_T_FMT,		"era_t_fmt" },

	{ T_ERA_D_T_FMT,	"era_d_t_fmt" },

	{ T_ALT_DIGITS,		"alt_digits" },

	{ T_CTYPE,		"LC_CTYPE" },

	{ T_ISUPPER,		"upper" },

	{ T_ISLOWER,		"lower" },

	{ T_ISALPHA,		"alpha" },

	{ T_ISDIGIT,		"digit" },

	{ T_ISPUNCT,		"punct" },

	{ T_ISXDIGIT,		"xdigit" },

	{ T_ISSPACE,		"space" },

	{ T_ISPRINT,		"print" },

	{ T_ISGRAPH,		"graph" },

	{ T_ISBLANK,		"blank" },

	{ T_ISCNTRL,		"cntrl" },

	/*

	 * These entries are local additions, and not specified by

	 * TOG.  Note that they are not guaranteed to be accurate for

	 * all locales, and so applications should not depend on them.

	 */

	{ T_ISSPECIAL,		"special" },

	{ T_ISENGLISH,		"english" },

	{ T_ISPHONOGRAM,	"phonogram" },

	{ T_ISIDEOGRAM,		"ideogram" },

	{ T_ISNUMBER,		"number" },

	/*

	 * We have to support this in the grammar, but it would be a

	 * syntax error to define a character as one of these without

	 * also defining it as an alpha or digit.  We ignore it in our

	 * parsing.

	 */

	{ T_ISALNUM,		"alnum" },

	{ T_TOUPPER,		"toupper" },

	{ T_TOLOWER,		"tolower" },

	/*

	 * These are keywords used in the charmap file.  Note that

	 * Solaris orginally used angle brackets to wrap some of them,

	 * but we removed that to simplify our parser.  The first of these

	 * items are "global items."

	 */

	{ T_CHARMAP,		"CHARMAP" },

	{ T_WIDTH,		"WIDTH" },

	{ -1, NULL },

};

/*

 * These special words are only used in a charmap file, enclosed in <>.

 */

static struct token symwords[] = {

	{ T_COM_CHAR,		"comment_char" },

	{ T_ESC_CHAR,		"escape_char" },

	{ T_CODE_SET,		"code_set_name" },

	{ T_MB_CUR_MAX,		"mb_cur_max" },

	{ T_MB_CUR_MIN,		"mb_cur_min" },

	{ -1, NULL },

};

static int categories[] = {

	T_CHARMAP,

	T_CTYPE,

	T_COLLATE,

	T_MESSAGES,

	T_MONETARY,

	T_NUMERIC,

	T_TIME,

	0

};

void

reset_scanner(const char *fname)

{

	if (fname == NULL) {

		filename = "<stdin>";

		input = stdin;

	} else {

		if (input != stdin)

			(void) fclose(input);

		if ((input = fopen(fname, "r")) == NULL) {

			perror("fopen");

			exit(4);

		}

		filename = fname;

	}

	com_char = '#';

	esc_char = '\\';

	instring = 0;

	escaped = 0;

	lineno = 1;

	nextline = 1;

	tokidx = 0;

	wideidx = 0;

}

#define	hex(x)	\

	(isdigit(x) ? (x - '0') : ((islower(x) ? (x - 'a') : (x - 'A')) + 10))

#define	isodigit(x)	((x >= '0') && (x <= '7'))

static int

scanc(void)

{

	int	c;

	c = getc(input);

	lineno = nextline;

	if (c == '\n') {

		nextline++;

	}

	return (c);

}

static void

unscanc(int c)

{

	if (c == '\n') {

		nextline--;

	}

	if (ungetc(c, input) < 0) {

		yyerror(_("ungetc failed"));

	}

}

static int

scan_hex_byte(void)

{

	int	c1, c2;

	int	v;

	c1 = scanc();

	if (!isxdigit(c1)) {

		yyerror(_("malformed hex digit"));

		return (0);

	}

	c2 = scanc();

	if (!isxdigit(c2)) {

		yyerror(_("malformed hex digit"));

		return (0);

	}

	v = ((hex(c1) << 4) | hex(c2));

	return (v);

}

static int

scan_dec_byte(void)

{

	int	c1, c2, c3;

	int	b;

	c1 = scanc();

	if (!isdigit(c1)) {

		yyerror(_("malformed decimal digit"));

		return (0);

	}

	b = c1 - '0';

	c2 = scanc();

	if (!isdigit(c2)) {

		yyerror(_("malformed decimal digit"));

		return (0);

	}

	b *= 10;

	b += (c2 - '0');

	c3 = scanc();

	if (!isdigit(c3)) {

		unscanc(c3);

	} else {

		b *= 10;

		b += (c3 - '0');

	}

	return (b);

}

static int

scan_oct_byte(void)

{

	int c1, c2, c3;

	int	b;

	b = 0;

	c1 = scanc();

	if (!isodigit(c1)) {

		yyerror(_("malformed octal digit"));

		return (0);

	}

	b = c1 - '0';

	c2 = scanc();

	if (!isodigit(c2)) {

		yyerror(_("malformed octal digit"));

		return (0);

	}

	b *= 8;

	b += (c2 - '0');

	c3 = scanc();

	if (!isodigit(c3)) {

		unscanc(c3);

	} else {

		b *= 8;

		b += (c3 - '0');

	}

	return (b);

}

void

add_tok(int c)

{

	if ((tokidx + 1) >= toksz) {

		toksz += 64;

		if ((token = realloc(token, toksz)) == NULL) {

			yyerror(_("out of memory"));

			tokidx = 0;

			toksz = 0;

			return;

		}

	}

	token[tokidx++] = (char)c;

	token[tokidx] = 0;

}

void

add_wcs(wchar_t c)

{

	if ((wideidx + 1) >= widesz) {

		widesz += 64;

		widestr = realloc(widestr, (widesz * sizeof (wchar_t)));

		if (widestr == NULL) {

			yyerror(_("out of memory"));

			wideidx = 0;

			widesz = 0;

			return;

		}

	}

	widestr[wideidx++] = c;

	widestr[wideidx] = 0;

}

wchar_t *

get_wcs(void)

{

	wchar_t *ws = widestr;

	wideidx = 0;

	widestr = NULL;

	widesz = 0;

	if (ws == NULL) {

		if ((ws = wsdup(L"")) == NULL) {

			yyerror(_("out of memory"));

		}

	}

	return (ws);

}

static int

get_byte(void)

{

	int	c;

	if ((c = scanc()) != esc_char) {

		unscanc(c);

		return (EOF);

	}

	c = scanc();

	switch (c) {

	case 'd':

	case 'D':

		return (scan_dec_byte());

	case 'x':

	case 'X':

		return (scan_hex_byte());

	case '0':

	case '1':

	case '2':

	case '3':

	case '4':

	case '5':

	case '6':

	case '7':

		/* put the character back so we can get it */

		unscanc(c);

		return (scan_oct_byte());

	default:

		unscanc(c);

		unscanc(esc_char);

		return (EOF);

	}

}

int

get_escaped(int c)

{

	switch (c) {

	case 'n':

		return ('\n');

	case 'r':

		return ('\r');

	case 't':

		return ('\t');

	case 'f':

		return ('\f');

	case 'v':

		return ('\v');

	case 'b':

		return ('\b');

	case 'a':

		return ('\a');

	default:

		return (c);

	}

}

int

get_wide(void)

{

	static char mbs[MB_LEN_MAX + 1] = "";

	static int mbi = 0;

	int c;

	wchar_t	wc;

	if (mb_cur_max >= sizeof (mbs)) {

		yyerror(_("max multibyte character size too big"));

		mbi = 0;

		return (T_NULL);

	}

	for (;;) {

		if ((mbi == mb_cur_max) || ((c = get_byte()) == EOF)) {

			/*

			 * end of the byte sequence reached, but no

			 * valid wide decoding.  fatal error.

			 */

			mbi = 0;

			yyerror(_("not a valid character encoding"));

			return (T_NULL);

		}

		mbs[mbi++] = c;

		mbs[mbi] = 0;

		/* does it decode? */

		if (to_wide(&wc, mbs) >= 0) {

			break;

		}

	}

	mbi = 0;

		if (check_charmap(wc) < 0) {

			yyerror(_("no symbolic name for character"));

			return (T_NULL);

		}

	}

	yylval.wc = wc;

	return (T_CHAR);

}

int

get_symbol(void)

{

	int	c;

	while ((c = scanc()) != EOF) {

		if (escaped) {

			escaped = 0;

			if (c == '\n')

				continue;

			add_tok(get_escaped(c));

			continue;

		}

		if (c == esc_char) {

			escaped = 1;

			continue;

		}

		if (c == '\n') {	/* well that's strange! */

			yyerror(_("unterminated symbolic name"));

			continue;

		}

		if (c == '>') {		/* end of symbol */

			/*

			 * This restarts the token from the beginning

			 * the next time we scan a character.  (This

			 * token is complete.)

			 */

			if (token == NULL) {

				yyerror(_("missing symbolic name"));

				return (T_NULL);

			}

			tokidx = 0;

			/*

			 * A few symbols are handled as keywords outside

			 * of the normal categories.

			 */

			if (category == T_END) {

				int i;

				for (i = 0; symwords[i].name != 0; i++) {

					if (strcmp(token, symwords[i].name) ==