/*
	CPP V5 -- Token parsing routines.

	source:  tok.c
	started: October 7, 1985
	version: May 26, 1988; July 21, 1988

	Written by Edward K. Ream.
	This software is in the public domain.

	See the read.me file for disclaimer and other information.
*/

#include "cpp.h"

/* Declare internal variables and routines. */
static int	 is_base_digit	(int);
static void	 scan_number	(int);
static en_tokens t_int		(void);

/*
	Return >= 0 if ch is a digit in the indicated base.
	Otherwise, return -1.
*/
static int
is_base_digit(base)
int base;
{
	TRACECH("is_base_digit");

	if (ch >= '0' && ch <= '9') {
		RETURN_INT("is_base_digit", ch - '0');
	}
	else if (base != 16) {
		RETURN_INT("is_base_digit", -1);
	}
	else if (ch >= 'a' && ch <= 'f') {
		RETURN_INT("is_base_digit", ch - 'a' + 10);
	}
	else if (ch >= 'A' && ch <= 'F') {
 		RETURN_INT("is_base_digit", ch - 'A' + 10);
	}
	else {
		RETURN_INT("is_base_digit", -1);
	}
}

/*
	Get value of a string of digits into t_value.
	Continue until a non base digit is found.
*/
static void
scan_number(base)
int base;
{
	int result;

	TRACECH("scan_number");

	t_value = 0;
	while (	(result = is_base_digit(base)) != -1) {
		t_value = ((long)base * t_value) + (long) result;
		sysnext();
	}

	LEAVE("scan_number");
}

/*
	Output a comment. Allow nested comments if nest_flag is TRUE.
	Surprisingly, this routine needs to be as fast as possible.
*/
void
copy_comment()
{
	register int clevel;
	int start_line;
	char line [LONG_DIGITS];

	TRACECH("copy_comment");

	/* Save starting line number for run-on comments. */
	start_line = t_line;
	clevel = 1;

	for (;;) {
		switch (ch) {

		case END_FILE:
			conv2s(start_line, line);
			err3("File ends in a comment starting at line ",
				line, ".");
			RETURN_VOID("copy_comment");

		case '\n':
			/* Keep track of line numbering. */
			bump_line();
			sysnlput();
			sysnext();
			continue;

		case '/':

			syscput(ch);
			sysnext();
			if (ch == '*') {
				syscput(ch);
				sysnext();
				if (nest_flag) {
					clevel++;
				}
			}
			continue;

		case '*':
			syscput(ch);
			sysnext();
			if (ch == '/') {
				syscput(ch);
				sysnext();
				if (--clevel == 0) {
					RETURN_VOID("copy_comment");
				}
			}
			continue;


		default:
			syscput(ch);
			sysnext();
		}
	}
}

void
skip_comment()
{
	register int clevel;
	int start_line;
	char line [LONG_DIGITS];

	TRACECH("skip_comment");

	/* Save starting line number for run-on comments. */
	start_line = t_line;
	clevel = 1;

	for (;;) {
		switch (ch) {

		case END_FILE:
			conv2s(start_line, line);
			err3("File ends in a comment starting at line ",
				line, ".");
			RETURN_VOID("skip_comment");

		case EORT:
			conv2s(start_line, line);
			err3("Macro arg ends in a comment starting at line ",
				line, ".");
			RETURN_VOID("skip_comment");
			

		case '\n':
			/* Keep track of line numbering. */
			bump_line();
			sysnext();
			continue;

		case '/':
			sysnext();
			if (ch == '*') {
				sysnext();
				if (nest_flag) {
					clevel++;
				}
			}
			continue;

		case '*':
			sysnext();
			if (ch == '/') {
				sysnext();
				if (--clevel == 0) {
					RETURN_VOID("skip_comment");
				}
			}
			continue;

		default:
			sysnext();
		}
	}
}

/*
	Copy an identifier into symbol[] and its length in the global t_length.
	Surprisingly, this routine should be as fast as possible.
*/
void
t_id(symbol, max_length)
char *	symbol;
int	max_length;
{
	int length = 0;

	TRACEPB("t_id", printf("(%p, %d)\n", symbol, max_length));

	max_length--;
	while (isid2(ch) && length < max_length) {
		*symbol++ = ch;
		length++;
		sysnext();
	}
	*symbol = '\0';
	t_length = length;

	if (length >= max_length) {
		error("Identifier too long.");
	}

	LEAVE("t_id");
}

/*
	Parse an integer constant (octal, decimal or hexadecimal) or float.
	Put the value in t_value if it is an integer.

	dot_flag is TRUE if a decimal point has been seen.

	Return the token type (INT_TOK, LONG_TOK, FLOAT_TOK).

	Legal integer forms:	ddd,	0ddd,	0xddd
	Legal float forms:	xxx.yyyE+zzz

	+-zzz is optional
	one of xxx and yyy may be omitted
	one of . and E may be omitted
*/
en_tokens
t_number(dot_flag)
bool dot_flag;
{
	en_tokens result;
	bool need_exp = FALSE;

	TRACECH("t_number");

	/* Defaults. */
	t_value = 0;

	if (dot_flag) {
		goto frac_part;
	}

	/* Integer part. */

	result = t_int();
	if (ch == '.') {
		sysnext();
		goto frac_part;
	}
	else if (ch == 'e' || ch == 'E') {
		goto exp_part;
	}
	else {
		RETURN_INT("t_number", result);
	}

	/* Fraction part. */
frac_part:	
	t_int();

exp_part:
	if (ch == 'e' || ch == 'E') {
		need_exp = TRUE;
		sysnext();
	}
	if (ch == '+' || ch == '-') {
		need_exp = TRUE;
		sysnext();
	}
	if (ch >= '0' && ch <= '9') {
		t_int();
	}
	else if (need_exp) {
		error("Ill formed floating constant.");
	}

	if (ch == 'l' || ch == 'L' || ch == 'f' || ch == 'F') {
		sysnext();
	}

	RETURN_INT("t_number", FLOAT_TOK);
}

