/*
 * Lexical Analysis Functions Takes input stream and returns "tokens".
 * Implements pre-processor, allowing #include's and #define's tokens are
 * character strings.
 */
#include <stdio.h>
#include <ctype.h>
#include <functions.h>
#include <exec/types.h>
#include "listmac.h"
#include "std.h"
#include "lex.h"


struct StringElt {
	struct Nod      node;
	char           *buf;
};

struct Token {
	struct Nod      node;
	char           *buf;
	short           type, can_be_macro;
	char            chr;
};

struct Macro {
	struct Nod      node;
	struct Lst      arguments;
	struct Lst      tokens;
	char           *name;
	short           active, nargs;
};

struct ActiveMacro {
	struct Nod      node;
	struct Macro   *mac;
	struct Token   *curtok;
};

struct LexFile {
	struct Nod      node;
	FILE           *fp;
	short           newln;
	short           nextchar;
};

struct IfBlock {
	struct Nod     *node;
	short           skip_else;
};


struct Token   *CopyToken ();
struct Macro   *FindMacro ();
char           *FindString ();


#define BUFLEN 100
static char     buf[BUFLEN];
static short    bufpos;
static struct Token
		rawtok, *lasttok, *retok;

static struct LexFile *toplf;
static struct Lst macros, activemacs, files, ifblocks;
static short    files_open = 0, init_done = 0;
static char	*includestr, *definestr, *ifdefstr,
		*ifndefstr, *elsestr, *endifstr;

static char    *libbase = "hd:include/", libnam[80], basnam[80];

#define NHASH 53
struct Lst      hashTab[NHASH];


/*
 * Open a file for lexing - could be an include.
 * Set newline flag to true.
 */
short OpenLexFile (name)
	char           *name;
{
	struct LexFile *lf;
	struct Macro   *mac;

	/*
	 * on first call, init environment vars 
	 */
	if (!init_done) {
		NewList (&files);
		NewList (&macros);
		NewList (&ifblocks);
		NewList (&activemacs);
		InitHash ();
		includestr = FindString ("include");
		definestr = FindString ("define");
		ifdefstr = FindString ("ifdef");
		ifndefstr = FindString ("ifndef");
		elsestr = FindString ("else");
		endifstr = FindString ("endif");
		init_done = 1;
	}

	/*
	 * if there are no files currently open, prepare for a new one 
	 */
	if (!files_open) {
		while (mac = (struct Macro *) RemHead (&macros))
			FreeMacro (mac);
		ASSERT (!TEST (HEAD (&ifblocks)));
		ASSERT (!TEST (HEAD (&activemacs)));
		retok = NULL;
	}
	lf = NEW (struct LexFile);
	if (!lf) return 0;

	/*
	 * printf ("opening \"%s\"\n", name); 
	 */
	lf->fp = fopen (name, "r");
	if (!lf->fp) {
		FREI (lf);
		return 0;
	}
	lf->newln = 1;
	lf->nextchar = getc (lf->fp);
	AddHead (&files, lf);
	toplf = lf;

	if (feof (lf->fp)) {
		CloseLexFile ();
		return 0;
	}
	files_open = 1;
	return 1;
}


/*
 * Close top file returning 1 for the last file now closed.
 */
short CloseLexFile ()
{
	if (!files_open) return 1;

	fclose (toplf->fp);
	Remove (toplf);
	FREI (toplf);
	toplf = HEAD (&files);
	if (TEST (toplf)) return 0;
	files_open = 0;
	toplf = 0;
	return 1;
}


/*
 * free stuff up 
 */
LexCleanup ()
{
	struct Macro   *mac, *nmac;

	while (files_open) CloseLexFile ();

	FreeHash ();
	for (mac = HEAD (&macros); nmac = NEXT (mac); mac = nmac)
		FreeMacro (mac);
	ASSERT (!TEST (HEAD (&activemacs)));

	/*
	 * initialization can be done again 
	 */
	init_done = 0;
}


FreeMacro (mac)
	struct Macro   *mac;
{
	struct Token   *tok;
	struct StringElt *se;

	while (tok = (struct Token *) RemHead (&mac->tokens))
		FREI (tok);
	while (se = (struct StringElt *) RemHead (&mac->arguments))
		FREI (se);
	FREI (mac);
}


