ANALYSEUR LEXICAL POUR UN COMPILATEUR ALGORITHMIQUE

#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();


}

Télécharger le zip

24 juillet 2008 22:04:28 :

lexical pas syntaxique exusé

24 juillet 2008 22:12:33 :

modification d'un commentaire

24 juillet 2008 22:25:32 :

le est cours de développement pour prévoir une éventuelle lecture en fichier.algo