#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <malloc.h>
#define SIZE 2046

#define SAFEALLOC(var,Type) if((var=(Type*)malloc(sizeof(Type)))==NULL)err("not enough memory");

enum{
	ID, END,
	//constants
	CT_INT, CT_REAL, CT_CHAR, CT_STRING,
	//keywords
	BREAK, CHAR, DOUBLE, ELSE, FOR, IF, INT, RETURN, STRUCT, VOID, WHILE,
	//delimiters
	COMMA, SEMICOLON, LPAR, RPAR, LBRACKET, RBRACKET, LACC, RACC,
	//operators
	ADD, SUB, MUL, DIV, DOT, AND, OR, NOT, ASSIGN, EQUAL, NOTEQ, LESS, LESSEQ, GREATER, GREATEREQ,
	SPACE, LINECOMMENT, COMMENT
}; //tokens codes

typedef struct _Token
{
	int code;
	union{
		char *text;
		long int i;
		double r;
	    };
	int line;
	struct _Token *next;
}Token;

Token *tokens;
Token *lastToken = NULL;
const char *pCrtCh;
int line;

void err(const char *fmt,...)
{
	va_list va;
	va_start(va,fmt);
	fprintf(stderr,"error: ");
	vfprintf(stderr,fmt,va);
	fputc('\n',stderr);
	va_end(va);
	exit(-1);
}


void tkerr(const Token *tk,const char *fmt,...)
{
	va_list va;
	va_start(va,fmt);
	fprintf(stderr,"error in line %d: ",tk->line);
	vfprintf(stderr,fmt,va);
	fputc('\n',stderr);
	va_end(va);
	exit(-1);
}


Token *addTk(int code)
{
	Token *tk;
	SAFEALLOC(tk,Token)
	tk->code=code;
	tk->line=line;
	tk->next=NULL;
	if(lastToken)
	{
		lastToken->next=tk;
	}
	else
	{
		tokens=tk;
	}
	lastToken=tk;
	return tk;
}

char* createString(const char *pStartCh,const char *pCrtCh)
{
	int nCh=pCrtCh-pStartCh+1;
	char *str;
	str=(char *)malloc(nCh*sizeof(char));
	snprintf(str,nCh,"%s",pStartCh);
	return str;
}

char escCode(char ch)
{
	char newCh;
	switch(ch)
	{
		case 'a': newCh='\a'; break;
		case 'b': newCh='\b'; break;
		case 'f': newCh='\f'; break;
		case 'n': newCh='\n'; break;
		case 'r': newCh='\r'; break;
		case 't': newCh='\t'; break;
		case '\'': newCh='\''; break;
		case '\?': newCh='\?'; break;
		case '\"': newCh='\"'; break;
		case '\\': newCh='\\'; break;
		case '0': newCh='\0'; break;
	}
	return newCh;
}

void printTokens()
{
	Token *current=tokens;
	while(current!=NULL)
	{
		printf("%i", current->code);
		switch(current->code)
		{
			case ID:
			case CT_STRING:
				printf(":%s",current->text);
				break;
			case CT_CHAR:
				printf(":%c",(int)current->i);
				break;
			case CT_INT:
				printf(":%li",current->i);
				break;
			case CT_REAL:
				printf(":%lf",current->r);
				break;
		}
		printf(" ");
		current=current->next;
	}
	printf("\n");
}

