%{
#include <stdlib.h>
#include <limits.h>

#include <tlog.h>
#include <tmalloc.h>
#include <template.h>
#include <tmpl_gram.h>

#ifndef yylval
#define yylval tmpl_yylval
#endif

extern char* fileToParse;

static int yyerror(char *s, int line);
static int getIdent(char *word);

static char *strbuf = NULL;
static int length;
static int total;
static void addstring(char *s, int l); 
static void addchar(char s); 
static MemoryContext *lexContext;	

%}

%option 8bit
%option never-interactive
%option nodefault
%option noyywrap
%option nounput
%option prefix="tmpl_yy"
%option yylineno

%x	xVAR
%x	xEXPR
%x  xINCLUDE
%x  xQUOTED
%x  xCOMMENT

LEXEMCHARSTART 	[a-zA-Z_]
LEXEMCHAR 	[a-zA-Z0-9_]
PATH 	  	[a-zA-Z0-9_/\.]
DIGIT		[0-9]

%%

<INITIAL>\<\%		{
						BEGIN xVAR;
						return VAR_OPEN;
					}

<INITIAL>\<\@		{
						BEGIN xEXPR;
						return EXPR_OPEN;
					}

<INITIAL>\<\&		{
						BEGIN xINCLUDE;
						return INCLUDE_OPEN;
					}

<INITIAL>\<\#		{
						BEGIN xCOMMENT;
					}

<xVAR>[,\|#]		{
						yylval.punct = *yytext;
						return yylval.punct;
					}

<xVAR>\%\>			{
						BEGIN INITIAL;
						return VAR_CLOSE;
					}

<xVAR>\"			{
						total = 1024;
						strbuf = mcalloc(lexContext, total);
						length=0;
						BEGIN xQUOTED;
					}


<xQUOTED>\\(.|\n)	{ addchar(yytext[1]); }

<xQUOTED>\"			{
						yylval.str = strbuf;
						BEGIN xVAR;
						strbuf = NULL;
						return STRING;
					}
						
<xQUOTED>[^\"\\]+	{ addstring(yytext, yyleng); }

<xQUOTED>\\			{ 
						/* This is only needed for \ just before EOF */
						addchar(*yytext); 
					}

<xEXPR,xVAR>{DIGIT}+  	{
    					yylval.intval = strtoll(yytext, NULL, 0);
						return INTEGER;
					}

<xEXPR,xVAR>{LEXEMCHARSTART}{LEXEMCHAR}* {
						yylval.str  = strlower(mcnstrdup(lexContext, yytext, yyleng));
						return  getIdent(yylval.str);
					}

<xEXPR,xVAR>\|\|			{ return OR_P; }

<xEXPR,xVAR>\&\&			{ return AND_P; }

<xEXPR,xVAR>\!			{ return NOT_P; }

<xEXPR,xVAR>[\^\%\+\*\/\-\(\)\?\:]		{
						yylval.punct = *yytext;
						return yylval.punct;
					}

<xEXPR,xVAR>(\<|\<=|\>=|\>|==|\!=|\<\>)	{
						yylval.str  = mcnstrdup(lexContext, yytext, yyleng);
						return CMP_P;
					}

<xEXPR,xVAR>{DIGIT}+"."{DIGIT}+	{
    					yylval.floatval = atof(yytext);
						return DOUBLE;
					}

<xEXPR,xVAR>{DIGIT}+[eE]["+""-"]?{DIGIT}+    {
    					yylval.floatval = atof(yytext);
						return DOUBLE;
					}

<xEXPR,xVAR>{DIGIT}+"."{DIGIT}+[eE]["+""-"]?{DIGIT}+   {
						yylval.floatval = atof(yytext);
						return DOUBLE;
					}

<xEXPR>\@\>			{
						BEGIN INITIAL;
						return	EXPR_CLOSE;
					}

<xINCLUDE>{PATH}+	{
						yylval.str  = mcnstrdup(lexContext, yytext, yyleng);
						return FILENAME;
					}

<xINCLUDE>\&\>		{
						BEGIN INITIAL;
						return INCLUDE_CLOSE;
					}

<xCOMMENT>\#\>		{
						BEGIN INITIAL;
					}

<xVAR,xINCLUDE,xEXPR,xCOMMENT>\n+ 	;

<xVAR,xINCLUDE,xEXPR,xCOMMENT>[\r\t ]+ 	;

<xCOMMENT>. 		;

<xVAR,xINCLUDE,xEXPR>.	{ 
						return yyerror("Syntax error in template tag", yylineno); 
					}

<xVAR,xQUOTED,xINCLUDE,xEXPR,xCOMMENT><<EOF>> { 
						return yyerror("unterminated template tag", yylineno); 
					}

<INITIAL>[^\<]+		{
						yylval.str  = mcnstrdup(lexContext, yytext, yyleng);
						return TEXT_P;
					}

<INITIAL>([^\<]*\<[^\&\#\@\%][^\<]*)+	{
						yylval.str  = mcnstrdup(lexContext, yytext, yyleng);
						return TEXT_P;
					}
				

<INITIAL>\< 		{
						/* This is only needed for < just before EOF */
						yylval.str  = mcnstrdup(lexContext, yytext, yyleng);
						return TEXT_P;
					}

<INITIAL><<EOF>>	{
					yyterminate();
			}

%%

typedef struct KeyWord {
	char	*word;
	int		len;
	int		id;
} KeyWord;

static KeyWord keywords[] = {
	{ "H",			0, 	HTMLESCAPE 	},
	{ "U",			0, 	URLESCAPE 	},
	{ "IF",			0, 	IF_P 		},
	{ "ELSE", 		0, 	ELSE_P 		},
	{ "LOOP",		0, 	LOOP_P 		},
	{ "SELF",		0, 	SELF_P 		},
	{ "ELSIF",		0, 	ELSIF_P 	},
	{ "ENDIF",		0, 	ENDIF_P 	},
	{ "ENDLOOP",	0, 	ENDLOOP_P 	} 
};

void
startTemplateLex(Template tmpl, FILE *in) {
	if ( keywords->len == 0 ) {
		int i;
		for(i=0; i<sizeof(keywords)/sizeof(KeyWord);i++)
			keywords[i].len = strlen(keywords[i].word);
	}

	lexContext = tmpl->templateContext;

	yylineno=1;
	yyrestart(in);
	BEGIN INITIAL;
}

static int
getIdent(char *word) {
	int len = strlen(word);
	int i;

	if ( len > keywords[ sizeof(keywords)/sizeof(KeyWord)-1 ].len )
		return LEXEME;

	for(i=0; i<sizeof(keywords)/sizeof(KeyWord) && len >= keywords[i].len; i++)
		if ( len == keywords[i].len && strcasecmp(word, keywords[i].word) == 0 )
			return keywords[i].id;

	return LEXEME;
}

static int 
yyerror(char *s, int line) {
	strbuf = NULL;
	tlog(TL_CRIT,"template error at line %d in '%s': %s", line, fileToParse, s);

	return 0;
}

static void
addstring(char *s, int l) {
	while( length + l + 1 >= total ) {
		total*=2;
		strbuf=mcrealloc(strbuf, total);
	}

	memcpy( strbuf+length, s, l);
	length+=l;
	strbuf[length] = '\0';
}

static void
addchar(char s) {
	if(  length + 2 >= total ) {
		total*=2;
		strbuf=mcrealloc(strbuf, total);
	}

	strbuf[ length++ ] = s;
	strbuf[length] = '\0';
}