Расшифровка алгоритмов в коде(Машина Тьюринга)

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
 
using namespace std;
 
class Exeption {
public:
    static void error(int line) {
        cout << "Error in " << line + 1 << " line" << endl;
    }
 
    static void undefined_transition(string st, char lt) {
        cout << "Error! Undefined transition from state " << "[" << st << "]" << " and the letter " << "[" << lt << "]" << endl;
    }
};
 
class TuringMashine {
private:
    int repeated, pointer;
    bool stopped;
    string src_filename, in_filename, out_filename, log_filename, now_state, line;
    vector<string>stack_src;
 
    void go();
    void execute_command(string cmd);
    void change_letter(char let);
    void move_right();
    void move_left();
    void stop();
 
    string get_state(string cmd);
    string get_read_letter(string cmd);
    string get_write_letter(string cmd);
    string get_next_state(string cmd);
    string get(string cmd, int k);
    string uncomment(string str);
 
    bool test_of_execute(string cmd);
    bool validation_command_test(string cmd);
    bool errors_test();
public:
    TuringMashine(string src_filename_, string in_filename_, string out_filename_);
    TuringMashine();
 
    void run();
    void print_result();
};
 
TuringMashine::TuringMashine(string src_filename_, string in_filename_, string out_filename_) :
src_filename(src_filename_),in_filename(in_filename_), now_state("00"),  repeated(0), stopped(false) {}
 
TuringMashine::TuringMashine() : src_filename("src.txt"),in_filename("input.txt"), now_state("00"), repeated(0), stopped(false) {}
 
void TuringMashine::run() {
    ifstream src(src_filename.c_str());
    ifstream in(in_filename.c_str());
 
    while(!in.eof()) {
        getline(in, line);
    }
 
    pointer = line.size();
    line.push_back(' ');
 
    while(!src.eof()) {
        string cmd;
        getline(src, cmd);
        cmd = uncomment(cmd);
        if(cmd.size() > 0) {
            stack_src.push_back(cmd);
        }
    }
 
    errors_test();
 
    if(!stopped) {
        go();
        print_result();
        cout << "Success!" << endl;
    }
}
 
bool TuringMashine::errors_test() {
    int s = 0;
    for(int i = 0; i < stack_src.size(); ++i) {
        string state = get_state(stack_src[i]);
        string read_letter = get_read_letter(stack_src[i]);
        string write_letter = get_write_letter(stack_src[i]);
        string next_state = get_next_state(stack_src[i]);
 
        if(state.size() == 0 || read_letter.size() == 0 || read_letter.size() > 1 || write_letter.size() == 0 || write_letter.size() > 1 || next_state.size() == 0) {
            Exeption::error(i);
            stopped = true;
            ++s;
        }
    }
 
    cout << s << " errors" << endl;
}
 
void TuringMashine::go() {
    for(int i = 0; i < stack_src.size() && !stopped; ++i) {
        if(test_of_execute(stack_src[i])) {
            execute_command(stack_src[i]);
            i = -1;
        }
        if(i == stack_src.size() - 1) {
            Exeption::undefined_transition(now_state, line[pointer]);
            i = -1;
            stopped = true;
        }
    }
}
 
string TuringMashine::get(string cmd, int k) {
    int s = 0;
    string tmp;
 
    for(int i = 0; i < cmd.size(); ++i) {
        if(cmd[i] == ',') {++s; ++i;}
        if(s == k && i < cmd.size()) tmp.push_back(cmd[i]);
        if(s > k) return tmp;
    }
 
    return tmp;
}
 
string TuringMashine::get_state(string cmd) {return get(cmd, 0);}
string TuringMashine::get_read_letter(string cmd) {return get(cmd, 1);}
string TuringMashine::get_write_letter(string cmd) {return get(cmd, 2);}
string TuringMashine::get_next_state(string cmd) {return get(cmd, 3);}
 
string TuringMashine::uncomment(string str) {
    string tmp;
 
    for(int i = 0; i < str.size(); ++i) {
        if(str[i] == '/' && i < str[i] - 1) {
            if(str[i+1] == '/') {
                return tmp;
            }
 
            else {
                tmp.push_back(str[i]);
                continue;
            }
        }
        tmp.push_back(str[i]);
    }
}
 
bool validation_command_test(string cmd) {
    return true;
}
 
bool TuringMashine::test_of_execute(string cmd) {
    string state = get_state(cmd);
    string read_letter = get_read_letter(cmd);
 
    return state == now_state && read_letter[0] == line[pointer];
}
 
void TuringMashine::execute_command(string cmd) {
    string write_letter = get_write_letter(cmd);
    string next_state = get_next_state(cmd);
 
    if(write_letter == ">") {move_right();}
    else if(write_letter == "<") {move_left();}
    else if(write_letter == "#") {stopped = true;}
    else {change_letter(write_letter[0]);}
 
    now_state = next_state;
 
    print_result();
 
}
 
void TuringMashine::change_letter(char let) {
    line[pointer] = let;
}
 
void TuringMashine::move_right() {
    pointer++;
    if(pointer >= line.size()) {
        line.push_back(' ');
    }
}
 
void TuringMashine::move_left() {
    if(pointer > 0) {
        pointer--;
    }
}
 
void TuringMashine::print_result() {
    cout << line << endl;
 
    for(int i = 0; i < pointer; ++i) {
        cout << " ";
    }
 
    cout << "^" << endl << endl;
}
int main() {
    TuringMashine sturing = TuringMashine();
    sturing.run();
    cin.get();
}