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



typedef int transition[20][256];
transition T;
typedef char etat[20];
char TMP[80], Lexeme[30], UL[20],Error[256],Mesg[256];
int ptrdeb = 0, ptrfin = 0,ALEC=1; // initialisation des pointeurs et de la variable d'aythorisation de lecture
// prototype des fonctions
int lex();
void getlex(); 
void init(transition *T);
int instr_SQL();
int inster_create();
int mot_cle_table();
int id();
int chaine();
 
int liste_id();
int mot_cle_insert();
int mot_cle_into();
int mot_cle_values();
int list_para();
int list_args();
int ParOpen();
int ParClose();
int Virgule();
int Scolon();
int constant();
int mot_cle_type();


//*****************************************ANALYSE LEXICALE*********************************************************



//AUTOMATE FINI DETERMINISTE
 
int AFD(transition T, etat F){
    int e=0;
    while ( (T[e][TMP[ptrfin]] != -1) && (ptrfin<strlen(TMP)) ){ // les transitions permises sont juste celles kon a permi et on a pas excedé la taille
    
          Lexeme[ptrfin-ptrdeb] = TMP[ptrfin]; // lespace nest po une T donc lexeme reçoit juste un mot
          e = T[e][TMP[ptrfin]]; // e reçoit létat suivant
          ptrfin++;
    }
    Lexeme[ptrfin - ptrdeb] = 0;
    if ( (strchr(F, e) && (e!=0)) ){
       ptrdeb = ptrfin;
       return 1;
    }
    ptrfin = ptrdeb;
    return 0;         
}

//------------------------------initialitation de la transition---------------
void init(transition *T)
{
     int i,j;
     for(i=0;i<20;i++)
     for(j=0;j<256;j++)
     (*T)[i][j]= -1;
}


//----------------------------------fonction pour extraire le mot clé CREATE--------------------
int mot_cle_create()
{ 
   init(&T);//initialiser les états
   
   // en majuscule
   T[0]['C']=1;
   T[1]['R']=2;
   T[2]['E']=3;
   T[3]['A']=4;
   T[4]['T']=5;
   T[5]['E']=6;
    // en minuscule
   T[0]['c']=1;
   T[1]['r']=2;
   T[2]['e']=3;
   T[3]['a']=4;
   T[4]['t']=5;
   T[5]['e']=6;
   
   etat F={6};
   
    if(AFD(T,F))
     { 
       strcpy(UL,"create");//----------unité lexical = mot_cle_create
       return 1;
     }
      return 0;
}

//----------------------------------fonction pour extraire le mot clé table--------------------
int mot_cle_table()
{ 
   init(&T);//initialiser les états
   
   // en majuscule
   T[0]['T']=1;
   T[1]['A']=2;
   T[2]['B']=3;
   T[3]['L']=4;
   T[4]['E']=5;
    // en minuscule
   T[0]['t']=1;
   T[1]['a']=2;
   T[2]['b']=3;
   T[3]['l']=4;
   T[4]['e']=5;
   
   etat F={5};
   
    if(AFD(T,F))
     { 
       strcpy(UL,"table");//----------unité lexical = mot_cle_table
       return 1;
     }
      return 0;
}

//-------------------------- fonction pour extraire les identificateurs --------------------
int id(){
  char c;
  init(&T); //initialiser les états
  
  T[0]['_']=1; 
  T[1]['_']=1;
  for (c='a';c<='z';c++) { 
      T[0][c]=1;T[1][c]=1;
      }
  for (c='A';c<='Z';c++) {
       T[0][c]=1;T[1][c]=1;
       }
  for (c='0';c<='9';c++)    
       T[1][c]=1;
  
  etat F={1};
  
  if (AFD(T,F))
  {
  strcpy (UL,"id");//----------unité lexical = id
  return 1;
  }
return 0;
}
//-------------------------- fonction pour extraire les constantes --------------------
int chaine(){
  char c;
  init(&T); //initialiser les états
  
  T[0]['_']=1; 
  T[1]['_']=1;
  
  for (c='a';c<='z';c++) { 
      T[0][c]=1;T[1][c]=1;
      }
   for (c='A';c<='Z';c++) { 
       T[0][c]=1;T[1][c]=1;
       }
  
  etat F={1};
  
  if (AFD(T,F))
  {
  strcpy (UL,"const");
  return 1;
  }
return 0;
}

