CALCULETTE (PEUT ÊTRE GRAPHIQUE UN JOURS ^^)

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<stdlib.h>
#include<math.h>

#define _XOPEN_SOURCE 600   /* or #define _ISOC99_SOURCE */
#define maxP 1024 //maximum de parentheses externes d'un calcul.
#define MAX 2048
#define MAXarg 1024


typedef struct noeud {	
	char  node;
	char fct[4]; // pour pouvoir distinguer facilement les fonctions, comme sinus, des signes.
	struct noeud *  parent;
	struct noeud *  filsG;
	struct noeud *  filsD;
	double val;
	char sVal;
	float exposant;

} noeud;


noeud * arbre(char *chaine, noeud * parent);
void afficher_arbre ( noeud * root);
double calculer( noeud *root);
void ajouter_lettre(char * chaine, char lettre); //décale la chaine et ajoute la lettre au debut.
void repere_fonctions(char * chaine);
int par(char*chaine);//retourne l'indice dans la chaine de la parenthese qui ferme la premiere (toujours le premier caractere.)
void signe_implicite(char * chaine); // corrige les '*' implicites devant les parentheses
char * enleveParenthese(char *chaine);



/** ***********************//** ***********************//** *********//** ***********************/
noeud * creerNoeud(noeud * parents)
{
	noeud * nNoeud=malloc(sizeof(noeud));
	nNoeud->filsD=NULL;
	nNoeud->filsG=NULL;
	nNoeud->val=0;
	nNoeud->node='\0';
	nNoeud->sVal='\0';
	//nNoeud->fct[0]='\0';
	//printf("noeud cree.\n");
	nNoeud->parent=parents;
	if(parents!=NULL)
	{
		if(parents->filsG!=NULL)
		{
			if(parents->filsD!=NULL)
			{
			printf("NULL Il y a un noeud qui est fiere de sa virilite... il voudrais un troisieme fils :D \n");
			return NULL;
			}
		    	parents->filsD=nNoeud;
		    	//printf("noeudD cree.\n");
			return nNoeud;
		}
		parents->filsG=nNoeud;
		//printf("noeudG cree.\n");
		return nNoeud;
	}
	else 
    //printf("root cree.\n");	
	return nNoeud;
}

/** ***********************//** ***********************//** ***********************//** ***********************//** ***********************//** ***********************/









int chx[MAXarg]={0};

int main(){
	
	chx[0]=0;chx[2]=1;/*
	printf("choisisez l'affichage(mettre 1 pour oui( 0 pour on) dans l'ordre):\n\t'0'=>commentaires\n\t'1'=>commentaires complementaire\n\t'2'=>utile pour le debogage(conseille)\n\t'3'=>pour le debogage le reste en vrac (deconseille :D)" );
	scanf("%d%d%d%d",&chx[0],&chx[1],&chx[2],&chx[3]);*/
	noeud * root=NULL;
	char chaine[MAX];
	//chaine=malloc(sizeof(chaine)+1);
	printf("coucou, entre ton calcul.\n");
	scanf("%s",chaine);
	root=arbre(chaine,root);
	
	printf("afficher arbre:\n");
	afficher_arbre (root);
	printf("\nle resultat est %f\n",calculer(root));
	printf("\n");
    return 0;
}

