Analyseur lexical pour un compilateur algorithmique

Soyez le premier à donner votre avis sur cette source.

Vue 23 295 fois - Téléchargée 2 339 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

Messages postés
1
Date d'inscription
jeudi 7 janvier 2010
Statut
Membre
Dernière intervention
8 janvier 2010

merci cheriky !
ou est l'analyseur sintaxique?
Messages postés
1
Date d'inscription
samedi 21 mars 2009
Statut
Membre
Dernière intervention
22 mars 2009

salut tout le monde
j aurais besoin d un code source en c pour un analyseur lexicale , un compilateur si possible
merci de m' aider
merci d'avance
Messages postés
240
Date d'inscription
jeudi 9 janvier 2003
Statut
Membre
Dernière intervention
22 mars 2009

EXAR << complètement hors sujet, maintenant si tu veux critiquer les gens qui essais de maitriser au maximum ce qu'ils font va leur dire directement.

EXAR << "Il y a déjà au moins 15 à 20 ans que les entreprises sérieuses se sont mises à autre chose que l'ASM."
laisse moi rire la moitié des boite passe en .net, du langage à la va vite ou le développeur de maitrise rien, et ou après lors d' audits de sécurité on se retrouve avec des applications bourrés de bugs et de failles de sécu (dev de m.).

EXAR << et pour ce qui ai de microsoft sur lequel tu as l'air de cracher dans la soupe et bien c'est encore un des système les plus utilisé et les plus répendu du coté utilisateur. na :p (c'est un pro linux qui code qu'en windows ki dis sa :p)

mohtouati << le principe de ce code est très intéressant (je viens de voir la partie avec le code pascal pas mal, c'est le début d'un projet scolaire ou tu prévois de créer une appli ?

bon codage
Messages postés
286
Date d'inscription
vendredi 5 décembre 2003
Statut
Membre
Dernière intervention
22 avril 2012
1
Mon message n'est apparemment pas passé complet, je parlais de Brunews...
Messages postés
286
Date d'inscription
vendredi 5 décembre 2003
Statut
Membre
Dernière intervention
22 avril 2012
1
mohtouati: pour moi, il semblait qu'il ne s'agissait que d'un analyseur lexical. Donc, je me demande pq on te demande du code c++ ! Il va te taper une foultitude d'assembleur, comme à son habitude. On se demande pq il est admin c++, parce qu'il en connait plus en asm qu'en c++...
Il va te refaire ton projet en trois lignes d'asm, avec un exécutable qui prendra moins d'1 Ko, parce qu'il travaille encore avec un XT des années 80, il te ridiculisera, il va te dire que seul l'ASM sauvera le monde, mais n'en crois rien ! Il y a déjà au moins 15 à 20 ans que les entreprises sérieuses se sont mises à autre chose que l'ASM.
En plus, il fait cela UNIQUEMENT pour Windaube !!!
Peine perdue, c'est un virus !
Mais c'est sans doute pour cela qu'il doit optimiser avec ASM... Son âme a été vendue (pour pas cher) à Microsoft !
Afficher les 10 commentaires

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.