Parser Logico

// Parser de fonctions booléennes A.Villanueva
#include <iostream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

using namespace std;

//Definitions
//----------------------------------------------------------------------
//----------------------------------------------------------------------
string CreeFonctLogique (string &str);//Récupère l'état logique d'un emplacement de mémoire, réécrit la fonction logique
char NumeroToBoolChar (string &str);//Trouver l'équivalent logique d'un in ou out nnn -> 1 o 0
string EraseSpaces (string &str);//Supprimer les espaces de la chaîne d'entrée
string BoolStandard (string &str);//Changer '*' par '&' et '-' par '!'
bool CharToLogical (char &c);//retourne la valeur booléenne logique equivalente du char
char Inverse (char &c);//Char inverter
string Negation (string &str);//Inverse si devant a ! et élimine les négations
string OperateXOR (string &str);//Opère des opérations XORs d'abord ,avant NOT
string OperateAND (string &str);//Opère des opérations ANDs d'abord ,avant NOT
char OperateOR (string s);//Résoudre l'opération logique OR (uniquement en fonction de OU pas AND)
bool Operate (string &str);//Opere XOR , AND et OR


//Declarations
//----------------------------------------------------------------------
//----------------------------------------------------------------------
string CreeFonctLogique (string &str){//Récupère l'état logique d'un emplacement de mémoire, réécrit la fonction logique
    string alarme;
    string out;
        for ( std::string::iterator it=str.begin(); it!=str.end(); ++it){
            if (isdigit (*it)){alarme+=*it;}
            else {
                out+=NumeroToBoolChar(alarme);//Ecrire l'equivalente logique à l'alarme
                out+=*it;//Ecrire la fonction logique
                alarme.clear();
            }
        }
    out+= NumeroToBoolChar(alarme);//Dernier  ..equivalente logique à l'alarme
    return out;
}
char NumeroToBoolChar (string &str){//Trouver l'équivalent logique d'un in ou out nnn -> 1 o 0
    //Plonge dans strac pour recuperer l'etat logique
    //mod16_dispin mod16_dispout

    //Fake function !!!!
    cout <<"Alarme ="<<str<<endl;
    if ( stoi (str.c_str() ) %2 ){return '1';}

    return '0';
}
//----------------------------------------------------------------------
string EraseSpaces (string &str){//Supprimer les espaces de la chaîne d'entrée
    string out("");
    for ( std::string::iterator it=str.begin(); it!=str.end(); ++it){
        if(*it!=' '){out+=*it;}
    }
return out;
}
//----------------------------------------------------------------------
string BoolStandard (string &str){//Changer '*' par '&' et '-' par '!' 11 1&1..
    char old;
    for ( std::string::iterator it=str.begin(); it!=str.end(); ++it){
        if (isdigit(old) && isdigit(*it)){str.insert(it,1,'&'); }//logiclogic =logic & logic
        if(*it=='*'){*it='&';}
        if(*it=='-'){*it='!';}
        old=*it;
    }

return str;
}
//----------------------------------------------------------------------
bool CharToLogical (char &c){//retourne la valeur booléenne logique equivalente du char
    return (c=='1') ? true :false ;
}
//----------------------------------------------------------------------
char Inverse (char &c){//Char inverter
    return (c == '1' ? '0' : '1');
}
//----------------------------------------------------------------------
string Negation (string &str){//Inverse si devant a ! et élimine les négations
    string out("");
    for ( std::string::iterator it=str.begin(); it!=str.end(); ++it){
        if (*it=='!'){
            it++;
            out+= (*it=='1'? '0':'1');
        }else {out+=*it;}
    }
return out;
}
//----------------------------------------------------------------------
string OperateXOR (string &str){//Opère des opérations XORs d'abord ,avant NOT
    string out ("");
    for ( std::string::iterator it=str.begin(); it!=str.end(); ++it){

        if(*it=='^'){
            ++it;//avance
            if (out.back()==*(it)){ //XOR egal
                out.pop_back();//Efface valeur
                out.push_back('0');
            }else{
                out.pop_back();//Efface valeur
                out.push_back('1');
                }
        }else {out.push_back(*it);}
    }
    return out;
}
//----------------------------------------------------------------------
string OperateAND (string &str){//Opère des opérations ANDs d'abord ,avant NOT
    string out ("");
    for ( std::string::iterator it=str.begin(); it!=str.end(); ++it){

        if(*it=='&'){
            ++it;//avance
            if (out.back()==*(it) && out.back()=='1'){ //AND
                out.pop_back();//Efface valeur
                out.push_back('1');
            }else{
                out.pop_back();//Efface valeur
                out.push_back('0');
                }
        }else {out.push_back(*it);}
    }
    return out;
}
//----------------------------------------------------------------------
char OperateOR (string s){//Résoudre l'opération logique (uniquement en fonction de OU pas AND)
       for (size_t p=0; p<=s.size() ;p++){
            if ( isdigit (s[p]) && s[p]=='1'){return '1';}
        }
    return '0';
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
bool Operate (string &str){//Opere XOR , AND et OR
    string out ("");
    //Process AND & EXOR
    for ( std::string::iterator it=str.begin(); it!=str.end(); ++it){

        if(*it=='&'||*it=='^'){

            ++it;//avance

            if (  out.back()==*(it) &&  ((*(it-1)=='&') ? (out.back()=='1') :true) ){ //AND  EXOR
                out.pop_back();//Efface valeur
                out.push_back(*(it-1)=='&' ? '1':'0');//Select AND or XOR
            }else{
                out.pop_back();//Efface valeur
                out.push_back(*(it-1)=='&' ? '0':'1');//Select AND or XOR
                }
        }else {out.push_back(*it);} //Num


    }
    //Process OR
    for ( std::string::iterator it=out.begin(); it!=out.end(); ++it){
        if(*it=='1'){return true;}//Trouve 1 !
    }
return false;
}

//----------------------------------------------------------------------
//----------------------------------------------------------------------
int main (){
    string Test2="10+56+512^201+48*13";
    string Test ="11-1 ^0^ !1+0+1^   1+-0+1*!0*1";
    string Test3="1";
    string Test4="1^1";

    cout <<"Fonction d'entrée "<< Test<<endl;
    cout <<"Effacer les espaces "<<(Test= EraseSpaces (Test)) << endl;
    cout <<"fonction avec des paramètres logiques standard "<<(Test=BoolStandard (Test))<<endl;
    cout <<"Faire les négations et les éliminer "<<(Test=Negation (Test))<<endl;
    cout <<"Resoudre la  fonction logique en fonction de EXOR AND et OR ="<<Operate(Test)<<endl;

    cout <<"----------------------------------------------------------------------"<<endl;
    cout <<"Fonction d'entrée "<< Test2<<endl;
    cout <<CreeFonctLogique (Test2)<<endl;

    cout <<"----------------------------------------------------------------------"<<endl;
    cout <<CreeFonctLogique (Test3)<<endl;

    cout <<"----------------------------------------------------------------------"<<endl;
    cout <<CreeFonctLogique (Test4)<<endl;
    cout <<" "<<Operate(Test4)<<endl;

return 0;
}