noeud * arbre(char *chaine,noeud *parent){
	char *chaineG;
	char *chaineD;
	noeud * root;
	float f1=0;
	

	root = creerNoeud(parent);
	int i;
	printf("la chaine est :%s\n",chaine);
if(chx[0]==1){printf("\t\t=======initialisation=========");}
	chaine=enleveParenthese(chaine); 
	repere_fonctions(chaine); // met des parentheses au tour des fonctions definies et des parametres 
	signe_implicite(chaine); // corrige les '*' implicites devant les parentheses
if(chx[2]==1){	printf("chaine avec tous les signes et les parentheses en extra:%s\n",chaine);}
	chaine=enleveParenthese(chaine);  // protege des cas type (((1+2)))
if(chx[3]==1){	printf("chaine les parentheses aux extremitees:%s\n",chaine);}

                            /**  décomposer la chaine en "S1 signe S2 " */

/** étape 1 : mise en boite des parentheses.*/
if(chx[0]==1){printf("\t\t=================mise en boite des parentheses==============\n");}
	int  cpt=0, par[maxP],j=0; //dans le tableau par on met les addresses (dans la chaine "chaine",as les pointeurs) des premieres parentheses externes 
	
	for (i=0;(chaine[i]!='\0');i++)
	{
		if (chaine[i]=='(')
		{
			
			if (cpt==0)
			{
				par[j]=i;
				j++;
			}
			cpt++;
		}
		
		if (chaine[i]==')')
		{
			cpt--;
			if (cpt==0)
			{
				par[j]=i;
				j++;
			}
		}
	
	}
	if(j%2!=0)
	{printf("il y a une erreur dans les parentheses.\n");return NULL;}

if(chx[0]==1){printf("\t\t=================fait==============\n");}

	/** étape 2 définition des critaires d'arret de la récurtion . */
if(chx[0]==1){printf("\t\t=================criteres d'arret de la recursion==============\n");}
	/** repere si il ne reste plus qu'un flotant */ //(la méthode n'est pas très elegante mais nous n'arrivons pas a utiliser strtof)
	char suite;
	suite='\0';
	int lect=0;
	lect=sscanf(chaine,"%f%c",&f1,&suite);
	if ((suite=='\0')&(lect>=1))
	{
		sscanf(chaine,"%f",&f1);
		printf("c'est un flotant flotant:%f\n\n",f1);
		root->val=f1;
		return root;
	}
	/**  */
if(chx[1]==1){printf("\t\t== c'est pas un flotant==\n");}



	/** repere si il ne reste plus qu'une fonction */
	//printf("strlen(chaine)%d   par[1]+1=%d  isalpha(chaine[0])=%d  isalpha(chaine[1])=%d  \n",strlen(chaine),par[1]+1,isalpha(chaine[0]),isalpha(chaine[1]));
	i=1;	
	 if ((j==2)&(strlen(chaine)== par[1]+1)&(isalpha(chaine[0])>0)&(isalpha(chaine[1])>0)) //si il n'y a plus qu'e 2 parentheses externes et qu'elles se terminent a la fin de la chaine.
	{
	//printf(" chaine+3 :%s",chaine+3);
	switch (chaine[1])
		{
			case'i': //sinus
			strcpy(root->fct,"sin");
			root->filsG= arbre(chaine+3,root);
			break;
			case 'o': //cosinus
			strcpy(root->fct,"cos");
			root->filsG= arbre(chaine+3,root);
			break;
			case 'a': //tan
			strcpy(root->fct,"tan");
			root->filsG= arbre(chaine+3,root);
			break;


			case 's': //arcsinus
			strcpy(root->fct,"asin");
			root->filsG= arbre(chaine+4,root);
			break;
			case 'c': //acosinus
			strcpy(root->fct,"cos");
			root->filsG= arbre(chaine+4,root);
			break;
			case 't': //atan
			strcpy(root->fct,"tan");
			root->filsG= arbre(chaine+4,root);
			break;

			case 'x': //exp
			strcpy(root->fct,"exp");
			root->filsG= arbre(chaine+3,root);
			break;

			default:
			printf("default\n");
		}
	root->parent= parent;
	printf("la fonction est %s\n\n",root->fct);
	return root;
	}
if(chx[1]==1){printf("\t\t== c'est pas une fonction connue==\n");}
	/**  */

/** repere si il ne reste plus qu'un parametre */
	char param='\0';
	sscanf(chaine,"%c",&param);
	if ((param <'a')||(param>'z')){param='\0';}
	if ((chaine[1]=='\0')&(param != '\0'))
	{
		printf("\nle parametre est:%c (=%d);chaine[0]=%c\n\n",param,param,chaine[0]);
		root->sVal=chaine[0];
		return root;
	}
if(chx[1]==1){printf("\t\t== c'est pas un parametre==\n");}
	/**  */


/** repere si il ne reste plus qu'une chaine avec un exposant. Dans un premier temps l'exposant devras etre un flotant, pourras etre élargis a un parametre *
// pour cette version un format est a respecter pour que l'exposant sois bien lu: si c'est un flotatn il faut le mettre entre parentheses.le flotant après lui sans parentheses.
printf("expo\n");
float exp;
for(i=0;i maxP ;i++ )
{
	if ((chaine[(par[i]+1)]=='^')&(j==2))
	{
		sscanf(chaine+par[1]+1,"%f",&exp);
		root-exposant=exp;
	}
printf("f-expo");
}
printf("f-expo\n");
printf("\t\t== c'est pas unun exposant==\n");
**  */

if(chx[1]==1){printf("\t\t== en fait il n'y a pas lieux de s'arreter==\n");}
if(chx[0]==1){printf("\t\t== fait==\n");}

/** étape 3 décomposition de la chaine autour du signe du noeud */
/** on trouve le signe a mettre dans le noeud: c'est le signe le moins prioritaire dans le calcul  */
if(chx[0]==1){printf("\t\t============on trouve le signe a mettre dans le noeud===============\n");}
	int iS=0;	
	int k=0;
	char signe[3];


	for (i=0;chaine[i]!='\0';i++)
	{
		if(i== par[k])
		{
		//printf("(...)");
		i=par[k+1]+1;
		k+=2;
		}/** on ne regarde pas ce qu'il y a dans les parentheses. **/	
		//printf("%c",chaine[i]);
		if ((chaine[i]=='+')&(iS==0))
		{
			iS=i;
			signe[0]=chaine[i];
		}
		
	}


if(chx[1]==1){printf("\t\t============si iS=0 il n'y a pas de signe '+'ou'-' (iS=%d)  ===============\n",iS);}	
	for (i=0;chaine[i]!='\0';i++)
	{
		if((i== par[k])&(par[k]!=par[k+1]))
		{
// 		printf("(...)");
		i=par[k+1]+1;
		k+=2;
		}/** on ne regarde pas ce qu'il y a dans les parentheses. **/	
// 		printf("%c",chaine[i]);
		if (((chaine[i]=='*')||(chaine[i]=='/'))&(iS==0))
		{
			iS=i;
			signe[0]=chaine[i];
		}
		
	}


if(chx[0]==1){printf("\t\t============fait===============\n");}







/** test  */
if(iS==0){printf("\nerrrrrooooooooooooorrrrrrrrrrrrrrrrrrrr\n");}
/** test  */


/**  on coupe notre chaine en 2 autour du signe et on applique la récurtion */
if(chx[0]==1){printf("\t\t=====on coupe la chaine en 2, a droite et a gauche du signe et on aplique la recurtion======\n");}
		chaineD=(chaine+iS+1);
		strncpy(chaineG,chaine,strlen(chaine)-strlen(chaineD)-1);
		chaineG[strlen(chaine)-strlen(chaineD)-1]='\0';
		/** ****************************/
		if(chx[2]==1){printf("chaineG:'%s'\n",chaineG);}
		if(chx[2]==1){printf("noeud:%c\n",signe[0]);}
		if(chx[2]==1){printf("chaineD:'%s'\n\n",chaineD);}
		/** ****************************/
		root->node= signe[0];
		root->filsG=arbre(chaineG,root);
		root->filsD=arbre(chaineD,root);
		root->parent= parent;
if(chx[1]==1){printf("\t\t=====fait on retourne la racine======\n");}
		return root;
}