int getNextToken()
{
	int state=0,nCh;
	char ch;
	const char *pStartCh;
	Token *tk;

	long int ct_int;
	double ct_real;
	int ct_char;
	char *ct_string;
	char *p;
	int noBacks=0;
	int i;

	while(1)
	{
		ch=*pCrtCh;
		//if(ch=='\0')printf("ch e null in state %i\n",state);
		//printf("ch=%c\n",ch);
		switch(state)
		{
			case 0:
				if(ch<='9'&&ch>='1')
				{
					pStartCh=pCrtCh;
					pCrtCh++;
					state=1;
				}
				else if(ch=='0')
				{
					pStartCh=pCrtCh;
					pCrtCh++;
					state=2;
				}
				else if(ch=='/')
				{
					pCrtCh++;
					state=14;
				}
				else if(ch==' '||ch=='\r'||ch=='\t')
				{
					pCrtCh++;
					//state=0;
				}
				else if(ch=='\n')
				{
					line++;
					pCrtCh++;
					//state=0;
				}
				else if(ch=='\'')
				{
					pStartCh=pCrtCh; // ?
					pCrtCh++;
					state=18;
				}
				else if(ch=='\"')
				{
					pStartCh=pCrtCh; // ?
					pCrtCh++;
					state=22;
				}
				else if(ch==',')
				{
					pCrtCh++;
					state=26;
				}
				else if(ch==';')
				{
					pCrtCh++;
					state=27;
				}
				else if(ch=='(')
				{
					pCrtCh++;
					state=28;
				}
				else if(ch==')')
				{
					pCrtCh++;
					state=29;
				}
				else if(ch=='[')
				{
					pCrtCh++;
					state=30;
				}else if(ch==']')
				{
					pCrtCh++;
					state=31;
				}else if(ch=='{')
				{
					pCrtCh++;
					state=32;
				}
				else if(ch=='}')
				{
					pCrtCh++;
					state=33;
				}
				else if(ch=='+')
				{
					pCrtCh++;
					state=34;
				}
				else if(ch=='-')
				{
					pCrtCh++;
					state=35;
				}
				else if(ch=='*')
				{
					pCrtCh++;
					state=36;
				}
				else if(ch=='.')
				{
					pCrtCh++;
					state=38;
				}
				else if(ch=='&')
				{
					pCrtCh++;
					state=39;
				}
				else if(ch=='|')
				{
					pCrtCh++;
					state=41;
				}
				else if(ch=='!')
				{
					pCrtCh++;
					state=43;
				}
				else if(ch=='=')
				{
					pCrtCh++;
					state=46;
				}
				else if(ch=='<')
				{
					pCrtCh++;
					state=49;
				}
				else if(ch=='>')
				{
					pCrtCh++;
					state=52;
				}
				else if(ch=='_' || (ch>='a'&&ch<='z') || (ch>='A'&&ch<='Z'))
				{
					pStartCh=pCrtCh;
					pCrtCh++;
					state=55;
				}

				else if(ch=='\0') // the end of the input string
				{
					printf("At END.\n");
					addTk(END);
					return END;
				}
				else
				{	printf("invalid character ch=%c\n",ch);
					tkerr(addTk(END),"invalid character");}
				break;
			case 1:
				if(ch>='0'&&ch<='9')
				{
					pCrtCh++;
					//state=1;
				}
				else if(ch=='.')
				{
					pCrtCh++;
					state=8;
				}
				else if(ch=='e'||ch=='E')
				{
					pCrtCh++;
					state=10;
				}
				else
					state=6;
				break;
			case 2:
				if(ch=='x'||ch=='X')
				{
					pCrtCh++;
					state=4;
				}
				else
					state=3;
				break;
			case 3:
				if(ch>='0'&&ch<='7')
				{
					pCrtCh++;
					//state=3;
				}
				else if(ch=='.')
				{
					pCrtCh++;
					state=8;
				}
				else if(ch=='e'||ch=='E')
				{
					pCrtCh++;
					state=10;
				}
				else
					state=6;
				break;
			case 4:
				if((ch>='0'&&ch<='9') || (ch>='a'&&ch<='f') || (ch>='A'&&ch<='F'))
				{
					pCrtCh++;
					state=5;
				}
				//Am nevoie de error?
				else
					tkerr(addTk(END),"not a valid int");
				break;
			case 5:
				if((ch>='0'&&ch<='9') || (ch>='a'&&ch<='f') || (ch>='A'&&ch<='F'))
				{
					pCrtCh++;
					//state=5;
				}
				else
					state=6;
				break;
			case 6: //CT_INT
				//nCh=pCrtCh-pStartCh;
				//Char *ct_int=createString(pStartCh,pCrtCh);
				ct_int=strtol(pStartCh,NULL,0);
				tk=addTk(CT_INT);
				tk->i=ct_int;
				return CT_INT;
			case 8:
				if(ch>='0'&&ch<='9')
				{
					pCrtCh++;
					state=9;
				}
				// error?
				else
					tkerr(addTk(END),"after a point should be a digit");
				break;
			case 9:
				if(ch=='e'||ch=='E')
				{
					pCrtCh++;
					state=10;
				}
				else if(ch>='0'&&ch<='9')
				{
					pCrtCh++;
					//state=9;
				}
				else state=13;
				break;
			case 10:
				if(ch=='+'||ch=='-')
				{
					pCrtCh++;
					state=11;
				}
				else
					state=11;
				break;
			case 11:
				if(ch>='0'&&ch<='9')
				{
					pCrtCh++;
					state=12;
				}
				// error?
				else
					//printf("at error ch=%c\n",ch);
					tkerr(addTk(END),"after + or - should come a digit");
				break;
			case 12:
				if(ch>='0'&&ch<='9')
				{
					pCrtCh++;
					//state=12;
				}
				else
					state=13;
				break;
			case 13:
				ct_real=strtod(pStartCh,NULL);
				tk=addTk(CT_REAL);
				tk->r=ct_real;
				return CT_REAL;
			case 14:
				if(ch=='*')
				{
					pCrtCh++;
					state=15;
				}
				else if(ch=='/')
				{
					pCrtCh++;
					state=17;
				}
				else
					state=37;
				break;
			case 15:
				if(ch=='*')
				{
					pCrtCh++;
					state=16;
				}
				else
				{
					pCrtCh++;
					//state=15;
				}
				break;
			case 16:
				if(ch=='*')
				{
					pCrtCh++;
					//state=16;
				}
				else if(ch=='/')
				{
					pCrtCh++;
					state=0;
				}
				else
					state=15;
				break;
			case 17:
				if(ch=='\r'||ch=='\0')
				{
					pCrtCh++;
					state=0;
				}
				else if(ch=='\n')
				{
					line++;
					pCrtCh++;
					state=0;
				}
				else
				{
					pCrtCh++;
					//state=17;
				}
				break;
			case 18:
				if(ch=='\\')
				{
					//pStartCh=pCrtCh; // ?

					pCrtCh++;
					state=19;
				}
				else if(ch!='\'')
				{
					//pStartCh=pCrtCh; // ?

					ct_char=ch;
					pCrtCh++;
					state=20;
				}
				// ch=='\''
				// else error?
				else
					tkerr(addTk(END)," empty character constant");
				break;
			case 19:
				//if(ch=='\a'||ch=='\b'||ch=='\f'||ch=='\n'||ch=='\r'||ch=='\t'||ch=='\v'||ch=='\''||ch=='\"'||ch=='\?'||ch=='\\'||ch=='\0')
				if(strchr("abfnrtv'?\"\\0", ch))
				{
					ct_char=escCode(ch);
					pCrtCh++;
					state=20;
				}
				// error?
				else
					tkerr(addTk(END),"should come a character to be escaped");
				break;
			case 20:
				if(ch=='\'')
				{
					pCrtCh++;
					state=21;
				}
				// error?
				else
					//printf("not a qoute ch=%c",ch);
					tkerr(addTk(END),"not a quote");
				break;
			case 21:
				//nCh=pCrtCh-pStartCh;
				//ct_char=createString(pStartCh+1,pCrtCh-1);
				//tk=addTk(CT_CHAR);
				//tk->text=ct_char;
				//ct_char=(int)(*(pStartCh+1));
				//ct_char=strtol(pStartCh+1,NULL,0);
				tk=addTk(CT_CHAR);
				tk->i=ct_char;
				return CT_CHAR;
			case 22:
				if(ch=='\\')
				{
					//pStartCh=pCrtCh; // ?
					noBacks++;
					pCrtCh++;
					state=23;
				}
				else if(ch!='\"')
				{
					//pStartCh=pCrtCh; // ?
					pCrtCh++;
					state=24;
				}
				else if (ch=='\"')
				{
					pCrtCh++;
					state=25;
				}
				break;
			case 23:
				//if(ch=='\a'||ch=='\b'||ch=='\f'||ch=='\n'||ch=='\r'||ch=='\t'||ch=='\v'||ch=='\''||ch=='\"'||ch=='\?'||ch=='\\'||ch=='\0')
				if(strchr("abfnrtv'?\"\\0", ch))
				{
					pCrtCh++;
					state=24;
				}
				//else error?
				else
					tkerr(addTk(END),"should come a character to be escaped");
				break;
			case 24:
				if(ch=='\"')
				{
					pCrtCh++;
					state=25;
				}
				else
					state=22;
				break;
			case 25:
				ct_string=createString(pStartCh+1,pCrtCh-1);

				while((p=strchr(ct_string,'\\'))!=NULL)
				{
					//p=strchr(ct_string,'\\');
					//puts(p);
					memmove(p,p+1,strlen(p));
					*p=escCode(*p);
				}
				/*
				printf("No of \\ is %i\n",noBacks);
				printf("String before is %s\n",ct_string);
				for(i=0;i<noBacks;i++)
				{
					p=strchr(ct_string,'\\');
					strcpy(p,p+1);
					*p=escCode(*p);
					printf("Escaped %c\n",*p);
					printf("String at %i is %s\n",i,ct_string);
				}
				*/
				tk=addTk(CT_STRING);
				tk->text=ct_string;
				return CT_STRING;
			case 26:
				addTk(COMMA);
				return COMMA;
			case 27:
				addTk(SEMICOLON);
				return SEMICOLON;
			case 28:
				addTk(LPAR);
				return LPAR;
			case 29:
				addTk(RPAR);
				return RPAR;
			case 30:
				addTk(LBRACKET);
				return LBRACKET;
			case 31:
				addTk(RBRACKET);
				return RBRACKET;
			case 32:
				addTk(LACC);
				return LACC;
			case 33:
				addTk(RACC);
				return RACC;
			case 34:
				addTk(ADD);
				return ADD;
			case 35:
				addTk(SUB);
				return SUB;
			case 36:
				addTk(MUL);
				return MUL;
			case 37:
				addTk(DIV);
				return DIV;
			case 38:
				addTk(DOT);
				return DOT;
			case 39:
				if(ch=='&')
				{
					pCrtCh++;
					state=40;
				}
				//else error?
				else
					tkerr(addTk(END),"should come a &");
				break;
			case 40:
				addTk(AND);
				return AND;
			case 41:
				if(ch=='|')
				{
					pCrtCh++;
					state=42;
				}
				//else error?
				else
					tkerr(addTk(END),"should come a |");
				break;
			case 42:
				addTk(OR);
				return OR;
			case 43:
				if(ch=='=')
				{
					pCrtCh++;
					state=45;
				}
				else
					state=44;
				break;
			case 44:
				addTk(NOT);
				return NOT;
			case 45:
				addTk(NOTEQ);
				return NOTEQ;
			case 46:
				if(ch=='=')
				{
					pCrtCh++;
					state=48;
				}
				else
					state=47;
				break;
			case 47:
				addTk(ASSIGN);
				return ASSIGN;
			case 48:
				addTk(EQUAL);
				return EQUAL;
			case 49:
				if(ch=='=')
				{
					pCrtCh++;
					state=51;
				}
				else
					state=50;
				break;
			case 50:
				addTk(LESS);
				return LESS;
			case 51:
				addTk(LESSEQ);
				return LESSEQ;
			case 52:
				if(ch=='=')
				{
					pCrtCh++;
					state=54;
				}
				else
					state=53;
				break;
			case 53:
				addTk(GREATER);
				return GREATER;
			case 54:
				addTk(GREATEREQ);
				return GREATEREQ;
			case 55:
				if(ch=='_' || (ch>='a'&&ch<='z') || (ch>='A'&&ch<='Z'))
				{
					pCrtCh++;
					//state=55;
				}
				else
					state=56;
				break;
			case 56:
				// the id length
				nCh=pCrtCh-pStartCh;
				// keywords tests
				if(nCh==5&&!memcmp(pStartCh,"break",5))
					tk=addTk(BREAK);
				else if(nCh==4&&!memcmp(pStartCh,"char",4))
					tk=addTk(CHAR);
				else if(nCh==6&&!memcmp(pStartCh,"double",6))
					tk=addTk(DOUBLE);
				else if(nCh==4&&!memcmp(pStartCh,"else",4))
					tk=addTk(ELSE);
				else if(nCh==3&&!memcmp(pStartCh,"for",3))
					tk=addTk(FOR);
				else if(nCh==2&&!memcmp(pStartCh,"if",2))
					tk=addTk(IF);
				else if(nCh==3&&!memcmp(pStartCh,"int",3))
					tk=addTk(INT);
				else if(nCh==6&&!memcmp(pStartCh,"return",6))
					tk=addTk(RETURN);
				else if(nCh==6&&!memcmp(pStartCh,"struct",6))
					tk=addTk(STRUCT);
				else if(nCh==4&&!memcmp(pStartCh,"void",4))
					tk=addTk(VOID);
				else if(nCh==5&&!memcmp(pStartCh,"while",5))
					tk=addTk(WHILE);
				// if no keyword, then it is an ID
				else
				{
					tk=addTk(ID);
					tk->text=createString(pStartCh,pCrtCh);

				}
				return tk->code;

		}
	    //printf("state=%i\n",state);
	}
}

