Compilateur

Bonjour,
je dois faire un compliteur qui gère les équations avec + - / * et ^(puissance)...

J'utilise les tableaux pour mon équations en postfixée...

pour la transformation en postfixée ca marche bien... sauf que quand je dois afficher mes informations, j'ai un problème pour éliminer mes symboles déjà traités...

voici l'énoncé du problème...

http://w3.uqo.ca/jurek/inf4393/d3.pdf

Pouvez vous m'aider???:$:$:$:$

voici mon code sources....

/////////////////////////////////////////////////////////
//But: mettre une équation en post fixée.
//Auteur : Eric Soulard
//Date de création : 14 novembre 2005
//dernière modification :
/////////////////////////////////////

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <string>
#include <ctype.h>

using namespace std;

struct LISTE{
char element;
LISTE *suivant;
};
void AfficherListe(char element[255], int nbElement);
// void SupprimerUnNoeud(char liste[255], int numero_noeud);
char ObtenirUnNoeud(char liste[255], int i );
int LireFichier(char element[255]);
bool EstVide(char liste[255]);
char ObtenirPremierElement(char liste[255]);
void MettreEnPostFixe(char liste[255], char listeOperante[255], int &nbElementPile,
int &nbElementListeOperante, int nbCarLu);
int PrioriteOperateur(char op);
void AfficherResultat(char liste[255]);
void InsererListe(char liste[255], char valeur);
//void Supprimer(char liste[255]);
int LireFichier(void);
void PlacerOperateur(char listeOperante[255], char pile[255], char liste, int &nbElementPile,
int &nbElementListeOperante, char valeur);
int PrioriteOperateur(char op);

//////////////////////////////////////////////////
//But : insérer un nouveau noeud à la fin de la liste.
//paramètre entré : tete la liste des noeuds
// valeur : la valeur à insérer dans la liste
////////////////////////////////////////////

void InsererListe(char liste[255], char valeur){

// LISTE *liste = tete, *nouveau = new LISTE;
//nouveau->element=valeur;
//nouveau->suivant=NULL;

/*for( ; liste->suivant != NULL; liste= liste->suivant);

if ( liste->suivant == NULL)
liste = nouveau;
else{
cerr << "Erreur lors de l'ajout";
exit(1);
}
*/
}

//////////////////////////////////////////////////
//But : supprimer un noeud en particulier dans la liste
//paramètre entré : tete la liste des noeuds
// numero_noeau : le numéro du noeud à enlever
////////////////////////////////////////////

//////////////////////////////////////////////////
//But : lire le fichier
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////

int LireFichier(char element[255]){
ifstream fichier;
//char element;
// LISTE* liste = tete;

fichier.open("donnee.txt", ios::in);
int compteur = 0;
if ( !fichier){
cerr << "Erreur lors de l'ouverture du fichier donnee.txt";
exit(1);
}

//lire le nombre
// si le caractère lu est un nombre
//ajouter le nombre dans le tableau
//sinon afficher le message d'erreur à l'écran
fichier.getline(element,255,'\n');

element[strlen(element)+1]= '\0';

return strlen(element);

}
//////////////////////////////////////////////////
//But : vérifier si la liste est vide ou pas
//paramètre entré : tete la liste des noeuds
//retour : true si la liste est vide
// false si la liste est non vide
////////////////////////////////////////////

bool EstVide(char liste[255]){

return ( liste[0] == 0 );
}

//////////////////////////////////////////////////
//But : obtenir le dernier élément de la liste
//paramètre entré : tete la liste des noeuds
//retour : le caractère du dernier noeud de la liste
////////////////////////////////////////////

char ObtenirDernierElement(char liste[255], int taille){

/* if ( tete == NULL ) return '-';
LISTE *liste = tete, *temp;
char elementListe;

for ( liste ; liste->suivant != NULL ; liste = liste->suivant);

if ( liste->suivant != NULL){
temp = liste->suivant;
liste = liste->suivant;
temp->suivant=NULL;
delete temp;
}else{
delete liste;
}*/

return liste[taille];
}

//////////////////////////////////////////////////
//But : obtenir le premier élément de la liste
//paramètre entré : tete la liste des noeuds
//retour : le caractère du premier noeud de la liste
////////////////////////////////////////////