void afficher_arbre ( noeud *root)
{	
	
	if (root->filsG==NULL && root->filsD==NULL){
		if(root->val==0)
		{
			printf("%c",root->sVal);
		}
		else
		{
			printf("%f",root->val); // seul les noeuds sans fils ont des valeures en flotant
		}
	}
	else if ((root->filsG!=NULL)&(root->filsD!=NULL))
	{// si le fils gauche n'est pas NULL  il n'as pas de valeur, et a apriori un filsG et un filsD

	printf("(");
	afficher_arbre ( root->filsG );

	printf("%c",root->node);
	
	afficher_arbre ( root->filsD );
	printf(")");
	}

	else if ((root->filsG!=NULL)&(root->filsD==NULL))// on est dans le cas d'une fonction;
	{
		printf("%s(",root->fct);
		afficher_arbre( root->filsG );
		printf(")");
	}

	else if (root ==NULL){ 	printf("haaaaaaaaa");}//si il n'y a pas de fils droit il me semble que c'est impossible, mais dans le doute.. 
	else {printf("errorrrrrre");} // tous les autres cas.
}



double tabascii[127]={0};// déclaré en globale pour memoriser les parametres


double calculer( noeud *root)
{
if(chx[3]==1){printf("\n le parametre sVal :%c\n",root->sVal);}
	if((root->sVal >= 'a')&( root->sVal <= 'z'))
	{
		if (tabascii[root->sVal]==0)
		{
			printf("\nentrez une valeur pour le parametre :%c\n",root->sVal);
			scanf("%lf",&tabascii[root->sVal]);
			return tabascii[(root->sVal)];
		}
		else
		{
			return tabascii[(root->sVal)];
		}
	}
	if(root->fct!='\0')
	{
		switch (root->fct[1])
		{
			case 'i':
			return sin(calculer(root->filsG));
			case 'o':
			return cos(calculer(root->filsG));
			case 'a':
			return tan(calculer(root->filsG));
			case 't':
			return atan(calculer(root->filsG));
			case 's':
			return asin(calculer(root->filsG));
			case 'c':
			return acos(calculer(root->filsG));
			case 'x':
			return exp(calculer(root->filsG));
		}

	}

	if (root->val!=0.)
		return root->val;

	else
	switch (root->node)
	{
		
		case '+':
		return calculer(root->filsG) + calculer(root->filsD);
		break;
		case '-':
		return calculer(root->filsG) - calculer(root->filsD);
		break;
		case '*':
		return calculer(root->filsG) * calculer(root->filsD);
		break;
		case '/':
		return calculer(root->filsG) / calculer(root->filsD);
		break;
		default:
	
		printf("\nerreur opérateur de calcul inconu\nun signe ecris deux fois? ");
		//printf("\n le parametre sVal :%c\n",root->sVal);
		return 0.;
	
		
	}
	return 0;
}