void getTokens()
{
	do
	{
		getNextToken();
	}while(*pCrtCh);
}

/*
int main()
{
	FILE *file=fopen("code.c","r+");
	if(file==NULL)
	{
		printf("The file could not be opened.\n");
		exit(1);
	}
	char *buffer;
	char *input;
	int no;

	input=(char *)malloc(SIZE*sizeof(char));
	buffer=(char *)malloc(SIZE*sizeof(char));
	strcpy(input,"");
	while((no=fread(buffer,sizeof(char),SIZE,file))>0)
	{
		input=(char *)realloc(input, no*sizeof(char));
		strcat(input, buffer);
	}
	input=(char *)realloc(input, (strlen(input)+1)*sizeof(char));
	input[strlen(input)]='\0';
	pCrtCh=input;
	getTokens();
	printTokens();
	return 0;
}
*/

int main()
{
	FILE *file=fopen("8.c","r+");
	if(file==NULL)
	{
		printf("The file could not be opened.\n");
		exit(1);
	}
	char *input;
	int size;

	fseek(file, 0, SEEK_END); // seek to end of file
	size = ftell(file); // get current file pointer
	fseek(file, 0, SEEK_SET); // seek back to beginning of file

	input=(char *)malloc((size+1)*sizeof(char));
	fread(input,sizeof(char),size,file);
	input[size]='\0';
	pCrtCh=input;
	getTokens();
	printTokens();
	fclose(file);
	return 0;
}