Програмирование упращения логических выражений

#include <iostream>
using namespace std;
struct node{
    node *l,*r;
    char val;
    node(node *ll,node *rr,char c):l(ll),r(rr),val(c){}
};
void print(node *t,int n)
{
    if (t)
    {
        print(t->r,n+1);
        for (int i=0;i<n;i++) cout << "  ";
        cout << t->val << '\n';
        print(t->l,n+1);
    }
}
void del(node *&t)
{
    if (t)
    {
        del(t->r);
        del(t->l);
        delete t;
    }
 
}
char lookahead;
int amount_of_errors=0;
void match(char c)
{
    if (lookahead==c) {
        cin.get(lookahead);
        while(lookahead==' ' || lookahead=='\t')
            scin.get(lookahead);
    } else {
        cout << "\nsyntax error in " << lookahead << '\n';
        amount_of_errors++;
    }
}
node *scan()
{
    while(lookahead==' '||lookahead=='\t')cin.get(lookahead);
    if (isalpha(lookahead)||isdigit(lookahead))return new node(0,0,lookahead);
    else
    {
        cout << "\nsyntax error in " << lookahead << '\n';
        amount_of_errors++;
        return 0;
    }
}
node *expr();
node *factor()
{
    if (lookahead=='(')
    {
        match('('); node *t=expr(); match(')');
        return t;
    }
    else
    {
        node *t = scan();
        match(lookahead);
        return t;
    }
}
node *prim();
node *prim1()
{
    if (lookahead=='&') {
        match('&'); return prim();
    } else {}
}
node *prim()
{
    node *t1=factor();
    if (lookahead=='&') {
        char c=lookahead;
        node *t2=prim1();
        return new node(t1,t2,c);
    } else return t1;
}
node *expr1()
{
    if (lookahead=='|') {
        match('|'); return expr();
    } else {}
}
node *expr()
{
    node *t1=prim();
    if (lookahead=='|') {
        char c=lookahead;
        node *t2=expr1();
        return new node(t1,t2,c);
    } else return t1;
}
int main()
{
    node *root=0;
    match(lookahead);
    root=expr();
    if (amount_of_errors) {
        cout << "error\n";
    } else {
        print(root,0);
    }
    del(root);
    return 0;
}

bool is_idempotent(node *t)
{
    if (t != NULL) {
        if (t->l != NULL and t->r != NULL) {
            return t->r->val == t->l->val;
        } else return false;
    }
    return false;
}

void simplification_idempotency(node *&t)
{
     node *tmp = t->r; // или t = t->l; без разницы в данном случае.
     delete t->l;
     delete t;
     t = tmp;
}

void simplification(node *&t)
{
     if (t != NULL) {
         simplification(t->r);
         simplification(t->l);
         if (is_idempotent(t)) 
             simplification_idempotency(t);
         // тут могут быть другие проверки и упрощения
     }
}

//////////////////////////////////////////////////////////////////////////////////////
//НЕ(A*B) - первый закон де моргана (ввел например человек в программу - да что угодно, 
//просто в этом случае оно очень легко раскрывается)
//ответ программы: НЕ A + НЕ B
//Таблица истинности для данного выражения:
//X Y F
//0 0 = 1
//0 1 = 1
//1 0 = 1
//1 1 = 0
//////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <valarray>
#include <vector>
//////////////////////////////////////////////////////////////////////////////////////
typedef std::string          T_str;
typedef std::vector<T_str>   T_user_var_names;
typedef std::valarray<bool>  T_truth_table;
typedef std::vector<T_str>   T_resultant_expressions;
//////////////////////////////////////////////////////////////////////////////////////
class  T_log_calculator
{
    static const size_t  LOG_VARIABLES_TOTAL               = 2;
    static const size_t  TRUTH_TABLE_SIZE                  = 4;
    static const size_t  BIN_LOG_FUNCTIONS_TOTAL_QUANTITY  = 16;
    //--------------------------------------------------------------------------------        
    T_resultant_expressions  resultant_expressions_;    
    T_user_var_names         user_var_names_;
    //--------------------------------------------------------------------------------
public:
    //Строковые константы:
    const T_str   AND;
    const T_str   EQ;
    const T_str   FALSE;
 
    const T_str   GR;
    const T_str   GR_EQ;
    const T_str   L_EQ;
 
    const T_str   LEFT_BR;
    const T_str   LESS;
    const T_str   NOT;
 
    const T_str   OR;
    const T_str   RIGHT_BR;
    const T_str   TRUE;
 
