//lexer.h
//22.maj 2202
//Datamatiker, Systemprogrammering C++
//F. Bierlich, N. Grove-Rasmussen, M. Munksgaard, B. Nielsen og N. Nugent

#ifndef _LEXER_H
#define _LEXER_H

#include <stdlib.h>//exit()
#include <stdio.h>//FILE struktur
#include <ctype.h> //isalpha(), isdigit()
#include <fcntl.h>
#include <unistd.h>//_open()
#include <sys/types.h>
#include <sys/stat.h>
#include "symbolTable.h"

/********************************************************************
/*
/*Dette program kan læse et standard HTML-dokument og indsætte
/*et forvalgs-IP-adresse på formen ccc.ccc.ccc.ccc:(portnummer)/
/*de steder i dokumentet hvor følgende linktyper forekommer:
/*
/*      1. <a href="http://server.domænenavn.landekode..."
/*      2. <a href="ftp://domænenavn.landekode..."
/*      3. <a href="server.domænenavn.landekode...!
/*      4. <a href="123.123.123.123"
/*      5.  location.href="...
/*
/*således at f.eks. http://sever.domænenavn.landekode...
/*bliver til;
/*http://ccc.ccc.ccc.ccc:(portnummer)/server.domænenavn.landekode...
/*
/*eller 123.123.123.123
/*bliver til;
/*ccc.ccc.ccc.ccc:(portnummer)/123.123.123.123
/*
/********************************************************************/

//globale variabler
int token;
int bytesCounted;
//Her afsaettes plads til stoerrelsen af et token
const int BSIZE=128;
class lexer
{
private:
        FILE* streamOut;
        int fileHandlerIn;
        char lexbuf[BSIZE];
        int lineno;
        int put_char(int t) {ungetc(t,streamOut); return 0;};
        int get_char(int& t){return t=getc(streamOut);};

public:
        lexer(); //constructor
	~lexer(); //destructor
	
	//erklærer et symbol_table objekt
	//symbol_table symObj;
	//returnerer det token som staar paa plads 'tokenvalue'
	//virker ikke
	//const char*  fetchToken(int tokenvalue) {return symObj.symtable[tokenvalue].get_lex();};
        char* makeTempFile();
        
        //Kaldes fra proxy.cc og tager en 1448 bytes chunk
        //med og sender den i gennem lexan() samt det filnavn
        //som data skal laeses ned i
        void readPageBuffer(char* pBuffer, char* file_name);
        void closeFile();//lukker for FILE *stream
        void error(char *m);
        //Soerger for den leksikalske analyse
        int lexan();
};

lexer::lexer()
{
lineno=0;        
};

lexer::~lexer()
{
  delete lexbuf;
  fclose( streamOut );
  close(fileHandlerIn);
  cout<<"\nLexer Objekt nedlagt\n";

};  

lexer lexObj;
//==================================================================
//                      IMPLEMENTERING                                                                           //
//==================================================================
//opretter en unik filnavn som vi 
//vil skrive det uparsede dokument til
char*lexer::makeTempFile()
{

char* tempFileName;
char* nameBuf;
 nameBuf = new char[L_tmpnam ]; 
 //L_tmpnam er max size defineret i <stdio.h>

//tmpnam() generer et temporert filnavn 
//og anbringer det i roden af drevet /tmp/
//men det er vi ligeglade med, for vi har 
//en FH som peger på filen!!

//det temporere filnavn anbringes i 
//arrayet peget på af nameBuf pointeren
if( ( tempFileName =  tmpnam( nameBuf ) ) == NULL )  
exit(1);
	
return tempFileName;
}
//===================================================================

