/*****
*
*	Michael Riff
*	Scanner software version 1.0  10 Jun 2015.
*
*	Diese Datei implementiert die lexikalische Analyse als separate Routine wie es
*	bei de Werkzeuge Yacc & Lex gemacht wird.
*	Diese Verion der SW identifiziert nicht direckt die Zeichen in dem Eingangstext.
*	Als Laufzeit Verbesserung, werden die Zeichen im Eingangstext duch einen numerischen
*	Wert identifiziert der zeigt ob es sich um eine Zeichenkette, eine Zahl(Ganz/Gleikomma) oder
*	einen Operator ansonste sonderzeichen.
*
*	Dies ist noch ein Prototyp, so ist der Test Kode sowie Laufzeitmessungs Kode
*	mit enthalten.
*
*****/
//#define RESER_WD


#include <stdio.h>
#include <stdlib.h>


#include <math.h>

#ifdef RESER_WD
#include <string.h>
#endif


//typedef enum { string, integer, floating, operator, openexpr, closeexpr, opencode, endcode, separator } status_type;
typedef enum { string, integer, floating, operator, openexpr, closeexpr, opencode, endcode, semicol, separator
#ifndef RESER_WD
	} token_type;
#else
	, and, or, xor, not, leth, geth, lth, gth, t_if, t_else, t_for, t_while, t_do } token_type;
#endif

/*
const unsigned char Str_Msk = 1<<string;
const unsigned char Int_Msk = 1<<integer;
const unsigned char Flt_Msk = 1<<floating;
const unsigned char Op_Msk = 1<<operator;
const unsigned char Opn_Msk = 1<<openexpr;
const unsigned char Cls_Msk = 1<<closeexpr;
const unsigned char Start_Msk = 1<<opencode;
const unsigned char End_Msk = 1<<endcode;
const unsigned char Scol_Msk = 1<<semicol;
const unsigned char UnOp_Msk = 1<<;
const unsigned char Sep_Msk = 1<<separator;

const unsigned char AlpNum_Msk = 1<<string | 1<<integer; //Str_Msk | Int_Msk;
const unsigned char Num_Msk = 1<<integer | 1<<floating; //Int_Msk | Flt_Msk;

const unsigned char Err_Msk = 0x80;

*/


#define		Str_Msk 1
#define		Int_Msk 2
#define		Flt_Msk 4
#define		Op_Msk 8
#define		Opn_Msk 16
#define		Cls_Msk 32
#define		Start_Msk 64
#define		End_Msk 128
#define		Scol_Msk 256
#define		UnOp_Msk 512	// Special case of - and + that can be operators or sign of a numeric value
#define		Sep_Msk 1024

#define		AlpNum_Msk 3
#define		Num_Msk 6

#define		Err_Msk 0x800



const unsigned int	statis[] = {
	// 0 - 9
	Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Sep_Msk,
	// 10 - 19
	Sep_Msk, Err_Msk, Err_Msk, Sep_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk,
	// 20 - 29
	Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Sep_Msk,
	// 30 - 39
	Err_Msk, Err_Msk, Sep_Msk, Op_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk,
	// 40 - 49
	Opn_Msk, Cls_Msk, Op_Msk, Op_Msk|UnOp_Msk, Flt_Msk, Op_Msk|UnOp_Msk, Flt_Msk, Op_Msk, Num_Msk, Num_Msk,
//	Opn_Msk, Cls_Msk, Op_Msk, Op_Msk, Flt_Msk, Op_Msk, Flt_Msk, Op_Msk, Num_Msk, Num_Msk,
	// 50 - 59
	Num_Msk, Num_Msk, Num_Msk, Num_Msk, Num_Msk, Num_Msk, Num_Msk, Num_Msk, Err_Msk, Scol_Msk,
	// 60 - 69
	Op_Msk, Op_Msk, Op_Msk, Op_Msk, Err_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk|Flt_Msk,
	// 70 - 79
	Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk,
	// 80 - 89
	Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk,
	// 90 - 99
	Str_Msk, Err_Msk, Err_Msk, Err_Msk, Op_Msk, Str_Msk, Err_Msk, Str_Msk, Str_Msk, Str_Msk,
	// 100 - 109
	Str_Msk, Str_Msk|Flt_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk,
	// 110 - 119
	Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk, Str_Msk,
	// 120 - 127
	Str_Msk, Str_Msk, Str_Msk, Start_Msk, Op_Msk, End_Msk, Err_Msk, Err_Msk
/*
	// 120 - 129
	AlpNum_Msk, AlpNum_Msk, AlpNum_Msk, Err_Msk, Op_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk,
	// 130 - 139
	Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk,
	// 140 - 149
	Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk,
	// 150 - 159
	Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk,
	// 160 - 169
	Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk, Err_Msk,
	// 170 -179

	// 180 - 189

	// 190 - 199

	// 200 - 209

	// 210 - 219

	// 220 - 229

	// 230 - 239

	// 240 - 249

	// 250 - 255
*/
};


