Parser In Progress

#pragma once

#include <map>
#include <string>
#include <variant>

namespace TokenTools
{
    enum class TokenGroup
    {
        KEYWORD,
        IDENTIFIER,
        NUMERIC_LITERAL,
        USER_LITERALS,
        OPERATORS,
        PUNCTUATORS
    };

    enum class UniCharOperators
    {
        MEMBER_OBJECT_ACCESS = '.',
        ARRAY_SUBSCRIPT_LEFT = '[',
        ARRAY_SUBSCRIPT_RIGHT = ']',
        LEFT_PARANTHESIS = '(',
        RIGHT_PARANTHESIS = ')',
        BINARY_NOT = '~',
        LOGICAL_NOT = '!',
        UNARY_NEGATION = '-',
        UNARY_PLUS = '+',
        ADDRESS_ACCESS = '&',
        DEREFERENCE = '*',
        MULTIPLICATION = '*',
        DIVISION = '/',
        MODULUS = '%',
        ADDITION = '+',
        SUBTRACTION = '-',
        LESS_THAN = '<',
        GREATER_THAN = '>',
        BITWISE_AND = '&',
        BITWISE_EXCLUSIVE_OR = '^',
        BITWISE_INCLUSIVE_OR = '|',
        TERNARY_LEFT = '?',
        TERNARY_RIGHT = ':',
        ASSIGNMENT = '=',
        COMMA = ','
    };

    enum class MultiCharOperators
    {
        SCOPE_RESOLUTION,
        MEMBER_ACCESS_POINTER,
        ARRAY_SUBSCRIPT,
        FUNCTION_CALL,
        POSTFIX_INCREMENT,
        POSTFIX_DECREMENT,
        TYPE_NAME,
        CONST_TYPE_CONERSION,
        DYNAMIC_TYPE_CONVERSION,
        REINTERPRETED_TYPE_CONVERSION,
        STATIC_TYPE_CONVERSION,
        SIZE_OF_OBJECT,
        PREFIX_INCREMENT,
        PREFIX_DECREMENT,
        CREATE_HEAP_OBJECT,
        DESTROY_HEAP_OBJECT,
        TYPE_CAST,
        MEMBER_ACCESS_OBJECT_DEREFERENCE,
        MEMBER_ACCESS_POINTER_DEREFERENCE,
        BINARY_LEFT_SHIFT,
        BINARY_RIGHT_SHIFT,
        LESS_THAN_OR_EQUAL_TO,
        GREATER_THAN_OR_EQUAL_TO,
        EQUALITY,
        INEQUALITY,
        LOGICAL_AND,
        LOGICAL_OR,
        TERNARY_OPERATOR,
        MULTIPLY_ASSIGNMENT,
        DIVISION_ASSIGNMENT,
        MODULUS_ASSIGNMENT,
        ADDITION_ASSIGNMENT,
        SUBTRACTION_ASSIGNMENT,
        LEFT_SHIFT_ASSIGNMENT,
        RIGHT_SHIFT_ASSIGNMENT,
        BITWISE_AND_ASSIGNMENT,
        BITWISE_INCLUSIVE_OR_ASSIGNMENT,
        BITWISE_EXCLUSIVE_OR_ASSIGNMENT,
        THROW_EXCEPTION,

        // UniCharacter Operators that have multi-character counterparts
        BINARY_NOT,
        LOGICAL_NOT,
        BITWISE_AND,
        BITWISE_EXCLUSIVE_OR,
        BITWISE_INCLUSIVE_OR,

        // Generalized operator types to avoid duplicate keys
        PARANTHESIS,
        INCREMENT,
        DECREMENT
    };
}

using namespace TokenTools;

