src/Parser.cpp - main - thomas-king/IdentifierParser

src/Parser.cpp
123 строки3 KB
AceRodstin
Replace Node with ListNode.
30 дек 2022, 17:23
30 дек 2022, 17:23f8a3286
//
//  Parser.cpp
//  IdentifierParser
//
//  Created by Ace Rodstin on 27 Dec 2022.
//

#include "../include/Parser.h"

using namespace Identifier;

class Parser::Error: exception {
    public:
    enum class Reason {
        invalid_character,
        is_empty
    };

    Error(Reason reason) {
        this->reason = reason;
    }

    const char* what() {
        switch (reason) {
            case Reason::invalid_character:
                return "Invalid character";
            case Reason::is_empty:
                return "Is empty";
        }
    }

    private:
    Reason reason;
};

string Parser::parse(string identifier) {
    auto list = create_list(identifier);
    return to_string(std::move(list));
}

unique_ptr<Parser::Node> Parser::create_list(string identifier) {
    if (identifier.front() == backtick && identifier.back() == backtick) {
        return create_enclosed_identifier(identifier);
    } else {
        stringstream buffer { identifier };
        return create_identifier(buffer);
    }
}

unique_ptr<Parser::Node> Parser::create_enclosed_identifier(string identifier) {
    // Drop backticks from source
    identifier.erase(0, 1);
    identifier.pop_back();

    stringstream buffer { identifier };

    // Adding opening backtick to the tree
    auto head = make_unique<Node>(nullptr, backtick);
    head->next = create_identifier(buffer);

    // Adding closing backtick to the tree
    Node& end = head->end();
    end.next = make_unique<Node>(nullptr, backtick);

    return head;
}

unique_ptr<Parser::Node> Parser::create_identifier(stringstream& buffer) {
    char character = buffer.get();
    char peeked = buffer.peek();

    // identifier -> identifier-head identifier-characters opt
    auto node = create_identifier_head(character);
    
    if (!buffer.eof()) {
        // Recursion
        node->next = create_identifier_characters(buffer);
    }

    return node;
}

unique_ptr<Parser::Node> Parser::create_identifier_head(char character) {
    if (identifier_head_characters.contains(character)) {
        // identifier-head -> Upper- or lowercase letter A through Z
        return make_unique<Node>(nullptr, character);
    } else {
        throw Error { Error::Reason::invalid_character };
    }
}

unique_ptr<Parser::Node> Parser::create_identifier_characters(stringstream& buffer) {
    char character = buffer.get();
    char peeked = buffer.peek();

    // identifier-characters -> identifier-character identifier-characters opt
    auto node = create_identifier_character(character);
    
    if (!buffer.eof()) {
        // Recursion
        node->next = create_identifier_characters(buffer);
    }

    return node;
}

unique_ptr<Parser::Node> Parser::create_identifier_character(char character) {
    if (isdigit(character)) {
        // identifier-character -> Digit 0 through 9
        return make_unique<Node>(nullptr, character);
    } else {
        return create_identifier_head(character);
    }
}

string Parser::to_string(unique_ptr<Parser::Node> head) {
    stringstream buffer;

    auto closure = [&](auto value) { buffer << value; };
    head->for_each(closure);

    return buffer.str();
}