    T_str         X;
    const T_str   XOR;
    T_str         Y;
    //--------------------------------------------------------------------------------
    T_log_calculator();
    void   print_prompt             ();
    bool   input_and_calc_log_expr  ();
    //--------------------------------------------------------------------------------
private:
    void   remove_spaces               (T_str&                s);
    bool   calc_expr                   (T_str&          s, T_truth_table&  truth_table);
    void   print_res                   (const T_truth_table&  truth_table);
    bool   calc_for_xor                (T_str&          s, T_truth_table&  truth_table);
 
    bool   calc_for_xor_tail           (T_str&          s, T_truth_table&  truth_table);
    bool   calc_xor_for_xor            (T_str&          s, T_truth_table&  truth_table);
    
    bool   calc_xor                    (T_str&          s);    
    bool   calculate                   (T_str&          s, T_truth_table&  truth_table);
    bool   calc_for_eq                 (T_str&          s, T_truth_table&  truth_table);
 
    bool   calc_for_eq_tail            (T_str&          s, T_truth_table&  truth_table);
    bool   calc_for_comparison         (T_str&          s, T_truth_table&  truth_table);
 
    bool   calc_for_comparison_tail    (T_str&          s, T_truth_table&  truth_table);
    bool   calc_less_for_comparison    (T_str&          s, T_truth_table&  truth_table);
    bool   calc_less                   (T_str&          s);
    bool   calc_less_eq                (T_str&          s);
    bool   calc_greater                (T_str&          s);
    bool   calc_greater_eq             (T_str&          s);
    bool   calc_eq                     (T_str&          s);
    bool   calc_plus                   (T_str&          s);
    bool   calc_asterisk               (T_str&          s);
 
    bool   calc_less_eq_for_comparison (T_str&          s, T_truth_table&  truth_table);
    bool   calc_greater_for_comparison (T_str&          s, T_truth_table&  truth_table);
    bool   calc_greater_eq_for_comparison (T_str&          s, T_truth_table&  truth_table);
 
    void   fill_expr_res_str           ();    
    T_str  make_str
        (
            T_str s1 = T_str(),
            T_str s2 = T_str(),
            T_str s3 = T_str(),
            T_str s4 = T_str(),
            T_str s5 = T_str(),
            T_str s6 = T_str()
        );    
    
    T_str  get_resultant_expr          (const T_truth_table&  truth_table);
 
    T_truth_table 
           get_truth_table_X           ();
 
    T_truth_table 
           get_truth_table_Y           ();
 
    T_truth_table 
           get_truth_table_from_ind    (int  ind);
 
    bool   calc_substr                 (T_str&          s,    const T_str     substr);
    bool   calc_eq_for_eq              (T_str&          s,    T_truth_table&  truth_table);
    bool   calc_summand                (T_str&          s,    T_truth_table&  truth_table);
 
    bool   calc_summands_tail          (T_str&          s,    T_truth_table&  truth_table);
    bool   calc_add_summand            (T_str&          s,    T_truth_table&  truth_table);
 
    size_t  get_ind_from_truth_table   (const T_truth_table&  truth_table);
    bool   calc_factor                 (T_str&          s,    T_truth_table&  truth_table);
 
    bool   calc_factors_tail           (T_str&          s,    T_truth_table&  truth_table);
    bool   calc_mult_to_factor         (T_str&          s,    T_truth_table&  truth_table);
 