/*
 * Get next raw character from file dealing with backslash escape chars.
 * This is kind of wrong since these really ought to be recognized only
 * inside strings.  Doing it this way deals with backslashes before
 * newlines.
 */
short NextC1 (fp)
	FILE           *fp;
{
	short           c, k, radix;

	c = getc (fp);
	if (c == '\\') {
		c = getc (fp);
		if (isdigit (c)) {
			radix = 10;
			if (c == '0') radix = 8;
			k = (c - '0');
			while (isdigit (c = getc (fp)))
				k = k * radix + (c - '0');
			ungetc (c, fp);
			c = k;
		} else {
			switch (c) {
			    case '\\':
				break;
			    case '"':
				c = '.';
				break;
			    case 'n':
				c = '\n';
				break;
			    case 'b':
				c = '\b';
				break;
			    case 't':
				c = '\t';
				break;
			    case '\n':
				c = getc (fp);
			}
		}
	}
	return c;
}


/*
 * Get next character from Top Lex File, updating nextchar.
 */
short NextC ()
{
	short           c;

	if (!toplf) return EOF;
	c = toplf->nextchar;
	toplf->nextchar = NextC1 (toplf->fp);
	return c;
}


/*
 * Move the top lex file to the next newline.
 */
AdvanceEOL ()
{
	if (!toplf) return;
	while (toplf->nextchar != '\n' && !feof (toplf->fp))
		NextC ();
}


/*
 * Read a raw set of characters updating newline state.  Sets the
 * fields in rawtok to the type and string pointer, if any. 
 */
RawToken ()
{
	short           c;
	short           nochar = 1, comment, nl;

	bufpos = 0;
	rawtok.can_be_macro = 1;

	/*
	 * get a non-blank char 
	 */
	while (nochar) {

		/*
		 * get a character testing for end-of-file if EOF, just
		 * return that fact right away 
		 */
		c = NextC ();
		if (c == EOF) {
			rawtok.type = RT_EOF;
			return;
		}

		/*
		 * test next char: if it's white space other than newline,
		 * just clear the newline flag and continue looking. 
		 */
		if (isspace (c) && c != '\n')
			toplf->newln = 0;
		else {

			/*
			 * otherwise, this is potentially interesting, but it
			 * might be the start of a comment - if so, scan til
			 * the end of the comment (no nested comments ala
			 * "C").  If not, exit the loop. 
			 */
			if (c == '/' && toplf->nextchar == '*') {
				comment = 1;
				while (comment) {
					c = NextC ();
					if (c == '*'
					  && toplf->nextchar == '/') {
						c = NextC ();
						comment = 0;
					}
				}

			} else nochar = 0;
		}
	}

	nl = toplf->newln;
	toplf->newln = 0;
	bufpos = 0;

	/*
	 * otherwise, read out the cases id symbol starting with char 
	 */
	if (nl && c == '#')
		rawtok.type = RT_ESC;

	else if (c == '\'') {
		rawtok.chr = NextC ();
		c = NextC ();

		/*
		 * Skip past weird character constants, like 'FOOL',
		 * making no attempt to deal with them correctly.
		 */
		comment = 0;
		while (c != '\'' && comment < 6) {
			c = NextC ();
			comment++;
		}
		if (comment >= 6) printf ("error in character constant\n");
		rawtok.type = RT_CHRC;

	} else if (isalpha (c) || c == '_') {
		buf[bufpos++] = c;
		while (isalnum (toplf->nextchar) || toplf->nextchar == '_')
			buf[bufpos++] = NextC ();
		buf[bufpos] = 0;
		rawtok.type = RT_ID;
		rawtok.buf = FindString (buf);

	} else if (c == '\n') {
		toplf->newln = 1;
		rawtok.type = RT_NEWLN;

	} else if (isdigit (c)) {
		buf[bufpos++] = c;
		while (isdigit (toplf->nextchar)) buf[bufpos++] = NextC ();
		buf[bufpos] = 0;
		rawtok.buf = FindString (buf);
		rawtok.type = RT_NUM;

	} else if (c == '"') {
		while ((c = NextC ()) != '"')
			if (bufpos < BUFLEN)
				buf[bufpos++] = c;

		if (bufpos + 1 == BUFLEN) printf ("string overflow\n");
		buf[bufpos] = 0;
		rawtok.buf = FindString (buf);
		rawtok.type = RT_STR;

	} else {
		rawtok.chr = c;
		rawtok.type = RT_CHR;
	}
}