typedef struct {
	char *text;
	unsigned int length;
} text_token;

typedef union {
	text_token str_val;
	double	flt_val;
	int	int_val;
} lex_buf_type;

lex_buf_type	yyval;



//token_type token;

unsigned int	position;
unsigned char	*input;

int Init_Lex(char *data) {
	position = 0;
	input = (unsigned char*)data;
	return 0;
}


/*
	For performance reason, we do not copy the strings in a null terminated buffer, but use a pointer to the start and
	a length value. For this we have to use adapted routines 

	Routine used here to convert to integer
*/
int c2int(text_token value) {
	int result = 0;
	int idx;
	int sgn=1;

	idx = 0;
	if ('-'==value.text[idx]) {
		sgn = -1;
		idx++;
	}
if ('+'==value.text[idx]) idx++;

	for(; idx<value.length; idx++) {
		result *=10;
		result += value.text[idx]-'0';
	}
	return result*sgn;
}

/*
	Routine used here to convert to integer
*/
double c2float(text_token value) {
	double result = 0;
	double factor;
	int idx;
	int sgn=1;

	idx = 0;
	if ('-'==value.text[idx]) {
		sgn = -1;
		idx++;
	}
if ('+'==value.text[idx]) idx++;

	for(; idx<value.length && '.' !=value.text[idx]; idx++) {
		result *= 10;
		result += value.text[idx]-'0';
	}

	// Fractionnary part
	idx++;
	factor = 0.1;
	while (idx<value.length && 'e'!=value.text[idx] && 'E'!=value.text[idx]) {	// A revoir
		result += (value.text[idx]-'0')*factor;
		idx++;
		factor /= 10;
	}

	result *= sgn;

	// Check for exponent
	factor = 0;
	idx++;
	if ('-'==value.text[idx]) {
		idx++;
		sgn=-1;
	} else {
		sgn=1;
	}

	while (idx<value.length) {
		factor*= 10;
		factor+= value.text[idx]-'0';
		idx++;
	}
	
	result *= pow(10, sgn*factor);

	return result;
}


