begin process at 2012 05 29 09:56:47
  Trouver un code source :
 
dans
 
[ Dernières recherches ]
Accueil > Forum > 

C

 > 

Base de données

 > 

SQL

 > 

interpreteur sql

Derniers messages déposésPoser une question dans le forum ou lancer une discussion

interpreteur sql

dimanche 16 mai 2010 à 00:36:55 | interpreteur sql

cobutanisme154
bonjours tout le monde,
j'ai cherché sur ce site et sur google ,mais je n'arrive pas à trouver un interpréteur sql écrit en c.Quand je dis un interpréteur je parle d'un programme en c qui est capable de lire une requête sql et de la valider.voici le code que j'ai déjà fait moi même.c'est un peu long mais si vous avez du temps lisez le .
Si vous pouvez m'aider à corriger l'erreur, ou me montrer un autre programme je vous serais trés reconnaissant.
Merci


Code C/C++ :
#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,"("))[code=cpp][code=cpp]
[/code]
{
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();
}


Code C/C++ :
[code=cpp]
[/code][/code]


Cette discussion est classée dans : int, ul, strcmp, if, getlex

Répondre à ce message

Sujets en rapport avec ce message

Table de hachage avec patronyme [ par guitoontruant ] Bonjour, Désolé, j'avais d'abord poster dans les discussions libres.Voilà je dois créer une table de hashage de patronymes par le biais de N entrées, maths et autres [ par jeanphilippe37 ] Slt, j'ai fais un prgm de maths pour savoir les nbrs premiers mais, quand je mets system("pause"), j'ai une erreur, pouvez vous me corriger ? Erreur de segmentation : à cause d'un strcmp() [ par tibs624 ] Tout est dit dans le titre à la compilation aucun problème mais lors de l'exécution de mon programme. Je vous met le code et les explications. Ce code Fuite de mémoire ? Pourquoi ? [ par steph12358 ] Bonjour à tousPour tester un problème rencontré dans une de mes applis j'ai créé une autre petite appli et mis le code suivant exécuté dans un timer.I BLITZ++ [ par ciaonataha ] Salut a tous!!!J'ai besoin d'aide..Qn travaillent avec biblioteque BLITZ++....Je veux recrier ça:for (int t=0; t {  for (int p=0; p     if (T==Tr(t PB de foction (sortie avan la fin de celle ci) [ par malkommalkom ] Bonjour a tous , g un petit probleme:Voila le bout de code conserné  :int Ul()//Sert a envoyer un fichier{ Code pour recup les infos fichiers etc..... Segmentation fault sur un tableau de char [ par MaxSoldier ] Bonsoir tout le monde !Je me suis mis au C/C++ sous linux il y a quelques jours et j'ai de nombreuses erreur de dépassement de tampon (segmentation fa rien ne s'affiche a l'execution(les tubes ordinaires) [ par brekiano ] bonsoir,  svp chui débutant dans la programmation systeme sous unix.j'ai fait ce programme qui affiche normalement le résultats de ce pipes :    ]$ ps analyseur lexical pascal [ par perrotta ] Bonjour, dsl pour ma langue je parle pas bien le français; je suis entrin de devlopper un analyseur lexical pour un programme (pascal) prèci ,et j'ai ce code ne marche pas?????????? [ par banak3181 ] s'il vous plait les gars je veux que quelqu'un me disent pourquoi ce code ne marche sur dev C++:#include #include #include #include # include<myconio.


Nos sponsors


Sondage...

Comparez les prix


Apple iPhone 4 Noir (32 Go)
Entre 1290€ et 1333€

Visiter le guide achat

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir
 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,515 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales
Outils Convertisseur VB/C# Snippets et scripts Outils en ligne La ToolBox
Communauté Programmation Photographie Technologie Newsgroups Emploi Forum Blogs
Guide d'achat Téléphonie mobile Image et son Informatique Bureautique Jeux vidéo
Logiciels Internet & Réseau Développement Market Android Jeux & Loisirs Graphisme Multimédia Sécurité Pilotes
Loisirs Cartes virtuelles Vidéos droles Jeux en ligne Géoguide AndroLib (Android Market)