%{
#include <iostream>
#include <fstream>
#include <string>
#include "tdl-lexer.hpp"

typedef delphin::TdlParser::token token;
typedef delphin::TdlParser::token_type token_type;

#define yyterminate() return token::END

%}

%option c++
%option batch noyywrap debug nodefault
%option prefix="Tdl"

ws	[ \t]+
U	[\x80-\xbf]
U2	[\xc2-\xdf]
U3	[\xe0-\xef]
U4	[\xf0-\xf4]
UTFEXONLY	{U2}{U}|{U3}{U}{U}|{U4}{U}{U}{U}
idchar [-_+*?A-Za-z0-9]|{UTFEXONLY}
ident {idchar}+

%{
#define YY_USER_ACTION yylloc->columns(yyleng); 
%}

%%
%{
	yylloc->step();
%}
{ws}+	{yylloc->step();}
[\n]+ {yylloc->lines(yyleng); yylloc->step();}
;[^\n]* {yylloc->step();}
"#|"	{
			int c;
			while ((c = yyinput()) != 0) {
				if (c == '|') {
					yylloc->columns();
					if ((c = yyinput()) == '#') {
						yylloc->columns();
						break;
					}
					else
						unput(c);
				} else {
					if (c == '\n')
						yylloc->lines();
					else
						yylloc->columns();
				}
			}
			yylloc->step();
		}


{ident}	{ 
				delphin::TdlParser::token_type i = check_keywords(yytext);
				yylval->sval = new std::string(yytext, yyleng);
				if (i == token::END) return token::ID;
				else {
					delete yylval->sval;
					return i;
				}
			}

^%.*\n	{
				yylval->sval = new std::string(yytext, yyleng);
				return token::INFLR;
			}

["]([^"\\]*(\\.)*)+["]	{
									yylval->sval = new std::string(yytext, yyleng);
									return token::STRING;
								}

[\^]([^$\\]*(\\.)*)+[$]	{
									yylval->sval = new std::string(yytext, yyleng);
									return token::REGEX;
								}

"<!"	{return token::LDIFF;}
"!>"	{return token::RDIFF;}
"-->" {return token::ARROW;}
":="	{return token::ISEQ;}
":<"	{return token::ISEQ;}
":+"	{return token::ISPLUS;}
"<"	{return token::LANGLE;}
">"	{return token::RANGLE;}
"["	{return token::LBRACKET;}
"]"	{return token::RBRACKET;}
"("	{return token::LPAREN;}
")"	{return token::RPAREN;}
"$"	{return token::DOLLAR;}
"^"	{return token::CAP;}
"@"	{return token::AT;}
"&"	{return token::AMPERSAND;}
"'"	{return token::QUOTE;}
"#"	{return token::HASH;}
"="	{return token::EQUALS;}
":"	{return token::COLON;}
","	{return token::COMMA;}
"."	{return token::DOT;}
"}"	{return token::RBRACE;}
"{"	{return token::LBRACE;}

<<EOF>>	{
				currentstream->close();
				if (include_stack_ptr == 0)
					yyterminate();
				else {
					delete currentstream;
					include_stack_ptr--;
					yy_delete_buffer(YY_CURRENT_BUFFER);
					yy_switch_to_buffer(include_stack[include_stack_ptr]);
					//reset location
					yylloc->end = location_stack[include_stack_ptr]->end;
					delete location_stack[include_stack_ptr];
					delete includefnames.back();
					includefnames.pop_back();
				}
			}

.	{return static_cast<token_type>(*yytext);}

%%

namespace delphin {

TdlParser::token_type TdlLexer::check_keywords(const char *val) {
	if (strcmp(val, "declare") == 0) return token::KW_DECLARE;
	if (strcmp(val, "domain") == 0) return token::KW_DOMAIN;
	if (strcmp(val, "instance") == 0) return token::KW_INSTANCE;
	if (strcmp(val, "lisp") == 0) return token::KW_LISP;
	if (strcmp(val, "template") == 0) return token::KW_TEMPLATE;
	if (strcmp(val, "type") == 0) return token::KW_TYPE;
	if (strcmp(val, "begin") == 0) return token::KW_BEGIN;
	if (strcmp(val, "defdomain") == 0) return token::KW_DEFDOMAIN;
	if (strcmp(val, "deldomain") == 0) return token::KW_DELDOMAIN;
	if (strcmp(val, "delete-package-p") == 0) return token::KW_DELETEPACKAGEP;
	if (strcmp(val, "end") == 0) return token::KW_END;
	if (strcmp(val, "end!") == 0) return token::KW_ENDBANG;
	if (strcmp(val, "errorp") == 0) return token::KW_ERRORP;
	if (strcmp(val, "expand-all-instances") == 0) 
		return token::KW_EXPANDALLINSTANCES;
	if (strcmp(val, "include") == 0) return token::KW_INCLUDE;
	if (strcmp(val, "leval") == 0) return token::KW_LEVAL;
	if (strcmp(val, "sorts") == 0) return token::KW_SORTS;
	if (strcmp(val, "status") == 0) return token::KW_STATUS;

	return token::END;
}

TdlLexer::TdlLexer(std::istream *in, std::ostream *out)
	: include_stack_ptr(0), TdlFlexLexer(in, out)
{
	currentstream = static_cast<std::ifstream *>(in);
}

TdlLexer::~TdlLexer()
{
}

void TdlLexer::set_debug(bool b)
{
	yy_flex_debug = b;
}

bool TdlLexer::push_includefile(std::string &fname, 
	TdlParser::location_type *loc)
{
	if (include_stack_ptr >= MAX_INCLUDE_DEPTH) {
		std::cerr << "Includes nest too deeply" << std::endl;
		return false;
	}
	std::string fullname(fname);
	currentstream = new std::ifstream();
	currentstream->open(fullname.c_str());
	if (!currentstream->good()) {
		fullname += std::string(".tdl");
		currentstream->open(fullname.c_str());
	}
	if (!currentstream->good()) {
		std::cerr << "Couldn't open " << fname << "[.tdl]" << std::endl;
		return false;
	}

	TdlParser::location_type *storedloc = new TdlParser::location_type();
	storedloc->begin = loc->begin;
	storedloc->end = loc->end;
	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
	location_stack[include_stack_ptr] = storedloc;
	include_stack_ptr++;

	yy_switch_to_buffer(yy_create_buffer(static_cast<std::istream *>
		(currentstream), YY_BUF_SIZE));
	includefnames.push_back(new std::string(fullname));
	loc->initialize(includefnames.back());
	return true;
}

} //namespace

#ifdef yylex
#undef yylex
#endif

int TdlFlexLexer::yylex()
{
	std::cerr << "in TdlFlexLexer::yylex() !" << std::endl;
	return 1;
}