instructions.hpp

 
#pragma once
 
#include <vector>
#include <assert.h>
#include <iostream>
#include <sstream>
 
#include <torquescript/function.hpp>
#include <torquescript/interpreter.hpp>
#include <torquescript/executionscope.hpp>
#include <torquescript/storedvalue.hpp>
#include <torquescript/storedvaluestack.hpp>
#include <torquescript/executionstate.hpp>
#include <torquescript/instructionsequence.hpp>
 
namespace TorqueScript
{
    namespace Instructions
    {
        class Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) = 0;
 
                virtual std::string disassemble() = 0;
 
                std::string mComment;
        };
 
        class PushFloatInstruction : public Instruction
        {
            public:
                PushFloatInstruction(const float value) : mParameter(value)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
                    stack.push_back(StoredValue(mParameter));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "PushFloat " << mParameter;
                    return out.str();
                }
 
            private:
                float mParameter;
        };
 
        class PushIntegerInstruction : public Instruction
        {
            public:
                PushIntegerInstruction(const int value) : mParameter(value)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
                    stack.push_back(StoredValue(mParameter));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "PushInteger " << mParameter;
                    return out.str();
                }
 
            private:
                int mParameter;
        };
 
        class PushStringInstruction : public Instruction
        {
            public:
                PushStringInstruction(const std::size_t value) : mStringID(value)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
                    stack.push_back(StoredValue(mStringID, StoredValueType::String));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "PushString " << mStringID;
                    return out.str();
                }
 
            private:
                std::size_t mStringID;
        };
 
        class PushLocalReferenceInstruction : public Instruction
        {
            public:
                PushLocalReferenceInstruction(const std::size_t value) : mStringID(value)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
                    stack.push_back(StoredValue(mStringID, StoredValueType::LocalReference));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "PushLocalReference " << mStringID;
                    return out.str();
                }
 
            private:
                std::size_t mStringID;
        };
 
        class PushGlobalReferenceInstruction : public Instruction
        {
            public:
                PushGlobalReferenceInstruction(const std::size_t value) : mStringID(value)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
                    stack.push_back(StoredValue(mStringID, StoredValueType::GlobalReference));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "PushGlobalReference " << mStringID;
                    return out.str();
                }
 
            private:
                std::size_t mStringID;
        };
 
        class AddAssignmentInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    // Pull two values off the stack
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
 
                    float resultRaw = 0.0f;
                    resultRaw = lhsStored.toFloat(state);
                    resultRaw += rhsStored.toFloat(state);
 
                    StoredValue result = StoredValue(resultRaw);
                    if (!lhsStored.setValue(result, state))
                    {
                        state->mInterpreter->mConfig.mPlatform->logError("Attempted to perform no-op assignment!");
                    }
 
                    // In Torque, the result of the assignment is pushed to stack
                    stack.push_back(result);
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "AddAssignment";
                }
        };
 
        class AssignmentInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    // Pull two values off the stack
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
 
                    if (!lhsStored.setValue(rhsStored, state))
                    {
                        state->mInterpreter->mConfig.mPlatform->logError("Attempted to perform no-op assignment!");
                    }
 
                    // In Torque, the result of the assignment is pushed to stack
                    stack.push_back(rhsStored);
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "Assignment";
                }
        };
 
        class ConcatInstruction : public Instruction
        {
            public:
                ConcatInstruction(const std::string& seperator) : mSeperator(seperator)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    // Pull two values off the stack
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
 
                    std::string lhs = lhsStored.toString(state);
                    std::string rhs = rhsStored.toString(state);
 
                    // Generate a new string ID
                    const std::size_t requestedStringID = state->mInterpreter->mStringTable.getOrAssign(lhs + mSeperator + rhs);
                    stack.push_back(StoredValue(requestedStringID, StoredValueType::String));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream result;
                    result << "Concat " << mSeperator;
                    return result.str();
                }
 
            private:
                std::string mSeperator;
        };
 
        class NegateInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 1);
 
                    // Pull two values off the stack
                    StoredValue storedTarget = stack.back();
                    stack.pop_back();
 
                    stack.push_back(StoredValue(-storedTarget.toFloat(state)));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "Negate";
                }
        };
 
        class NotInstruction : public Instruction
        {
        public:
            virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
            {
                StoredValueStack& stack = state->mExecutionScope.getStack();
 
                assert(stack.size() >= 1);
 
                // Pull two values off the stack
                StoredValue storedTarget = stack.back();
                stack.pop_back();
 
                stack.push_back(StoredValue(!storedTarget.toBoolean(state) ? 1 : 0));
                return 1;
            };
 
            virtual std::string disassemble() override
            {
                return "Not";
            }
        };
 
        class CallFunctionInstruction : public Instruction
        {
            public:
                CallFunctionInstruction(const std::string& space, const std::string& name, const std::size_t argc) : mNameSpace(space), mName(name), mArgc(argc)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    const std::string namespaceName = toLowerCase(mNameSpace);
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    // If we're calling a parent function, perform an alternative lookup
                    if (namespaceName == "parent")
                    {
                        Function* currentFunction = state->mExecutionScope.getCurrentFunction();
                        if (currentFunction == nullptr)
                        {
                            state->mInterpreter->mConfig.mPlatform->logError("Attempted to call parent:: function at root!");
                            stack.push_back(StoredValue(0));
                            return 1;
                        }
 
                        // Once we have a valid function pointer, ask the interpreter to find a super function higher up the chain
                        std::shared_ptr<Function> parentFunction = state->mInterpreter->getFunctionParent(currentFunction);
                        if (!parentFunction)
                        {
                            std::ostringstream stream;
 
                            stream << "Could not find parent function '" << mName << "' for calling! Placing 0 on the stack.";
                            state->mInterpreter->mConfig.mPlatform->logError(stream.str());
 
                            stack.push_back(StoredValue(0));
                            return 1;
                        }
 
                        // Otherwise, call it
                        parentFunction->execute(nullptr, state, mArgc);
 
                        return 1;
                    }
 
                    std::shared_ptr<Function> functionLookup = state->mInterpreter->getFunction(mNameSpace, mName);
                    if (functionLookup)
                    {
                        functionLookup->execute(nullptr, state, mArgc);
                    }
                    else
                    {
                        std::ostringstream stream;
 
                        stream << "Could not find function '" << mName << "' for calling! Placing 0 on the stack.";
                        state->mInterpreter->mConfig.mPlatform->logError(stream.str());
 
                        stack.push_back(StoredValue(0));
                    }
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
 
                    if (mNameSpace == "")
                    {
                        out << "CallFunction " << mName << " argc=" << mArgc;
                    }
                    else
                    {
                        out << "CallFunction " << mNameSpace << "::" << mName << " argc=" << mArgc;
                    }
                    return out.str();
                }
 
                private:
                    std::string mNameSpace;
 
                    std::string mName;
 
                    std::size_t mArgc;
        };
 
        class AddInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
 
                    // NOTE: For now we normalize to floats
                    float lhs = lhsStored.toFloat(state);
                    float rhs = rhsStored.toFloat(state);
 
                    const float result = lhs + rhs;
                    stack.push_back(StoredValue(result));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "Add";
                }
        };
 
        class LessThanInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
 
                    // NOTE: For now we normalize to floats
                    float lhs = lhsStored.toFloat(state);
                    float rhs = rhsStored.toFloat(state);
 
                    const int result = lhs < rhs ? 1 : 0;
                    stack.push_back(StoredValue(result));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "LessThan";
                }
        };
 
        class EqualsInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
 
                    // NOTE: For now we normalize to floats
                    float lhs = lhsStored.toFloat(state);
                    float rhs = rhsStored.toFloat(state);
 
                    const int result = lhs == rhs ? 1 : 0;
                    stack.push_back(StoredValue(result));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "Equals";
                }
        };
 
        class BitwiseAndInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
 
                    // NOTE: For now we normalize to floats
                    int lhs = lhsStored.toInteger(state);
                    int rhs = rhsStored.toInteger(state);
 
                    const int result = lhs & rhs;
                    stack.push_back(StoredValue(result));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "BitwiseAnd";
                }
        };
 
        class MultiplyInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
 
                    // NOTE: For now we normalize to floats
 
                    float lhs = lhsStored.toFloat(state);
                    float rhs = rhsStored.toFloat(state);
 
                    const float result = lhs * rhs;
                    stack.push_back(StoredValue(result));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "Multiply";
                }
        };
 
        class DivideInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 2);
 
                    StoredValue rhsStored = stack.back();
                    stack.pop_back();
                    StoredValue lhsStored = stack.back();
                    stack.pop_back();
 
                    // NOTE: For now we normalize to floats
 
                    float lhs = lhsStored.toFloat(state);
                    float rhs = rhsStored.toFloat(state);
 
                    const float result = lhs / rhs;
                    stack.push_back(StoredValue(result));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "Divide";
                }
        };
 
        class PopInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 1);
                    stack.pop_back();
 
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "Pop";
                }
        };
 
        class JumpInstruction : public Instruction
        {
            public:
                JumpInstruction(const AddressType offset) : mOffset(offset)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    return mOffset;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "Jump " << mOffset;
                    return out.str();
                }
 
            private:
                AddressType mOffset;
        };
 
        class JumpTrueInstruction : public Instruction
        {
            public:
                JumpTrueInstruction(const AddressType offset) : mOffset(offset)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 1);
 
                    StoredValue booleanStored = stack.back();
                    stack.pop_back();
 
                    if (booleanStored.toBoolean(state))
                    {
                        return mOffset;
                    }
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "JumpTrue " << mOffset;
                    return out.str();
                }
 
            private:
                AddressType mOffset;
        };
 
        class JumpFalseInstruction : public Instruction
        {
            public:
                JumpFalseInstruction(const AddressType offset) : mOffset(offset)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 1);
 
                    StoredValue booleanStored = stack.back();
                    stack.pop_back();
 
                    if (!booleanStored.toBoolean(state))
                    {
                        return mOffset;
                    }
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "JumpFalse " << mOffset;
                    return out.str();
                }
 
            private:
                AddressType mOffset;
        };
 
        class NOPInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "NOP";
                }
        };
 
        class FunctionDeclarationInstruction : public Instruction
        {
            public:
                FunctionDeclarationInstruction(const std::string package, const std::string& space, const std::string& name, const std::vector<std::string> parameterNames, const InstructionSequence& instructions) : mPackageName(package), mNameSpace(space), mName(name), mParameterNames(parameterNames), mInstructions(instructions)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    // Register the function
                    std::shared_ptr<Function> newFunction = std::shared_ptr<Function>(new Function(mPackageName, mNameSpace, mName, mParameterNames));
                    newFunction->addInstructions(mInstructions);
                    state->mInterpreter->addFunction(newFunction);
 
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
 
                    if (mNameSpace == NAMESPACE_EMPTY)
                    {
                        out << "FunctionDeclaration " << mName;
                    }
                    else
                    {
                        out << "FunctionDeclaration " << mNameSpace << "::" << mName;
                    }
 
                    if (mPackageName != PACKAGE_EMPTY)
                    {
                        out << "[in Package " << mPackageName << "] ";
                    }
 
                    out << "(";
 
                    // Generate parameter list
                    for (auto iterator = mParameterNames.begin(); iterator != mParameterNames.end(); ++iterator)
                    {
                        if (iterator != mParameterNames.begin())
                        {
                            out << ", ";
                        }
 
                        out << *iterator;
                    }
 
                    // Output all instructions
                    out << ")" << std::endl;
                    for (auto&& instruction : mInstructions)
                    {
                        out << "    " << instruction->disassemble();
                        if (instruction->mComment != "")
                        {
                            out << " // " << instruction->mComment;
                        }
                        out << std::endl;
                    }
                    return out.str();
                }
 
            private:
                std::string mPackageName;
                std::string mNameSpace;
                std::string mName;
                std::vector<std::string> mParameterNames;
                InstructionSequence mInstructions;
        };
 
        class SubReferenceInstruction : public Instruction
        {
            public:
                SubReferenceInstruction(const std::size_t value, const std::size_t arrayIndices) : mStringID(value), mArrayIndices(arrayIndices)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 1);
 
                    const std::string arrayName = resolveArrayNameFromStack(stack, state, state->mInterpreter->mStringTable.getString(mStringID), mArrayIndices);
 
                    StoredValue targetStored = stack.back();
                    stack.pop_back();
                    std::shared_ptr<ConsoleObject> referenced = targetStored.toConsoleObject(state);
 
                    if (referenced)
                    {
                        const std::size_t stringID = state->mInterpreter->mStringTable.getOrAssign(arrayName);
 
                        stack.push_back(StoredValue(referenced, mStringID));
                        return 1;
                    }
 
                    stack.push_back(StoredValue(0));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "SubReference " << mStringID << " argc=" << mArrayIndices;
                    return out.str();
                }
 
            private:
                std::size_t mStringID;
                std::size_t mArrayIndices;
        };
 
        class ReturnInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 1);
 
                    StoredValue targetStored = stack.back();
                    stack.pop_back();
 
                    // For if we return a variable reference, we want to pass back a copy
                    StoredValueStack& returnStack = state->mExecutionScope.getReturnStack();
                    returnStack.push_back(targetStored.getReferencedValueCopy(state));
                    return 0;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "Return";
                    return out.str();
                }
        };
 
        class PushLoopInstruction : public Instruction
        {
            public:
                PushLoopInstruction(const std::size_t loopSize) : mLoopSize(loopSize)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    const AddressType loopPosition = state->mInstructionPointer;
                    state->mExecutionScope.pushLoop(loopPosition, mLoopSize);
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "PushLoop " << mLoopSize;
                    return out.str();
                }
 
            private:
                std::size_t mLoopSize;
        };
 
        class PopLoopInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    state->mExecutionScope.popLoop();
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "PopLoop";
                }
        };
 
        class BreakInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    if (state->mExecutionScope.isLoopStackEmpty())
                    {
                        state->mInterpreter->mConfig.mPlatform->logWarning("Break outside of loop, ignoring ...");
                        return 1;
                    }
 
                    LoopDescriptor descriptor = state->mExecutionScope.currentLoopDescriptor();
                    // This should lead to a PopLoop instruction so we don't pop here
                    const AddressType loopProgress = state->mInstructionPointer - descriptor.mInstructionPointer;
                    return descriptor.mLoopSize - loopProgress;
                };
 
                virtual std::string disassemble() override
                {
                    return "Break";
                }
        };
 
        class AccessArrayInstruction : public Instruction
        {
            public:
                AccessArrayInstruction(const std::string& name, const std::size_t argc, bool global) : mName(name), mArgc(argc), mGlobal(global)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    // When we encounter this instruction, we generate a new variable reference by appending all string representations together
                    // This is what T2 does - it has no concept of arrays despite pretending to
 
                    // FIXME: With more clever use of the ostream we might be able to make this work without the vector
                    std::vector<std::string> variableComponents;
                    for (unsigned int iteration = 0; iteration < mArgc; ++iteration)
                    {
                        variableComponents.push_back(stack.popString(state));
                    }
 
                    std::ostringstream out;
                    out << mName;
                    for (auto iterator = variableComponents.rbegin(); iterator != variableComponents.rend(); ++iterator)
                    {
                        if (iterator != variableComponents.rbegin())
                        {
                            out << "_";
                        }
                        out << *iterator;
                    }
 
                    const std::size_t stringID = state->mInterpreter->mStringTable.getOrAssign(out.str());
                    if (mGlobal)
                    {
                        stack.push_back(StoredValue(stringID, StoredValueType::GlobalReference));
                    }
                    else
                    {
                        stack.push_back(StoredValue(stringID, StoredValueType::LocalReference));
                    }
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "AccessArray " << mName << " argc=" << mArgc << " global=" << mGlobal;
                    return out.str();
                }
 
                private:
                    std::string mName;
                    std::size_t mArgc;
                    bool mGlobal;
        };
 
        class CallBoundFunctionInstruction : public Instruction
        {
            public:
                CallBoundFunctionInstruction(const std::string& name, const std::size_t argc) : mName(name), mArgc(argc)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    assert(stack.size() >= 1);
 
                    StoredValue targetStored = stack.back();
                    stack.pop_back();
 
                    // Retrieve the referenced ConsoleObject
                    std::shared_ptr<ConsoleObject> targetObject = targetStored.toConsoleObject(state);
                    if (!targetObject)
                    {
                        std::ostringstream output;
                        output << "Cannot find object '" << targetStored.toString(state) << "' to call function '" << mName << "'!";
                        state->mInterpreter->mConfig.mPlatform->logWarning(output.str());
 
                        stack.push_back(StoredValue(0));
                        return 1;
                    }
 
                    // Walk the class hierarchy
                    ConsoleObjectDescriptor* descriptor = sConsoleObjectDescriptors->at(targetObject->getClassName());
                    assert(descriptor->mHierarchy.size() != 0);
 
                    for (const std::string& className : descriptor->mHierarchy)
                    {
                        // Ask the interpreter to lookup the function
                        std::shared_ptr<Function> calledFunction = state->mInterpreter->getFunction(className, mName);
                        if (calledFunction)
                        {
                            calledFunction->execute(targetObject, state, mArgc);
                            return 1;
                        }
                    }
 
                    stack.push_back(StoredValue(0));
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "CallBoundFunctionInstruction " << mName << " argc=" << mArgc;
                    return out.str();
                }
 
                private:
                    std::string mName;
                    std::size_t mArgc;
        };
 
        class PushObjectInstantiationInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
                    assert(stack.size() >= 2);
 
                    StoredValue objectName = stack.back();
                    stack.pop_back();
                    StoredValue objectTypeName = stack.back();
                    stack.pop_back();
 
                    state->mExecutionScope.pushObjectInstantiation(objectTypeName.toString(state), objectName.toString(state));
 
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "PushObjectInstantiation";
                }
        };
 
        class PushObjectFieldInstruction : public Instruction
        {
            public:
                PushObjectFieldInstruction(const std::size_t fieldComponentCount) : mFieldComponentCount(fieldComponentCount)
                {
 
                }
 
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
 
                    StoredValue rvalue = stack.back();
                    stack.pop_back();
 
                    // Load array components
                    std::vector<std::string> arrayComponents;
                    for (unsigned int iteration = 0; iteration < mFieldComponentCount; ++iteration)
                    {
                        arrayComponents.push_back(stack.popString(state));
                    }
 
                    // Load base name
                    StoredValue fieldBaseName = stack.back();
                    stack.pop_back();
 
                    std::ostringstream out;
                    out << fieldBaseName.toString(state);
                    for (auto iterator = arrayComponents.rbegin(); iterator != arrayComponents.rend(); ++iterator)
                    {
                        if (iterator != arrayComponents.rbegin())
                        {
                            out << "_";
                        }
                        out << *iterator;
                    }
 
                    // Final field assignment
                    ObjectInstantiationDescriptor& descriptor = state->mExecutionScope.currentObjectInstantiation();
 
                    auto search = descriptor.mFieldAssignments.find(out.str());
                    if (search != descriptor.mFieldAssignments.end())
                    {
                        search->second = rvalue;
                    }
                    else
                    {
                        descriptor.mFieldAssignments.insert(std::make_pair(out.str(), rvalue));
                    }
                    //descriptor.mFieldAssignments[out.str()] = rvalue;
 
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    std::ostringstream out;
                    out << "PushObjectField argc=" << mFieldComponentCount;
                    return out.str();
                }
 
            private:
                std::size_t mFieldComponentCount;
        };
 
        class PopObjectInstantiationInstruction : public Instruction
        {
            public:
                virtual AddressOffsetType execute(std::shared_ptr<ExecutionState> state) override
                {
                    StoredValueStack& stack = state->mExecutionScope.getStack();
                    ObjectInstantiationDescriptor descriptor = state->mExecutionScope.popObjectInstantiation();
 
                    // Track parent/child relationships so we can walk the tree later
                    if (state->mExecutionScope.isAwaitingParentInstantiation())
                    {
                        ObjectInstantiationDescriptor& parentDescriptor = state->mExecutionScope.currentObjectInstantiation();
                        parentDescriptor.mChildren.push_back(descriptor);
                    }
                    else
                    {
                        // Ask the interpreter to initialize the resulting tree
                        std::shared_ptr<ConsoleObject> result = state->mInterpreter->initializeConsoleObjectTree(descriptor);
 
                        if (result)
                        {
                            stack.push_back(StoredValue((int)state->mInterpreter->mConsoleObjectRegistry.getConsoleObjectID(result)));
                        }
                        else
                        {
                            stack.push_back(StoredValue(-1));
                        }
                    }
 
 
                    return 1;
                };
 
                virtual std::string disassemble() override
                {
                    return "PopObjectInstantiation";
                }
        };
    }
}