/*
 * Main function -- returns string pointer for next token makes include files
 * and macros transparent reads from top open file and returns pointer to
 * string of chars could be a symbol, could be a number, could be a character 
 */
short NextToken (tbuf)
	char          **tbuf;
{
	struct Token   *tok;
	struct Macro   *mac;
	struct ActiveMacro *amac;
	short           i;
	char            c;

	while () {

		/*
		 * get raw token from file or active macro 
		 */
		amac = HEAD (&activemacs);
		if (retok) {
			tok = retok;
			retok = NULL;
		} else if (TEST (amac)) {
			tok = amac->curtok;
			if (!TEST (tok)) {
				amac->mac->active = 0;
				for (i = 0; i < amac->mac->nargs; i++)
					FreeMacro (RemHead (&macros));
				Remove (amac);
				FREI (amac);
				continue;
			}
			amac->curtok = NEXT (amac->curtok);
		} else {
			RawToken ();
			tok = &rawtok;
		}
		switch (tok->type) {
		    case RT_EOF:
			if (CloseLexFile ()) {
				lasttok = tok;
				return RT_EOF;
			}
			break;
		    case RT_ESC:
			RawToken ();
			if (rawtok.type != RT_ID) {
				printf ("real problem with lexer directive\n");
				AdvanceEOL ();
				break;
			}
			if (rawtok.buf == includestr)		Include ();
			else if (rawtok.buf == definestr)	Define ();
			else if (rawtok.buf == ifdefstr)	IfDef (1);
			else if (rawtok.buf == ifndefstr)	IfDef (0);
			else if (rawtok.buf == elsestr)		Else ();
			else if (rawtok.buf == endifstr)	EndIf ();
			else {
				printf ("unknown directive \"%s\"\n", rawtok.buf);
				AdvanceEOL ();
			}
			break;

		    case RT_ID:

			/*
			 * test for known macros (if this token can be one) 
			 */
			if (tok->can_be_macro) {
				mac = FindMacro (tok->buf);
				if (mac) {
					InstantiateMacro (mac);
					break;
				}
			}
		    case RT_STR:
		    case RT_NUM:
			*tbuf = tok->buf;
			lasttok = tok;
			return tok->type;
		    case RT_CHR:
		    case RT_CHRC:
			*tbuf = &tok->chr;
			lasttok = tok;
			return tok->type;
		}
	}
}


/*
 * The given macro has occured in the text, cause it to come into existence
 * with argument substitution. 
 */
InstantiateMacro (mac)
	struct Macro   *mac;
{
	struct ActiveMacro *amac;
	struct StringElt *arg;
	struct Macro   *smac;
	struct Token   *tok;
	char           *buf;
	short           vtok, level, endarglist;

	if (mac->active) {
		printf ("recursive macro ignored\n");
		return;
	}

	/*
	 * read arguments, if any, and make them macros in their own right
	 * arguments are read recursively using NextToken (right? I'm not
	 * sure...) 
	 */
	arg = HEAD (&mac->arguments);
	if (TEST (arg)) {

		/*
		 * get first open paren 
		 */
		vtok = NextToken (&buf);
		if (vtok != RT_CHR || *buf != '(')
			goto argfail;

		/*
		 * loop through args separated with commas 
		 */
		endarglist = 0;
		while (TEST (arg)) {
			smac = NEW (struct Macro);
			if (!smac) goto argfail;
			smac->name = arg->buf;
			smac->active = 0;
			smac->nargs = 0;
			NewList (&smac->arguments);
			NewList (&smac->tokens);

			/*
			 * scan out tokens allowing for nested commas 
			 */
			level = 0;
			while () {
				vtok = NextToken (&buf);
				if (vtok == RT_CHR) {
					if (*buf == '(' || *buf == '{')
						level++;
					if (*buf == '}')
						level--;
					if (*buf == ')') {
						if (level == 0) {
							endarglist = 1;
							break;
						}
						level--;
					}
					if (*buf == ',' && level == 0)
						break;
				}
				tok = CopyToken (lasttok);
				if (!tok) goto argfail;
				tok->can_be_macro = 0;
				AddTail (&smac->tokens, tok);
			}
			AddHead (&macros, smac);
			if (endarglist) break;
			arg = NEXT (arg);
		}
		if (vtok != RT_CHR || *buf != ')') goto argfail;
	}

