Разработать программу лексического анализа для языка программирования

// Учебная рограмма 
// собранная по учебнику "Язык С++ ПРОГРАММИРОВАНИЯ специальное издание"
// Bjarne Stroustrup AT&T Labs Murray Hill, New Jersey
// Москва, Издательство БИНОМ, 2011г
//
// Версия 0,0,0,1 однофайловая, функциональная, упрощенная.
// --------------------------------------------------------
 
// ------------- Условие задачи ---------------------------
/* 6.1. Калькулятор
      1 ---------- OK
 *  Мы рассмотрим операторы и выражения языка C++ на примере программы
 * калькулятора, реализующего четыре стандартных арифметических действия в
 * форме инфиксных операций над числами с плавающей запятой.
 * Пользователь может также определять переменные. Например,
 * если на входе калькулятора имеется
 * г=2.5
 * area=pi* г* r
 * (где pi — это предопределенная переменная) то в результате работы
 * программа-калькулятор выдаст
 * 2.5
 * 19.635
 * где 2.5 — это результат обработки первой строки, а 19. 635 — второй.
 * Наш калькулятор состоит из четырех основных частей:
        2 ---------- OK
 *      Модифицируйте программу-калькулятор, чтобы она сообщала номера
 * строк, в которых произошла ошибка.
        3 ----------
 * Разделить парсер, лексический анализатор и обработку ошибок
 * за Именами пространств. Максимально разделить внутреннюю реализацию и
 * пользовательский доступ.
 * Добавить обработку исключений встроенными обработчиками. throw и catch.
 *
 *
 *
*/
 
/* Нкмного о алгоритме и отдельных частях кода :
 *
 *
 * Применяемый нами стиль синтаксического анализа называется рекурсивным спуском
 * (recursive descent).
 * Терминальные символы (например, END, NUMBER, + и -) распознаются лексическим
 * анализатором gettoken()
 * нетерминальные символы распознаются функциями синтаксического анализа,
 * ехрг (), term () и prim ().
 *
 * Функция ехрг () обрабатывает сложение и вычитание.
 *
 * Функция term{) обрабатывает умножение и деление аналогично тому, как
 * ехрг {) обрабатывает сложение и вычитание:
 *
 * Функция prim(), обрабатывающая первичные элементы, похожа на ехрг()
 * и term (), но поскольку тут мы забрались ниже по иерархии вызовов
 * некоторая реальная работа уже выполняется (и цикл не нужен).
 *
 * функции ехрг{),
 * которая вызывает term {), которая вызывает prim {), которая вызывает ехрг {).
 *
 * Входные данные для парсера поставляет функция get token (). Самый
 * последний возврат функции gettokenO хранится в глобальной переменной curr_tok,
 * имеющей тип перечисления Token_value:
 * Когда встречается NUMBER (то есть целый литерал или литерал с плавающей
 * запятой), возвращается его значение. Вводимое функцией get_token () значение
 * помещается в глобальную переменную number value.
 * Аналогично тому, как последнее значение NUMBER хранится в переменной
 * number value, строковое представление последнего NAME хранится в string value.
 * Прежде, чем обработать имя, калькулятору нужно заглянуть вперед и узнать, как
 * это имя используется — читается или оно участвует в операции присваивания.
 * В любом случае происходит обращение к таблице символов, имеющей тип тар
 *
 * Из-за того, что наша программа чрезвычайно проста, обработка ошибок для нее
 * не является предметом первостепенного интереса. Наша функция обработки
 * ошибок просто подсчитывает их количество, выводит сообщение и завершает работу:
 *
 *
 *
 *
 *
 *
 */
#include "m_types.h" // собственные типы данных.
#include <fstream>   // файловые потоки и операции
#include <iostream>  // I/O (ввод/вывод), cin, cout, cerr, и т д.
#include <cstdlib>   // exitQ, и т.д.
#include <string>    // For std::string overloads.
#include <cctype>    // isalphaQ, и т.д.
#include <map>       // map (ассоциативные массивы)
#include <algorithm> // алгоритмы для работы с STL классами vector, map, string и т.д.
//#include <sstream>  // for stringstream
 
using namespace std;
using namespace M_Types;
 
map<string, double>     table;
istream*                input=0; //указатель на поток ввода
ostream*                    output=0;
 
namespace Error
{
    int no_of_errors;   // Подсчет количества ошибок при парсинге.
    struct Zero_divide
    {
        Zero_divide() { no_of_errors++; }
    };
 
    struct Syntax_error
    {
        const char* p ;
        Syntax_error(const char* q) { p = q; no_of_errors++; }
    };
}
 
