EVALUER UNE EXPRESSION MATHÉMATIQUE

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<dos.h>
#include<math.h>







typedef struct noeud
{
	char val;
	noeud *suivant;
} noeud;



typedef struct noeud1
{
	long int val;
	noeud1 *suivant;
} noeud1;


#define pile noeud *

#define pile1 noeud1 *

/*dans cette partie, je vais déclarer quelques opérations nécessaires pour manipuler notre pile*/

/*fonction pour ajouter un élément*/
pile1 empiler1 (pile1 pil, long int v);


/*fonction pour supprimer le sommet de la pile*/
pile1 depiler1  (pile1 pil, long int &v);


/*fonction servant à retourner le sommet de la pile uniquement*/
void top1 (pile1 pil, long int &v);

/*fonction pour vider la pile */
pile1 mettreazero1 (pile1 pil);


/*fonction pour vérifier si la pile est vide */
int vide1 (pile1 pil);






/*fonction pour ajouter un élément à la pile */
pile empiler (pile pil, char v);


/*fonction pour supprimer le sommet de la pile*/
pile depiler  (pile pil, char &v);


/*fonction pour retourner le sommet de la pile uniquement*/
void top (pile pil, char &v);

/*fonction pour vider la pile*/
pile mettreazero (pile pil);


/*fonction pour vérifier si la pile est vide */
int vide (pile pil);

/* cette fonction servira à la saisie d'un caractère par caractère et l'empilement en meme temps
*  cette fonction force l'utilisateur à n'accepter que les caractères corrects*/

pile saisie(pile pil)
{
	textcolor(15);
	cprintf("Veuillez saisir votre expression (puis appuyez sur ENTREE) :  ");
	gotoxy(1,3);
	char ch;

	do
	{
		ch=getch();
		if (ch>=48 && ch<=57 || ch>=40 && ch<=43 || ch==37 || ch==45 || ch==47 || ch==91 || ch==93 || ch==94 || ch==123 || ch==125)
		{
			putch(ch);
			pil=empiler(pil,ch);
		}
		else if (ch !=8 && ch !=13)
		{
			sound(400);
			delay(250);
			nosound();
		}
		/*ici, on doit tenir compte de la saisie de l'espace blanc*/
		if (ch==8)
		{	putch(ch);
			putch(' ');
			putch(ch);
			if (!vide(pil))
				pil=depiler(pil,ch);

		}
	}
	/* lorsque l'utilisateur tape sur ENTREE, je dois sortir de la boucle*/
	while (ch!=13);
	return(pil);
}

/* renverser la pile de caractères*/
pile renverser_pil(pile pil)
{
	char c;
	pile temp=NULL;
	while (!vide(pil))
	{
		pil=depiler(pil,c);
		temp=empiler(temp,c);
	}
	return(temp);
}

/* renverser  la pile de type long*/
pile1 renverser_pil1(pile1 pil)
{
	long int c;
	pile1 temp=NULL;
	while (!vide1(pil))
	{
		pil=depiler1(pil,c);
		temp=empiler1(temp,c);
	}
	return(temp);
}

/*fonction pour extraire les nombres saisis et les stoker comme étant des entiers long dans la pile long*/
pile remplirno(pile1 *no,pile pil)
{
	int i,j;
	long int x;
	char ch;

	pile temp=NULL;
	pile tmp_no=NULL;

	do{
		i=0;
		/* incrémenter i tant que le caractère saisi est un chiffre et l'empiler juste après*/
		while (!vide((pil=depiler(pil,ch))) && ch>=48 && ch<=57)
		{
			i++;
			tmp_no=empiler(tmp_no,ch);
		}

		if (i)
		{
			temp=empiler(temp,'N');
			if (!(ch>=48 && ch<=57))
				temp=empiler(temp,ch);
			else
			{
				i++;
				tmp_no=empiler(tmp_no,ch);
			}
			/* convertir le chiffre saisi en long int (note: '0'=48) */
			tmp_no=depiler(tmp_no,ch);
			x=ch-48;
			for (j=1;j<i;j++)
			{
				tmp_no=depiler(tmp_no,ch);
				x=x+(ch-48)*pow(10,j);
			}
			*no=empiler1(*no,x);
		}
		else
		{
			if(ch>=48 && ch<=57)
			{	*no=empiler1(*no,ch-48);
				temp=empiler(temp,'N');
			}
			else
				temp=empiler(temp,ch);
		}
	} while (!vide(pil));
	temp=renverser_pil(temp);
	*no =renverser_pil1(*no);
	return(temp);
}

