Написать Интерпретатор Программного Языка(собственного)

#include <iostream>
#include <string>
using namespace std;
 
void type(char *c, int number_begin, int number_end, FILE *file);
void name(char *c, int number_begin, int number_end, FILE *file);
int check_1(char *c, int number_begin, int number_end);
int check_2(char *c, int number_begin, int number_end, int number, char *mas_name);
char write_name(char *c, int number_begin, int number_end, int number);
 
int main()
{
    char c[50];
    int b=1, help, number=0;
    char *mas_name = new char [number];
    FILE *file;
    while (b == 1)
    {
        cout << "Vvedite adres faila: ";
        cin.getline(c, 50);
        if ((file = fopen(c, "w")) == 0)
        {
            cout << "Povtorite vvod" << "\n";
            b=1;
        }
        else
            b=0;
    }
    fputs("#include <iostream>\n" "#include <string>\n" "using namespace std;\n\n" "int main()\n" "{\n", file); 
    do
    {
        cout << "VVedite comandy: ";
        cin.getline(c, 50);
        b = strlen(c);
        if (b == 1 && c[0] == '^')
        {
            fputs("system (\"PAUSE\");\n" "return 0;\n" "}", file);
            return 0;
        }
        else
        {
            if (c[0] != '-')
            {
                if (c[0] == ':')                    
                {
                    if (c[1] == '>')
                    {
                        help = check_1(c, 1, b);
                        if (help == 1)
                        {
                            type(c, 1, b, file);
                            fputs(" ", file);
                            name(c, 1, b, file);
                            help = check_2(c, 1, b, number, mas_name);
                            if (help == 1)
                            {
                                fputs("[50]", file);
                            }
                            fputs (";\n", file);
                        }
                        fputs("cin >> ", file);
                        name(c, 1, b, file);
                        fputs (";\n", file);
                        number = number + 1;
                        mas_name[number] = write_name(c, 1, b, number);
                    }
                    else if (c[b-1] == '>')
                    {
                        help = check_1(c, 1, b);
                        if (help == 1)
                        {
                            name(c, 1, b, file);
                            fputs(" = (", file);
                            type(c, 1, b, file);
                            fputs(") ", file);
                            name(c, 1, b, file);
                            fputs(";\n", file);
                        }
                        else
                        {
                            fputs("cout << ", file);
                            name(c, 0, b, file);
                            fputs(";\n", file);
                        }
                    }
                    else
                    {
                        for (int i=1; i<b; i++)
                        {
                            if (c[i] == '>')
                            {
                                int number_c = i;
                                help = check_2(c, number_c, b, number, mas_name);
                                if (help == 0)
                                {
                                    help = check_1(c, i, b);
                                    if (help == 1)
                                    {
                                        type(c, number_c, b, file);
                                        fputs(" ", file);
                                    }
                                    name(c, i, b, file);
                                    number = number + 1;
                                    mas_name[number] = write_name(c, 1, b, number);
                                    fputs(" = ", file);
                                    for (int i=1; i<b; i++)
                                    {
                                        if (c[i] == '#')
                                        {
                                            fputs("strlen(", file);
                                            name(c, i, number_c, file);
                                            fputs(");\n", file);
                                        }
                                        else if (c[i] == '\'')
                                            {
                                                i=i+1;
                                                while (c[i] != '\'')
                                                {
                                                    if (c[i] == ',')
                                                    {
                                                        fputs(".", file);
                                                        i=i+1;
                                                    }
                                                    else
                                                    {
                                                        fprintf(file, "%c", c[i]);
                                                        i=i+1;
                                                    }
                                                }
                                                fputs(";\n", file);
                                            }
                                            else
                                            {
                                                help = check_2(c, 1, b, number, mas_name);
                                                if (c[i] == '&' && help == 0)
                                                {
                                                    fputs("- ", file);
                                                    name(c, i, number_c, file);
                                                    fputs(";\n", file);
                                                }
                                            }
                                    }
                                }
                                else
                                {
                                    help = check_1(c, number_c, b);
                                    if (help == 1)
                                    {
                                        for (int i=1; i<b; i++)
                                        {
                                            if (c[i] == '\'')
                                            {
                                                type(c, number_c, b, file);
                                                fputs(" ", file);
                                                name(c, number_c, b, file);
                                                fputs("[50];\n", file);
                                                fputs("strcpy(", file);
                                                name(c, number_c, b, file);
                                                fputs(", \"", file);
                                                i=i+1;
                                                while (c[i] != '\'')
                                                {
                                                    fprintf(file, "%c", c[i]);
                                                    i=i+1;
                                                }
                                                fputs("\");\n", file);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        for (int i=1; i<b; i++)
                                        {
                                            if (c[i] == '\'')
                                            {
                                                fputs("strcpy(", file);
                                                name(c, number_c, b, file);
                                                fputs(", \"", file);
                                                i=i+1;
                                                while (c[i] != '\'')
                                                {
                                                    fprintf(file, "%c", c[i]);
                                                    i=i+1;
                                                }
                                                fputs("\");\n", file);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        help = 0;
                        for (int i=1; i<b; i++)
                        {
                            if (c[i] == '>')
                            {
                                help = 1;
                            }
                        }
                        if (help == 0)
                        {
                            help = check_2(c, 1, b, number, mas_name);
                            if (c[1] == '&' && help == 1)
                            {
                                fputs("for (int i=0; i<=((strlen(", file);
                                name(c, 1, b, file);
                                fputs(")/2)-1); i++)\n" "{\n", file);
                                fputs("int buf = ", file);
                                name(c, 1, b, file);
                                fputs("[i];\n", file);
                                name(c, 1, b, file);
                                fputs("[i] = ", file);
                                name(c, 1, b, file);
                                fputs("[strlen(", file);
                                name(c, 1, b, file);
                                fputs(")-i-1];\n", file);
                                name(c, 1, b, file);
                                fputs("[strlen(", file);
                                name(c, 1, b, file);
                                fputs(")-i-1] = buf;\n}\n", file);
                            }
                            else
                            {
                                help = check_1(c, 1, b);
                                if (help == 1)
                                {
                                    type(c, 1, b, file);
                                    fputs(" ", file);
                                    name(c, 1, b, file);
                                    fputs(";\n", file);
                                    number = number + 1;
                                    mas_name[number] = write_name(c, 1, b, number);
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                cout << "Error! (An invalid command)" << "\n";
            }
        }
    }
    while (1);
    fclose(file);
    system ("PAUSE");
    return 0;
}
void type(char *c, int number_begin, int number_end, FILE *file)
{
    for (int i=number_begin; i<number_end; i++)
    {
        if (c[i] == '@')
        {
            fputs("int", file);
        }
        if (c[i] == '$')
        {
            fputs("char", file);
        } 
        if (c[i] == '%')
        {
            fputs("float", file);
        }
    }
}
void name(char *c, int number_begin, int number_end, FILE *file)
{
    for (int i=number_begin; i<=number_end; i++)
    {
        if (c[i] == '@' || c[i] == '$' || c[i] == '%')
        {
            i=i+1;
            while (c[i] != '>' && i < number_end)
            {
                fprintf(file, "%c", c[i]);
                i=i+1;
            }
        }
        else if (c[i] == ':' || c[i] == '#' || c[i] == '&' || c[i] == '>')
        {
            if (c[i+1] == '@' || c[i+1] == '$' || c[i+1] == '%')
            {
                continue;
            }
            else
            {
                i=i+1;
                while (c[i] != '>' && i < number_end)
                {
                    fprintf(file, "%c", c[i]);
                    i=i+1;
                }
            }
        }
    }
}
int check_1(char *c, int number_begin, int number_end)
{
    int help = 0;
    for (int i=number_begin; i<number_end; i++)
    {
        if (c[i] == '@' || c[i] == '$' || c[i] == '%')
        {
            help = 1;
        }
    }
    return help;
}
int check_2(char *c, int number_begin, int number_end, int number, char *mas_name)
{
    int help = 0;
    for (int i=number_begin; i<number_end; i++)
    {
        if (c[i] == '$')
        {
            help = 1;
        }
    }
    char str[20];
    int k=0;
    for (int i=number_begin; i<=number_end; i++)
    {
        if (c[i] == '$')
        {
            i=i+1;
            while (c[i] != '>' && i < number_end)
            {
                str[k] = c[i];
                i=i+1;
                k=k+1;
            }
            str[k] = NULL;
        }
        else if (c[i] == ':' || c[i] == '#' || c[i] == '&' || c[i] == '>')
        {
            if (c[i+1] == '$')
            {
                continue;
            }
            else
            {
                i=i+1;
                while (c[i] != '>' && i < number_end)
                {
                    str[k] = c[i];
                    i=i+1;
                    k=k+1;
                }
                str[k] = NULL;
            }
        }
    }
    for (int i=1; i<=number; i++)
    {
        if (mas_name[i] == *str)
        {
            help=1;
        }
    }
    return help;
}
char write_name(char *c, int number_begin, int number_end, int number)
{
    char str[20];
    int k=0;
    for (int i=number_begin; i<number_end; i++)
    {
        if (c[i] == '$')
        {
            i=i+1;
            while (c[i] != '>' && i < number_end)
            {
                str[k] = c[i];
                i=i+1;
                k=k+1;
            }
            str[k] = NULL;
        }
    }
    return *str;
}

/////////////////////////////////////////////////////////////////////////////////////////
//Задание
//Написать интерпретатор программного языка (далее называемого В.*) 
//Программа должна считывать код на языке В.* с клавиатуры и исполнять этот код 
//Синтаксис языка:
//• Программная строка начинается с символа «:» (двоеточие), строка с комментарием
//начинается с символа «-» (минус).
//• Строка может содержать только одну операцию.
//• Переменные не декларируются заранее, их тип определяется при первом использовании.
//• Типы данных $ – строка, % – число с плавающей запятой (вводятся с запятой а не с
//точкой), @ – целое число.
//• Переменные могут быть преобразованы временно в другой тип, если при их последующем
//использовании они обозначены как другой тип данных.
//• Каждый тип данных должен уметь преобразовываться в другой (например число в строку,
//или целое число в число с плавающей запятой).
//• Операция > может означать:
//◦ Ввод с клавиатуры, если она является первой после :
//◦ Вывод на экран, если она является последней на строке.
//◦ Запись данных из переменной или константы слева в переменную с права.
//• Константы пишутся в одинарных кавычках (вне зависимости от типа данных).
//• Операция & – это операция «наоборот»
//◦ переписывает строку в обратном порядке символов в ней
//◦ с численными переменными она меняет их значение с положительного на
//отрицательное
//• Программа заканчивается строкой начинающейся с «^».
//Пример программы на языке :
//- Это пример программы
//- считываем строку с клавиатуры
//:>$a
//- переписываем строку задом на перёд
//:&a
//- выводим строку на экран
//:a>
//- записываем строку из двух пробелов в переменную s
//:' '>$s
//- выводим пробелы на экран
//:s>
//- записываем длину строки a в чело-численную переменную b
//:#a>@b
//- выводим значение b на экран
//:b>
//- записываем число 1,8 в переменную с плавающей запятой
//:'1,8'>%c
//- выводим на экран
//:c>
//- выводим на экран переменную преобразованную в целое число
//:@c>
//^
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string  T_str;
/////////////////////////////////////////////////////////////////////////////////////////
enum  T_B_symb
{
    INT_TYPE_SYMB           = '@',
    REAL_TYPE_SYMB          = '%',
    STR_TYPE_SYMB           = '$',
    IN_OUT_SYMB             = '>',
    PROGRAM_END_SYMB        = '^',
    REVERSE_SYMB            = '&',    
    INSTRUCTION_BEGIN_SYMB  = ':',    
    MINUS_SYMB              = '-',
    COMMENT_BEGIN_SYMB      = MINUS_SYMB,
    APOSTROPHE_SYMB         = '\'',
    COMMA_SYMB              = ','    
};
/////////////////////////////////////////////////////////////////////////////////////////
class  T_variable
{
    char            type_symb_;
    mutable T_str   str_val_;    
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------            
    T_variable(char  type_symb)
        :
        type_symb_(type_symb)
    {}    
    //-----------------------------------------------------------------------------------        
    char  get_type_symb()
    {
        return  type_symb_;
    }
    //-----------------------------------------------------------------------------------
    void  operator= (const T_str&  val)
    {       
        switch(type_symb_)
        {
        case INT_TYPE_SYMB:
            str_val_ = get_int_val  (val);
            break;  
 
        case REAL_TYPE_SYMB:
            str_val_ = get_real_val (val);
            break;  
 
        default:
            str_val_ = get_str_val  (val);
            break;  
        }
    }
    //-----------------------------------------------------------------------------------
    void  operator= (const T_variable&  variable)
    {
        *this = variable.str_val_;
    }
    //-----------------------------------------------------------------------------------
    bool  successfully_set_val(T_str  str_val)
    {
        bool  bool_res = false;
        switch(type_symb_)
        {
        case INT_TYPE_SYMB:
            bool_res = is_int_val   (str_val);
            break;
 
        case REAL_TYPE_SYMB:
            bool_res = is_real_val  (str_val);
            break;
 
        case STR_TYPE_SYMB:
            bool_res = is_str_val   (str_val);
            break;
        }
        
        if(bool_res)
        {
            str_val_ = str_val;
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    void  reverse()
    {
        switch( type_symb_ )
        {
        case STR_TYPE_SYMB:
            std::reverse
                (
                    str_val_.begin(),
                    str_val_.end()
                );
            break;
 
        default:
            if(str_val_[0] == MINUS_SYMB)
            {
                str_val_.erase(0, 1);
            }
            else
            {
                str_val_ = T_str(1, MINUS_SYMB) + str_val_;
            }       
        }
    }    
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static T_str  get_int_val(T_str  val)
    {        
        while( 
                    !val.empty()
                &&  !is_int_val(val) 
             )
        {
            val.erase( val.size() - 1 );
        }
 
        return  val.empty() ? T_str("0") : val;
    }
    //-----------------------------------------------------------------------------------
    static T_str  get_real_val(T_str  val)
    {
        if( is_int_val(val) )
        {
            val += ",0";
        }
        else
        {
            while( 
                        !val.empty()
                    &&  !is_real_val(val) 
                 )
            {
                val.erase( val.size() - 1 );
            }        
        }
        return  val.empty() ? T_str("0,0") : val;
    }
    //-----------------------------------------------------------------------------------
    static T_str  get_str_val(T_str  val)
    {        
        return  val;
    }
    //-----------------------------------------------------------------------------------
    friend std::ostream& operator<<
        (
            std::ostream&       os, 
            const T_variable&   variable
        )
    {
        os << variable.str_val_;
        return  os; 
    }
    //-----------------------------------------------------------------------------------
    static bool  is_int_val(T_str  str_val)
    {
        if(
                !str_val.empty()
            &&  str_val[0] == MINUS_SYMB
          )
        {
            str_val.erase(0, 1);
        }
 
        bool  bool_res = !str_val.empty();
        if(bool_res)
        {
            T_str::const_iterator  not_dig_it =     std::find_if
                                                        (
                                                            str_val.begin(),
                                                            str_val.end(),
                                                            std::not1( std::ptr_fun(isdigit) )
                                                        );
 
            bool_res = not_dig_it == str_val.end();
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    static bool  is_real_val(T_str  str_val)
    {
        if(
                !str_val.empty()
            &&  str_val[0] == MINUS_SYMB
          )
        {
            str_val.erase(0, 1);
        }
 
        bool  bool_res = !str_val.empty();
        if(bool_res)
        {
            T_str::size_type  coma_pos = str_val.find(COMMA_SYMB);
            bool_res = coma_pos != T_str::npos;
            if(bool_res)
            {
                str_val.erase(coma_pos, 1);
 
                T_str::const_iterator  not_dig_it 
                    =   std::find_if
                            (
                                str_val.begin(),
                                str_val.end(),
                                std::not1( std::ptr_fun(isdigit) )
                            );
 
                bool_res = not_dig_it == str_val.end();
            }
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    static bool  is_str_val(const T_str&  str_val)
    {
        return  true;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::map<char, T_variable>  T_variables;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_B_variables
{
    //-----------------------------------------------------------------------------------
    T_variables  variables_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    bool  compile_instruction
        (
            T_str   instruction,
            bool&   stop
        )
    {
        bool  bool_res = !instruction.empty();
        if(bool_res)
        {
            stop = instruction[0] == PROGRAM_END_SYMB;
            if(!stop)
            {
                switch( instruction[0] )
                {
                case COMMENT_BEGIN_SYMB:
                    break;
 
                case INSTRUCTION_BEGIN_SYMB:
                    //Удаляем символ INSTRUCTION_BEGIN_SYMB.
                    instruction.erase(0, 1);
 
                    bool_res = !instruction.empty();
                    if(bool_res)
                    {
                        switch( instruction[0] )
                        {
                        case IN_OUT_SYMB:
                            bool_res =  input_var_or_var_with_type(instruction);
                            break;
 
                        case REVERSE_SYMB:
                            bool_res =  reverse_var(instruction);
                            break;
 
                        case APOSTROPHE_SYMB:
                            bool_res =  output_const_in_var_or_var_with_type_or_console
                                            (instruction);
                            break;
 
                        case INT_TYPE_SYMB  :
                        case REAL_TYPE_SYMB :
                        case STR_TYPE_SYMB  :
                            bool_res =  output_var_with_type_in_var_or_var_with_type_or_console
                                            (instruction);
                            break;
 
                        default:
                            bool_res =  output_var_in_var_or_var_with_type_or_console
                                            (instruction);
                        }//switch                
                    }//if(bool_res)
                    break;
 
                default:
                    bool_res = false;
                }//switch                
            }//if(!stop)                        
        }//if(bool_res)
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    bool  input_var_or_var_with_type(T_str  instruction)
    {
        //Удаляем символ IN_OUT_SYMB.
        instruction.erase(0, 1);
 
        T_variables::iterator   var_it;
        bool  bool_res =        set_or_get_var
                                    (
                                        instruction,
                                        var_it
                                    )
                            &&  instruction.empty();
 
        if(bool_res)
        {
            T_str  str_val;
            do
            {
                switch( var_it->second.get_type_symb() )
                {
                case INT_TYPE_SYMB:
                    std::cout << "Введите целое значение : ";
                    break;
 
                case REAL_TYPE_SYMB:
                    std::cout << "Введите действительное значение (с запятой вместо точки): ";
                    break;
 
                case STR_TYPE_SYMB:
                    std::cout << "Введите строковое значение: ";
                    break;
                }
                
                std::cin >> str_val;                
            }while( !var_it->second.successfully_set_val(str_val) );            
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  set_or_get_var
        (
            T_str&                  instruction,
            T_variables::iterator&  var_it
        )
    {
        bool  bool_res = !instruction.empty();
        if(bool_res)
        {
            switch( instruction[0] )
            {
            case INT_TYPE_SYMB:
            case REAL_TYPE_SYMB:
            case STR_TYPE_SYMB:
                bool_res =  set_var
                                (
                                    instruction,
                                    var_it
                                );
                break;
            
            default:
                bool_res =  get_var
                                (
                                    instruction,
                                    var_it
                                );
            }        
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  reverse_var(T_str  instruction)
    {
        //Удаляем символ REVERSE_SYMB.
        instruction.erase(0, 1);
 
        T_variables::iterator   var_it;
        bool  bool_res =        get_var
                                    (
                                        instruction,
                                        var_it
                                    )
                            &&  instruction.empty();
 
        if(bool_res)
        {
            var_it->second.reverse();
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  output_const_in_var_or_var_with_type_or_console(T_str  instruction)
    {        
        //Удаляем символ APOSTROPHE_SYMB.
        instruction.erase(0, 1);
 
        T_str  const_val;
        bool  bool_res =        get_const_val
                                    (
                                        instruction,
                                        const_val
                                    )
                            &&  instruction[0] == IN_OUT_SYMB;
 
        if(bool_res)
        {
            //Удаляем символ IN_OUT_SYMB.
            instruction.erase(0, 1);
 
            if( instruction.empty() )
            {
                std::cout << const_val
                          << std::endl;
            }
            else
            {
                T_variables::iterator  var_it;
                bool_res =      set_or_get_var
                                    (
                                        instruction,
                                        var_it
                                    )
                            &&  instruction.empty();
 
                if(bool_res)
                {
                    var_it->second = const_val;
                }
            }
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  output_var_with_type_in_var_or_var_with_type_or_console(T_str  instruction)
    {        
        char  type_symb = instruction[0];
        //Удаляем символ типа.
        instruction.erase(0, 1);
 
        T_variables::iterator   left_var_it;
        bool  bool_res =        get_var
                                    (
                                        instruction,
                                        left_var_it
                                    )
                            &&  instruction[0] == IN_OUT_SYMB;
 
        if(bool_res)
        {
            //Удаляем символ IN_OUT_SYMB.
            instruction.erase(0, 1);
 
            T_variable  temp_var(type_symb);
            temp_var = left_var_it->second;            
 
            if( instruction.empty() )
            {
                std::cout << temp_var
                          << std::endl;
            }
            else
            {
                T_variables::iterator  right_var_it;
                bool_res =      set_or_get_var
                                    (
                                        instruction,
                                        right_var_it
                                    )
                            &&  instruction.empty();
 
                if(bool_res)
                {
                    right_var_it->second = temp_var;
                }//if
            }//if
        }//if
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  output_var_in_var_or_var_with_type_or_console(T_str  instruction)
    {
        T_variables::iterator  left_var_it;
        bool  bool_res =    get_var
                                (
                                    instruction,
                                    left_var_it
                                )
                    &&  instruction[0] == IN_OUT_SYMB;
 
        if(bool_res)
        {
            //Удаляем символ IN_OUT_SYMB.
            instruction.erase(0, 1);
 
            if( instruction.empty() )
            {
                std::cout << left_var_it->second
                          << std::endl;
            }
            else
            {
                T_variables::iterator  right_var_it;
                bool_res =      set_or_get_var
                                    (
                                        instruction,
                                        right_var_it
                                    )
                            &&  instruction.empty();
 
                if(bool_res)
                {
                    right_var_it->second = left_var_it->second;
                }//if
            }//if
        }//if 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  set_var
        (
            T_str&                  instruction,
            T_variables::iterator&  var_it_ref
        )
    {
        bool  bool_res = !instruction.empty();
        if(bool_res)
        {
            char  type_symb = instruction[0];
            //Удаляем символ типа.
            instruction.erase(0, 1);
 
            bool_res =      !instruction.empty()
                        &&  isalpha(instruction[0]);
 
            if(bool_res)
            {
                char  var_name_symb = instruction[0];
                //Удаляем символ имени переменной.
                instruction.erase(0, 1);
 
                T_variables::const_iterator  var_it = variables_.find(var_name_symb);
                bool_res = var_it == variables_.end();
                if(bool_res)
                {
                    variables_.insert
                        (
                            std::make_pair
                                (
                                    var_name_symb,
                                    T_variable(type_symb)
                                )
                        );
                    var_it_ref = variables_.find(var_name_symb);
                }            
            }
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  get_var
        (
            T_str&                  instruction,
            T_variables::iterator&  var_it_ref
        )
    {
        bool  bool_res =        !instruction.empty()
                            &&  isalpha( instruction[0] );
 
        if(bool_res)
        {
            char  var_name_symb = instruction[0];
            //Удаляем символ имени переменной.
            instruction.erase(0, 1);
 
            var_it_ref = variables_.find(var_name_symb);
            bool_res = var_it_ref != variables_.end();
        }
        return  bool_res;    
    }
    //-----------------------------------------------------------------------------------
    static bool  get_const_val
        (
            T_str&  instruction,
            T_str&  const_val
        )
    {
        bool  bool_res = !instruction.empty();
        if(bool_res)
        {
            T_str::size_type  apostrophe_pos = instruction.find(APOSTROPHE_SYMB);
            bool_res = apostrophe_pos != T_str::npos;
            if(bool_res)
            {
                const_val = instruction.substr(0, apostrophe_pos);
                //Удаляем значение константы.
                instruction.erase(0, apostrophe_pos);
                //Удаляем символ APOSTROPHE_SYMB.
                instruction.erase(0, 1);                      
            }
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    T_B_variables  B_variables;
    for(;;)
    {
        std::cout   << std::endl
                    << "Введите команду языка В.*:"
                    << std::endl;
 
        T_str  instruction;        
        std::cin >> instruction;        
        bool  stop      =   false;
        bool  bool_res  =   B_variables.compile_instruction
                                (
                                    instruction,
                                    stop
                                );
 
        if(stop)  break;
 
        if(!bool_res)
        {
            std::cout   << "Команда некорректна."
                        << std::endl;        
        }
    }//for(;;)
}

/////////////////////////////////////////////////////////////////////////////////////////
//Задание
//Написать интерпретатор программного языка (далее называемого В.*) 
//Программа должна считывать код на языке В.* с клавиатуры и исполнять этот код 
//Синтаксис языка:
//• Программная строка начинается с символа «:» (двоеточие), строка с комментарием
//начинается с символа «-» (минус).
//• Строка может содержать только одну операцию.
//• Переменные не декларируются заранее, их тип определяется при первом использовании.
//• Типы данных $ – строка, % – число с плавающей запятой (вводятся с запятой а не с
//точкой), @ – целое число.
//• Переменные могут быть преобразованы временно в другой тип, если при их последующем
//использовании они обозначены как другой тип данных.
//• Каждый тип данных должен уметь преобразовываться в другой (например число в строку,
//или целое число в число с плавающей запятой).
//• Операция > может означать:
//◦ Ввод с клавиатуры, если она является первой после :
//◦ Вывод на экран, если она является последней на строке.
//◦ Запись данных из переменной или константы слева в переменную с права.
//• Константы пишутся в одинарных кавычках (вне зависимости от типа данных).
//• Операция & – это операция «наоборот»
//◦ переписывает строку в обратном порядке символов в ней
//◦ с численными переменными она меняет их значение с положительного на
//отрицательное
//• Программа заканчивается строкой начинающейся с «^».
//Пример программы на языке :
//- Это пример программы
//- считываем строку с клавиатуры
//:>$a
//- переписываем строку задом на перёд
//:&a
//- выводим строку на экран
//:a>
//- записываем строку из двух пробелов в переменную s
//:' '>$s
//- выводим пробелы на экран
//:s>
//- записываем длину строки a в чело-численную переменную b
//:#a>@b
//- выводим значение b на экран
//:b>
//- записываем число 1,8 в переменную с плавающей запятой
//:'1,8'>%c
//- выводим на экран
//:c>
//- выводим на экран переменную преобразованную в целое число
//:@c>
//^
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string  T_str;
/////////////////////////////////////////////////////////////////////////////////////////
enum  T_B_symb
{
    INT_TYPE_SYMB           = '@',
    REAL_TYPE_SYMB          = '%',
    STR_TYPE_SYMB           = '$',
    IN_OUT_SYMB             = '>',
    PROGRAM_END_SYMB        = '^',
    REVERSE_SYMB            = '&',    
    OPERATOR_BEGIN_SYMB     = ':',    
    MINUS_SYMB              = '-',
    COMMENT_BEGIN_SYMB      = MINUS_SYMB,
    APOSTROPHE_SYMB         = '\'',
    COMMA_SYMB              = ','    
};
/////////////////////////////////////////////////////////////////////////////////////////
bool  parse_symb
    (
        char    symb,
        T_str&  s
    )
{
    bool  bool_res =        !s.empty()
                        &&  s[0] == symb;
 
    if(bool_res)
    {
        s.erase(0, 1);
    }
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
class  T_variable
{
    char    type_symb_;    
    T_str   str_val_;    
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------    
    T_variable
        (
            char            type_symb,
            const T_str&    val = T_str()
        )
        :
        type_symb_(type_symb)
    {
        *this = val;
    }    
    //-----------------------------------------------------------------------------------         
    operator T_str() const
    {
        return  str_val_;
    }     
    //-----------------------------------------------------------------------------------     
    char  get_type_symb()
    {
        return  type_symb_;
    }    
    //-----------------------------------------------------------------------------------    
    void  operator= (const T_str&  val)
    {       
        switch(type_symb_)
        {
        case INT_TYPE_SYMB:
            str_val_ = get_int_val  (val);
            break;  
 
        case REAL_TYPE_SYMB:
            str_val_ = get_real_val (val);
            break;  
 
        default:
            str_val_ = val;
            break;  
        }
    }    
    //-----------------------------------------------------------------------------------
    bool  successfully_set_val(T_str  str_val)
    {
        bool  bool_res = false;
        switch(type_symb_)
        {
        case INT_TYPE_SYMB:
            bool_res = is_int_val   (str_val);
            break;
 
        case REAL_TYPE_SYMB:
            bool_res = is_real_val  (str_val);
            break;
 
        default:
            bool_res = true;           
        }
        
        if(bool_res)
        {
            str_val_ = str_val;
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  reverse()
    {
        switch( type_symb_ )
        {
        case STR_TYPE_SYMB:
            std::reverse
                (
                    str_val_.begin(),
                    str_val_.end()
                );
            break;
 
        default:
            if(str_val_[0] == MINUS_SYMB)
            {
                str_val_.erase(0, 1);
            }
            else
            {
                str_val_ = T_str(1, MINUS_SYMB) + str_val_;
            }       
        }
        return  true;
    }    
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static T_str  get_int_val(T_str  val)
    {        
        while( 
                    !val.empty()
                &&  !is_int_val(val)
             )
        {
            val.erase( val.size() - 1 );
        }
 
        return  val.empty() ? T_str("0") : val;
    }
    //-----------------------------------------------------------------------------------
    static T_str  get_real_val(T_str  val)
    {
        if( is_int_val(val) )
        {
            val += ",0";
        }
        else
        {
            while( 
                        !val.empty()
                    &&  !is_real_val(val) 
                 )
            {
                val.erase( val.size() - 1 );
            }        
        }
        return  val.empty() ? T_str("0,0") : val;
    }
    //-----------------------------------------------------------------------------------
    static bool  is_int_val(T_str  str_val)
    {
        return      (   
                            parse_symb
                                (
                                    MINUS_SYMB,
                                    str_val
                                )
 
                        ||  true
                    )
                &&  is_not_empty_digits_str(str_val);
    }
    //-----------------------------------------------------------------------------------
    static bool  is_real_val(T_str  str_val)
    {     
        bool  bool_res =    (   
                                    parse_symb
                                        (
                                            MINUS_SYMB,
                                            str_val
                                        )
 
                                ||  true
                            )
 
                        &&  !str_val.empty();
 
        if(bool_res)
        {
            T_str::size_type  comma_pos = str_val.find(COMMA_SYMB);
            bool_res = comma_pos != T_str::npos;
            if(bool_res)
            {
                str_val.erase(comma_pos, 1);
                bool_res = is_not_empty_digits_str(str_val);
            }
        }
        return  bool_res;        
    }
    //-----------------------------------------------------------------------------------
    static bool  is_not_empty_digits_str(T_str  str_val)
    {
        return  std::find_if
                    (
                        str_val.begin(),
                        str_val.end(),
                        std::not1( std::ptr_fun(isdigit) )
                    ) == str_val.end();
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::map<char, T_variable>  T_variables;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_B
{
    //-----------------------------------------------------------------------------------
    T_variables  variables_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    bool  parse_instruction
        (
            T_str   instruction,
            bool&   stop
        )
    {
        return      parse_stop      
                        (
                            instruction, 
                            stop
                        )
 
                ||  parse_comment   (instruction)
                ||  parse_operator  (instruction);
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    bool  parse_stop      
        (
            T_str   instruction, 
            bool&   stop   
        )
    {
        return  stop =  parse_symb
                            (
                                PROGRAM_END_SYMB,
                                instruction
                            );
    }
    //-----------------------------------------------------------------------------------
    bool  parse_comment(T_str   instruction)
    {
        return  parse_symb
                    (
                        COMMENT_BEGIN_SYMB,
                        instruction
                    );
    }
    //-----------------------------------------------------------------------------------
    bool  parse_operator(T_str   instruction)
    {
        return      parse_symb
                        (
                            OPERATOR_BEGIN_SYMB,
                            instruction
                        )
                &&
                    (
                            parse_input_operator    (instruction)
                        ||  parse_output_operator   (instruction)
                        ||  parse_reverse_operator  (instruction)                    
                    );
    }
    //-----------------------------------------------------------------------------------    
    bool  parse_input_operator(T_str   instruction)
    {
        T_variables::iterator  var_it;
        return      parse_symb
                        (
                            IN_OUT_SYMB,
                            instruction
                        )               
                
                &&  (
                            parse_set_right_var 
                                (
                                    instruction,
                                    var_it
                                ) 
 
                        ||  parse_get_right_var 
                                (
                                    instruction,
                                    var_it
                                ) 
                    )
                    
                &&  input_var(var_it);
    }
    //-----------------------------------------------------------------------------------
    bool  parse_output_operator(T_str   instruction)
    {
        T_str  left_val;       
        return      parse_left_output_operand
                        (
                            instruction,
                            left_val
                        )
 
                &&  parse_symb
                        (
                            IN_OUT_SYMB,
                            instruction                        
                        )
 
                &&  instruction.empty()
                        ?   output_in_console   (left_val)
                        :   parse_right_output_operand_and_assign
                                (
                                    instruction,
                                    left_val  
                                );                    
   }
    //-----------------------------------------------------------------------------------
    bool  parse_reverse_operator(T_str   instruction)
    {
        T_variables::iterator  var_it;
        return      parse_symb
                        (
                            REVERSE_SYMB,
                            instruction
                        )
                
                &&  parse_get_right_var
                        (
                            instruction,
                            var_it
                        )
 
                &&  var_it->second.reverse();
    }
    //-----------------------------------------------------------------------------------
    bool  get_var
        (
            char                    var_name_symb,
            T_variables::iterator&  var_it
        )
    {
        var_it = variables_.find(var_name_symb);
        return  var_it != variables_.end();
    }
    //-----------------------------------------------------------------------------------
    bool  parse_left_output_operand
        (
            T_str&  instruction,
            T_str&  val
        )
    {
        return      parse_get_const_val
                        (
                            instruction,
                            val
                        )
 
                ||  parse_type_symb_and_get_left_var_val_for_output_operand
                        (
                            instruction,
                            val                        
                        )
                
                ||  parse_get_left_var_val_for_output_operand
                        (
                            instruction,
                            val                                               
                        );
    }
    //-----------------------------------------------------------------------------------
    bool  parse_right_output_operand_and_assign
        (
            T_str&          instruction,
            const T_str&    left_val
        )
    {
        T_variables::iterator   right_var_it;
        return  (       
                        parse_get_right_var
                            (
                                instruction,
                                right_var_it
                            )
 
                    ||  parse_set_right_var
                            (
                                instruction,
                                right_var_it                            
                            )
                )
            
            &&  assign_var
                    (
                        left_val,
                        right_var_it
                    );
    }
    //-----------------------------------------------------------------------------------
    bool  parse_get_right_var
        (
            T_str&                  instruction,
            T_variables::iterator&  right_var_it
        )
    {
        T_str   new_instruction     = instruction;
        char    var_name_symb       = 0;
 
        bool    bool_res =      parse_var_name_symb
                                    (
                                        new_instruction,
                                        var_name_symb                        
                                    )
 
                            &&  new_instruction.empty()
                            &&  get_var
                                    (
                                        var_name_symb,
                                        right_var_it
                                    );
 
        if(bool_res)
        {
            instruction = new_instruction;
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  parse_set_right_var
        (
            T_str&                  instruction,
            T_variables::iterator&  var_it
        )
    {
        T_str   new_instruction     = instruction;
        char    type_symb           = 0;
        char    var_name_symb       = 0;
 
        bool    bool_res =      parse_type_symb
                                    (
                                        new_instruction,
                                        type_symb
                                    )
 
                            &&  parse_var_name_symb
                                    (
                                        new_instruction,
                                        var_name_symb                        
                                    )
 
                            &&  new_instruction.empty()
                            &&  set_var
                                    (
                                        type_symb,
                                        var_name_symb,
                                        var_it                    
                                    );   
 
        if(bool_res)
        {           
            instruction = new_instruction;
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------    
    bool  set_var
        (
            char                    type_symb,
            char                    var_name_symb,
            T_variables::iterator&  var_it                    
        )
    {
        bool  bool_res =    variables_.insert
                                (
                                    std::make_pair
                                        (
                                            var_name_symb,
                                            T_variable(type_symb)
                                        )
                                ).second;                  
        
        if(bool_res)
        {
            var_it = variables_.find(var_name_symb);
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  parse_get_left_var_val_for_output_operand
        (
            T_str&  instruction,
            T_str&  val
        )
    {   
        T_str  new_instruction = instruction;
        T_variables::iterator   var_it;
        char                    var_name_symb   = 0;        
    
        bool  bool_res =        parse_var_name_symb
                                    (
                                        new_instruction,
                                        var_name_symb                        
                                    )
 
                            &&  new_instruction[0] == IN_OUT_SYMB
                            &&  get_var
                                    (
                                        var_name_symb,
                                        var_it
                                    );  
 
        if(bool_res)
        {           
            val             = var_it->second;
            instruction     = new_instruction;
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------    
    bool  input_var(const T_variables::iterator&    var_it)
    {
        T_str  str_val;
        do
        {
            switch( var_it->second.get_type_symb() )
            {
            case INT_TYPE_SYMB:
                std::cout << "Введите целое значение : ";
                break;
 
            case REAL_TYPE_SYMB:
                std::cout << "Введите действительное значение (с запятой вместо точки): ";
                break;
 
            case STR_TYPE_SYMB:
                std::cout << "Введите строковое значение: ";
                break;
            }            
            std::cin >> str_val;                
        }while( !var_it->second.successfully_set_val(str_val) );
        return  true;
    }
    //-----------------------------------------------------------------------------------
    bool  parse_get_const_val
        (
            T_str&  instruction,
            T_str&  val
        )
    {
        T_str  new_instruction = instruction;
        bool  bool_res =        parse_symb
                                    (
                                        APOSTROPHE_SYMB,
                                        new_instruction
                                    )
 
                            &&  parse_not_apostrophe_symbols
                                    (
                                        new_instruction,
                                        val
                                    )
 
                            &&  parse_symb
                                    (
                                        APOSTROPHE_SYMB,
                                        new_instruction
                                    );
 
        if(bool_res)
        {
            instruction = new_instruction;
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  parse_type_symb_and_get_left_var_val_for_output_operand
        (
            T_str&  instruction,
            T_str&  val
        )
    {
        T_str                   new_instruction     = instruction;
        T_variables::iterator   var_it;
        char                    type_symb           = 0;
        char                    var_name_symb       = 0;        
        
        bool  bool_res =        parse_type_symb
                                    (
                                        new_instruction,
                                        type_symb
                                    )
 
                            &&  parse_var_name_symb
                                    (
                                        new_instruction,
                                        var_name_symb
                                    )
 
                            &&  new_instruction[0] == IN_OUT_SYMB
                            &&  get_var
                                    (
                                        var_name_symb,
                                        var_it
                                    );
 
        if(bool_res)
        {
            val             =   T_variable
                                    (
                                        type_symb,
                                        var_it->second
                                    );
 
            instruction     =   new_instruction;
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  assign_var
        (
            const T_str&            val,
            T_variables::iterator   var_it
        )
    {
        var_it->second = val;
        return  true;
    }
    //-----------------------------------------------------------------------------------
    bool  parse_type_symb
        (
            T_str&  instruction,
            char&   type_symb
        )
    {
        if( !instruction.empty() )
        {
            type_symb = instruction[0];
        }
 
        return      parse_symb
                        (
                            INT_TYPE_SYMB,
                            instruction
                        )
 
                ||  parse_symb
                        (
                            REAL_TYPE_SYMB,
                            instruction
                        )  
 
                ||  parse_symb
                        (
                            STR_TYPE_SYMB,
                            instruction
                        );
    }
    //-----------------------------------------------------------------------------------
    bool  parse_var_name_symb
        (
            T_str&  instruction,
            char&   var_name_symb
        )
    {
        return      !instruction.empty()
                &&  isalpha
                        (
                            var_name_symb = instruction[0]
                        ) != 0
 
                &&  parse_symb
                        (
                            var_name_symb,
                            instruction
                        );  
    }
    //-----------------------------------------------------------------------------------
    bool  parse_not_apostrophe_symbols
        (
            T_str&  instruction,
            T_str&  val
        )
    {
        T_str::size_type    apostrophe_pos  = instruction.find(APOSTROPHE_SYMB);        
        bool                bool_res        = apostrophe_pos != T_str::npos;
        if(bool_res)
        {
            val = instruction.substr(0, apostrophe_pos);
            //Удаляем из инструкции константное значение.
            instruction.erase(0, apostrophe_pos);
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  output_in_console(const T_str&  val)
    {
        std::cout << val;        
        return  true;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    T_B  B;
    for(;;)
    {
        std::cout   << std::endl
                    << "Введите команду языка В.*:"
                    << std::endl;
 
        T_str  instruction;        
        std::cin >> instruction;        
        bool  stop      =   false;
        bool  bool_res  =   B.parse_instruction
                                (
                                    instruction,
                                    stop
                                );
 
        if(stop)  break;
 
        if(!bool_res)
        {
            std::cout   << "Команда некорректна."
                        << std::endl;        
        }
    }//for(;;)
}