void ajouter_lettre(char * chaine, char lettre)
{
	char temp[2048];
	strcpy(temp, chaine);
	chaine[0]=lettre;
	strcpy(chaine+1,temp);
	
}




void signe_implicite(char * chaine) // corrige les '*' implicites devant les parentheses et remplace -5 par +-5 et 5-(123+4) par 5+-1*(123+4)
{
	int i=0;
	for (i=0; chaine[i]!='\0';i++)
	{
		if(chaine[i+1]=='(')
		{
			if ((chaine[i]!='+')&(chaine[i]!='-')&(chaine[i]!='*')&(chaine[i]!='/'))
			{
				if(isalpha(chaine[i-1])&isalpha(chaine[i-2]))
				{}
				else
				{
					ajouter_lettre(chaine+i+1,'*');
				}
			}

			if ((chaine[i]=='-')& (((chaine[i-1]!='+')&(chaine[i-1]!='*')&(chaine[i-1]!='/'))||(i==0)))
			{
				if (i==0)
				{
					printf("la chaine est :%s\n",chaine);
					ajouter_lettre(chaine+i+1,'*');	
					ajouter_lettre(chaine+i+1,'1');

				}
				else
				{
					printf("la chaine est :%s\n",chaine);
					scanf("%*c");
					ajouter_lettre(chaine+i,'+');
					ajouter_lettre(chaine+i+2,'*');	
					ajouter_lettre(chaine+i+2,'1');
				}
			}
		}
		
		if ((chaine[i]=='-')&(isdigit(chaine[i+1])>0)&(i>0)& ((chaine[i-1]!='+')&(chaine[i-1]!='*')&(chaine[i-1]!='/')))
		{
			ajouter_lettre(chaine+i,'+');
			i++;
		}
		
	} 
}






char * enleveParenthese(char *chaine)// cette fonction est recursive et permet d'enlever plusieurs parentheses inutiles,dont sont si friand ces etres humains, sans erreur.
{
	int i;

	int  cpt=0, par[maxP],j=0; //dans le tableau par on met les addresses (dans la chaine "chaine",as les pointeurs) des premieres parentheses externes 
	
	for (i=0;(chaine[i]!='\0');i++)
	{
		if (chaine[i]=='(')
		{
			
			if (cpt==0)
			{
				par[j]=i;
				j++;
			}
			cpt++;
		}
		
		if (chaine[i]==')')
		{
			cpt--;
			if (cpt==0)
			{
				par[j]=i;
				j++;
			}
		}
	
	}
	if(j%2!=0)
	{printf("il y a une erreur dans les parentheses.\n");return NULL;}

	if ((j==2)&(chaine[0]=='(')&(chaine[strlen(chaine)-1]==')')) // si il n'y a que 2 parentheses , sont elles aux extrémitées?, si oui, on les enleve.
	{
	chaine++;
	chaine[strlen(chaine)-1]='\0';
	j+=-2;
	if(chx[2]==1){printf("chaine sans parentheses : %s \n",chaine);}
	return enleveParenthese(chaine);
	}

	return chaine;

}