void lexer::readPageBuffer(char* pBuffer, char* file_name)
{
FILE* streamIn;	//lokal stream pointer
 
//den fysiske fil oprettes (_O_CREAT) og gives skriverettigheder 
//(_O_WRONLY) samt tilknyttes en file handler. 
//Når filehandleren slettes slettes filen også (_O_TEMPORARY ) 
 if((fileHandlerIn = open(file_name, O_CREAT | O_RDWR /*|O_TEMPORARY*/, 0666)) == -1 ) 
		exit(1);					

	//file handleren overlader nu arbejdet til stream pointeren
	//"a+" tilføjer i enden af filen - 
   if( (streamIn = fdopen(fileHandlerIn, "w" )) == NULL )
      exit(1);
   lseek(fileHandlerIn,0,SEEK_END);      

    //her skrives indholdet af pagebufferen til filen
   fprintf(streamIn,"%s", pBuffer);

   //cout<<"\nFil1\n";
   cout<<"\n------------PageBuffer fra lexer------------\n"<<pBuffer<<"\n------------PageBuffer End------------\n"; 

   //den lokale stream pointer lukkes
   fclose(streamIn);	

   //den private attribut streamOut lukker op for læsning af filen
   //"r" tillade kun læsning
   if((streamOut = fopen(file_name, "r" ) ) == NULL )	
  exit(1);
}
//===================================================================
//kaldes som det sidste (fra parse() )og lukker 
//for streamOut og fileHandlerIn
void lexer::closeFile()
{
        //fclose( streamOut );
       // close(fileHandlerIn);
}

//===================================================================

void lexer::error(char *m)
{ fprintf(stderr, "linje %d: %s\n", lineno, m);
        exit(1);}

//===================================================================

int  lexer::lexan()
{
int t;
   while(1)
   {
   //læser det første tegn og tæller op
   get_char(t);bytesCounted++;
   
  //opskriver antal linjer ved linjeskift
  //bruges ved fejlfinding
   if(t=='\n')
   lineno ++;

   if(isdigit(t))
   {
   int q,d=0;

       lexbuf[d++]=t;
        get_char(t);bytesCounted++;

           while(isdigit(t)||t=='.'||t==':')
           {
           lexbuf[d++]=t;
           get_char(t);bytesCounted++;

            if(d>=BSIZE)
            error("compiler error: input max. 128 tegn!");
           }
           lexbuf[d++]=EOS;
           //tilsidst indlæses EOS (end of string)
           //for at afslutte strengen

             if(t!=EOS)      //det tegn som stopper while-løkken
             {put_char(t);//sendes tilbage i strømmen
              bytesCounted--;}


          //her kaldes lookup(), som undersøger om ordet
          //findes i symboltabellen.
          //Hvis ja, får q værdien svarende til pladsen i tabellen
           q = symObj.lookup(lexbuf);

           if(q == 0)//vores IP
           {
           token = q;
           return  symObj.symtable[q].get_tok();
           }
           else //alt andet
           {
           token = symObj.insert(lexbuf,IPID);
           return  IPID;
           }
          }//end while digits

          else if(isalpha(t))
          {
          int p,i,b = 0;

           lexbuf[b++]=t;
           get_char(t);bytesCounted++;

             while(isalnum(t))
             {
             lexbuf[b++]=t;
             get_char(t);bytesCounted++;

           //hvis det indlæste ord er større end 128 tegn
                  if(b>=BSIZE)
                  error("compiler error: input max. 128 tegn!");
             }
             lexbuf[b++]=EOS;

             if(t!=EOS)
             {put_char(t);
              bytesCounted--;}
      
             //her konverteres token til små bogstaver
             //da alle keywords kun er stavet med småt
             //så uanset hvordan token er stavet kan det genkendes
             char lowBuf[BSIZE];
             for(i=0;i<b;i++)
             lowBuf[i]=tolower(lexbuf[i]);

             p = symObj.lookup(lowBuf);
             if(p>=1)
             {
             token = p;
             //returnerer tokentypen svarende til 
             //pladsnummeret for det indsatte tokennavn
             return symObj.symtable[p].get_tok();
             }
             else if(p==-1)
             {
             token = symObj.insert(lexbuf,ID);
             return  ID;
             }
             }
             else if(t == EOF)
             //keyword DONE afslutter parse-funktionen
             return DONE;    

             else
             {
       	//for t lig ';', '|' ,'+',space, ....osv
             token = NONE;
             return t;
             }
           }//end while
};
#endif //_LEXER_H