#include "scanner.h"
#include <iostream>
using namespace std;

#define TOKEN_LEN 100
unsigned int LineNo;
static FILE *InFile;
static char TokenBuffer[TOKEN_LEN];

extern int InitScanner(const char *FileName)
{   LineNo = 1;
    InFile = fopen(FileName,"r");
	if(InFile != NULL)    return 1;
	else     return 0;
}


extern void CloseScanner(void)
{   if(InFile != NULL)
        fclose(InFile);
}


static char GetChar(void)
{   int Char = getc(InFile);
        return toupper(Char);
}

static void BackChar(char Char)
{  if(Char != EOF)  
         ungetc(Char,InFile);
}


static void AddCharTokenString(char Char)
{   int TokenLength = strlen(TokenBuffer);
    if(TokenLength+1 >= sizeof(TokenBuffer))
		return;
    TokenBuffer[TokenLength] = Char;
	TokenBuffer[TokenLength+1] = '\0';
}


static void EmptyTokenString()
{   memset(TokenBuffer,0,TOKEN_LEN);  }


static Token JudgeKeyToken(const char * IDString)
{   
    for (int i=0; i < sizeof(TokenTab)/sizeof(TokenTab[0]); i++)
	{  if(strcmp(TokenTab[i].lexeme,IDString) == 0)
	           return TokenTab[i];
	}
	Token errortoken;
	memset(&errortoken,0,sizeof(Token));
	errortoken.type = ERRTOKEN;
	return errortoken;
}


extern Token GetToken(void)
{  Token token;
   int Char;
   memset(&token,0,sizeof(Token));
   EmptyTokenString();
   token.lexeme = TokenBuffer;
   for(;;)
   {  Char = GetChar();
      if(Char == EOF)
	  {   token.type = NONTOKEN;
	      return token;
	  }
	  if(Char == '\n')    LineNo++;
	  if(!isspace(Char))    break;
   }
   AddCharTokenString(Char);

   if(isalpha(Char))
   {   while(1)
   {   Char = GetChar();
       if(isalnum(Char))   
		   AddCharTokenString(Char);
	   else    break;
   }
     BackChar(Char);
	 token = JudgeKeyToken(TokenBuffer);
	 token.lexeme = TokenBuffer;
	 return token;
   }

   else if(isdigit(Char))
   {   while(1)
   {   Char = GetChar();
       if(isdigit(Char))    AddCharTokenString(Char);
	      else   break;
   }
   if(Char == '.')
   {  AddCharTokenString(Char);
       while(1)
	   {  Char = GetChar();
	      if(isdigit(Char))
			  AddCharTokenString(Char);
		  else    break;
	   }
   }
   BackChar(Char);
   token.type = CONST_ID;
   token.value = atof(TokenBuffer);
   return token;
   }

   else
   {   switch(Char)
   {    case';':  token.type = SEMICO;  break;
        case'(':  token.type = L_BRACKET; break;
		case')':  token.type = R_BRACKET;  break;
		case',':  token.type = COMMA;   break;
		case'+':  token.type = PLUS;    break;
		case'-':
			Char = GetChar();
			if(Char == '-')
			{   while(Char != '\n' && Char != EOF)
			         Char = GetChar();
			    BackChar(Char);
			    return GetToken();
			}
			else
			{  BackChar(Char);
			   token.type = MINUS;
			   break;
			}
		case'/':
			Char = GetChar();
			if(Char == '/')
			{    while(Char != '\n' && Char != EOF)
			          Char = GetChar();
			     BackChar(Char);
			     return GetToken();
			}
             	else
			{  BackChar(Char);
			   token.type = DIV;
			   break;
			}
		case'*':
            Char = GetChar();
			if(Char == '*')
			{    token.type = POWER;
			     break;
			}
             	else
			{  BackChar(Char);
			   token.type = MUL;
			   break;
			}
		default: token.type = ERRTOKEN;  break;
   }
   }

   return token;
}



void main()
{  Token token; 
   char *argv;
   argv = "text.txt";
   if(!InitScanner(argv))
   {  cout << "Open Source File Error!" << endl;
      return;
   }
   cout << "記號類別          字符串          常數值          函數指針" << endl;
   while(1)
   {   token = GetToken();
       if(token.type != NONTOKEN)
		   cout << token.type << "          " << token.lexeme << "          " << token.value << "          " << token.FuncPtr << endl;
	   else
		   break;
   };
   cout << "_______________________________________________________________" << endl;
   CloseScanner();
}