char ObtenirPremierElement(char liste[255]){

/*LISTE *liste = tete, *temp;
char elementListe;

if ( liste->suivant != NULL){
if ( liste->suivant != NULL){
temp = liste->suivant;
liste->suivant = liste->suivant->suivant;
temp->suivant=NULL;
elementListe = temp->element;
}else{
temp = liste->suivant;
elementListe = temp->element;
temp->suivant=NULL;
}
delete temp;
}
*/

return liste[0];
}

//////////////////////////////////////////////////
//But : mettre l'équation en post fixée
//paramètre entré : tete la liste des noeuds
// pile la pile d'opérateur( +-/*^)
// listeOperante la liste des variables
////////////////////////////////////////////

void MettreEnPostFixe( char pile[255], char listeOperante[255], char tete[255], int &nbElementPile,
int &nbElementListeOperante, int NbValeurLu){

// LISTE* liste = tete;

int compteur = 0, nbLettre = 0,nbOperateur=0;
while(NbValeurLu > compteur){
if ( isalpha(tete[compteur]) == 1 && tete[compteur] != '='){
listeOperante[nbElementListeOperante++] = tete[compteur];
nbLettre++;
//InsererListe(listeOperante, tete[0]);
}else{

PlacerOperateur(listeOperante, pile, tete[compteur], nbElementPile, nbElementListeOperante, NbValeurLu);
nbOperateur++;
nbLettre=nbElementListeOperante;
// (nbElementPile)++;
}
compteur++;
//liste=liste->suivant;
}

/* if ( nbLettre != nbOperateur +1){
cerr << "Le nombre d'élément est invalide..."<<endl;
exit(1);
}
*/ if ( compteur > 5 ) compteur--;
else compteur--;
while(pile[0] != 0){
listeOperante[nbLettre++] = pile[nbElementPile-1];
pile[nbElementPile-1]=0;
nbElementPile--;
// compteur++;
nbElementListeOperante++;

//InsererListe(listeOperante, ObtenirPremierElement(pile));
}
}
//////////////////////////////////////////////////
//But : vérifie si j'ai bien un bon opérateur
//paramètre entré : opérateur à tester
//retour : true si l'élément est bien un opérateur
// false si l'élément n'est pas un opérateur
////////////////////////////////////////////

bool IsValideOperator(char element){

if (element != '+' || element != '-' || element != '/' || element != '*' || element != '^' || element != ';')
return true ;
return false;
}

//////////////////////////////////////////////////
//But : obtenir un élément de la liste
//paramètre entré : tete la liste des noeuds
// i le numéro du noeud
//retour : le caractère du noeud i de la liste
////////////////////////////////////////////

char ObtenirUnNoeud(char liste[255], int i ){

/* LISTE* liste = tete;
int compteur=1;
for( ; liste->suivant != NULL; liste = liste->suivant){

if ( compteur++ == i) return liste->element ;
}
return '-1';*/

return liste[i];
}

//////////////////////////////////////////////////
//But : afficher les informations en langage machine
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////