int nombre(){
  int n;
  init(&T); //initialiser les états
   for (n='0';n<='9';n++)    
       T[0][n]=1;
  
  etat F={1};
  
  if (AFD(T,F))
  {
  strcpy (UL,"const");
  return 1;
  }
return 0;
}

int constant()
 {
    if(chaine()) return 1;
    if(nombre()) return 1;    
    
 }     



int mot_cle_insert()
{ 
   init(&T);//initialiser les états

   // en majuscule
   T[0]['I']=1;
   T[1]['N']=2;
   T[2]['S']=3;
   T[3]['E']=4;
   T[4]['R']=5;
   T[5]['T']=6;
    // en minuscule
   T[0]['i']=1;
   T[1]['n']=2;
   T[2]['s']=3;
   T[3]['e']=4;
   T[4]['r']=5;
   T[5]['t']=6;
   
    etat F={6};
      
    if(AFD(T,F))
     { 
       strcpy(UL,"insert");
       return 1;
     }
      return 0;
}

int mot_cle_into()
{ 
   init(&T);//initialiser les états
  
   // en majuscule
   T[0]['I']=1;
   T[1]['N']=2;
   T[2]['T']=3;
   T[3]['O']=4;

    // en minuscule
   T[0]['i']=1;
   T[1]['n']=2;
   T[2]['t']=3;
   T[3]['o']=4;

     etat F={4};
   
    if(AFD(T,F))
     { 
       strcpy(UL,"into");
       return 1;
     }
      return 0;
}

int mot_cle_values()
{ 
   init(&T);//initialiser les états
   // en majuscule
   T[0]['V']=1;
   T[1]['A']=2;
   T[2]['L']=3;
   T[3]['U']=4;
   T[4]['E']=5;
   T[5]['S']=6;
    // en minuscule
   T[0]['v']=1;
   T[1]['a']=2;
   T[2]['l']=3;
   T[3]['u']=4;
   T[4]['e']=5;
   T[5]['s']=6;
   
    etat F={6};
    if(AFD(T,F))
     { 
       strcpy(UL,"values");
       return 1;
     }
      return 0;
}

int ParOpen(){
  init(&T); //initialiser les états
  etat F={1};
  T[0]['(']=1; 
  if (AFD(T,F))
  {
  strcpy (UL,"(");
  return 1;
  }
return 0;
}

int ParClose(){
  init(&T); //initialiser les états
  etat F={1};
  T[0][')']=1; 
  if (AFD(T,F))
  {
  strcpy (UL,")");
  return 1;
  }
return 0;
}


int Virgule(){
  init(&T); // //initialiser les états
  etat F={1};
  T[0][',']=1; 
  if (AFD(T,F))
  {
  strcpy (UL,",");
  return 1;
  }
return 0;
}