/* copier la pile de type long */
pile1 copier_pil1(pile1 *src)
{
	pile1 dest=NULL;
	pile1 temp=NULL;

	long int ch;

	while (!vide1(*src))
	{
		*src=depiler1(*src,ch);
		temp=empiler1(temp,ch);
		dest=empiler1(dest,ch);
	}
	temp=renverser_pil1(temp);
	dest=renverser_pil1(dest);
	*src=temp;
	return(dest);
}

/* copier la pile de caractères*/
pile copier_pil(pile *src)
{
	pile dest=NULL;
	pile temp=NULL;

	char ch;

	while (!vide(*src))
	{
		*src=depiler(*src,ch);
		temp=empiler(temp,ch);
		dest=empiler(dest,ch);
	}
	temp=renverser_pil(temp);
	dest=renverser_pil(dest);
	*src=temp;
	return(dest);
}

/* afficher le message d'erreur*/
void erreur(char code)
{
	sound(400);
	delay(400);
	nosound();

	gotoxy(35,12);
	textcolor(4+128);
	cprintf("Erreur syntaxique dans votre expression.");
	gotoxy(35,14);
	switch (code){
	case 0:
			 cprintf(") manquant");
			 break;
	case 1:
			 cprintf("] manquant");
			 break;
	case 2:
			 cprintf("} manquant");
			 break;

	case 3:
			 gotoxy(28,14);
			 cprintf("Operateur sans operande.");
			 break;
	case 4:
			 gotoxy(28,14);
			 cprintf("Operande sans operateur.");
			 break;
	}

}
/* vérifier si la saisie est correcte sinon afficher le message d'erreur avec la fonction erreur précédente
*  il y a un compteur tel que i-- si opérande,i++  si opérateur et i==1 si il n'y a pas d'erreurs de saisie
*  pour les parenthèses, il y a une pile telle que lorsque l'on renctonre celle qui ferment on doit dépiler et on doit
* doit retrouver les parenthèses ouvrantes sinon erreur, et pour les parenthèses de fin la pile doit etre vide sinon erreur*/

int verifiersicorrect(pile *pil)
{
	int compteur=0;
	char ch,br;
	pile parenthese=NULL;
	pile temp=NULL;
	temp=copier_pil(pil);
	while (!vide(temp))
	{
		br=0;
		temp=depiler(temp,ch);
		if (ch=='N')
			compteur++;
		else if (ch==42 || ch==43 || ch==45 || ch==47 || ch==37 || ch==94)
			compteur--;
		else if (ch==41)
		{	if (parenthese)
			{
				parenthese=depiler(parenthese,br);
			}
			if (br!=40)
			{     erreur(0); return(0);}
		}
		else if (ch==93)
		{	if (parenthese)
			{
				parenthese=depiler(parenthese,br);
			}
			if (br!=91)
			{     erreur(1); return(0) ;}
		}
		else if (ch==125)
		{	if (parenthese)
			{
				parenthese=depiler(parenthese,br);
			}
			if (br!=123)
			{     erreur(2);  return(0);}
		}
		else
			parenthese=empiler(parenthese,ch);

	}
	if (!vide(parenthese))
	{	erreur(0);
		gotoxy(35,14);
		parenthese=depiler(parenthese,ch);
		if (ch!=40)
			cprintf("%c manquant",ch+2);
		else
			cprintf("%c manquant",ch+1);
		return(0);
	}

	if (compteur>1)
	{
		erreur(3);
		return(0);
	}
	else if (compteur<1)
	{	erreur(4); return(0);}
	else
		return(1);
}
/* retourner la précédence 1 si ch1 est premier sinon la précédence 0 */
int prioritaire(char ch1,char ch2)
{
	if (ch1==40 && ch2!=40)
		return(0);
	else if (ch1=='^')
		return(1);
	else if ((ch1=='*' || ch1=='/' || ch1=='%') && ch2!='^')
		return(1);
	else if ((ch1=='+' || ch1=='-') && (ch2=='-' || ch2=='+'))
		return(1);
	else if ((ch1=='*' || ch1=='/' || ch2=='%') && (ch2=='/' || ch2=='*' || ch2=='%'))
		return(1);
	else
		return(0);
}

