Analyseur lexical pour un compilateur algorithmique

Soyez le premier à donner votre avis sur cette source.

Vue 21 157 fois - Téléchargée 2 115 fois

Description

Ce programme fait une analyse lexical pour un compilateur algorithmique il détecte les erreurs lexical est toute les unités lexicales fixés au début.

Source / Exemple :


#include<stdio.h>
#include<math.h>
#include<string.h>
#include <conio.h>
#include<stdlib.h>
#include<dos.h>
int i,j,l,x;
char code[1000][20];
char typ[1000];

int tc;/////////////////////ti pour se deplacer dans la table code/////////
int err=1;
///////////////////////////les fonction de l'analyseur syntaxique /////////
void algo();
void declaration();
void type();
void instruction();
void inst();
void instaffectation();

//////////////////////////////////////////////////////////////////la fonction pour l'analyse lexical
int f(char sy)
{
int s;
if(sy >= 'a' && sy <= 'z')
	{
	 s=0;
	}
	else
	{
	if(sy >= '0' && sy <= '9')
		{
		s=1;
		}
		else
		{
		if(sy=='.')
		{s =2;}
		else
		s=-1;
		}

	}

 return s;
}
/////////////////////////////////////////////////////le programme principale  ///////////////////////////////////////////
main()
{

int v,ec,ind,u;          //''ind'' pour l'indice dans le tableau syntaxique
char tc;
v=0;
 int	mat[10][10];
 mat[0][0]= 1;
 mat[0][1]= 2;
 mat[0][2]= -1;

 mat[1][0]= 1;
 mat[1][1]= 1;
 mat[1][2]= -1;

 mat[2][0]= -1;
 mat[2][1]= 2;
 mat[2][2]= 3;

 mat[3][0]= -1;
 mat[3][1]= 4;
 mat[3][2]= -1;

 mat[4][0]= -1;

 mat[4][1]= 4;
 mat[4][2]= -1;

char cs[1000],c1[20],c2[10],c3[10];
char p;
char  motres[][20]= {"si", "tantque","fair","fait","pour","sinon","alors","var","reel","entier","char","algorithme","debut","fin"};
char opr[][20]= {"+","*","-","/","et","ou","non","<","<=",">",">=",":=","<>"};
char separ[][20]={";"," "};

gets(cs);
//printf("%d",strlen(cs));
printf("\n");
c1[0]='#';
strncat(cs,c1,1);
//printf("%d",strlen(cs));
printf("\n");

 ind=0;

i=0;

while(cs[i]!='#')
	 {
		  //getch();
				while((f(cs[i])==-1)&&(cs[i]!='#'))
					{

					if(cs [i]=='+')
					{
					printf("\n\n");
					printf("+ est un opérateur\n\n");
					typ[ind]='o';
					code[ind][0]='+';
					ind=ind+1;
					}

					if(cs [i]=='*')
					{
					printf("\n\n");
					printf("* est un opérateur\n\n");
					typ[ind]='o';
					code[ind][0]='*';
					ind++;
					}

					if(cs [i]=='/')
					{
					printf("\n\n");
					printf("/ est un opérateur\n\n");
					typ[ind]='o';
					code[ind][0]='/';
					ind++;
					}
					if(cs [i]=='-')
					{
					printf("\n\n");
					printf("- est un opérateur\n\n");
					typ[ind]='o';
					code[ind][0]='-';
					ind++;
					}

					if(cs [i]=='<')
					{
						if(cs [i+1]=='=')
							{
								printf("\n\n");
								printf("<= est un opérateur\n\n");
								typ[ind]='o';
								code[ind][0]='<';
								code[ind][1]='=';
								ind++;
								i++;
							}
						if(cs [i+1]=='>')
							{
								printf("\n\n");
								printf("<> est un opérateur\n\n");
								typ[ind]='o';
								code[ind][0]='<';
								code[ind][1]='>';
								ind++;
								i++;
							}
						else
							{
								printf("< est un opérateur\n\n");
								typ[ind]='o';
								code[ind][0]='<';
								ind++;
							}
					}

					if((cs [i]=='>'))
						{
							if(cs [i+1]=='=')
								{
									printf(">= est un opérateur\n\n");
									typ[ind]='o';
									code[ind][0]='>';
									code[ind][1]='=';
									ind++;
									i++;
								}
							else
								{
									printf("> est un opérateur\n\n");
									typ[ind]='o';
									code[ind][0]='>';
									ind++;
								}
					}

					if((cs [i]==':')&&(cs [i+1]=='='))
						{
							printf(":= est un opérateur\n\n");
							typ[ind]='o';
							code[ind][0]=':';
							code[ind][1]='=';
							ind++;
							i++;
						}
					if(cs [i]==';')
						{
							printf("; est un separateur\n\n");
							typ[ind]='s';
							code[ind][0]=';';
							ind++;
						}

						i++;
					}
				  //	getch();
				j=i;
				while((f(cs[j])!=-1))
					j++;

					////////////////////////extraction de la chaine a analysé//////////////////////////

						 //for(u=0;u<20;u++) //pour ecraser la c1
						 // c1[u]=' ';

						 l=i;
						 while((l<=j)&&cs[l]!='#')
						 {
						 p=cs[l];
						 c1[l-i]=p;
						  l++;
						 }
							u=0;
						 c1[j-i]='#';
						  while(c1[u]!='#')
						  {
							code[ind][u]=c1[u];
							u++;
							}
						 //ind=ind+1;

					 //getch();
					 /*printf("\n");
					 printf("c1 =%s",c1);
					 printf("\n\n");
					 printf("code%d=",ind-2,code[ind-2]);
					 printf("\n\n");
					 printf("code%d =%s",ind-1,code[ind-1]);
					 printf("\n");
					 //printf("%s",cs);*/

			  ////////////////// analyse de la chaine cs(i.j-1)////////////////////////////////

	  if(c1[0]=='#')
	  v=10;

			  ////////////////////le traitement avec les tableau /////////////////////////////

	  if (v==0)
	  {
	  x=0;
	  while(c1[x]!='#')
	  {
	  x++;
	  }
	 // printf("%d",x);
				 for(l=0;l<=13;l++)
					{
					 if(strlen(motres[l])==x)
					 {
					 if(strncmp(c1,motres[l],x)==0)     //strlen(motres[l])
					 {v=1;}
					 }
					}
					 //printf("%d",v);

					  x=0;
					  while(c1[x]!='#')
					  {
					  x++;
					  }
					 if(v==0)
					 {
						 for(l=0;l<=11;l++)
							{   if(strlen(opr[l])==x)
							{
								if(strncmp(c1,opr[l],strlen(opr[l]))==0)
								 v=2;
								 }
							}
					  }

		 }
	  ///////////////////////////////le traitement avec l'autoamte//////////////////
	  if(v==0)
	  {

				l=0;
				tc=c1 [l];
				ec=0;

				while((ec!=-1)&&(tc!='#'))
						 {
								l++;
								ec=mat[ec][f(tc)];
								tc=c1 [l];
						 }

				if(ec==1)
						{
							printf("\n");
							v=3;
							//printf("c'est un identificateur");
						}
						else
						{
							if(ec==2)
								{
									printf("\n");
									v=4;
									//printf("c'ent une constante entière ");
								}
								else
								{
									if(ec==4)
										{
											printf("\n");
											v=5;
										  //	printf("c'ent une constante réelle ");
										}
										else
										{
											printf("\n");
											v=6;
										  //	printf("erreur lexicale");
										}

								}
						}
		  }

		  //printf("\n");printf("\n");printf("\n");printf("\n");
		  //printf("j=%d",j);
		  //printf("\n");printf("\n");
		  //printf("cs[j]=%c",cs[j]);
			printf("\n");
			printf("\n");
			 l=0;
			 while(c1[l]!='#')
			 {
			  printf("%c",c1[l]);
			  l++;
				//getch();
			  }
			  printf("\n");
					 if(v==1)
						{
						printf("c'est un mot réservé");
						typ[ind]='m';
						ind++;
						printf("\n");
						}
					 if(v==2)
						{
						 printf("c'est un operateur");
						 typ[ind]='o';
						 ind++;
						 printf("\n");
						}
					  if(v==3)
						  {
							printf("c'est un identificateur");
							typ[ind]='i';
							ind++;
							 printf("\n");
						  }
					  if(v==4)
						 {
						 printf("c'ent une constante entière ");
						 typ[ind]='e';
						 ind++;
						 printf("\n");
						 }
					  if(v==5)
						 {
							printf("c'ent une constante réelle ");
							typ[ind]='r';
							ind++;
							printf("\n");
						 }
					  if(v==6)
						{
						printf("erreur lexicale");
						typ[ind]='#';
						 ind++;
						printf("\n");
						}
			 v=0;

		  i=j;
	 }

	 /***  le tableau typ contien les types des unité lexicale assosier au meme
		  emlasement que dans la table code:

		  e ----> entier
		  r----->reelle
		  i----->identificateur
		  m----->mot réservé
		  o----->operateur
		  s----->separateur
		  #----->erreur lexicale

      • /
///////////////////////////fin de l'analyse lexical///////////////////////////////////////////////////////////////////// printf("\n\n"); printf("les unités lexicales a traité dans l'analyseur syntaxique"); printf("\n\n"); //printf("%s",code [0]); for(u=0;u<ind;u++) { printf(" %s",code[u]); printf("\n"); } ///////////////////////////////////debut de l'analyse syntaxique////////////////////////////////// getch(); }

Conclusion :


Ce programme donne une idée général sur les technique algorithmique traduit en langage c

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Cyberboy2054
Messages postés
173
Date d'inscription
jeudi 20 décembre 2001
Statut
Membre
Dernière intervention
22 août 2008
-
Tu peux mettre un exemple de code que ton programme execute stp ?
Ca a l'air bien excellent ce truc mais pour le moment on peut pas tester...
cs_exar
Messages postés
287
Date d'inscription
vendredi 5 décembre 2003
Statut
Membre
Dernière intervention
22 avril 2012
1 -
Tu ne sauras rien exécuter, il ne fait pour l'instant que l'analyse lexicale !
Je n'ai pas essayé, mais ça a l'air correct (du point de vue fonctionnement).
Petite amélioration (enfin, tu en fais ce que tu veux): mets des switch / case à la place de ifs, ainsi, une fois qu'il a trouvé ce qu'il cherche, il ne doit plus tester...
mohtouati
Messages postés
6
Date d'inscription
vendredi 16 mai 2008
Statut
Membre
Dernière intervention
26 juillet 2008
-
C’est exact ce que a dit exar pour les modifs de switch case c’est tout à fait vrai mais il ya encor d’autre modifs pour l’optimisé merci pour votre consultation et remarques
Cyberboy2054
Messages postés
173
Date d'inscription
jeudi 20 décembre 2001
Statut
Membre
Dernière intervention
22 août 2008
-
Ha ok (j'y connais rien)
Ca correspond à quoi du coup l'analyse lexicale ? Transformer un string en liste de token, ou egalement vérifier que par exemple apres un token "if " on a bien un token ouverture parenthese, du code, puis fermer parenthese ?

Ca sert à quoi de programmer un analyseur lexicale seul, à part vérifier si un code est bien conforme à certaines règles (une expression régulière par gex?)
mohtouati
Messages postés
6
Date d'inscription
vendredi 16 mai 2008
Statut
Membre
Dernière intervention
26 juillet 2008
-
Un analyseur lexical fait partie des structures de base lors de la construction d'un compilateur c'est pour séparer les unités lexicales également reconnaitre les erreurs lexical par exemple:
« algorithme»appartiens au langage il le reconnait comme un mot réservé mais « algorithm »n'appartiens pas au langage donc c'est une erreur lexical
Sa répond a votre question Cyberboy2054 ?

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.