int mot_cle_type()
{ 
   init(&T);//initialiser les états
   
   // en majuscule
   T[0]['I']=1;
   T[1]['N']=2;
   T[2]['T']=3;
   T[3]['E']=4;
   T[4]['G']=5;
   T[5]['E']=6;
   T[6]['R']=7;
    // en minuscule
   T[0]['i']=1;
   T[1]['n']=2;
   T[2]['t']=3;
   T[3]['e']=4;
   T[4]['g']=5;
   T[5]['e']=6;
   T[6]['r']=7;
   
   T[0]['V']=8;
   T[8]['A']=9;
   T[9]['R']=10;
   T[10]['C']=11;
   T[11]['H']=12;
   T[12]['A']=13;
   T[13]['R']=14;
   
   T[0]['v']=8;
   T[8]['a']=9;
   T[9]['r']=10;
   T[10]['c']=11;
   T[11]['h']=12;
   T[12]['a']=13;
   T[13]['r']=14;
   
   etat F={7,14};
    if(AFD(T,F))
     { 
       strcpy(UL,"type");
       return 1;
     }
      return 0;
}


 
int espace() 
{ 
  init(&T);//initialiser les états
  T[0][' ']=1;
  etat F={1};
  if(AFD(T,F)) 
  {
  return 1;
  }
  return 0;
}

int Scolon(){
  init(&T);//initialiser les états
  etat F={1};
  T[0][';']=1; 
  if(AFD(T,F)) 
  {
  strcpy (UL,";");
  return 1;
  }
return 0;
}

     
//-------------------------verifier type de lexeme trouvé, s'il s'agit d'un espace on l'ignore----------
int lex()
{
    if(mot_cle_create()) return 1;
    if(mot_cle_table()) return 1;     
    if(mot_cle_insert()) return 1; 
    if(mot_cle_into()) return 1;
    if(mot_cle_values()) return 1;
    if(mot_cle_type()) return 1;
    if(id()) return 1; 
    if(ParOpen()) return 1;  
    if(ParClose()) return 1; 
    if(Virgule()) return 1; 
    if(Scolon()) return 1; 
    if(espace()) return lex(); 
    return 0;
}

void getlex()
{
     if(ALEC==1) lex();
     else ALEC=1;
}


//*****************************************ANALYSE SYNTAXIQUE*********************************************************



  


/*-------------------------------------- Grammaire :--------------------------------
  list_args-> (virgule id mot_cle_type)*
  -------Verifier la syntaxe de l'instruction create s'il y a plusieurs id entre les parentheses--------*/
int list_para()// parametres de create est une liste de types avec id
{
    getlex();
    if(!strcmp(UL,","))
    {
       getlex();
       if(!strcmp(UL,"id"))
       {
          getlex();
          if(!strcmp(UL,"type"))
          {
             if(list_para()) return 1;
          }
       }
       return 0;
    }
    ALEC=0;
    return 1;
} 

int list_args()// arguments de insert ou on a une liste de id
{
    getlex();
    if(!strcmp(UL,","))
    {
       getlex();
       if(!strcmp(UL,"id"))
       {
            
             if(list_args()) return 1;
          
       }
       return 0;
    }
    ALEC=0;
    return 1;
} 

int list_const()
{
    getlex();
    if(!strcmp(UL,","))
    {
       getlex();
       if(!strcmp(UL,"const"))
       {
             if(list_const()) return 1;
          
       }
       return 0;
    }
    ALEC=0;
    return 1;
} 

 
//-------------------------------------- Grammaire Create :--------------------------------
   
int instr_create()
{  int i=0;
    getlex();
    if(!strcmp(UL,"create"))
    {
       getlex();
       if(!strcmp(UL,"table"))
       {    printf("%s",UL);
          getlex();
          if(!strcmp(UL,"id"))
          {    printf("%s",UL);
             strcpy(Mesg,UL);
             getlex();
              if(!strcmp(UL,"("))
              {         printf("%s",UL);                   
                 getlex();
                 if(!strcmp(UL,"id"))
                {           printf("%s",UL);    
                    getlex();      
                    if(!strcmp(UL,"type"))
                    {    printf("%s",UL);
                         if(list_para())
                         {    printf("%s",UL);
                             getlex();
                             if(!strcmp(UL,")"))
                             {    printf("%s",UL);
                                getlex();
                                if(!strcmp(UL,";")) 
                                { printf("%s",UL);return 1;}
                                
                             } 
                         }
                                                            
                    
                    }                
                
                }                  
             
             }
          
          }
       
       }
    
    }
    return 0;
    
}

