%option noyywrap
%option yylineno

%{

#include <bits/stdc++.h>

using namespace std;

int error_count = 0;

FILE *f_log = fopen("log.txt", "w");
FILE *f_token = fopen("token.txt", "w");

class symbol_info
{
public:
	string name, type;
	symbol_info *next = 0;

	symbol_info() {}
	symbol_info(string n, string t) : name(n), type(t) {}
};

class scope_table
{
	const int n = 7;
	symbol_info **arr;

public:
	scope_table()
	{
		arr = new symbol_info*[n];

		for (int i = 0; i < n; i++)
			arr[i] = new symbol_info();
	}

	~scope_table()
	{
		for (int i = 0; i < n; i++)
			delete(arr[i]);
		parent_scope = 0;
	}

	long polynomial_hash(string s)
	{
		long val = 0, _pow = 1;

		for (int i = 0; i < s.size(); i++, _pow *= 29)
			val = (val + int(s[i]) * _pow) % int(1e9 + 7);

		return val % n;
	}

	void insert(string name, string type)
	{
		bool err = 0;
		symbol_info *temp = arr[polynomial_hash(name)];

		if (!temp) temp = new symbol_info();

		if (temp->name.empty())
			temp = new symbol_info(name, type);

		while (temp->next && !err)
		{
			err |= temp->name == name && temp->type == type;
			temp = temp->next;
		}

		if (err || (temp->name == name && temp->type == type)) return;
		temp->next = new symbol_info(name, type);
		print();
	}

	void print()
	{
		for (int i = 0; i < n; i++)
		{
			symbol_info *temp = arr[i];
			if (temp->name.empty()) continue;

			cout << i << " --> ";

			while (temp)
			{
				if (temp->name.empty()) continue;

				cout << "<" << temp->name << ", " << temp->type << "> ";
				temp = temp->next;
			}

			cout << endl;
		}
	}
} table;

%}