/*
	Postkondition: position points to the nonseprator character ( \t\n\r ) following the read token.
*/
token_type yylex() {
	token_type mode;

	switch(statis[*(input+position)]) {

		case Str_Msk:
			// We have a string. The following characters are alphanumeric.
			yyval.str_val.text = (char*)input+position;
			yyval.str_val.length = 0;
			while (statis[*(input+position)] & AlpNum_Msk) {
				position++;
			}
			yyval.str_val.length = (char*)input+position - yyval.str_val.text;
#ifndef RESER_WD
			mode = string;
#else
			// Now we try to identify the reserved words
			if (!strncmp("and",yyval.str_val.text,3)) {
				mode = and;
			} else if (!strncmp("or",yyval.str_val.text,2)) {
				mode = or;
			} else if (!strncmp("xor",yyval.str_val.text,3)) {
				mode = xor;
			} else if (!strncmp("not",yyval.str_val.text,3)) {
				mode = not;
			} else if (!strncmp("leth",yyval.str_val.text,4)) {
				mode = leth;
			} else if (!strncmp("geth",yyval.str_val.text,4)) {
				mode = geth;
			} else if (!strncmp("lth",yyval.str_val.text,3)) {
				mode = lth;
			} else if (!strncmp("gth",yyval.str_val.text,3)) {
				mode = gth;
			} else if (!strncmp("if",yyval.str_val.text,2)) {
				mode = t_if;
			} else if (!strncmp("else",yyval.str_val.text,4)) {
				mode = t_else;
			} else if (!strncmp("for",yyval.str_val.text,4)) {
				mode = t_for;
			} else if (!strncmp("while",yyval.str_val.text,5)) {
				mode = t_while;
			} else if (!strncmp("do",yyval.str_val.text,2)) {
				mode = t_do;

			} else {
				mode = string;
			}
#endif
			break;

		case AlpNum_Msk: // à revoir !
			// 
			mode = -1;
			break;

		case Op_Msk|UnOp_Msk:
			// we have - sign that can be a normal operator or an unary sign
			// Check the following character
			if (Num_Msk == statis[*(input+position+1)]) {
				mode = integer;
				yyval.str_val.text = (char*)input+position;
/*
				while (statis[*(input+position)] & Num_Msk) {
					if ('.'==*(input+position)) {
						mode = floating;
					}
					position++;
				}
*/
				position++;
				while (Num_Msk == statis[*(input+position)]) {
					position++;
				}
				if ('.'==*(input+position)) {
					mode = floating;
					position++;
					// Read in fractionary part
					while (Num_Msk == statis[*(input+position)]) {
						position++;
					}
				}

				yyval.str_val.length = (char*)input+position - yyval.str_val.text;
				if (integer == mode) {
					yyval.int_val = c2int(yyval.str_val);
				} else {
					yyval.flt_val = c2float(yyval.str_val);
				}

			} else {
				// We have an operator
				mode = operator;

				yyval.str_val.text = (char*)input+position;
				while (statis[*(input+position)] & Op_Msk) {
					position++;
				}
				yyval.str_val.length = (char*)input+position - yyval.str_val.text;
			}
			break;
		
		case Num_Msk:
			// We have an integer or floating point value.
			mode = integer;
			yyval.str_val.text = (char*)input+position;
/*
			while (statis[*(input+position)] & Num_Msk) {
				if ('.'==*(input+position)) {
					mode = floating;
				}
				position++;
			}
*/
			while (Num_Msk == statis[*(input+position)]) {
				position++;
			}
			if ('.'==*(input+position)) {
				mode = floating;
				position++;
			}
			while ((Flt_Msk|Num_Msk) & statis[*(input+position)]) {
				position++;
			}
			yyval.str_val.length = (char*)input+position - yyval.str_val.text;
			if (integer == mode) {
				yyval.int_val = c2int(yyval.str_val);
			} else {
				yyval.flt_val = c2float(yyval.str_val);
			}
			break;

		case Flt_Msk:
			// Floating point value starting with .
			mode = floating;
			yyval.str_val.text = (char*)input+position;
			while (statis[*(input+position)] & (Flt_Msk|Num_Msk)) {
				position++;
			}
			yyval.str_val.length = (char*)input+position - yyval.str_val.text;
			yyval.flt_val = c2float(yyval.str_val);
			break;

		case Op_Msk:
			// We have an operator
			yyval.str_val.text = (char*)input+position;
			while (statis[*(input+position)] & Op_Msk) {
				position++;
			}
			yyval.str_val.length = (char*)input+position - yyval.str_val.text;
			mode = operator;
			break;

		case Opn_Msk:
			mode = openexpr;
			position++;
			break;

		case Cls_Msk:
			mode = closeexpr;
			position++;
			break;

		case Start_Msk:
			mode = opencode;
			position++;
			break;

		case End_Msk:
			mode = endcode;
			position++;
			break;

		case Scol_Msk:
			mode = semicol;
			position++;
			break;

		default:
			mode = -1;
	}

	// Suppress separator characters
	while (statis[*(input+position)] & Sep_Msk) {
		position++;
	}
	return mode;
}




/*
	TEST CODE
*/

char buffer[20];

void print(text_token value) {
	int lgth;

	for(lgth=0; lgth<value.length; lgth++) {
		buffer[lgth] = value.text[lgth];
	}
	buffer[lgth] = ' ';
	buffer[lgth+1] = 0;
	printf(buffer);
}


//char test_data[] = "if 33 >= variable -45 test_1 *= 654.0976  ++value  .524E-41\r-2.5746";

char test_data[] = "for(idx=76;idx<87;idx--) { var = val1+ 6574.78-97;} += -var +1.12} {-var_1 * ++idx";

token_type token;

#define PRFORMANCE

#ifdef PRFORMANCE

#include <Timer.h>

//TMTask	TimeData;

#include <Processes.h>

struct ExtendedTimerRec {
	TMTask	tmTask;
	ProcessSerialNumber	taskPSN;
};
typedef struct ExtendedTimerRec ExtendedTimerRec, *ExtendedTimerPtr;

ExtendedTimerRec TimeData;


Boolean called;

pascal void dummyTask()
{
	called = true;
//	WakeUpProcess(&((ExtendedTimerRec) TimeData).taskPSN);
	WakeUpProcess(&(TimeData).taskPSN);
}

/*
short dummyTask() {
	called = true;
	WakeUpProcess(&((ExtendedTimerRec) TimeData).taskPSN);
}
*/

typedef struct {
	token_type	tok;
	char text[15];
	int iVal;
	double fVal;
} Entry_Type;

Entry_Type Code[100];

int numTok;

#endif	