void Affichage(char liste[255],int nbElement){

// LISTE *liste = tete ;
bool Variable[10];
char arg1, arg2;
int numero_noeud = -1;
bool op ;
int i ,posArg1;
int compteur = 0 ;
int EmplacementRD, EmplacementRA;
for ( i = 0 ; i <10;++i){
Variable[i]=false;
}
//liste = tete;
// InsererListe(liste, '-1');
while(nbElement >= 1){
EmplacementRD =100;
EmplacementRA = 100;
++numero_noeud;
op=false;
/* while ( IsValideOperator(liste->element) == false){
arg1=liste->element ;
liste=liste->suivant ;
arg2 = liste->element ;
liste=liste->suivant ;
}*/
if ( IsValideOperator(liste[numero_noeud]) == true ){
switch(liste[numero_noeud]){
case 43/*'+'*/:
cout << "ADD " ;
op=true;

for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 ) Variable[0] = true;
else Variable[i+1] = true;
if ( numero_noeud == 3 )
arg1= liste[1];
if ( i == 10 && Variable[i-1] == false ){
if( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else EmplacementRD=i;
posArg1 = numero_noeud-2;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( i == 10 ) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
if ( i == 10 ) Variable[0] = true ;
else Variable[i+1] = true ;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
EmplacementRA = i;
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
Variable[i] = true ;
if ( liste[EmplacementRA] == '='){
liste[1] = liste[2];
posArg1 =2;
}
else{
liste[numero_noeud] = liste[nbElement];
posArg1 = EmplacementRA;
}
nbElement--;
Variable[i] = true ;
break;
}
for( i =0 ; i <=9 ; ++i) {
if ( Variable[i] == false) break;

cout <<"R"<<i;
cout << " , "<<"R"<<i<<" "<<arg2<<endl;
posArg1 = numero_noeud;

}
posArg1 = numero_noeud-1;
Variable[i] = true;

for ( i = 0 ; i <=9 ; i++)
if ( Variable[i] == true ) break;
cout <<"R"<<i<<",";
cout <<"R"<<i;
cout << " , "<<arg1 <<endl;
Variable[i] = true ;
break;
case 45/*-'*/:
cout << "SOU " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else EmplacementRD=i;
posArg1 =numero_noeud-2 ;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

if ( EmplacementRD != 100){
if ( i == 10 ) cout << "R0";
else cout <<"R"<<i;
cout << " , R"<<EmplacementRD<<" "<<arg2<<endl;
posArg1 = numero_noeud-1;

}else{
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
}
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
Variable[i] = true;
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;

break;
case 42/*'*'*/:
cout << "MUL " ;
op=true;
for ( i = 0 ; i <=9; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if (liste[numero_noeud+1]== '+' || liste[numero_noeud+1] =='-'
|| liste[numero_noeud+1] == '*' || liste[numero_noeud+1] == '/'
|| liste[numero_noeud+1] == '^'){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}
else
EmplacementRD=i;
}

posArg1 = numero_noeud-2;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
if ( i == 10 ) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
for( i = 0 ; i < 10 ; i++)
if ( Variable[i] == false ) break;
Variable[i] = true ;
//}
break;
case 47 /*'/'*/:
cout << "DIV " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}
EmplacementRD=i;
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if (liste[numero_noeud+1]== '+' || liste[numero_noeud+1] =='-'
|| liste[numero_noeud+1] == '*' || liste[numero_noeud+1] == '/'
|| liste[numero_noeud+1] == '^'){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
EmplacementRD=i;
}
else
EmplacementRD=i;
}

for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( EmplacementRD == 10) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
if ( EmplacementRD == 10) cout <<"R0";
else cout <<"R"<<i;
cout <<", R" << EmplacementRD <<" R"<<EmplacementRA<<endl;
posArg1 = numero_noeud-2;
if (EmplacementRA!=100) Variable[EmplacementRA] = false;
posArg1 = EmplacementRA;
break;
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}

cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
Variable[i] = true;
break;
case 94/*'^'-*/:
cout << "EXP " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ){
break;
}
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
else{
cerr << "Manque de registres."<<endl;
exit(1);
}
}

if ( i == 10 && Variable[i-1] == 0 || IsValideOperator(liste[numero_noeud+1])){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
posArg1 = numero_noeud-2;
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}
EmplacementRD=i;
}else EmplacementRD=i;

for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false || IsValideOperator(liste[numero_noeud+1])){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( EmplacementRD == 10)
cout <<"R0";
else
cout <<"R"<< i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
posArg1 = numero_noeud-2;
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
Variable[i]=true;
if ( EmplacementRD <= 10) cout <<"R"<<i;
else cout <<"R0";
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
Variable[0] = true ;
break;
case 61 /*'='*/:
cout << "AFF " ;
op=true;
if ( (arg1 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
break;
}
cout <<arg1;
cout << " , "<<"R"<<i<<endl;

posArg1 = numero_noeud-1;

break;

};
if ( op == true){
if ( liste[2]!= '+' && liste[2] !='-' && liste[2] != '*' && liste[2] != '/' && liste[2] != '^'&& liste[2] != '=' ){
/*if ( liste[3]!= '+' && liste[3] !='-' && liste[3] != '*' && liste[3] != '/' && liste[3] != '^'&& liste[3] != '='
&& liste[3] != '1'){*/
liste[numero_noeud-2] = '-1';
liste[numero_noeud-1] = '-1';
liste[numero_noeud] = '-1';
/* }else{
liste[numero_noeud-1] = '-1';
if ( liste[numero_noeud+1] != '=')
liste[numero_noeud] = '-1';
}*/
}else{
if ( liste[2] != '=' )
liste[1]=liste[3];
else
liste[1]=liste[2];
posArg1++;
}
for (compteur = posArg1; compteur < nbElement ; compteur ++){
if ( compteur > 3|| posArg1 ==1)
liste[compteur]=liste[compteur+3];
/*else
if ( posArg1 == 1)
liste[compteur+1]=liste[compteur+3];*/
else
liste[compteur]=liste[compteur+1];

}
nbElement-=2;
numero_noeud=-1;
}

}
}

}
//////////////////////////////////////////////////
//But : placer dans la pile au bon endroit l'opérateur(+-...)
//paramètre entré : tete la liste des noeuds
// pile la pile d'opérateur
// valeur : la valeur à ajouter dans la pile
////////////////////////////////////////////