static en_tokens
t_int()
{
	TRACECH("t_int");

	/* Leading 0 or 0x changes base. */	
	if (ch == '0') {
		sysnext();
		if (ch == 'x' || ch == 'X') {
			sysnext();
			scan_number(16);
		}
		else if (isdigit(ch)) {
			scan_number(8);
		}
		else {
			/* Lone '0'. */
			t_value = 0;
		}
	}
	else {
		scan_number(10);
	}

	if (ch == 'l' || ch == 'L') {
		sysnext();
		if(ch == 'u' || ch == 'U') {
			sysnext();
		}
		RETURN_INT("t_int", LONG_TOK);
	}
	else if (ch == 'u' || ch == 'U') {
		sysnext();
		if (ch == 'l' || ch == 'L') {
			RETURN_INT("t_int", LONG_TOK);
		}
		else {
			RETURN_INT("t_int", INT_TOK);
		}
	}
	else {
		RETURN_INT("t_int", INT_TOK);
	}
}

/*
	Copy a string into out[] and puts its length in the global t_length.
	Copy the opening or closing delimiters if the copy_flag is TRUE.

	This is used to parse both strings and character constants.
*/
void
t_string(out, max_out, copy_flag)
register char * out;	/* The output buffer.				*/
int	max_out;	/* The size of out[].				*/
bool	copy_flag;	/* Copy the delimiters if copy_flag is TRUE.	*/
{
	register int length;
	int	start_line;
	char *	start_string;
	char	line [10];
	int	delim;

	TRACECH("t_string");

	/* Save starting line number for error messages. */
	start_line = t_line;
	start_string = out;

	/* Handle the opening single or double quote */
	delim = ch;
	sysnext();
	length = 0;
	if (copy_flag) {
		*out++ = delim;
		length++;
	}

	max_out--;
	while (length < max_out) {

		switch(ch) {

		case END_FILE:
		case '\n':
			goto runon1;

		case '"':
		case '\'':
			if (ch == delim) {
				sysnext();
				if(copy_flag) {
					*out++ = delim;
					length++;
				}
				*out++ = '\0';
				t_length  = length;
				TRACEP("t_string", printf("<%s>\n",
					start_string));
				RETURN_VOID("t_string");
			}
			else{
				*out++ = ch;
				length++;
				sysnext();
			}
			continue;

		case '\\':

			sysnext();
			if (ch == END_FILE) {
				goto runon1;
			}
			else if (ch == '\n') {
				/* Ignore back slash and newline. */
				t_line++;
				sysnext();
			}
			else {
				*out++ = '\\';
				*out++ = ch;
				length += 2;
				sysnext();
			}
			continue;

		default:
			*out++ = ch;
			length++;
			sysnext();
		}
	}

	conv2s(start_line, line);
	err3("String starting at line ", line, " is too long.");

	*out = '\0';
	t_length = length;
	RETURN_VOID("t_string");

runon1:
	*out   = '\0';
	err2("String crosses a line: ", start_string);
	t_length  = length;
	LEAVE("t_string");
}

/*
	Parse a string (including delimiters) from in[] to out.
	Return the length of the ORIGINAL string.
*/
int
in_string(in, out, max_out)
char *	in;		/* The output buffer	*/
char *	out;		/* The output buffer.	*/
int	max_out;	/* The size of out[].	*/
{
	register int length;
	int	start_line;
	char *	start_string;
	char	line [10];
	int	delim;

	TRACEPB("in_string", printf("(<%s>, %p, %d)\n",
		in, out, max_out));

	/* Save starting line number for error messages. */
	start_line = t_line;
	start_string = out;

	/* Copy the opening single or double quote */
	*out++ = delim = *in++;
	length = 1;
	max_out--;
	while (length < max_out) {

		switch(*in) {

		case END_FILE:
		case '\n':
			goto runon1;

		case '"':
		case '\'':
			if (*in == delim) {
				*out++ = *in++;
				*out++ = '\0';
				length++;
				RETURN_INT("in_string", length);
			}
			else{
				*out++ = *in++;
				length++;
			}
			continue;

		case '\\':

			in++;
			if (*in == END_FILE) {
				goto runon1;
			}
			else if (*in == '\n') {
				/* Ignore back slash and newline. */
				t_line++;
				in++;

				/* Keep track of ORIGINAL length. */
				length += 2;
			}
			else {
				*out++ = '\\';
				*out++ = *in++;
				length += 2;
			}
			continue;

		default:
			*out++ = *in++;
			length++;
		}
	}

	conv2s(start_line, line);
	err3("Strinized argument starting at line ", line, " is too long.");
	*out = '\0';
	RETURN_INT("in_string", length);

runon1:
	*out   = '\0';
	err2("Stringized argument crosses a line: ", start_string);
	RETURN_INT("in_string", length);
}