	/*
	 * Macro does not become active in the global list until all
	 * arguments have been parsed and interpreted. 
	 */
	amac = NEW (struct ActiveMacro);
	if (!amac) return;		/* what the fuck do I do here? */
	amac->mac = mac;
	amac->curtok = HEAD (&mac->tokens);
	mac->active = 1;
	AddHead (&activemacs, amac);
	return;

argfail:
	printf ("bad problem with arguments\n");
}


/*
 * locate a specified macro in the available macros list 
 */
struct Macro * FindMacro (buf)
	char           *buf;
{
	struct Macro   *mac;

	for (mac = HEAD (&macros); TEST (mac); mac = NEXT (mac))
		if (mac->name == buf)
			return mac;

	return NULL;
}


/*
 * Do an "include" directive 
 */
Include ()
{
	short           pos, ok, global;
	char            c;

	/*
	 * get filename 
	 */
	RawToken ();
	ok = 0;
	global = 0;

	if (rawtok.type == RT_STR) {
		ok = 1;
		strcpy (basnam, rawtok.buf);
	} else if (rawtok.type == RT_CHR && rawtok.chr == '<') {
		ok = 1;
		pos = 0;
		while () {
			c = NextC ();
			if (c == '>') break;
			basnam[pos++] = c;
		}
		basnam[pos] = 0;
		global = 1;
	}
	AdvanceEOL ();
	if (!ok) {
		printf ("no file to include\n");
		return;
	}
	if (!global) if (OpenLexFile (basnam)) return;
	strcpy (libnam, libbase);
	strcat (libnam, basnam);
	if (OpenLexFile (libnam)) return;
	printf ("error open include file <%s>\n", libnam);
}


/*
 * Do the "define" directive.
 */
Define ()
{
	struct Macro   *mac = NULL;
	struct Token   *tok;
	struct StringElt *se;

	/*
	 * get identifier to define 
	 */
	RawToken ();
	if (rawtok.type != RT_ID) {
		printf ("error in define - no identifier\n");
		goto escape;
	}
	mac = NEW (struct Macro);
	if (!mac) goto escape;
	mac->name = rawtok.buf;
	mac->active = 0;
	mac->nargs = 0;
	NewList (&mac->arguments);
	NewList (&mac->tokens);

	/*
	 * Look for parenthized argument list.
	 */
	if (toplf->nextchar == '(') {
		RawToken ();
		while () {
			RawToken ();

			/*
			 * deal with special case of "#define MACRO()" 
			 */
			if (!mac->nargs && rawtok.type == RT_CHR
			  && rawtok.chr == ')')
				break;
			if (rawtok.type != RT_ID) {
				printf ("macro argument not an identifier\n");
				goto escape;
			}
			se = NEW (struct StringElt);
			if (!se) goto escape;
			se->buf = rawtok.buf;
			AddTail (&mac->arguments, se);
			mac->nargs++;
			RawToken ();
			if (rawtok.type != RT_CHR) {
				printf ("macro arg list delimiter not a character\n");
				goto escape;
			}
			if (rawtok.chr == ')') break;
			if (rawtok.chr != ',') {
				printf ("macro arg list delimiter not ',' or ')'\n");
				goto escape;
			}
		}
	}

	/*
	 * get the sequence of tokens which make up this definition 
	 */
	while () {
		RawToken ();
		if (rawtok.type == RT_NEWLN || rawtok.type == RT_EOF) break;
		tok = CopyToken (&rawtok);
		if (!tok) goto escape;
		tok->can_be_macro = 1;
		AddTail (&mac->tokens, tok);
	}

	AddHead (&macros, mac);
	return;

escape:
	if (mac) FreeMacro (mac);
	AdvanceEOL ();
}


