Технологии синтаксического анализа и интерпретации команд

/////////////////////////////////////////////////////////////////////////////////////////
//Составить программу, которая проверяет корректность арифметических выражений, 
//в которых могуть быть скобки трех типов "()", "[]", "{}" и действия "+-*/".
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <sstream>
#include <stack>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string       T_expr;
typedef std::stack<char>  T_brackets_stack;
typedef int               T_num;
/////////////////////////////////////////////////////////////////////////////////////////
enum
{
    OPEN_ROUND_BRACKET      = '(',    
    CLOSING_ROUND_BRACKET   = ')',    
 
    OPEN_SQUARE_BRACKET     = '[',    
    CLOSING_SQUARE_BRACKET  = ']',    
 
    OPEN_BRACE              = '{',    
    CLOSING_BRACE           = '}'
};
/////////////////////////////////////////////////////////////////////////////////////////
bool  parse_num(T_expr&  e)
{
    std::istringstream  e_stream(e);
    T_num               num = 0;
    if(!(e_stream >> num)) return  false;
    e.clear();
    e_stream >> e;
    return  true;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  is_open_bracket(char  c)
{ 
    return    c == OPEN_ROUND_BRACKET
           || c == OPEN_SQUARE_BRACKET
           || c == OPEN_BRACE;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  is_closing_bracket(char  c)
{ 
    return    c == CLOSING_ROUND_BRACKET
           || c == CLOSING_SQUARE_BRACKET
           || c == CLOSING_BRACE;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  open_bracket_is_correct
    (
        char               open_bracket_symb, 
        T_brackets_stack&  brackets_stack
    )
{    
    switch(open_bracket_symb)
    {
    case OPEN_ROUND_BRACKET:
        if(   brackets_stack.empty()
           || brackets_stack.top() == OPEN_SQUARE_BRACKET
           || brackets_stack.top() == OPEN_BRACE)
        {
            brackets_stack.push(open_bracket_symb);            
            return  true;        
        }
        return  false;
               
    case OPEN_SQUARE_BRACKET:
        if(   brackets_stack.empty()           
           || brackets_stack.top() == OPEN_BRACE)
        {
            brackets_stack.push(open_bracket_symb);            
            return  true;        
        }
        return  false;
 
    case OPEN_BRACE: 
        if( brackets_stack.empty() )
        {
            brackets_stack.push(open_bracket_symb);            
            return  true;        
        }
        return  false;
 
    default:
        return  false;
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  closing_bracket_is_correct
    (
        char               closing_bracket_symb, 
        T_brackets_stack&  brackets_stack
    )
{    
    switch(closing_bracket_symb)
    {
    case CLOSING_ROUND_BRACKET:
        if( brackets_stack.top() == OPEN_ROUND_BRACKET )
        {
            brackets_stack.pop();            
            return  true;        
        }
        return  false;
               
    case CLOSING_SQUARE_BRACKET:
        if( brackets_stack.top() == OPEN_SQUARE_BRACKET )
        {
            brackets_stack.pop();            
            return  true;        
        }
        return  false;
 
    case CLOSING_BRACE: 
        if( brackets_stack.top() == OPEN_BRACE )
        {
            brackets_stack.pop();            
            return  true;        
        }
        return  false;
 
    default:
        return  false;
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  parse_open_brackets_arr_or_nothing
    (
        T_expr&            e, 
        T_brackets_stack&  brackets_stack
    )
{
    while(   !e.empty()
          && is_open_bracket(e[0]))
    {
        if(!open_bracket_is_correct(e[0], brackets_stack)) return  false;
        e.erase(0, 1);
    }
    return  true;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  parse_closing_brackets_arr_or_nothing
    (
        T_expr&            e, 
        T_brackets_stack&  brackets_stack
    )
{    
    while(   !e.empty()
          && is_closing_bracket(e[0]))
    {
        if(!closing_bracket_is_correct(e[0], brackets_stack)) return  false;
        e.erase(0, 1);
    }
    return  true;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  parse_num_with_brackets_arr
    (
        T_expr&            e, 
        T_brackets_stack&  brackets_stack
    )
{
    return    parse_open_brackets_arr_or_nothing     (e, brackets_stack)
           && parse_num(e)
           && parse_closing_brackets_arr_or_nothing  (e, brackets_stack);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  parse_op(T_expr&  e)
{
    if(e.empty())  return  false;    
    switch(e[0])
    {
    case '+':
    case '-':
    case '*':
    case '/':
        e.erase(0, 1);
        return  true; 
 
    default:
        return  false;
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  expr_is_correct(const T_expr&  expr)
{
    T_expr  e;    
    std::remove_copy_if(expr.begin(), expr.end(), 
                        std::back_inserter(e), isspace);
 
    T_brackets_stack  brackets_stack;
    if(!parse_num_with_brackets_arr(e, brackets_stack))  return  false;
    while(!e.empty())
    {
        if(   !parse_op                     (e)
           || !parse_num_with_brackets_arr  (e, brackets_stack))  return  false;        
    }
 
    return  brackets_stack.empty();
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    std::cout << "Введите арифметическое выражение, содержащее целые числа,"
              << std::endl
              << "скобки трех типов \"()\", \"[]\", \"{}\" и действия \"+-*/\":"
              << std::endl;
 
    T_expr  expr;
    getline(std::cin, expr);
    std::cout << "Выражение "
              << (expr_is_correct(expr) ? "" : "НЕ ")
              << "корректно."
              << std::endl;
}