//-------------------------------------- Grammaire Insert:--------------------------------
   
int instr_insert()
{
    getlex();
    if(!strcmp(UL,"insert"))
    {                             
       getlex();
       if(!strcmp(UL,"into"))
       {
            
          getlex();
         if(!strcmp(UL,"id"))
         {  
            getlex();
            if(!strcmp(UL,"("))
          {
           getlex();
          if(!strcmp(UL,"id"))
          {
               if(list_args())
            {
                 
              strcpy(Error,"Erreur syntaxe insert: mot cle VALUES absent");
              getlex();
               if(!strcmp(UL,")"))
          {
              getlex();
              if(!strcmp(UL,"values"))
              {
                 strcpy(Error,"Erreur syntaxe insert: expression absente apres VALUES");
                 getlex();
                 if(!strcmp(UL,"("))
                 {  
                    getlex();  
                    if(!strcmp(UL,"const"))
                    {                                           
                       if(list_const())
                       {
                          getlex();
                          if(!strcmp(UL,")"))
                          {
                              getlex();
                              if(!strcmp(UL,";"))
                              return 1;
                          } 
                        }
                       else// si on a une seule constante
                       { 
                           getlex();
                          if(!strcmp(UL,")"))
                          {
                              getlex();
                              if(!strcmp(UL,";"))
                              return 1;
                          } 
                       
                        }  // fin else const
                        
                        
                       } 
                        
                     }
                    }    
                 }   
              }      // fin plusieurs arguments
              
              
              else // si on a un seul id 
              {
                  getlex();
                  if(!strcmp(UL,")"))
                {
                   getlex();
                   if(!strcmp(UL,"values"))
                   {
                     strcpy(Error,"Erreur syntaxe insert: expression absente apres VALUES");
                     getlex();
                     if(!strcmp(UL,"("))
                     {  
                       getlex();  
                     if(!strcmp(UL,"const"))
                      {                                           
                          if(list_const())
                           {
                            getlex();
                            if(!strcmp(UL,")"))
                             {
                              getlex();
                              if(!strcmp(UL,";"))
                              return 1;
                              } 
                            }
                        else// si on a une seule constante
                          { 
                             getlex();
                            if(!strcmp(UL,")"))
                            {
                              getlex();
                              if(!strcmp(UL,";"))
                              return 1;
                             } 
                           
                          }    //fin d else const
                          
                           
                         }
                        } 
                      }    
                  }   
              }    // fin d else id
                           
            }
           
           }            
          
         }
         strcpy(Error,"veuillez spécifier un nom de table"); 
       }
        //strcpy(Error,"mot cle INTO manquant");
    }
    
    ALEC=0;
    return 0;
}
 


//------------------ Grammaire: instr_SQL()->instr_create() | instr_insert() ------------------
//------------------ Verifier si la chaine saisie equivalent à une instruction sql valide----------
int instr_SQL()
{
    if(instr_create()) return 1;
    else {
         ALEC=0;
         if(instr_insert()) return 1;  
         
         }
      
    return 0;
}










//--------------------------------fonction main ----------------------------------------
int main()
{
    printf("Exécution TD1:Instruction SQL(exemple de create et insert)\n\n\n\n\n\n\n");
    printf("Veillez taper votre requete: \n");      
    //gets(TMP);//lire les caracteres saisi au clavier et les stockés dans TMP
    fgets(TMP,80,stdin);
    ptrdeb=0;ptrfin=0;ALEC=1;
    if(instr_create())
    {
          ptrdeb=0;ptrfin=0;ALEC=1;//intialiation des variables car il sont modifiés par instr_SQL()
          printf("===> La table %s a été créee\n\n",UL[2]);
         
    }

    else printf("===> %s\n\n",Error);                 
    system("pause");
    return 0;
    getch(); 
}