/*
 * Skip over a defined-out section.  Returns 1 if it ends with #else, 0
 * if it ends with #endif, -1 for EOF.  Keeps track of nested if's
 * being skipped.
 */
short SkipRemovedSec ()
{
	short           level = 0;

	while () {
		RawToken ();
		if (rawtok.type == RT_EOF) return -1;
		if (rawtok.type == RT_ESC) {
			RawToken ();
			if (rawtok.type == RT_ID) {
				if (rawtok.buf == ifdefstr
				  || rawtok.buf == ifndefstr) level++;
				if (rawtok.buf == elsestr)
					if (!level) return 1;
				if (rawtok.buf == endifstr)
					if (!level--) return 0;
			}
		}
	}
}


/*
 * Does the "ifdef"/"ifndef" - "else" - "endif" directive.  Type is 1
 * for ifdef and 0 for ifndef.
 */
IfDef (type)
	short           type;
{
	struct Macro   *mac;
	struct IfBlock *ib;
	short           els;

	RawToken ();
	mac = FindMacro (rawtok.buf);

	/*
	 * If condition is true, add a node to say "skip the next #else
	 * section" if false, skip this section.  If section ends with an
	 * else, add a junk node to pop off for consistency at next #endif.
	 */
	if ((mac && type) || (!mac && !type)) {
		ib = NEW (struct IfBlock);
		if (!ib) return;
		ib->skip_else = 1;
		AddHead (&ifblocks, ib);
	} else {
		els = SkipRemovedSec ();
		if (els == 1) {
			ib = NEW (struct IfBlock);
			if (!ib) return;
			ib->skip_else = 0;
			AddHead (&ifblocks, ib);
		}
	}
}


Else ()
{
	struct IfBlock *ib;
	short           els;

	ib = HEAD (&ifblocks);
	ASSERT (TEST (ib));
	Remove (ib);
	if (!ib->skip_else) {
		printf ("strange \"else\" block found\n");
	} else {
		els = SkipRemovedSec ();
		if (els == 1 && ib->skip_else) {
			printf ("strange \"else\" block found\n");
		}
	}
	FREI (ib);
}


EndIf ()
{
	struct IfBlock *ib;

	ib = HEAD (&ifblocks);
	ASSERT (TEST (ib));
	Remove (ib);
	FREI (ib);
}


/*
 * Backs up one token 
 */
Backspace ()
{
	retok = lasttok;
}


struct Token * CopyToken (tok)
	struct Token   *tok;
{
	struct Token   *ntok;

	ntok = NEW (struct Token);
	if (ntok) *ntok = *tok;
	return ntok;
}



/* HASH TABLE STUFF */


InitHash ()
{
	short           i;

	for (i = 0; i < NHASH; i++)
		NewList (&hashTab[i]);
}


/*
 * Simple but (I hope) effective hash function.
 */
short HashVal (buf)
	char           *buf;
{
	unsigned long   hash;

	hash = 0;
	while (*buf) hash = hash * 3 + *buf++;
	return hash % NHASH;
}


/*
 * Finds (or creates) a stored string matching the given one return pointer
 * which acts as unique ident for this string.
 */
char * FindString (buf)
	char           *buf;
{
	short           hash;
	struct Lst     *hlist;
	struct StringElt *se;
	char           *sto;

	hash = HashVal (buf);
	hlist = &hashTab[hash];

	for (se = HEAD (hlist); TEST (se); se = NEXT (se)) {
		if (!strcmp (se->buf, buf))
			return se->buf;
	}
	se = NEW (struct StringElt);
	if (!se) return NULL;
	sto = NEW_N (char, strlen (buf) + 1);
	if (!sto) {
		FREI (se);
		return NULL;
	}
	AddTail (hlist, se);
	strcpy (sto, buf);
	se->buf = sto;
	return sto;
}


FreeHash ()
{
	short           i;
	struct StringElt *se, *nse;

	for (i = 0; i < NHASH; i++) {
		for (se = HEAD (&hashTab[i]); nse = NEXT (se); se = nse) {
			FREE_N (se->buf, char, strlen (se->buf) + 1);
			FREI (se);
		}
	}
}