executionscope.hpp

 
#pragma once
 
#include <vector>
#include <memory>
#include <unordered_map>
 
#include <torquescript/storedvalue.hpp>
#include <torquescript/stringhelpers.hpp>
#include <torquescript/function.hpp>
#include <torquescript/stringtable.hpp>
#include <torquescript/codeblock.hpp>
#include <torquescript/stringtable.hpp>
#include <torquescript/interpreterconfiguration.hpp>
#include <torquescript/storedvaluestack.hpp>
#include <torquescript/consoleobject.hpp>
 
namespace TorqueScript
{
    struct LoopDescriptor
    {
        LoopDescriptor(const AddressType pointer, const std::size_t size) : mInstructionPointer(pointer), mLoopSize(size)
        {
 
        }
 
        AddressType mInstructionPointer;
        std::size_t mLoopSize;
    };
 
    struct ObjectInstantiationDescriptor
    {
        ObjectInstantiationDescriptor(const std::string typeName, const std::string& name) : mName(name), mTypeName(typeName)
        {
 
        }
 
        std::string mName;
 
        std::string mTypeName;
 
        std::vector<ObjectInstantiationDescriptor> mChildren;
        
        std::map<std::string, StoredValue> mFieldAssignments;
    };
 
    struct ExecutionScopeData
    {
        ExecutionScopeData(Function* function) : mCurrentFunction(function)
        {
 
        }
 
        Function* mCurrentFunction;
 
        StoredValueStack mStack;
 
        std::vector<ObjectInstantiationDescriptor> mObjectInstantiations;
 
        std::vector<LoopDescriptor> mLoopDescriptors;
        std::map<std::size_t, StoredValue> mLocalVariables;
    };
 
    class ExecutionScope
    {
        public:
            ExecutionScope(const InterpreterConfiguration& config, StringTable* table);
 
            void pushFrame(Function* function);
            void popFrame();
 
            void pushLoop(const AddressType pointer, const std::size_t depth);
            LoopDescriptor popLoop();
            LoopDescriptor currentLoopDescriptor();
 
            bool isAwaitingParentInstantiation();
            void pushObjectInstantiation(const std::string& typeName, const std::string& name);
            ObjectInstantiationDescriptor popObjectInstantiation();
            ObjectInstantiationDescriptor& currentObjectInstantiation();
 
            bool isLoopStackEmpty();
            std::size_t getFrameDepth();
 
            Function* getCurrentFunction();
            StoredValueStack& getStack();
            StoredValueStack& getReturnStack();
 
            StoredValue* getVariable(const std::string& name);
            StoredValue* getVariable(const std::size_t name);
            void setVariable(const std::string& name, StoredValue variable);
            void setVariable(const std::size_t name, StoredValue variable);
 
            const InterpreterConfiguration mConfig;
 
        private:
            StringTable* mStringTable;
 
            std::vector<ExecutionScopeData> mExecutionScopeData;
    };
}