Калькулятор

#include<conio.h>
#include<locale.h>
#include<stdio.h>
#define END '0'
#define ERROR 'a'
#include<stdlib.h>
int main() {
  setlocale( LC_ALL, "Ukrainian");
  int a, b, c;
  char sign;
  while(1){
  printf("Введiть вираз:\n"); 
  scanf(" %d%c%d",&a,&sign,&b); 
  switch (sign)
  {
     case '-': c = a - b; break;
     case '+': c = a + b; break;
     case '*': c = a * b; break;
     case '/':  
          if(b==0){
              printf("Дiлити на 0 неможна\n");
              c=ERROR;
           }
           else{
               c=a/b;
             }break;
     case '%': c = a % b; break;
     case END: exit(1);
     default: c=ERROR; 
}
         if(c!=ERROR)
             printf("%d%c%d=%d\n",a,sign,b,c);
         else
             printf("Невiрна операцiя(%c)\n");
 
  }
  getch();
  return 0;
}

/* 
 * Grammar
 * 
 * <expr> ::=
 *      <expr> '+' <term>
 * |    <expr> '-' <term>
 * |    <term>
 * 
 * <term> ::=
 *      <term> '*' <factor>
 * |    <term> '/' <factor>
 * |    <term> '%' <factor>
 * |    <factor>
 * 
 * <factor> ::=
 *      '+' <factor>
 * |    '-' <factor>
 * |    <pow>
 * 
 * <pow> ::=
 *      <atom> '^' <factor>
 * |    <atom>
 * 
 * <atom> ::=
 *      '(' <expr> ')'
 * |    <number>
 * 
 * <number> ::=
 *      <int_number> '.' <int_number>
 * 
 * <int_number> ::=
 *      <int_number> <digit>
 * |    <digit>
 * 
 * <digit> ::=
 *      '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
 */
 
#include <iostream>
#include <string>
#include <list>
#include <stack>
#include <map>
#include <limits>
#include <cstring>
#include <cmath>
 
namespace Calculator
{
    void error(const std::string& msg, int pos)
    {
        std::cerr << "error: " << pos << ": " << msg << std::endl;
    }
    
    namespace TokenType
    {
        enum TokenType
        {
            VOID,   // service
            NUMBER, // number
            ADD,    // +
            SUB,    // -
            MUL,    // *
            DIV,    // /
            MOD,    // %
            POW,    // ^
            LBRACE, // (
            RBRACE  // )
        };
    }
    
    class Token
    {
    public:
        explicit Token(TokenType::TokenType type = TokenType::VOID, double value = 0.0, int pos = -1):
        m_type(type),
        m_value(value),
        m_pos(pos)
        {
        }
        
    public:
        TokenType::TokenType type() const
        {
            return m_type;
        }
        
        double value() const
        {
            return m_value;
        }
        
        int pos() const
        {
            return m_pos;
        }
        
        void pos(int p)
        {
            m_pos = p;
        }
        
    private:
        TokenType::TokenType m_type;
        double               m_value;
        
        int m_pos;
    };
    
    class TokenMap
    {    
    public:
        TokenMap()
        {
            m_token_map['+'] = Token(TokenType::ADD);
            m_token_map['-'] = Token(TokenType::SUB);
            m_token_map['*'] = Token(TokenType::MUL);
            m_token_map['/'] = Token(TokenType::DIV);
            m_token_map['%'] = Token(TokenType::MOD);
            m_token_map['^'] = Token(TokenType::POW);
            m_token_map['('] = Token(TokenType::LBRACE);
            m_token_map[')'] = Token(TokenType::RBRACE);
        }
        
    public:
        Token get_token(char c)
        {
            token_map_type::const_iterator pos = m_token_map.find(c);
            
            if (pos != m_token_map.end())
                return pos->second;
            else
                return Token(TokenType::VOID);
        }
        
    private:
        typedef std::map<char, Token> token_map_type;
        
    private:
        token_map_type m_token_map;
    };
    
    class Lexer
    {
    public:
        Lexer():
        m_pos(m_tokens.end()),
        m_status(true)
        {
        }
        
        explicit Lexer(const std::string& expr_str)
        {
            m_status = analyze(expr_str);
        }
        
    public:
        bool analyze(const std::string& expr_str)
        {
            m_tokens.clear();
            
            std::string::const_iterator expr_str_begin = expr_str.begin();
            std::string::const_iterator it = expr_str_begin;
            
            while (it != expr_str.end())
            {
                Token tok = m_token_map.get_token(*it);
                
                if (tok.type() != TokenType::VOID)
                {
                    tok.pos(it - expr_str_begin + 1);
                    m_tokens.push_back(tok);
                    
                    ++it;
                }
                else
                {
                    char c = *it;
                    
                    if (isspace(c))
                    {
                        ++it;
                    }
                    else if (isdigit(c) || c == '.')
                    {
                        int pos = it - expr_str_begin + 1;
                        Token num = s_number(it);
                        
                        num.pos(pos);
                        m_tokens.push_back(num);
                    }
                    else
                    {
                        error("stray character", it - expr_str.begin() + 1);
                        
                        m_status = false;
                        
                        ++it;
                    }
                }
            }
            
            m_pos = m_tokens.begin();
            
            return m_status;
        }
        
