Дерево разбора

#include <iostream>
#include <vector>
#include <regex>
#include <windows.h>
#include <iomanip>
#include <memory>
 
using namespace std;
 
struct Token {
    string type;
    string value;
};
 
vector<pair<string, string>> tokenPatterns = {
    {"identif", "[a-zA-Z][a-zA-Z0-9]*"},
    {"number", "[0-9]+(\\.[0-9]+)?"},
    {"operator", "[+\\-*/]"},
    {"assignment", ":="},
    {"semicolon", ";"},
    {"left_round_brace", "\\("},
    {"right_round_brace", "\\)"},
    {"left_curly_brace", "\\{"},
    {"right_curly_brace", "\\}"},
    {"keyword_do", "do"},
    {"keyword_loop", "loop"},
    {"condition", "[=<>]"}
};
 
vector<Token> analyzer(const string& input) {
    vector<Token> tokens;
 
    size_t pos = 0;
 
    while (pos < input.length()) {
        smatch match;
        bool found = false;
 
        for (const auto& pattern : tokenPatterns) {
            regex regex(pattern.second);
 
            if (regex_search(input.cbegin() + pos, input.cend(), match, regex) && match.position() == 0) {
                found = true;
                if (match.str() == "do") tokens.push_back({ "keyword_do", match[0] });
                else if (match.str() == "loop") tokens.push_back({ "keyword_loop", match[0] });
                else tokens.push_back({ pattern.first, match[0] });
                pos += match.length();
                break;
            }
        }
 
        if (!found) {
            if (isspace(input[pos])) pos++;
            else {
                cout << "Error: Unexpected symbol - " << input[pos] << endl << endl;;
                break;
            }
        }
    }
 
    return tokens;
}
 
struct Node {
    string type;
    string value;
    Node* left = nullptr;
    Node* mid = nullptr;
    Node* right = nullptr;
};
 
int curlyTarget = -1;
int roundTarget = -1;
bool inCondition = false;
int counter = 0;
 
void searchCurly(vector<Token> tokens, int index) {
    if (curlyTarget == -1)
        for (int i = index; i < tokens.size(); i++)
            if (tokens[i].type == "right_curly_brace") {
                curlyTarget = i;
                return;
            }
}
 
void searchRound(vector<Token> tokens, int index) {
    if (roundTarget == -1)
        for (int i = index; i < tokens.size(); i++)
            if (tokens[i].type == "right_round_brace") {
                roundTarget = i;
                return;
            }
}
 
Node* buildParseTree(vector<Token>& tokens, int& index, bool isLeaf) {
    Node* node = new Node;
 
    if (isLeaf) {
        node->type = tokens[index].type;
        node->value = tokens[index].value;
        index++;
 
        if (node->type == "semicolon") curlyTarget = -1;
        if (node->type == "left_round_brace") inCondition = true;
        if (node->type == "right_round_brace") {
            roundTarget = -1;
            inCondition = false;
        }
 
        return node;
    }
 
    if (tokens[index].type == "left_curly_brace") {
        node->left = buildParseTree(tokens, index, true);
        node->mid = buildParseTree(tokens, index, true);
        node->right = buildParseTree(tokens, index, false);
    }
    else if (tokens[index].type == "keyword_do") {
        node->left = buildParseTree(tokens, index, true);
        node->mid = buildParseTree(tokens, index, false);
        node->right = buildParseTree(tokens, index, false);
    }
    else if (tokens[index].type == "identif" || tokens[index].type == "number") {
        if (!inCondition) searchCurly(tokens, index);
        else searchRound(tokens, index);
 
        if ((!inCondition && curlyTarget - index > 3) || (inCondition && roundTarget - index > 2)) {
            node->left = buildParseTree(tokens, index, true);
            node->mid = buildParseTree(tokens, index, true);
            node->right = buildParseTree(tokens, index, false);
        }
        else {
            node->left = buildParseTree(tokens, index, true);
            node->mid = buildParseTree(tokens, index, true);
        }
    }
    else if (tokens[index].type == "left_round_brace") {
        node->left = buildParseTree(tokens, index, true);
        node->mid = buildParseTree(tokens, index, false);
        node->right = buildParseTree(tokens, index, true);
    }
    else if (tokens[index].type == "keyword_loop") {
        node->left = buildParseTree(tokens, index, true);
        node->mid = buildParseTree(tokens, index, false);
        if (index > 0 && tokens[index - 1].type == "left_curly_brace") node->right = buildParseTree(tokens, index, false);
    }
 
    return node;
}
 
void printParseTree(Node* root, int depth) {
    if (root == nullptr) return;
 
    for (int i = 0; i < depth; i++) cout << "  ";
    if (root->left == nullptr) cout << "node: " << root->type << ": " << root->value << endl;
    else cout << "node: n" << ++counter << ":" << endl;
 
    printParseTree(root->left, depth + 1);
    printParseTree(root->mid, depth + 1);
    printParseTree(root->right, depth + 1);
}
 
int main() {
    setlocale(0, "");
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    string input = "loop ( a + 10 ) do { a := a + 5 } ;";
    vector<Token> tokens = analyzer(input);
 
    cout << "Input:\n" << input << endl << endl;
 
    int index = 0;
    Node* parseTree = buildParseTree(tokens, index, false);
    cout << "Дерево разбора:" << endl << endl;
    printParseTree(parseTree, 0);
 
    return 0;
}