void repere_fonctions(char * chaine) // met des parentheses au tour des fonctions definies et des parametres 
{
	int i,k;
	
	for (i=0;chaine[i]!='\0';i++)
	{
		if (isalpha(chaine[i])>0)
		{
			//printf("chaine[i+1]=%c i=%d chaine[i-1]=%c\n ",chaine[i+1],i,chaine[i-1]);
			switch (chaine[i])
			{
				case 'a'://soit on a affaire au parametre "a" soit c'est a la fonction asin ou acos ....
					if(((chaine[i+1]=='s')||(chaine[i+1]=='c')||(chaine[i+1]=='t'))&(par(chaine+i+4)+1!=')'))//pour alleger le code on estime que la probabilitée que ca ne sois pas un arcsinus ,arcosinus et arctangente est faible.
					{
						if ((chaine[i-1]!='(')||(i==0))
						{
							ajouter_lettre(chaine+i,'(');	
							k=par(chaine+i+4);	
							ajouter_lettre(chaine+i+k+4,')');
							i+=4;
						}
						else
						{
							i+=4;
						}
					}
					else if(((chaine[i-1]!='(')||(i==0))&(chaine[i+1]!=')')) 
					{
						ajouter_lettre(chaine+i,'(');
						ajouter_lettre(chaine+i+2,')');	
					}
				break;


				case 'c':
					if((chaine[i+1]=='o'))//pour alleger le code on estime que la probabilitée que ca ne sois pas un cosinus est faible.
					{
						if((chaine[i-1]!='(')||(i==0))
						{
							ajouter_lettre(chaine+i,'(');	
							k=par(chaine+i+3);	
							ajouter_lettre(chaine+i+k+3,')');
							i+=4;
						}
						else 
						i+=4;
					}
					else if(((chaine[i-1]!='(')||(i==0))&(chaine[i+1]!=')')) 
					{
						ajouter_lettre(chaine+i,'(');
						ajouter_lettre(chaine+i+2,')');	
					}
				break;




				case 's':
					printf("\navant, la chaine sinus est :%s  chaine[i-1]:%c\n",chaine,chaine[i-1]);
					if((chaine[i+1]=='i'))//pour alleger le code on estime que la probabilitée que ca ne sois pas un sinus est faible.
					{
						if((chaine[i-1]!='(')||(i==0))
						{
							ajouter_lettre(chaine+i,'(');	
							k=par(chaine+i+3);
							ajouter_lettre(chaine+i+k+3,')');
							i+=4;
						}
						else
						i+=4;

					}
					else if(((chaine[i-1]!='(')||(i==0))&(chaine[i+1]!=')')&(chaine[i+1]!='i')) 
					{
						ajouter_lettre(chaine+i,'(');
						ajouter_lettre(chaine+i+2,')');	
					}
				break;




				case 't':
					if((chaine[i+1]=='a'))//pour alleger le code on estime que la probabilitée que ca ne sois pas un cosinus est faible.
					{
						if ((chaine[i-1]!='(')||(i==0))
						{
							ajouter_lettre(chaine+i,'(');	
							k=par(chaine+i+3);
							ajouter_lettre(chaine+i+k+3,')');
							i+=4;
						}
						else
						i+=4;
					}
					else if(((chaine[i-1]!='(')||(i==0))&(chaine[i+1]!=')')) 
					{
						ajouter_lettre(chaine+i,'(');
						ajouter_lettre(chaine+i+2,')');	
					}
				break;



				case 'e':
					if(chaine[i+1]=='x')//pour alleger le code on estime que la probabilitée que ca ne sois pas un cosinus est faible.
					{
						if((chaine[i-1]!='(')||(i==0))
						{
							ajouter_lettre(chaine+i,'(');	
							k=par(chaine+i+3);
							ajouter_lettre(chaine+i+k+3,')');
							i+=4;
						}
						else
						i+=4;
					}
					else if(((chaine[i-1]!='(')||(i==0))&(chaine[i+1]!=')')) 
					{
						ajouter_lettre(chaine+i,'(');
						ajouter_lettre(chaine+i+2,')');	
					}
				break;


				case 'b':case 'd':case 'f':case 'g':case 'h':case 'i':case 'j':case 'k':case 'l':case 'm':case 'n':case 'o':case 'p':case 'q':case 'r':case 'u':case 'v':case 'w':case 'x':case 'y':case 'z':
					if(((chaine[i-1]!='(')||(i==0))&(chaine[i+1]!=')')) 
					{
						ajouter_lettre(chaine+i,'(');
						ajouter_lettre(chaine+i+2,')');	
					}
				break;
			}
		}
	}
}

int par(char *chaine)//retourne l'indice dans la chaine de la parenthese qui ferme la premiere (toujours le premier caractere.)
{
	int i,cpt=0;
	for (i=0;(chaine[i]!='\0');i++)
	{
		if (chaine[i]=='(')
		{
			cpt++;
		}
		
		if (chaine[i]==')')
		{
			cpt--;
			if (cpt==0)
			{
				return i;
			}
		}
	}
return 0;

}