Parser Constructor Complete

#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;

        mOperatorType = multiCharOperatorMappings[std::get<std::string>(mContents)];

        switch (std::get<MultiCharOperators>(mOperatorType))
        {
        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:
            mPrecedenceGroup = 16;
            break;

        case MCO::SIZE_OF_OBJECT: case MCO::BINARY_NOT: case MCO::LOGICAL_NOT: case MCO::CREATE_HEAP_OBJECT:
        case MCO::DESTROY_HEAP_OBJECT:
            mPrecedenceGroup = 15;
            break;

        case MCO::MEMBER_ACCESS_OBJECT_DEREFERENCE: case MCO::MEMBER_ACCESS_POINTER_DEREFERENCE:
            mPrecedenceGroup = 14;
            break;

        case MCO::BINARY_LEFT_SHIFT: case MCO::BINARY_RIGHT_SHIFT:
            mPrecedenceGroup = 11;
            break;

        case MCO::LESS_THAN_OR_EQUAL_TO: case MCO::GREATER_THAN_OR_EQUAL_TO:
            mPrecedenceGroup = 10;
            break;

        case MCO::EQUALITY: case MCO::INEQUALITY:
            mPrecedenceGroup = 9;
            break;

        case MCO::LOGICAL_AND:
            mPrecedenceGroup = 5;
            break;

        case MCO::LOGICAL_OR:
            mPrecedenceGroup = 4;
            break;

        case MCO::TERNARY_OPERATOR:
            mPrecedenceGroup = 3;
            break;

        case MCO::MULTIPLY_ASSIGNMENT: case MCO::DIVISION_ASSIGNMENT: case MCO::MODULUS_ASSIGNMENT:
        case MCO::ADDITION_ASSIGNMENT: case MCO::SUBTRACTION_ASSIGNMENT: case MCO::LEFT_SHIFT_ASSIGNMENT:
        case MCO::RIGHT_SHIFT_ASSIGNMENT: case MCO::BITWISE_AND_ASSIGNMENT: case MCO::BITWISE_INCLUSIVE_OR_ASSIGNMENT:
        case MCO::BITWISE_EXCLUSIVE_OR_ASSIGNMENT:
            mPrecedenceGroup = 2;
            break;

        case MCO::THROW_EXCEPTION:
            mPrecedenceGroup = 1;
            break;

        default:
            break;
        }
    }
    else
    {
        using UCO = UniCharOperators;

        mOperatorType = UCO{ std::get<char>(mContents) };

        switch (std::get<UniCharOperators>(mOperatorType))
        {
        case UCO::STAR_SYMBOL:
            if (previousToken != nullptr)
            {
                if (*previousToken == TokenGroup::NUMERIC_LITERAL || *previousToken == TokenGroup::USER_LITERAL ||
                    *previousToken == TokenGroup::IDENTIFIER)
                {
                    mOperatorType = UCO::MULTIPLICATION;
                    mPrecedenceGroup = 13;
                }
                else
                {
                    mOperatorType = UCO::DEREFERENCE;
                    mPrecedenceGroup = 15;
                }
            }
            else
            {
                mOperatorType = UCO::DEREFERENCE;
                mPrecedenceGroup = 15;
            }
            break;

        case UCO::PLUS_SIGN:
            if (previousToken != nullptr)
            {
                if (*previousToken == TokenGroup::NUMERIC_LITERAL || *previousToken == TokenGroup::USER_LITERAL ||
                    *previousToken == TokenGroup::IDENTIFIER)
                {
                    mOperatorType = UCO::ADDITION;
                    mPrecedenceGroup = 12;
                }
                else
                {
                    mOperatorType = UCO::UNARY_PLUS;
                    mPrecedenceGroup = 15;
                }
            }
            else
            {
                mOperatorType = UCO::UNARY_PLUS;
                mPrecedenceGroup = 15;
            }
            break;

        case UCO::MINUS_SIGN:
            if (previousToken != nullptr)
            {
                if (*previousToken == TokenGroup::NUMERIC_LITERAL || *previousToken == TokenGroup::USER_LITERAL ||
                    *previousToken == TokenGroup::IDENTIFIER)
                {
                    mOperatorType = UCO::SUBTRACTION;
                    mPrecedenceGroup = 12;
                }
                else
                {
                    mOperatorType = UCO::UNARY_NEGATION;
                    mPrecedenceGroup = 15;
                }
            }
            else
            {
                mOperatorType = UCO::UNARY_NEGATION;
                mPrecedenceGroup = 15;
            }
            break;

        case UCO::AND_SIGN:
            if (previousToken != nullptr)
            {
                if (*previousToken == TokenGroup::NUMERIC_LITERAL || *previousToken == TokenGroup::USER_LITERAL ||
                    *previousToken == TokenGroup::IDENTIFIER)
                {
                    mOperatorType = UCO::BITWISE_AND;
                    mPrecedenceGroup = 8;
                }
                else
                {
                    mOperatorType = UCO::ADDRESS_ACCESS;
                    mPrecedenceGroup = 15;
                }
            }
            else
            {
                mOperatorType = UCO::ADDRESS_ACCESS;
                mPrecedenceGroup = 15;
            }
            break;

        case UCO::LEFT_PARANTHESIS: case UCO::RIGHT_PARANTHESIS: case UCO::ARRAY_SUBSCRIPT_LEFT:
        case UCO::ARRAY_SUBSCRIPT_RIGHT:
            mPrecedenceGroup = -1;
            break;

        case UCO::MEMBER_OBJECT_ACCESS:
            mPrecedenceGroup = 16;
            break;

        case UCO::BINARY_NOT: case UCO::LOGICAL_NOT:
            mPrecedenceGroup = 15;
            break;

        case UCO::DIVISION: case UCO::MODULUS:
            mPrecedenceGroup = 13;
            break;

        case UCO::LESS_THAN: case UCO::GREATER_THAN:
            mPrecedenceGroup = 10;
            break;

        case UCO::BITWISE_EXCLUSIVE_OR:
            mPrecedenceGroup = 7;
            break;

        case UCO::BITWISE_INCLUSIVE_OR:
            mPrecedenceGroup = 6;
            break;

        case UCO::ASSIGNMENT:
            mPrecedenceGroup = 2;
            break;

        case UCO::COMMA:
            mPrecedenceGroup = 0;
            break;

        default:
            break;
        }
    }
}

std::string Token::getContents()
{
    if (!mContents.index())
        return std::string{ std::get<char>(mContents) };
    else
        return std::get<std::string>(mContents);
}

TokenGroup& Token::getGroup()
{
    return mGroup;
}