/*
 * Copyright 2005 Sun Microsystems, Inc.	 All rights reserved.
 * Use is subject to license terms.
 */


%{

#pragma ident	"@(#)mdlex.l	1.3	05/11/03 SMI"

/* any C includes here */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>

#include "basics.h"
#include "allocate.h"
#include "lexer.h"
#include "fatal.h"

lexer_t lex;	/* additional return value info */
#define	MAX_STR_LEN	(1024+1)
static struct {
	char base[MAX_STR_LEN];
	char * ptr;
} sbuffer;

#if TESTRIG /* { */
#include <stdarg.h>
#include <errno.h>
void fatal(char *s,...);
#endif		/* } */

#define	SBUFFER_INS(_c)	do {	\
		if ((sbuffer.ptr - sbuffer.base)>=MAX_STR_LEN)	\
			lex_fatal("Parse string too long - maximum is %d characters", MAX_STR_LEN);	\
		*sbuffer.ptr++ = (_c);	\
	} while(0)
%}

DECNUM	("0"|([1-9][0-9]*))

%x comment
%x string

%%

<<EOF>>			return T_EOF;

"{"			return T_L_Brace;

"}"			return T_R_Brace;

")"			return T_R_Bracket;

","			return T_Comma;

";"			return T_S_Colon;

"+"			return T_Plus;

"*"			return T_Multiply;

"-"			return T_Minus;

"&"			return T_And;

"|"			return T_Or;

"^"			return T_Xor;

"~"			return T_Not;

"<<"			return T_LShift;

"="			return T_Equals;

"]"			return T_R_Bracket;

"["			return T_L_Bracket;

^"#"[ \t].*$		{
				char lbuf[1024];
				int num;
				if (sscanf(mdlextext,"# %d \"%[^\"]\"", &num, lbuf)!=2)
					lex_fatal("Illegal # directive");
				lex.linenum = num-1;
				if (lex.fnamep != (char*)0) Xfree(lex.fnamep);
				lex.fnamep = Xstrdup(lbuf);
			}

"node"			return T_KW_node;

"proto"			return T_KW_proto;

"include"		return T_KW_include;

"("			return T_KW_expr;

"expr("			return T_KW_expr;

"lookup("		return T_KW_lookup;

"setprop("		return T_KW_setprop;

"->"			return T_KW_arc;


\"			{
				sbuffer.ptr = sbuffer.base;
				BEGIN(string);
			}

<string>\"		{	/* closing quote - wrap up string and return it */
				BEGIN(INITIAL);
				sbuffer.ptr[0]='\0';
				lex.strp = sbuffer.base;
				return T_String;
			}

<string>\n		{
				lex_fatal("unterminated string");
			}

<string>\\[0-7]{1,3}	{
				/* octal escape sequence */
				int result;

				result=-1;
				(void) sscanf( mdlextext + 1, "%o", &result );

				if ( result<0 || result>0xff )
					lex_fatal("error, constant is out-of-bounds");

				SBUFFER_INS( result );
			}

<string>\\[0-9]+		{
				lex_fatal("illegal escape sequence");
			}

<string>\\n		SBUFFER_INS( '\n' );
<string>\\t		SBUFFER_INS( '\t' );
<string>\\r		SBUFFER_INS( '\r' );
<string>\\b		SBUFFER_INS( '\b' );
<string>\\f		SBUFFER_INS( '\f' );

<string>\\(.|\n)	SBUFFER_INS( mdlextext[1] );

<string>[^\\\n\"]+	{
				char *iptr = mdlextext;

				while ( *iptr ) SBUFFER_INS( *iptr++ );
			}




"0x"[0-9A-F][0-9A-F]*	{
				lex.val = strtoull(mdlextext, (char **)NULL, 16);
				return T_Number;
			}

"0x"[0-9a-f][0-9a-f]*	{
				lex.val = strtoull(mdlextext, (char **)NULL, 16);

				return T_Number;
			}

{DECNUM}[KkMmGg]	{
				char * ep;
				lex.val = strtoll(mdlextext, &ep, 10);
				switch(*ep) {
				case 'G': case 'g':
					lex.val <<= 30;
					break;
				case 'M': case 'm':
					lex.val <<= 20;
					break;
				case 'K': case 'k':
					lex.val <<= 10;
					break;
				default:
					lex_fatal("parsing number");
				}
				return T_Number;
			}