void PlacerOperateur(char listeOperante[255], char pile[255], char liste, int &nbElementPile,
int &nbElementListeOperante, char valeur){

/* LISTE *Lpile = pile;
LISTE *Loperante = listeOperante;
LISTE *nouveau = new LISTE;
nouveau->element=valeur;
nouveau->suivant=NULL;
*/
bool ajout = false;
if ( liste == '('){
pile[nbElementPile++] = liste;
//InsererListe(listeOperante, valeur);
}
if ( liste == ')'){
while(pile[nbElementPile] != '('){
pile[(nbElementPile)++] == liste;
;
//InsererListe(listeOperante, valeur);
// Supprimer(pile);
}

}
while ( !EstVide(pile) && ObtenirPremierElement(pile) != '(' &&
PrioriteOperateur(liste) < PrioriteOperateur( pile[nbElementPile-1] )){
listeOperante[nbElementListeOperante] = pile[nbElementPile-1];
pile[(nbElementPile)] = '-1';
nbElementListeOperante++;
nbElementPile--;
//InsererListe(listeOperante, pile[sizeof(pile)]);
// Supprimer(pile);
pile[(nbElementPile)++]=liste;
ajout = true;
// InsererListe(pile, valeur);
// Supprimer(pile);
}
if ( ajout == false) pile[(nbElementPile)++]=liste;
}

//////////////////////////////////////////////////
//But : affchier le contenu de la liste des noeuds à l'écran
//paramètre entré : tete la liste des noeuds
///////////////////////////////////////////

void AfficherListe(char element[255], int nbElement){

for( int compteur = 0 ;compteur <nbElement ; ++compteur){
cout << element[compteur]<<endl;
}

}
//////////////////////////////////////////////////
//But : supprimer le dernier noeud de la liste de noeud
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////
/*
void Supprimer(LISTE* tete){

LISTE *liste = tete;
LISTE *temp;

for(liste = liste->suivant ; liste->suivant->suivant != NULL ; liste = liste->suivant) ;

temp = liste->suivant->suivant;
liste->suivant = NULL;

delete temp;
}*/

//////////////////////////////////////////////////
//But : obtenir la priorité d'un opérateur
//paramètre entré : op l'opérateur à tester
//retour : entre 0 et 2 si l'opérateur est valide
// -1 dans le cas contraire
////////////////////////////////////////////

int PrioriteOperateur(char op){
if ( op != '+' && op != '-' && op != '/' && op != '*' && op != '^' && op != '=')
return -1;

/*
= priorité 0
+ - priorité 1
* / priorité 2
^ priorité 3
*/

switch ( op){
case 61/*'='*/:return 0;
break;
case 43/*'+'*/:
case 45 /*'-'*/: return 1;
break;
case 47/*'/'*/:
case 42/*'*'*/: return 2;
break;
case 94/*'^'*/: return 3;
break;
};

return -1 ;
}

//////////////////////////////////////////////////
//But : fonction principale
////////////////////////////////////////////

int main(){

char element[255];
char pile[255];
char listeOperante[255];
int nbElementPile = 0;
int nbElementListeOperante = 0;
int nbElementLu = 0;
for (int i = 0 ; i < 255;i++){
element[i]=0;
//listeOperante[i]=0;
//pile[i]=0;
}
/* listeOperante->element='-1';
listeOperante->suivant=NULL;
pile->element='-1';
pile->suivant=NULL;*/
nbElementLu = LireFichier(element);
cout << "Afficher la liste apres lecteure du fichier..."<<endl;
AfficherListe(element,nbElementLu);
MettreEnPostFixe(pile, listeOperante, element,nbElementPile, nbElementListeOperante,nbElementLu);
cout << "Afficher la pile"<<endl;
AfficherListe(pile,nbElementPile);
cout << "Afficher la liste des opérante..."<<endl;
AfficherListe(listeOperante,nbElementListeOperante);
Affichage(listeOperante, nbElementListeOperante);

return 0;
}

voici le contenu du fichier texte...

A=A*B-B^C

merci
mousekey