        Token next_token()
        {
            if (m_pos == m_tokens.end())
                return Token(TokenType::VOID);
            
            Token result = *m_pos;
            
            ++m_pos;
            
            return result;
        }
        
        Token lookahead_token() const
        {
            if (m_pos == m_tokens.end())
                return Token(TokenType::VOID);
            
            return *m_pos;
        }
        
        void skip_token()
        {
            ++m_pos;
        }
        
        bool status() const
        {
            return m_status;
        }
        
    private:
        Token s_number(std::string::const_iterator& pos)
        {
            double result = 0.0;
            double div = 10.0;
            char c = *pos;
            
            while (isdigit(c))
            {
                result = result * 10.0 + (c - '0');
                
                c = *(++pos);
            }
            
            if (c == '.')
            {
                c = *(++pos);
                
                while (isdigit(c))
                {
                    result = result + (c - '0') / div;
                    div *= 10.0;
                    
                    c = *(++pos);
                }
            }
            
            return Token(TokenType::NUMBER, result);
        }
        
    private:
        TokenMap                         m_token_map;
        std::list<Token>                 m_tokens;
        std::list<Token>::const_iterator m_pos;
        
        bool m_status;
    };
    
    namespace RPNElementType
    {
        enum RPNElementType
        {
            NUMBER,
            ADD,
            SUB,
            MUL,
            DIV,
            MOD,
            POW,
            MINUS
        };
    }
    
    class RPNElement
    {
    public:
        explicit RPNElement(RPNElementType::RPNElementType type, double value = 0.0):
        m_type(type),
        m_value(value)
        {
        }
        
    public:
        RPNElementType::RPNElementType type() const
        {
            return m_type;
        }
        
        double value() const
        {
            return m_value;
        }
        
    private:
        RPNElementType::RPNElementType m_type;
        double                         m_value;
    };
    
    class RPNIterator;
    
    class ReversePolishNotation
    {
        friend RPNIterator;
        
    public:
        void add(const RPNElement& element)
        {
            m_expr.push_back(element);
        }
        
        void clear()
        {
            m_expr.clear();
        }
        
    private:
        typedef std::list<RPNElement>     expr_type;
        typedef expr_type::const_iterator expr_iterator;
        
    private:
        expr_type m_expr;
    };
    
    class RPNIterator
    {
    public:
        explicit RPNIterator(const ReversePolishNotation& rpn)
        {
            tie(rpn);
        }
        
    public:
        void tie(const ReversePolishNotation& rpn)
        {
            m_pos = rpn.m_expr.begin();
            m_end = rpn.m_expr.end();
        }
        
        void next()
        {
            ++m_pos;
        }
        
        bool has_next() const
        {
            return m_pos != m_end;
        }
        
        RPNElement get() const
        {
            return *m_pos;
        }
        
    private:
        ReversePolishNotation::expr_iterator m_pos;
        ReversePolishNotation::expr_iterator m_end;
    };
    
    class Parser
    {
    public:
        Parser():
        m_status(true)
        {
        }
        
        explicit Parser(const std::string& expr_str)
        {
            m_status = analyze(expr_str);
        }
        
    public:
        bool analyze(const std::string& expr_str)
        {
            m_status = m_lexer.analyze(expr_str);
            m_expr.clear();
            
            s_expr();
            
            return m_status;
        }
        
        bool status() const
        {
            return m_status;
        }
        
        ReversePolishNotation rpn_expr() const
        {
            return m_expr;
        }
        
    private:
        void s_expr()
        {
            s_term();
            
            Token tok;
            TokenType::TokenType type;
            
            do
            {
                tok = m_lexer.lookahead_token();
                type = tok.type();
                
                switch (type)
                {
                case TokenType::ADD:
                    s_add_expr_elem(RPNElementType::ADD, &Parser::s_term);
                    
                    break;
                    
                case TokenType::SUB:
                    s_add_expr_elem(RPNElementType::SUB, &Parser::s_term);
                    
                    break;
                    
                default:
                    break;
                }
            }
            while (type == TokenType::ADD || type == TokenType::SUB);
        }
        
        void s_term()
        {
            s_factor();
            
            Token tok;
            TokenType::TokenType type;
            
            do
            {
                tok = m_lexer.lookahead_token();
                type = tok.type();
                
                switch (type)
                {
                case TokenType::MUL:
                    s_add_expr_elem(RPNElementType::MUL, &Parser::s_factor);
                    
                    break;
                    
                case TokenType::DIV:
                    s_add_expr_elem(RPNElementType::DIV, &Parser::s_factor);
                    
                    break;
                    
                case TokenType::MOD:
                    s_add_expr_elem(RPNElementType::MOD, &Parser::s_factor);
                    
                    break;
                    
                default:
                    break;
                }
            }
            while (type == TokenType::MUL || type == TokenType::DIV || type == TokenType::MOD);
        }
        
