ScriptingEngine.h

#pragma once
 
#include "Base.h"
#include "Utilities/Parsing.h"
 
#include "Foundation/Collections/Pool.h"
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/StringView.h"
 
#include <functional>
#include <memory>
#include <vector>
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    enum class ScriptFlags
    {
      None = 0,
      Unknown = 1 << 0,
      JavaScript = 1 << 1,
      Lua = 1 << 2,
      SourceText = 1 << 3,
      SourcePath = 1 << 4,
    };
 
    ENABLE_ENUM_FLAGS(ScriptFlags);
 
    enum class ScriptValueType
    {
      Undefined = 0,
      Object = 1,
      String = 2,
      Proxy = 3,
    };
 
    struct ScriptObject;
 
    struct ScriptArg
    {
      std::string stringValue;
    };
 
    using ScriptArgs = std::vector<ScriptArg>;
 
    using ScriptFunctionType = std::function<ScriptObject *(ScriptObject *, const ScriptArgs & args)>;
    using ScriptProxyGet = std::function<ScriptObject *(ScriptObject *, const StringView & key)>;
    using ScriptProxySet = std::function<bool(ScriptObject *, const StringView & key, const ScriptArg & arg)>;
 
    struct ScriptFunction
    {
      ScriptFunctionType func;
      ScriptValueType retValue;
      std::vector<ScriptValueType> argTypes;
    };
 
    struct ScriptProperty
    {
      ScriptFunctionType getter;
      ScriptFunctionType setter;
      ScriptValueType type;
    };
 
    class ScriptContext;
 
    struct ScriptObject
    {
      std::vector<ScriptFunction> functions;
      ScriptValueType type;
      ScriptProxyGet proxyGet;
      ScriptProxySet proxySet;
      std::weak_ptr<ScriptContext> context;
      void * heapPtr;
      int heapIndex;
      int generation;
    };
    
    class ScriptContext
    {
    public:
      virtual ~ScriptContext() {}
      virtual void update() {}
 
      virtual bool addScript(const StringView & /*source*/, ScriptFlags /*flags*/ = ScriptFlags::None) { return false; }
      virtual Cogs::StringView eval(const StringView & /*str*/) { return {}; }
 
      virtual ScriptObject * createObject(ScriptValueType /*type*/ = ScriptValueType::Object, void * /*value*/ = nullptr) { return nullptr; }
      virtual ScriptObject * createObjectProxy(ScriptProxyGet /*get*/, ScriptProxySet /*set*/) { return nullptr; }
 
      virtual void setProperty(ScriptObject * /*target*/, const StringView & /*name*/, ScriptObject * /*value*/) {}
      virtual void setProperty(ScriptObject * /*target*/, const StringView & /*name*/, const StringView & /*value*/) {}
      virtual void setProperty(ScriptObject * /*target*/, const StringView & /*name*/, double /*value*/) {}
 
      virtual void addFunction(ScriptObject *, const StringView & /*name*/, ScriptValueType /*returnValue*/, std::vector<ScriptValueType> /*args*/, ScriptFunctionType /*func*/) {}
      virtual void addProperty(ScriptObject *, const StringView & /*name*/, ScriptValueType /*type*/, ScriptFunctionType /*getter*/, ScriptFunctionType /*setter*/) {}
 
      virtual void callFunction(ScriptObject *, const StringView & /*name*/, ScriptObject * /*arg*/) {}
 
      std::string source;
      std::string content;
 
      std::string evalResult;
      std::string evalStack;
 
      Cogs::Collections::Pool<ScriptObject> pool;
      std::weak_ptr<ScriptContext> self;
    };
 
    using ScriptContextHandle = std::shared_ptr<ScriptContext>;
 
    class ScriptingEngine
    {
    public:
      virtual ~ScriptingEngine() {}
 
      virtual void initialize() = 0;
      virtual void cleanup() = 0;
 
      virtual Cogs::StringView eval(const StringView & /*str*/) { return {}; }
      virtual void completions(const TokenStream & /*tokens*/, TokenStream & /*completions*/) {}
 
      virtual ScriptContextHandle createContext(Cogs::ComponentModel::Entity * /*entity*/, const StringView & /*source*/, ScriptFlags /*flags*/) = 0;
 
      struct EditorContext
      {
        std::string name;
 
        std::string buffer = std::string(16384, '\0');
        std::vector<std::string> history;
        std::vector<std::string> commandHistory;
        int historyIndex = 0;
        bool movedUp = false;
        bool movedDown = false;
 
        TokenStream currentCompletions;
        int completionIndex = 0;
        size_t completionOffset = 0;
        std::string original;
        std::string suggested;
 
        bool scrollToBottom = true;
      } editorContext;
 
      virtual bool canLoad(ScriptFlags flags) const = 0;
 
    protected:
      ScriptingEngine(Context * context) : context(context) {}
 
      Context * context;
    };
  }
}