namespace
{
    std::map<std::string, MultiCharOperators> multiCharOperatorMappings{
        {"::", MultiCharOperators::SCOPE_RESOLUTION},
        {"->", MultiCharOperators::MEMBER_ACCESS_POINTER},
        {"[]", MultiCharOperators::ARRAY_SUBSCRIPT},
        {"()", MultiCharOperators::PARANTHESIS},
        {"++", MultiCharOperators::INCREMENT},
        {"--", MultiCharOperators::DECREMENT},
        {"typeid", MultiCharOperators::TYPE_NAME},
        {"const_cast", MultiCharOperators::CONST_TYPE_CONERSION},
        {"dynamic_cast", MultiCharOperators::DYNAMIC_TYPE_CONVERSION},
        {"reinterpret_cast", MultiCharOperators::REINTERPRETED_TYPE_CONVERSION},
        {"static_cast", MultiCharOperators::STATIC_TYPE_CONVERSION},
        {"sizeof", MultiCharOperators::SIZE_OF_OBJECT},
        {"compl", MultiCharOperators::BINARY_NOT},
        {"not", MultiCharOperators::LOGICAL_NOT},
        {"new", MultiCharOperators::CREATE_HEAP_OBJECT},
        {"delete", MultiCharOperators::DESTROY_HEAP_OBJECT},
        {".*", MultiCharOperators::MEMBER_ACCESS_OBJECT_DEREFERENCE},
        {"->*", MultiCharOperators::MEMBER_ACCESS_POINTER_DEREFERENCE},
        {">>", MultiCharOperators::BINARY_LEFT_SHIFT},
        {"<<", MultiCharOperators::BINARY_RIGHT_SHIFT},
        {"<=", MultiCharOperators::LESS_THAN_OR_EQUAL_TO},
        {">=", MultiCharOperators::GREATER_THAN_OR_EQUAL_TO},
        {"==", MultiCharOperators::EQUALITY},
        {"!=", MultiCharOperators::INEQUALITY},
        {"not_eq", MultiCharOperators::INEQUALITY},
        {"bitand", MultiCharOperators::BITWISE_AND},
        {"xor", MultiCharOperators::BITWISE_EXCLUSIVE_OR},
        {"bitor", MultiCharOperators::BITWISE_INCLUSIVE_OR},
        {"&&", MultiCharOperators::LOGICAL_AND},
        {"and", MultiCharOperators::LOGICAL_AND},
        {"||", MultiCharOperators::LOGICAL_OR},
        {"or", MultiCharOperators::LOGICAL_OR},
        {"?:", MultiCharOperators::TERNARY_OPERATOR},
        {"*=", MultiCharOperators::MULTIPLY_ASSIGNMENT},
        {"/=", MultiCharOperators::DIVISION_ASSIGNMENT},
        {"%=", MultiCharOperators::MODULUS_ASSIGNMENT},
        {"+=", MultiCharOperators::ADDITION_ASSIGNMENT},
        {"-=", MultiCharOperators::SUBTRACTION_ASSIGNMENT},
        {"<<=", MultiCharOperators::LEFT_SHIFT_ASSIGNMENT},
        {">>=", MultiCharOperators::RIGHT_SHIFT_ASSIGNMENT},
        {"&=", MultiCharOperators::BITWISE_AND_ASSIGNMENT},
        {"and_eq", MultiCharOperators::BITWISE_AND_ASSIGNMENT},
        {"|=", MultiCharOperators::BITWISE_INCLUSIVE_OR_ASSIGNMENT},
        {"or_eq", MultiCharOperators::BITWISE_INCLUSIVE_OR_ASSIGNMENT},
        {"^=", MultiCharOperators::BITWISE_EXCLUSIVE_OR_ASSIGNMENT},
        {"xor_eq", MultiCharOperators::BITWISE_EXCLUSIVE_OR_ASSIGNMENT}
    };
}

class Token
{
public:
    Token(TokenGroup group, std::variant<char, std::string> contents, Token* previousToken);

    // Returns the group that the token is apart of
    TokenGroup& getGroup();

    // Comparison operators for comparing token types
    bool operator==(const TokenGroup group) const
    {
        return mGroup == group;
    }

    bool operator!=(const TokenGroup group) const
    {
        return mGroup != group;
    }

private:
    bool isMultiCharToken;

    int mPrecedenceGroup;

    TokenGroup mGroup;

    std::variant<char, std::string> mContents;
    std::variant<UniCharOperators, MultiCharOperators> mOperatorType;
};

#include "token.h"

using namespace TokenTools;

Token::Token(TokenGroup group, std::variant<char, std::string> contents, Token* previousToken) : mGroup(group), mContents(contents), mPrecedenceGroup(-1)
{
    isMultiCharToken = mContents.index();

    if (isMultiCharToken)
    {
        using MCO = MultiCharOperators;

        switch (multiCharOperatorMappings[std::get<std::string>(mContents)])
        {
        case MCO::SCOPE_RESOLUTION:
            mPrecedenceGroup = 17;
            break;

        case MCO::INCREMENT:
            if (previousToken != nullptr)
            {
                if (*previousToken == TokenGroup::NUMERIC_LITERAL || *previousToken == TokenGroup::IDENTIFIER)
                {
                    mOperatorType = MultiCharOperators::POSTFIX_INCREMENT;
                    mPrecedenceGroup = 16;
                    break;
                }
                else
                {
                    mOperatorType = MultiCharOperators::PREFIX_INCREMENT;
                    mPrecedenceGroup = 15;
                    break;
                }
            }

            mOperatorType = MultiCharOperators::INCREMENT;
            mPrecedenceGroup = -1;
            break;

        case MCO::DECREMENT:
            if (previousToken != nullptr)
            {
                if (*previousToken == TokenGroup::NUMERIC_LITERAL || *previousToken == TokenGroup::IDENTIFIER)
                {
                    mOperatorType = MultiCharOperators::POSTFIX_DECREMENT;
                    mPrecedenceGroup = 16;
                    break;
                }
                else
                {
                    mOperatorType = MultiCharOperators::PREFIX_DECREMENT;
                    mPrecedenceGroup = 15;
                    break;
                }
            }

            mOperatorType = MultiCharOperators::DECREMENT;
            mPrecedenceGroup = -1;
            break;

        case MCO::PARANTHESIS:
            if (previousToken != nullptr)
            {
                switch (previousToken->getGroup())
                {
                case TokenGroup::IDENTIFIER:
                    mOperatorType = MultiCharOperators::FUNCTION_CALL;
                    mPrecedenceGroup = 16;
                    break;

                case TokenGroup::KEYWORD:
                    mOperatorType = MultiCharOperators::TYPE_CAST;
                    mPrecedenceGroup = 15;
                    break;

                default:
                    break;
                }

                break;
            }

            mOperatorType = MultiCharOperators::PARANTHESIS;
            mPrecedenceGroup = -1;
            break;

        case MCO::MEMBER_ACCESS_POINTER: case MCO::ARRAY_SUBSCRIPT: case MCO::TYPE_NAME: case MCO::CONST_TYPE_CONERSION:
        case MCO::DYNAMIC_TYPE_CONVERSION: case MCO::REINTERPRETED_TYPE_CONVERSION: case MCO::STATIC_TYPE_CONVERSION:
            mOperatorType = multiCharOperatorMappings[std::get<std::string>(mContents)];
            mPrecedenceGroup = 16;
        }
    }
    else
    {

    }
}