interpreter.hpp

 
#pragma once
 
#include <vector>
#include <memory>
#include <unordered_map>
 
#include <torquescript/interpreterconfiguration.hpp>
#include <torquescript/function.hpp>
#include <torquescript/consoleobject.hpp>
#include <torquescript/storedvalue.hpp>
#include <torquescript/stringhelpers.hpp>
#include <torquescript/stringtable.hpp>
#include <torquescript/functionregistry.hpp>
#include <torquescript/storedvaluestack.hpp>
#include <torquescript/consoleobjectregistry.hpp>
 
#define NAMESPACE_EMPTY ""
#define PACKAGE_EMPTY ""
 
namespace TorqueScript
{
    class Compiler;
    class CodeBlock;
    class ExecutionState;
 
    class Interpreter
    {
        public:
            Interpreter();
 
            Interpreter(const InterpreterConfiguration& config);
            ~Interpreter();
 
            void setGlobal(const std::size_t name, StoredValue value);
            void setGlobal(const std::string& name, StoredValue value);
 
            StoredValue* getGlobal(const std::string& name);
 
            StoredValue* getGlobal(const std::size_t name);
 
 
            CodeBlock* compile(const std::string& input);
            void evaluate(const std::string& input, std::shared_ptr<ExecutionState> state = nullptr);
            void execute(const std::string& path, std::shared_ptr<ExecutionState> state = nullptr);
 
 
            void addFunction(std::shared_ptr<Function> function);
            std::shared_ptr<Function> getFunction(const std::string& space, const std::string& name);
            std::shared_ptr<Function> getFunctionParent(Function* function);
 
            FunctionRegistry* findFunctionRegistry(const std::string packageName);
            void addFunctionRegistry(const std::string& packageName);
            void activateFunctionRegistry(const std::string& packageName);
            void deactivateFunctionRegistry(const std::string& packageName);
            void removeFunctionRegistry(const std::string& packageName);
 
            std::shared_ptr<ExecutionState> getExecutionState();
 
            ConsoleObjectRegistry mConsoleObjectRegistry;
 
            StringTable mStringTable;
 
            const InterpreterConfiguration mConfig;
 
            std::shared_ptr<ConsoleObject> initializeConsoleObjectTree(ObjectInstantiationDescriptor& descriptor);
 
            template <typename classType>
            void registerConsoleObjectType()
            {
                // Ensure descriptors are initialized
                classType::initializeMemberFields(TypeInformation<classType>::Descriptor);
            }
 
        private:
            Compiler* mCompiler;
 
            std::vector<FunctionRegistry> mFunctionRegistries;
 
            std::unordered_map<std::size_t, StoredValue> mGlobalVariables;
    };
}