CHARACTER [a-zA-Z]|(\(n|t|a|f|r|b|v|\|"|0))
REAL_NUMBER ([0-9]+.?[0-9]*)|(.[0-9]+)
ALNUMS [ a-zA-Z0-9]*
NUMBER [0-9]+

%%

if 											{
												fprintf(f_token, "<IF> ");
											}

for											{
												fprintf(f_token, "<FOR> ");
											}

do											{
												fprintf(f_token, "<DO> ");
											}

int											{
												fprintf(f_token, "<INT> ");
											}

float										{
												fprintf(f_token, "<FLOAT> ");
											}

void										{
												fprintf(f_token, "<IF> ");
											}

switch										{
												fprintf(f_token, "<SWITCH> ");
											}

default										{
												fprintf(f_token, "<DEFAULT> ");
											}

else										{
												fprintf(f_token, "<ELSE> ");
											}

while										{
												fprintf(f_token, "<WHILE> ");
											}

break										{
												fprintf(f_token, "<BREAK> ");
											}

char										{
												fprintf(f_token, "<CHAR> ");
											}

double										{
												fprintf(f_token, "<DOUBLE> ");
											}

return										{
												fprintf(f_token, "<RETURN> ");
											}

case										{
												fprintf(f_token, "<CASE> ");
											}

continue									{
												fprintf(f_token, "<CONTINUE> ");
											}

{NUMBER}									{
												fprintf(f_token, "<CONST_INT> ");
												fprintf(f_log, "Line No. %d: Token <CONST_INT> Lexeme %s found\n", yylineno, yytext);
												table.insert(string(yytext),"CONST_INT");
											}

{REAL_NUMBER}(E-?{NUMBER})?					{
												fprintf(f_token, "<CONST_FLOAT> ");
												fprintf(f_log, "Line No. %d: Token <CONST_FLOAT> Lexeme %s found\n", yylineno, yytext);
												table.insert(string(yytext),"CONST_FLOAT");
											}

'{CHARACTER}'								{
												fprintf(f_token, "<CONST_CHAR> ");
												fprintf(f_log, "Line No. %d: Token <CONST_CHAR> Lexeme %s found\n", yylineno, yytext);
												table.insert(string(yytext),"CONST_CHAR");
											}

[a-zA-Z_][a-zA-Z0-9_]*						{
												fprintf(f_token, "<ID, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <ID> Lexeme %s found\n", yylineno, yytext);
												table.insert(string(yytext),"ID");

											}

+|-											{
												fprintf(f_token, "<ADDOP, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <ADDOP> Lexeme %s found\n", yylineno, yytext);
											}

*|/|%										{
												fprintf(f_token, "<MULOP, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <ADDOP> Lexeme %s found\n", yylineno, yytext);
											}

(++)|(--)									{
												fprintf(f_token, "<INCOP, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <INCOP> Lexeme %s found\n", yylineno, yytext);
											}

<|(<=)|>|(>=)|(==)|(!=)						{
												fprintf(f_token, "<RELOP, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <RELOP> Lexeme %s found\n", yylineno, yytext);
											}

=											{
												fprintf(f_token, "<ASSIGNOP, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <ASSIGNOP> Lexeme %s found\n", yylineno, yytext);
											}

(&&)|("||")									{
												fprintf(f_token, "<LOGICOP, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <LOGICOP> Lexeme %s found\n", yylineno, yytext);
											}

&|"|"|^|(<<)|(>>)							{
												fprintf(f_token, "<BITOP, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <BITOP> Lexeme %s found\n", yylineno, yytext);
											}

!											{
												fprintf(f_token, "<NOT, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <NOT> Lexeme %s found\n", yylineno, yytext);
											}

(											{
												fprintf(f_token, "<LPAREN, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <LPAREN> Lexeme %s found\n", yylineno, yytext);
											}

)											{
												fprintf(f_token, "<RPAREN, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <RPAREN> Lexeme %s found\n", yylineno, yytext);
											}

{											{
												fprintf(f_token, "<LCURL, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <LCURL> Lexeme %s found\n", yylineno, yytext);
											}

}											{
												fprintf(f_token, "<RCURL, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <RCURL> Lexeme %s found\n", yylineno, yytext);
											}

[											{
												fprintf(f_token, "<LTHIRD, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <LTHIRD> Lexeme %s found\n", yylineno, yytext);
											}

]											{
												fprintf(f_token, "<RTHIRD, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <RTHIRD> Lexeme %s found\n", yylineno, yytext);
											}

,											{
												fprintf(f_token, "<COMMA, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <COMMA> Lexeme %s found\n", yylineno, yytext);
											}

;											{
												fprintf(f_token, "<SEMICOLON, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <SEMICOLON> Lexeme %s found\n", yylineno, yytext);
											}

("""){ALNUMS}(\$(\n){ALNUMS})*(""")			{
												fprintf(f_token, "<STRING, %s> ", yytext);
												fprintf(f_log, "Line No. %d: Token <STRING> Lexeme %s found\n", yylineno, yytext);
											}

//{ALNUMS}(\$(\n){ALNUMS})*(\n)				{
												fprintf(f_log, "Line No. %d: Token <COMMENT> Lexeme %s found\n", yylineno, yytext);
											}

(/*)[ a-zA-Z0-9\n]*(*/)						{
												fprintf(f_log, "Line No. %d: Token <COMMENT> Lexeme %s found\n", yylineno, yytext);
											}

([0-9]*.)+{NUMBER}(.[0-9]*)+				{
												fprintf(f_log, "Error at line %d: Too many decimal point %s\n", yylineno, yytext);
												error_count++;
											}

{REAL_NUMBER}E-?{REAL_NUMBER}				{
												fprintf(f_log, "Error at line %d: Ill formed number %s\n", yylineno, yytext);
												error_count++;
											}

({NUMBER}[a-zA-Z_]+)|({NUMBER}[a-zA-Z]+)	{
												fprintf(f_log, "Error at line %d: Invalid prefix on ID or invalid suffix on Number %s\n", yylineno, yytext);
												error_count++;
											}

'{CHARACTER}{CHARACTER}+'					{
												fprintf(f_log, "Error at line %d: Multi character constant error %s\n", yylineno, yytext);
												error_count++;
											}

('{CHARACTER})|('\')						{
												fprintf(f_log, "Error at line %d: Unterminated character %s\n", yylineno, yytext);
												error_count++;
											}

''											{
												fprintf(f_log, "Error at line %d: Empty character constant error %s\n", yytext);
												error_count++;
											}

("""){ALNUMS}(\$(\n){ALNUMS})*(\n)			{
												fprintf(f_log, "Error at line %d: Unterminated String %s\n", yylineno, yytext);
												error_count++;
											}

(/*)[ a-zA-Z0-9\n]*							{
												fprintf(f_log, "Error at line %d: Unterminated comment %s\n", yylineno, yytext);
												error_count++;
											}

[ \n\t\f\r\v]								{

											}

.											{
												fprintf(f_log, "Unrecognized lexeme %s\n", yytext);
											}

%%

int main(int argc, char *argv[])
{
	if (argc != 2)
	{
		printf("Please provide input file name and try again\n");
		return 0;
	}

	yyin = fopen(argv[1], "r");

	if (yyin == NULL)
	{
		printf("Cannot open specified file\n");
		return 0;
	}

	yylex();
	scope.print();
	fprintf(f_log, "Total lines: %d\n", yylineno);
	fprintf(f_log, "Total errors: %d\n", error_count);

	fclose(yyin);
	fclose(f_token);
	fclose(f_log);
}