    bool   calc_var_name               (T_str&          s,    T_truth_table&  truth_table);
    bool   calc_0_const                (T_str&          s,    T_truth_table&  truth_table);
    bool   calc_1_const                (T_str&          s,    T_truth_table&  truth_table);
    bool   calc_not_val                (T_str&          s,    T_truth_table&  truth_table);
    bool   calc_exp_in_brackets        (T_str&          s,    T_truth_table&  truth_table);
    bool   calc_not                    (T_str&          s);
    bool   calc_left_bracket           (T_str&          s);
    bool   calc_right_bracket          (T_str&          s);
};
//////////////////////////////////////////////////////////////////////////////////////
T_log_calculator::T_log_calculator()
    : AND       ("*"), 
      EQ        ("=="), 
      FALSE     ("0"),
 
      GR        (">"), 
      GR_EQ     (">="), 
      L_EQ      ("<="), 
 
      LEFT_BR   ("("), 
      LESS      ("<"), 
      NOT       ("!"), 
 
      OR        ("+"),
      RIGHT_BR  (")"), 
      TRUE      ("1"), 
 
      X         ("x"), 
      XOR       ("^"), 
      Y         ("y")       
{}
//////////////////////////////////////////////////////////////////////////////////////
void  T_log_calculator::remove_spaces(T_str&  s)
{
    std::istringstream  ssin(s);
    std::ostringstream  sout;
    T_str  s_cur;
    while(ssin >> s_cur)
    {                                   
        sout << s_cur;
    }
    s = sout.str();
}
//////////////////////////////////////////////////////////////////////////////////////
void  T_log_calculator::print_res(const T_truth_table&  truth_table_res)
{
    int     sp_count       = 3;
    T_str   stand_space    = T_str(sp_count, ' ');
    T_str   space_after_X  = T_str(X.size() + sp_count - 1, ' ');    
    T_str   space_after_Y  = T_str(Y.size() + sp_count - 2, ' ') + T_str(" = ");
    T_str   resultant_expr = get_resultant_expr(truth_table_res);
 
    size_t  line_size      =   X              .size() 
                             + Y              .size() 
                             + resultant_expr .size() 
                             + stand_space    .size() * 2;
 
    T_str  line = T_str(line_size, '-');
 
    std::cout << std::endl
              << stand_space
              << "Таблица истинности:"
              << std::endl
              << stand_space
              << line
              << std::endl
              << stand_space              
              << X
              << stand_space
              << Y              
              << stand_space
              << resultant_expr
              << std::endl
              << stand_space
              << line
              << std::endl;
              
    T_truth_table  truth_table_X  (get_truth_table_X  ());
    T_truth_table  truth_table_Y  (get_truth_table_Y  ());
 
    for(size_t  i = 0; i < TRUTH_TABLE_SIZE; ++i)
    {
        std::cout << stand_space
                  << truth_table_X[i]                  
                  << space_after_X
                  << truth_table_Y[i]
                  << space_after_Y
                  << truth_table_res[i]
                  << std::endl;    
    }
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_expr(T_str&  s, T_truth_table&  truth_table)
{
    return    calc_for_xor       (s, truth_table)
           && calc_for_xor_tail  (s, truth_table);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_for_xor_tail
    (
        T_str&          s, 
        T_truth_table&  truth_table
    )
{
    return    !calc_xor             (s)
           ||    calc_xor_for_xor   (s, truth_table)
              && calc_for_xor_tail  (s, truth_table);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_for_xor
    (
        T_str&          s, 
        T_truth_table&  truth_table
    )
{
    return    calc_for_eq       (s, truth_table)
           && calc_for_eq_tail  (s, truth_table);                     
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calculate
    (
        T_str&          s, 
        T_truth_table&  truth_table_res
    )
{
    return    calc_expr(s, truth_table_res)    
           && s.empty();
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_xor(T_str&  s)
{
    return  calc_substr(s, XOR);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_for_eq_tail
    (
        T_str&          s, 
        T_truth_table&  truth_table
    )
{
    return    !calc_eq             (s)
           ||    calc_eq_for_eq    (s, truth_table)
              && calc_for_eq_tail  (s, truth_table);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_for_eq           
    (
        T_str&          s, 
        T_truth_table&  truth_table
    )
{
    return    calc_for_comparison       (s, truth_table)
           && calc_for_comparison_tail  (s, truth_table);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_substr(T_str&  s, const T_str  substr)
{
    bool  res = (s.find(substr) == 0);
    if(res)
    {        
        s.erase(0, substr.size());
    }
    return res;    
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_eq(T_str&  s)
{
    return  calc_substr(s, EQ);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_for_comparison  
    (
        T_str&          s, 
        T_truth_table&  truth_table
    )
{
    return    calc_summand        (s, truth_table)
           && calc_summands_tail  (s, truth_table);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_summands_tail   
    (
        T_str&          s,    
        T_truth_table&  truth_table
    )
{
    return    !calc_plus             (s)
           || calc_add_summand       (s, truth_table)
              && calc_summands_tail  (s, truth_table);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_summand         
    (
        T_str&          s,      
        T_truth_table&  truth_table
    )
{
    return    calc_factor        (s, truth_table)
           && calc_factors_tail  (s, truth_table);                     
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_factors_tail     
    (
        T_str&          s,    
        T_truth_table&  truth_table
    )
{
    return    !calc_asterisk          (s)
           ||    calc_mult_to_factor  (s, truth_table)
              && calc_factors_tail    (s, truth_table);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_factor           
    (
        T_str&          s,    
        T_truth_table&  truth_table
    )
{
    if(s.empty()) return false;
 
    if(isalpha(s[0]))
    {
        return  calc_var_name(s, truth_table);
    }
    
    if(s.find(FALSE) == 0)
    {
        return  calc_0_const(s, truth_table);
    }
    
    if(s.find(TRUE) == 0)
    {
        return  calc_1_const(s, truth_table);
    }
    
    if(s.find(NOT) == 0)
    {
        return  calc_not_val(s, truth_table);
    }
 
    if(s[0] == LEFT_BR[0])
    {
        return  calc_exp_in_brackets(s, truth_table);
    }
    else return false;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_exp_in_brackets  
    (
        T_str&          s,    
        T_truth_table&  truth_table
    )
{
    return    calc_left_bracket   (s)
           && calc_expr           (s, truth_table)
           && calc_right_bracket  (s);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_not_val          
    (
        T_str&          s,    
        T_truth_table&  truth_table
    )
{
    T_truth_table  truth_table_expr;
    bool  bool_res =    calc_not     (s)                     
                     && calc_factor  (s, truth_table_expr);
    if(bool_res)
    {
        truth_table = !truth_table_expr;
    }
    return  bool_res;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_1_const          
    (
        T_str&          s,    
        T_truth_table&  truth_table
    )
{    
    bool  bool_res = calc_substr(s, TRUE);
    if(bool_res)
    {               
        truth_table = T_truth_table(1, TRUTH_TABLE_SIZE);
    }
    return  bool_res;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_0_const          
    (
        T_str&          s,    
        T_truth_table&  truth_table
    )
{
    bool  bool_res = calc_substr(s, FALSE);
    if(bool_res)
    {               
        truth_table = T_truth_table(TRUTH_TABLE_SIZE);
    }
    return  bool_res;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_var_name         
    (
        T_str&          s,    
        T_truth_table&  truth_table
    )
{
    T_str::const_iterator  str_it = std::find_if(s.begin(), s.end(), 
                                                 std::not1(std::ptr_fun(isalpha)));
 
    T_str  var_name(s.begin(), str_it);
    s.assign(str_it, s.end());
 
    //Ищем это имя в списке существующих.
    T_user_var_names::const_iterator  var_name_it 
        = std::find(user_var_names_.begin(), user_var_names_.end(), var_name); 
 
    //Если не найдено, то:
    if(var_name_it == user_var_names_.end())
    {
        if(user_var_names_.size() >= LOG_VARIABLES_TOTAL)
        {
            return  false;
        }
        user_var_names_.push_back(var_name);
    }
 
    truth_table = var_name == user_var_names_.front    ()
                                  ? get_truth_table_X  ()
                                  : get_truth_table_Y  ();
 
    return  true;              
}
//////////////////////////////////////////////////////////////////////////////////////
void  T_log_calculator::fill_expr_res_str()
{
    if(user_var_names_.size() >= 1)
    {
        X = user_var_names_.front();
    }
 
    if(user_var_names_.size() == 2)
    {
        Y = user_var_names_.back();
    }
 
    resultant_expressions_.resize(BIN_LOG_FUNCTIONS_TOTAL_QUANTITY);
 
    resultant_expressions_[0]   = make_str(FALSE);   
    resultant_expressions_[1]   = make_str(NOT,  X,    AND,  NOT,  Y);    
    resultant_expressions_[2]   = make_str(NOT,  X,    AND,  Y);
    resultant_expressions_[3]   = make_str(NOT,  X);
 
    resultant_expressions_[4]   = make_str(X,    AND,  NOT,  Y);
    resultant_expressions_[5]   = make_str(NOT,  Y);
    resultant_expressions_[6]   = make_str(X,    XOR,        Y);    
    resultant_expressions_[7]   = make_str(NOT,  X,    OR,   NOT,  Y);
 
    resultant_expressions_[8]   = make_str(X,    AND,  Y); 
    resultant_expressions_[9]   = make_str(X,    EQ,   Y);            
    resultant_expressions_[10]  = make_str(Y);    
    resultant_expressions_[11]  = make_str(NOT,  X,    OR,   Y); 
 
    resultant_expressions_[12]  = make_str(X);    
    resultant_expressions_[13]  = make_str(X,    OR,   NOT,  Y);   
    resultant_expressions_[14]  = make_str(X,    OR,   Y);   
    resultant_expressions_[15]  = make_str(TRUE);
}
//////////////////////////////////////////////////////////////////////////////////////
T_truth_table  T_log_calculator::get_truth_table_Y()
{
    T_resultant_expressions::iterator  res_expr_it 
        = std::find(resultant_expressions_.begin  (),
                    resultant_expressions_.end    (), 
                    Y);
 
    return  get_truth_table_from_ind(std::distance(resultant_expressions_.begin(), 
                                     res_expr_it));
}
//////////////////////////////////////////////////////////////////////////////////////
T_truth_table  T_log_calculator::get_truth_table_X()
{
    T_resultant_expressions::iterator  res_expr_it 
        = std::find(resultant_expressions_.begin  (),
                    resultant_expressions_.end    (), 
                    X);
 
    return  get_truth_table_from_ind(std::distance(resultant_expressions_.begin(),
                                     res_expr_it));
}
//////////////////////////////////////////////////////////////////////////////////////
T_str  T_log_calculator::get_resultant_expr(const T_truth_table&  truth_table)
{
    return  resultant_expressions_[get_ind_from_truth_table(truth_table)];
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_right_bracket(T_str&  s)
{
    return  calc_substr(s, RIGHT_BR);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_left_bracket(T_str&  s)
{
    return  calc_substr(s, LEFT_BR);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_not(T_str&  s)
{
    return  calc_substr(s, NOT);
}
//////////////////////////////////////////////////////////////////////////////////////
T_truth_table  T_log_calculator::get_truth_table_from_ind(int  ind)
{
    T_truth_table  truth_table_res(TRUTH_TABLE_SIZE);
 
    int  i = 0;
    while(ind)
    {
        truth_table_res[i++] = ind % 2 != 0;
        ind /= 2;
    }
    return  truth_table_res;
}
//////////////////////////////////////////////////////////////////////////////////////
size_t  T_log_calculator::get_ind_from_truth_table(const T_truth_table&  truth_table)
{
    size_t  ind_res = 0;
    int     i       = 0;
    int     coef    = 1;
    while(i < TRUTH_TABLE_SIZE)
    {    
        ind_res += truth_table[i++] * coef;
        coef *= 2;
    }
    return  ind_res;
}
//////////////////////////////////////////////////////////////////////////////////////
 
bool  T_log_calculator::calc_xor_for_xor(T_str&  s, T_truth_table&  truth_table)
{
    T_truth_table  truth_table_for_xor;
    bool  bool_res = calc_for_xor(s, truth_table_for_xor);
 
    if(bool_res)
    {
        truth_table = truth_table != truth_table_for_xor;
    }
    return  bool_res;
}
 
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_for_comparison_tail(T_str&  s, T_truth_table&  truth_table)
{
    if(calc_less_eq(s))
    {
        return    calc_less_eq_for_comparison     (s, truth_table)
               && calc_for_comparison_tail        (s, truth_table);
    }
 
    if(calc_greater_eq(s))
    {
        return    calc_greater_eq_for_comparison  (s, truth_table)
               && calc_for_comparison_tail        (s, truth_table);
    }
 
    if(calc_less(s))
    {
        return    calc_less_for_comparison        (s, truth_table)
               && calc_for_comparison_tail        (s, truth_table);
    }
 
    if(calc_greater(s))
    {
        return    calc_greater_for_comparison     (s, truth_table)
               && calc_for_comparison_tail        (s, truth_table);
    }
    //Хвост может быть пустым.
    return  true;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_less_for_comparison(T_str&  s, T_truth_table&  truth_table)
{
    T_truth_table  truth_table_for_comparison;
    bool  bool_res = calc_for_comparison(s, truth_table_for_comparison);
 
    if(bool_res)
    {
        truth_table = truth_table < truth_table_for_comparison;
    }
    return  bool_res;    
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_less_eq_for_comparison(T_str&  s, T_truth_table&  truth_table)
{
    T_truth_table  truth_table_for_comparison;
    bool  bool_res = calc_for_comparison(s, truth_table_for_comparison);
 
    if(bool_res)
    {
        truth_table = truth_table <= truth_table_for_comparison;
    }
    return  bool_res;   
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_less(T_str&  s)
{
    return  calc_substr(s, LESS);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_less_eq(T_str&  s)
{
    return  calc_substr(s, L_EQ);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_greater_for_comparison(T_str&  s, T_truth_table&  truth_table)
{
    T_truth_table  truth_table_for_comparison;
    bool  bool_res = calc_for_comparison(s, truth_table_for_comparison);
 
    if(bool_res)
    {
        truth_table = truth_table > truth_table_for_comparison;
    }
    return  bool_res;  
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_greater(T_str&  s)
{
    return  calc_substr(s, GR);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_greater_eq_for_comparison(T_str&  s, T_truth_table&  truth_table)
{
    T_truth_table  truth_table_for_comparison;
    bool  bool_res = calc_for_comparison(s, truth_table_for_comparison);
 
    if(bool_res)
    {
        truth_table = truth_table >= truth_table_for_comparison;
    }
    return  bool_res;  
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_greater_eq(T_str&  s)
{
    return  calc_substr(s, GR_EQ);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_eq_for_eq(T_str&  s, T_truth_table&  truth_table)
{
    T_truth_table  truth_table_for_eq(TRUTH_TABLE_SIZE);
    bool  bool_res = calc_for_eq(s, truth_table_for_eq);
 
    if(bool_res)
    {
        truth_table = truth_table == truth_table_for_eq;
    }
    return  bool_res;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_add_summand(T_str&  s, T_truth_table&  truth_table)
{
    T_truth_table  truth_table_for_summand(TRUTH_TABLE_SIZE);
    bool  bool_res = calc_summand(s, truth_table_for_summand);
 
    if(bool_res)
    {
        truth_table = truth_table || truth_table_for_summand;
    }
    return  bool_res;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_plus(T_str&  s)
{
    return  calc_substr(s, OR);
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_mult_to_factor(T_str&  s, T_truth_table&  truth_table)
{
    T_truth_table  truth_table_for_factor(TRUTH_TABLE_SIZE);
    bool  bool_res = calc_factor(s, truth_table_for_factor);
 
    if(bool_res)
    {
        truth_table = truth_table  &&  truth_table_for_factor;
    }
    return  bool_res;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::calc_asterisk(T_str&  s)
{
    return  calc_substr(s, AND);
}
//////////////////////////////////////////////////////////////////////////////////////
T_str  T_log_calculator::make_str
    (
        T_str s1,
        T_str s2,
        T_str s3,
        T_str s4,
        T_str s5,
        T_str s6
    )
{
    return  T_str(s1) + s2 + s3 + s4 + s5 + s6;
}
//////////////////////////////////////////////////////////////////////////////////////
void  T_log_calculator::print_prompt()
{
    std::cout << "Введите логическое выражение, включающее не более "
              << LOG_VARIABLES_TOTAL 
              << " имен переменных,"
              << std::endl
              << "константы "
              << FALSE
              << " и "
              << TRUE
              << ", скобки "              
              << LEFT_BR
              << ", "
              << RIGHT_BR
              << std::endl
              << "унарный оператор "
              << std::endl
              << '\t'
              << NOT
              << " - ОТРИЦАНИЕ "
              << std::endl
              << "и бинарные операторы:"
              << std::endl
              << '\t'
              << OR
              << " - ИЛИ;"
              << std::endl
              << '\t'
              << AND
              << " - И;"
              << std::endl
              << '\t'
              << LESS << ", " << GR << ", " << L_EQ << ", " << GR_EQ << ", " << EQ
              << " - в том же смысле, что и в C;"
              << std::endl
              << '\t'
              << XOR
              << " - ИСКЛЮЧАЮЩЕЕ ИЛИ."
              << std::endl
              << "Приоритет операторов тот же, что и в языке C."
              << std::endl
              << "Для явного задания приоритета используйте круглые скобки."
              << std::endl;
}
//////////////////////////////////////////////////////////////////////////////////////
bool  T_log_calculator::input_and_calc_log_expr()
{
    user_var_names_.clear();
    std::cout << std::endl
              << std::endl
              << std::endl
              << "-> ";
    T_str  s;
    std::getline(std::cin, s);
 
    bool  bool_res = !s.empty();
    
    if(bool_res)
    {
        remove_spaces(s); 
        fill_expr_res_str();    
        
        T_truth_table  truth_table_res(TRUTH_TABLE_SIZE);    
        if(!calculate(s, truth_table_res))
        {
            std::cout << "Выражение некорректно.";
        }
        else
        {
            fill_expr_res_str ();
            print_res         (truth_table_res);
        }    
    }
    return  bool_res;
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    T_log_calculator  log_calculator;
    log_calculator.print_prompt();
 
    for(;;)
    {
        if(!log_calculator.input_and_calc_log_expr()) exit(0);
    }
}