        void s_factor()
        {
            Token tok = m_lexer.lookahead_token();
            
            switch (tok.type())
            {
            case TokenType::ADD:
                m_lexer.skip_token();
                s_factor();
                
                break;
            
            case TokenType::SUB:
                s_add_expr_elem(RPNElementType::MINUS, &Parser::s_factor);
                
                break;
                
            default:
                s_pow();
                
                break;
            }
        }
        
        void s_pow()
        {
            s_atom();
            
            if (m_lexer.lookahead_token().type() == TokenType::POW)
                s_add_expr_elem(RPNElementType::POW, &Parser::s_factor);
        }
        
        void s_atom()
        {
            Token tok = m_lexer.lookahead_token();
            
            switch (tok.type())
            {
            case TokenType::LBRACE:
            {
                m_lexer.skip_token();
                s_expr();
                
                Token exp = m_lexer.lookahead_token();
                
                if (exp.type() == TokenType::RBRACE)
                {
                    m_lexer.skip_token();
                }
                else
                {
                    error("expected \')\'", exp.pos());
                    
                    m_status = false;
                }
                
                break;
            }
            
            case TokenType::NUMBER:
                m_lexer.skip_token();
                m_expr.add(RPNElement(RPNElementType::NUMBER, tok.value()));
                
                break;
            
            default:
                error("expected \'(\' or <number>", tok.pos());
                
                m_status = false;
                
                break;
            }
        }
        
        void s_add_expr_elem(RPNElementType::RPNElementType type, void (Parser::*rule)())
        {
            m_lexer.skip_token();
            (this->*rule)();
            m_expr.add(RPNElement(type));
        }
        
    private:
        Lexer                 m_lexer;
        ReversePolishNotation m_expr;
        
        bool m_status;
    };
    
    class Calculator
    {
    public:
        static double calculate(const std::string& expr)
        {
            if (parser.analyze(expr))
            {
                ReversePolishNotation rpn = parser.rpn_expr();
                RPNIterator elem(rpn);
                std::stack<double> operands;
                
                double operand1, operand2;
                
                while (elem.has_next())
                {
                    switch (elem.get().type())
                    {
                    case RPNElementType::NUMBER:
                        operands.push(elem.get().value());
                        
                        break;
                    
                    case RPNElementType::ADD:
                        take2(operands, operand1, operand2);
                        operands.push(operand1 + operand2);
                        
                        break;
                    
                    case RPNElementType::SUB:
                        take2(operands, operand1, operand2);
                        operands.push(operand1 - operand2);
                        
                        break;
                    
                    case RPNElementType::MUL:
                        take2(operands, operand1, operand2);
                        operands.push(operand1 * operand2);
                        
                        break;
                    
                    case RPNElementType::DIV:
                        take2(operands, operand1, operand2);
                        
                        if (fabs(operand2) == std::numeric_limits<double>::epsilon())
                        {
                            std::cerr << "error: division by zero" << std::endl;
                            
                            return 0.0;
                        }
                        
                        operands.push(operand1 / operand2);
                        
                        break;
                    
                    case RPNElementType::MOD:
                        take2(operands, operand1, operand2);
                        
                        if (fabs(operand2) == std::numeric_limits<double>::epsilon())
                        {
                            std::cerr << "error: division by zero" << std::endl;
                            
                            return 0.0;
                        }
                        
                        operands.push(fmod(operand1, operand2));
                        
                    case RPNElementType::POW:
                        take2(operands, operand1, operand2);
                        operands.push(pow(operand1, operand2));
                        
                        break;
                    
                    case RPNElementType::MINUS:
                        take(operands, operand1);
                        operands.push(-operand1);
                        
                        break;
                    }
                    
                    elem.next();
                }
                
                return operands.top();
            }
            else
            {
                std::cerr << "error: calculation is impossible" << std::endl;
                
                return 0.0;
            }
        }
        
    private:
        static void take(std::stack<double>& operands, double& operand)
        {
            operand = operands.top();
            operands.pop();
        }
        
        static void take2(std::stack<double>& operands, double& operand1, double& operand2)
        {
            take(operands, operand2);
            take(operands, operand1);
        }
        
    private:
        static Parser parser;
    };
    
    Parser Calculator::parser;
}
 
int main()
{
    std::string expr;
    
    while (true)
    {
        std::cout << "Enter arithmetical expression (or \'exit\'): ";
        std::getline(std::cin, expr);
        
        if (expr == "exit")
            break;
        
        std::cout << expr << " = " << Calculator::Calculator::calculate(expr) << std::endl;
    }
    
    return 0;
}