{DECNUM}		{
				lex.val = atoll(mdlextext);
				return T_Number;
			}

\-{DECNUM}		{
				lex.val = atoll(mdlextext);
				return T_Number;
			}


[A-Za-z_#?$][A-Za-z_#\-?$0-9]* {
				lex.strp = mdlextext;
				return T_Token;
			}

			/* Note: . = any character EXCEPT newline */
\/\/.*			{ /* nada - swallow single line comments */ }

[\t ]*			{ /* nada - swallow white space */ }


"\n"			{
				lex.linenum ++;
			}

.			{
				lex_fatal("Illegal character %s", mdlextext);
			}

%%







void init_lexer(char * fnamep, FILE *fp, char * cleanup_filep)
{
	lex.cleanup_filep = cleanup_filep ? Xstrdup(cleanup_filep) : (char*)0;
	lex.linenum = 1;
	lex.fnamep = Xstrdup(fnamep);

	lex.ungot_available = false;
	lex.last_token = T_Error;

	mdlexin = fp;
}


lexer_tok_t lex_get_token()
{
	if (lex.ungot_available) {
		lex.ungot_available = false;
		return lex.last_token;
	}

	lex.last_token = mdlexlex();

	return lex.last_token;
}



void lex_unget()
{
	if (lex.ungot_available) fatal("Internal error, lex_unget with token already ungot");

	lex.ungot_available = true;
}


void lex_get(lexer_tok_t expected)
{
	lexer_tok_t tok;
	char *s;
	char buffer[1024];

	tok = lex_get_token();

	if (tok == expected) return;

	switch(tok) {
	case	T_EOF:		s="end of file";	break;
	case	T_L_Brace:	s="{";	break;
	case	T_R_Brace:	s="}";	break;
	case	T_S_Colon:	s=";";	break;
	case	T_Plus:		s="+";	break;
	case	T_Minus:	s="-";	break;
	case	T_Equals:	s="=";	break;
	case	T_Number:	s="number";	break;
	case	T_String:	s="string";	break;
	case	T_Token:
		sprintf(buffer,"token %s", lex.strp);
		s=buffer;
		break;
	case	T_KW_node:	s="node";	break;
	case	T_KW_proto:	s="proto";	break;
	case	T_KW_include:	s="include(";	break;
	case	T_KW_expr:	s="expr(";	break;
	case	T_KW_lookup:	s="lookup(";	break;
	case	T_KW_setprop:	s="setprop(";	break;

	case	T_Error:	s="error";	break;
	default:
		s="unknown token - internal error";
		break;
	}

	lex_fatal("unexpected %s", s);
}


/*
 * Special version of fatal for the lexer
 * to enable cleanup of stuff before death
 */
void
lex_fatal(char * fmt, ...)
{
	va_list	args;

	if (errno != 0)
		perror("FATAL: ");
	else
		fprintf(stderr,"FATAL: ");
	if (fmt) {
		va_start(args, fmt);
		(void) vfprintf(stderr, fmt, args);

		va_end(args);
	}

	if (lex.cleanup_filep != (char *)0) {
		unlink(lex.cleanup_filep);
		Xfree(lex.cleanup_filep);
	}
	fprintf(stderr," at line %d of %s\n", lex.linenum, lex.fnamep);
	Xfree(lex.fnamep);

	SANITY(	lex.fnamep = NULL; );
	SANITY(	lex.cleanup_filep = NULL; );
	exit(1);
}



int
mdlexwrap(void)
{
	return (1);
}

#if TESTRIG /* { */
main()
{
	lexer_tok_t tok;

	lex.linenum = 1;
	lex.fnamep = "test";

	do {
		tok = lexlex();

		fprintf(stderr,"token = %d at line %d in %s\n",tok, lex.linenum, lex.fnamep);
	} while (tok!=T_Error && tok!=T_EOF);
}


void fatal(char* fmt, ...)
{
	va_list 	args;
	int		status;
	
	if (errno!=0) perror("FATAL: "); else fprintf(stderr,"FATAL: ");
	if (fmt) {
		va_start(args, fmt);
		(void)vfprintf(stderr, fmt, args);

		va_end(args);
	}

	fprintf(stderr,"\n");
	fflush(stderr);
	fflush(stdout);

	thr_exit(&status);
}

#endif /* } */