/*fonction pour convertir l'expression saisie en expression postfixée*/

pile postfixe(pile pil)
{
		pile temp=NULL;
		pile oprnd=NULL;
		char ch,ch2;
		while (!vide(pil))
		{
		 pil=depiler(pil,ch);
		 ch2=0;
		 if (ch=='N')
		temp=empiler(temp,ch);
		 else if (ch==42 || ch==43 || ch==45 || ch==47 || ch==37 || ch==94)
		 {
		if (!vide(oprnd))
		{	top(oprnd,ch2);
			while (prioritaire(ch2,ch) && !vide(oprnd))
			{
				oprnd=depiler(oprnd,ch2);
				temp=empiler(temp,ch2);
				if (!vide(oprnd))
					top(oprnd,ch2);
			}
		}
		oprnd=empiler(oprnd,ch);
		 }
		 else if (ch==41 || ch==93 || ch ==125)
		 {
		do{
			if (!vide(oprnd))
				oprnd=depiler(oprnd,ch2);
			if (ch2!=40)
				temp=empiler(temp,ch2);
		}
		while (ch2!=40);
		 }
		 else
		oprnd=empiler(oprnd,40);

		}

		while (!vide(oprnd))
		{
		oprnd=depiler(oprnd,ch);
		temp=empiler(temp,ch);
		}
		temp=renverser_pil(temp);
		return(temp);
}

/* fonctions mathématiques pour : + - * / % et ^ */
long int ajouter(long int x,long int y)
{
	return(x+y);
}

long int dif(long int x,long int y)
{
	return(x-y);
}

long int mul(long int x,long int y)
{
	return(x*y);
}

long int div(long int x,long int y)
{

	if (y!=0)
		return(x/y);
}

long int mod(long int x,long int y)
{
	return(x%y);
}