namespace Lexer
{
    enum Token_value
    {
        NAME, NUMBER, END,
        PLUS='+', MINUS='-', MUL='*',  DIV='/',
        PRINT=';', ASSIGN='=', LP='(', RP=')'
    };
    Token_value             curr_tok = PRINT;
    double                  number_value=0;
    string                  string_value;
    word                        curr_line=0;
    Token_value get_token();
    Token_value get_token ()
    {
        char ch=0;
 
        do
        { // пропустить все пробельные символы кроме '\п'
            if( !input->get(ch) ) return curr_tok = END;
        }while ( ch !='\n' && isspace(ch) ) ;
 
 
        switch (ch)
        {
            case 0:
                return curr_tok=END;
            case ';' :
            case '\n' :
                return curr_tok=PRINT;
            case ':' :
            case '*' :
            case '/' :
            case '+' :
            case '-' :
            case '(' :
            case ')' :
            case '=' :
                return curr_tok=Token_value(ch);
            case '0' : case 'i' : case '2' : case '3' : case '4' :
            case '5' : case 'б' : case '7' : case '#' : case '9' :
            case '.' :
                input->putback(ch);
                (*input)>>number_value;
                return curr_tok=NUMBER ;
            default: //NAME, NAME=, или ошибка
                if (isalpha (ch) )
                {
                    string_value=ch;
                    while ( input->get(ch) && isalnum(ch) )
                        string_value.push_back(ch);
                    input->putback(ch) ;
                    return curr_tok=NAME;
                }
                throw Error::Syntax_error("bad token");
    //          return curr_tok=PRINT;
 
        }
    }
}
namespace Parser
{
    double expr(bool);
    double prim(bool);
    double term(bool);
 
    using namespace Lexer; // сделать все имена из Lexer доступными
    using namespace Error; // сделать все имена из Error доступными
 
 
    double prim (bool get) // обработка первичных выражений
    {
        if (get) get_token();
        switch (curr_tok)
        {
            case NUMBER:
            {
                double v = number_value;
                get_token () ;
                return v;
            }
            case NAME:
            {
                double& v = table[string_value];
                if (get_token () == ASSIGN) v = expr(true) ;
                return v;
            }
            case MINUS: //унарный минус
                return -prim (true) ;
            case LP:
            {
                double e = expr (true) ;
                if(curr_tok != RP) throw Error::Syntax_error(" ' ) ' expected") ;
                get_token(); // пропустить ')'
                return e;
            }
            default:
                throw Error::Syntax_error("primary expected");
        }
    }
 
 
    double term(bool get) //умножение и деление
    {
        double left = prim (get) ;
        for( ; ; )
            switch (curr_tok)
            {
                case MUL :
                    left *= prim (true) ;
                    break;
                case DIV:
                    if (double d = prim (true) )
                    {
                        left /= d;
                        break;
                    }
                    throw Zero_divide();
                default:
                    return left;
            }
    }
 
 
    double expr(bool get) // сложение и вычитание
    {
        double left = term(get);
        for( ; ; ) //"вечно"
            switch (curr_tok)
            {
                case PLUS:
                    left += term(true) ;
                    break;
                case MINUS:
                    left -= term(true) ;
                    break;
                default:
                    return left;
            }
    }
 
}
namespace Parser_Interface
{
    double expr(bool);
 
    double expr(bool get)
    {
        return Parser::expr(get);
    }
}
 
void skip()
{
    while (*input) //пропускать символы, пока не встретятся newline-или;
    {
        char ch ;
        input->get(ch);
        switch (ch)
        {
            case '\n' :
            case ';' :
                return ;
        }
    }
}
 
 
int main(int argc, char* argv[])
{
 
    table[ "pi" ] =3.1415926535897932385; // вводим предопределенные имена
    table[ "е" ] =2.7182818284590452354;
    //input = &cin;
    input  = new ifstream("input.txt");
    output = new ofstream("result.txt", ios_base::trunc);
    double res=0;
 
    using namespace Lexer;
 
 
    while (*input)
    {
        try
        {
 
            get_token();
            if (curr_tok==END) break;
            if (curr_tok==PRINT)    continue;
            curr_line++;
            res = Parser_Interface::expr(false);
            *(output)<<curr_line<<": "<<res<<endl;
        }
        catch(Error::Zero_divide e)
        {
            *(output)<<"error: "<<"Zero Divided"<<". At line : "<<curr_line<<endl;
            if (curr_tok != PRINT)  skip();
        }
        catch(Error::Syntax_error e)
        {
            *(output)<<"error: "<<e.p<<". At line : "<<curr_line<<endl;
            if (curr_tok != PRINT) skip();
        }
    }
 
    if (input != &cin)
        delete input;
    if (output != &cout)
        delete output;
 
    exit(Error::no_of_errors);
    return Error::no_of_errors;
}