int main() {

#ifdef PRFORMANCE
	int idx;
#endif	
	printf("Lexer test\n");

	Init_Lex(test_data);

#ifdef PRFORMANCE
	numTok = 0;
	called = false;

TimeData.tmTask.qLink = NULL;
TimeData.tmTask.qType = 0;
//	TimeData.tmAddr =  NewTimerProc(dummyTask);
	TimeData.tmTask.tmAddr =  NewTimerProc(dummyTask);
TimeData.tmTask.tmCount = 0;
//TimeData.tmTask.tmWakeup = 0;
TimeData.tmTask.tmReserved = 0;

//	InsTime(&TimeData);
	GetCurrentProcess(&TimeData.taskPSN);
	InsXTime((QElemPtr) &TimeData.tmTask);

//	PrimeTime(&TimeData, 1500);
	PrimeTime((QElemPtr) &TimeData.tmTask, 1500);

#endif

	token = yylex();
	do {
#ifdef PRFORMANCE
		Code[numTok].tok = token;
#endif
		switch(token) {

#ifndef PRFORMANCE
			case string:
				printf("Str ");
				print(yyval.str_val);
				printf("\n");
				break;
			case integer:
				printf("Int %d\n", yyval.int_val);
				break;
			case floating:
				printf("Ftl %f\n", yyval.flt_val);
//				printf("Ftl %g\n", yyval.flt_val);
				break;
			case operator:
				printf("Op ");
				print(yyval.str_val);
				printf("\n");
				break;
			case openexpr:
			 	printf("Parenth (\n");
				break;
			case closeexpr:
			 	printf("Parenth )\n");
				break;
			case opencode:
			 	printf("{\n");
				break;
			case endcode:
			 	printf("}\n");
				break;
			case separator:
				printf("Sep\n");
				break;
			case semicol:
				printf("Stop ;\n");
				break;
			default:
				printf("-> other token %d \n");
#else
			case string:
				BlockMove("Str ", (Code[numTok].text), 4);
				BlockMove(yyval.str_val.text, Code[numTok].text+4, yyval.str_val.length);
				Code[numTok].text[yyval.str_val.length+4] = 0;
				numTok++;
				break;
			case integer:
				BlockMove("Int ", (Code[numTok].text), 5);
				Code[numTok].iVal = yyval.int_val;
				numTok++;
				break;
			case floating:
				BlockMove("Ftl ", (Code[numTok].text), 5); 
				Code[numTok].fVal = yyval.flt_val;
				numTok++;
				break;
			case operator:
				BlockMove("Op ", (Code[numTok].text), 3);
				BlockMove(yyval.str_val.text, (Code[numTok].text+3), yyval.str_val.length);
				Code[numTok].text[yyval.str_val.length+3] = 0;
				numTok++;
				break;
			case openexpr:
			 	BlockMove("Parenth (", (Code[numTok].text), 10);
				numTok++;
				break;
			case closeexpr:
			 	BlockMove("Parenth )", (Code[numTok].text), 10);
				numTok++;
				break;
			case opencode:
			 	Code[numTok].text[0] = '{';
				numTok++;
				break;
			case endcode:
			 	Code[numTok].text[0] = '}';
				numTok++;
				break;
			case separator:
				BlockMove("Sep ", (Code[numTok].text), 4);
				numTok++;
				break;
			case semicol:
				BlockMove("Stop ;", (Code[numTok].text), 6);
				numTok++;
				break;
			default:
				printf("-> other token %d \n");

#endif
		}
		token = yylex();
	} while (-1 != token && 0xFF != token);


#ifdef PRFORMANCE
//	RmvTime(&TimeData);	// Immediately stop it. Unused time returned in negated microsecs
	RmvTime((QElemPtr)&TimeData.tmTask);	// Immediately stop it. Unused time returned in negated microsecs

	if (called) {
		printf("Timeout happened!!");
	} else {
//		printf("Rem time %d", TimeData.tmCount);
		printf("Rem time %d %d\n", numTok, TimeData.tmTask.tmCount);

		for (idx=0;idx<numTok; idx++) {
		switch(Code[idx].tok) {
			case string:
				printf("Str ");
				printf(" | ");
				break;
			case integer:
				printf("Int %d | ", Code[idx].iVal);
				break;
			case floating:
				printf("Ftl %f | ", Code[idx].fVal);
//				printf("Ftl %g\n", yyval.flt_val);
				break;
			case operator:
				printf(Code[idx].text);
				printf(" | ");
				break;
			case openexpr:
			 	printf("Parenth ( | ");
				break;
			case closeexpr:
			 	printf("Parenth ) | ");
				break;
			case opencode:
			 	printf("{ | ");
				break;
			case endcode:
			 	printf("} | ");
				break;
			case separator:
				printf("Sep | ");
				break;
			case semicol:
				printf("Stop | ");
				break;
			default:
				printf("-> other token %d \n");
		}
		}

	}
#endif

	return EXIT_SUCCESS;
}