/* évaluation  de notr eexpression postfixée après convertion */
void evaluation(pile *pil,pile1 *no)
{
	pile1 nos=NULL;
	long int x,y,z;
	char ch;
	while(!vide(*pil))
	{
		*pil=depiler(*pil,ch);
		if (ch=='N')
		{
			*no=depiler1(*no,x);
			nos=empiler1(nos,x);
		}
		else
		{
			nos=depiler1(nos,y);
			nos=depiler1(nos,x);

			switch (ch){
			case '+':
				z=ajouter(x,y);
				break;
			case '-':
				z=dif(x,y);
				break;
			case '*':
				z=mul(x,y);
				break;

			case '/':
				if (y==0)
				{
					 textcolor(4+128);
					 gotoxy(12,35);
					 cprintf("Division par zero !");
					 sound(500);
					 delay(400);
					 nosound();
					 return;
				}
				z=div(x,y);
				break;
			case '^':
				z=pow(x,y);
				break;

			case '%':
				z=mod(x,y);
				break;
			}
			nos=empiler1(nos,z);
		}
	}
	gotoxy(10,23);
	textcolor(2);
	nos=depiler1(nos,z);
	cprintf("Resultat = %li",z);

}
/**********************************************************************************************/
/**********************************************************************************************/
/*                                début de notre programme principal                                                        */
/**********************************************************************************************/
/**********************************************************************************************/
int main(void)
{
	textmode(3);
	_setcursortype(_NOCURSOR);

	clrscr();
	textcolor(15);
	gotoxy(5,2);
	cprintf("Evaluation des expressions arithmetiques.");
	gotoxy(10,4);
	cprintf("www.begueradj.com");

	textcolor(2);
	gotoxy(1,10);
	cprintf("Prise en compte de : (^ puissance) (% modulo) et (* / - +) avec precedence ^ puis * / % puis + -");
	gotoxy(1,25);
	textcolor(129);
	cprintf("Appuyez sur n\'importe quelle touche pour continuer ...");
	getch();

	pile input=NULL;
	pile1 num=NULL;

	pile tmp_in=NULL;
	pile1 tmp_no=NULL;

	do{
		clrscr();

		input=saisie(input);
		if (input)
		{	input=renverser_pil(input);

			input=remplirno(&num,input);
			if (verifiersicorrect(&input))
			{

				input=postfixe(input);

				/* copier la pile pour que l'on puisse l'afficher*/
				tmp_in=copier_pil(&input);
				tmp_no=copier_pil1(&num);

				gotoxy(2,18);
				cprintf("Postfixe:");
				char c;
				gotoxy(5,19);
				while (!vide(tmp_in))
				{
					tmp_in=depiler(tmp_in,c);
					cprintf("%c",c);

				}
				gotoxy(2,20);
				cprintf("Valeurs:");
				long int cc;
				gotoxy(5,21);
				while (!vide1(tmp_no))
				{
					tmp_no=depiler1(tmp_no,cc);
					cprintf("%li ",cc);


				}


				evaluation(&input,&num);
			}
		}

		gotoxy(1,25);
		textcolor(129);
		cprintf("Appuyez sur n\'importe quelle touche pour continuer, Esc pour terminer.");

		input=mettreazero(input);
		num=mettreazero1(num);
	}while ((getch())!=27);



	return(0);
}
/**********************************************************************************************/
/**********************************************************************************************/
/*                                           fin du programme principal                                                             */
/**********************************************************************************************/
/**********************************************************************************************/


/**********************************************************************************************/
/*implémentation des différentes fonctions et procédures déclarées là haut*/
/**********************************************************************************************/
pile empiler (pile pil, char v)
{
	pile temp;

	temp=(pile)malloc(sizeof(noeud));
	if (temp !=NULL)
	{	temp->val=v;

		temp->suivant=pil;
	}
	else
	{
		printf("\nDebordement.");
		exit(1);
	}
	return(temp);

}


pile depiler (pile pil, char &v)
{
	pile temp;

	if (pil==NULL)
	{
		printf("\nPile vide.");
		exit(1);
	}
	else
	{
		v=pil->val;

		temp=pil;

		pil=pil->suivant;

		free(temp);

	}
	return(pil);
}



void top (pile pil, char &v)
{
	if (pil==NULL)
	{
		printf("\nPile vide.");
		exit(1);
	}
	else
		v=pil->val;

}


pile mettreazero (pile pil)
{

	pile temp;

	while (pil != NULL)
	{
		temp=pil;

		pil=pil->suivant;

		free(temp);
	}
	return(NULL);

}

int vide (pile pil)
{
	if (pil==NULL)
		return(1);
	else
		return(0);
}



pile1 empiler1 (pile1 pil, long int v)
{
	pile1 temp;

	temp=(pile1)malloc(sizeof(noeud1));
	if (temp !=NULL)
	{	temp->val=v;

		temp->suivant=pil;
	}
	else
	{
		printf("\nDebordement.");
		exit(1);
	}
	return(temp);

}


pile1 depiler1 (pile1 pil, long int &v)
{
	pile1 temp;

	if (pil==NULL)
	{
		printf("\nPile vide.");
		exit(1);
	}
	else
	{
		v=pil->val;

		temp=pil;

		pil=pil->suivant;

		free(temp);

	}
	return(pil);
}



void top1 (pile1 pil, long int &v)
{
	if (pil==NULL)
	{
		printf("\nPile vide.");
		exit(1);
	}
	else
		v=pil->val;

}


pile1 mettreazero1 (pile1 pil)
{

	pile1 temp;

	while (pil != NULL)
	{
		temp=pil;

		pil=pil->suivant;

		free(temp);
	}
	return(NULL);

}

int vide1 (pile1 pil)
{
	if (pil==NULL)
		return(1);
	else
		return(0);
}