Changeset 904

Timestamp:

03/09/10 23:15:31 (5 months ago)

Author:

zoogie

Message:

Moving forward on the quest for a single scripting state with multiple sandboxed environments:

• Implemented Script::Env.
• Client::SysConsole is now a subclass of Script::Env.
• GameApp now manages what will be the single global scripting state.

Location:

trunk

Files:

• client/Game2/GameApp.cpp (modified) (4 diffs)
• client/Game2/GameApp.h (modified) (2 diffs)
• client/Game2/SysConsole.cpp (modified) (3 diffs)
• client/Game2/SysConsole.h (modified) (2 diffs)
• engine/Script/Env.cpp (modified) (2 diffs)
• engine/Script/Env.h (modified) (2 diffs)

trunk/client/Game2/GameApp.cpp

@@ -43 +43 @@
 #include "../../engine/VideoServices/VideoBuffer.h"
 #include "../../engine/MainCharacter/MainCharacter.h"
+#include "../../engine/Script/Core.h"
 #include "../../engine/Util/FuzzyLogic.h"
 #include "../../engine/Util/Profiler.h"
@@ -569 +570 @@
 
 MR_GameApp::MR_GameApp(HINSTANCE pInstance, bool safeMode) :
-    introMovie(NULL), sysConsole(NULL)
+    introMovie(NULL), scripting(NULL), sysConsole(NULL)
 {
     This = this;
@@ -612 +613 @@
         delete sysConsole;
         sysConsole = NULL;
+    }
+    if (scripting != NULL) {
+        delete scripting;
+        scripting = NULL;
     }
 
@@ -1136 +1141 @@
     // Create the system console and execute the init script.
     // This allows the script to modify the configuration (e.g. for unit tests).
-    sysConsole = new SysConsole();
-    sysConsole->Init();
+    scripting = new Script::Core();
+    sysConsole = new SysConsole(scripting);
     if (!initScript.empty()) {
         sysConsole->RunScript(initScript);

trunk/client/Game2/GameApp.h

@@ -37 +37 @@
         typedef boost::shared_ptr<Rulebook> RulebookPtr;
         class SysConsole;
+    }
+    namespace Script {
+        class Core;
     }
 }
@@ -83 +86 @@
         HoverRace::Client::IntroMovie *introMovie;
         HoverRace::Client::FullscreenTest *fullscreenTest;
+        HoverRace::Script::Core *scripting;
         HoverRace::Client::SysConsole *sysConsole;
         MR_ClientSession *mCurrentSession;

trunk/client/Game2/SysConsole.cpp

@@ -29 +29 @@
 #include <boost/format.hpp>
 
-#include "../../engine/Script/Core.h"
-
 #include "SysConsole.h"
 
 namespace fs = boost::filesystem;
 
-using namespace HoverRace;
-using namespace HoverRace::Client;
-using namespace HoverRace::Script;
-
-SysConsole::SysConsole() :
-    SUPER(), onInitRef(-1)
-{
+namespace {
+    class LogStreamBuf : public std::stringbuf
+    {
+        typedef std::stringbuf SUPER;
+        public:
+            LogStreamBuf() { }
+            virtual ~LogStreamBuf() { sync(); }
+
+        protected:
+            virtual int sync()
+            {
+                std::string s = str();
+
+#               ifdef _WIN32
+                    OutputDebugString(s.c_str());
+#               endif
+                std::cout << s << std::flush;
+
+                str(std::string());
+                return 0;
+            }
+    };
+
+    class LogStream : public std::ostream
+    {
+        typedef std::ostream SUPER;
+        public:
+            LogStream() : SUPER(new LogStreamBuf()) { }
+            virtual ~LogStream() { delete rdbuf(); }
+    };
+}
+
+namespace HoverRace {
+namespace Client {
+
+SysConsole::SysConsole(Script::Core *scripting) :
+    SUPER(scripting), outHandle(scripting->AddOutput(boost::make_shared<LogStream>()))
+{
+    lua_State *state = scripting->GetState();
+
+    scripting->PrintStack();
+
+    // Initial table for callbacks.
+    lua_newtable(state);
+    onInitRef = luaL_ref(scripting->GetState(), LUA_REGISTRYINDEX);
 }
 
 SysConsole::~SysConsole()
 {
-    if (onInitRef >= 0) {
-        lua_State *state = GetScripting()->GetState();
-        luaL_unref(state, LUA_REGISTRYINDEX, onInitRef);
-    }
-}
-
-void SysConsole::InitEnv(Script::Core *scripting)
-{
-    SUPER::InitEnv(scripting);
-    onInitRef = luaL_ref(scripting->GetState(), LUA_REGISTRYINDEX);
-}
-
-void SysConsole::InitGlobals(Script::Core *scripting)
-{
-    SUPER::InitGlobals(scripting);
-
+    Script::Core *scripting = GetScripting();
+    luaL_unref(scripting->GetState(), LUA_REGISTRYINDEX, onInitRef);
+    scripting->RemoveOutput(outHandle);
+}
+
+void SysConsole::InitEnv()
+{
+    Script::Core *scripting = GetScripting();
     lua_State *state = scripting->GetState();
 
-    lua_pushlightuserdata(state, this);
-    lua_pushcclosure(state, SysConsole::LOnInit, 1);
-    lua_setglobal(state, "on_init");
-
-    lua_pushlightuserdata(state, this);
-    lua_pushcclosure(state, SysConsole::LGetOnInit, 1);
-    lua_setglobal(state, "get_on_init");
-
-    // Initial arrays for callbacks.
-    lua_newtable(state);
-    lua_rawseti(state, LUA_REGISTRYINDEX, onInitRef);
+    // Start with the standard global environment.
+    CopyGlobals();
+
+    lua_pushlightuserdata(state, this);  // table this
+    lua_pushcclosure(state, SysConsole::LOnInit, 1);  // table fn
+    lua_pushstring(state, "on_init");  // table fn str
+    lua_insert(state, -2);  // table str fn
+    lua_rawset(state, -3);  // table
+
+    lua_pushlightuserdata(state, this);  // table this
+    lua_pushcclosure(state, SysConsole::LGetOnInit, 1);  // table fn
+    lua_pushstring(state, "get_on_init");  // table fn str
+    lua_insert(state, -2);  // table str fn
+    lua_rawset(state, -3);  // table
 }
 
@@ -113 +144 @@
     fs::ifstream ifs(scriptPath, std::ios_base::in);
     std::string ris((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
-    SubmitChunk(ris);
+    try {
+        Execute(ris);
+    }
+    catch (Script::ScriptExn &ex) {
+        LogError(ex.what());
+    }
 }
 
@@ -166 +202 @@
     return 1;
 }
+
+}  // namespace Client
+}  // namespace HoverRace

trunk/client/Game2/SysConsole.h

@@ -23 +23 @@
 #pragma once
 
-#include "Console.h"
+#include "../../engine/Script/Core.h"
+#include "../../engine/Script/Env.h"
+
+namespace HoverRace {
+    namespace Script {
+        class Core;
+    }
+}
 
 namespace HoverRace {
 namespace Client {
 
-class SysConsole : public Console
+class SysConsole : private Script::Env
 {
-    typedef Console SUPER;
+    typedef Script::Env SUPER;
 
     public:
-        SysConsole();
+        SysConsole(Script::Core *scripting);
         virtual ~SysConsole();
 
     protected:
-        virtual void InitEnv(Script::Core *scripting);
-        virtual void InitGlobals(Script::Core *scripting);
+        virtual void InitEnv();
 
-    public:
-        virtual void Advance(Util::OS::timestamp_t tick) { };
-        virtual void Clear() { };
-    
     protected:
         virtual void LogInfo(const std::string &s);
@@ -59 +61 @@
 
     private:
+        Script::Core::OutHandle outHandle;
         int onInitRef;
 };

trunk/engine/Script/Env.cpp

@@ -23 +23 @@
 #include "StdAfx.h"
 
+#include "Core.h"
+
 #include "Env.h"
 
@@ -28 +30 @@
 namespace Script {
 
+/**
+ * Constructor.
+ * @param scripting The scripting engine (may not be @c NULL).
+ */
 Env::Env(Core *scripting) :
-    scripting(scripting)
+    scripting(scripting), initialized(false)
 {
+    lua_State *state = scripting->GetState();
+
+    // Store a placeholder at the registry location.
+    lua_pushinteger(state, 1);
+    envRef = luaL_ref(state, LUA_REGISTRYINDEX);
 }
 
 Env::~Env()
 {
+    luaL_unref(scripting->GetState(), LUA_REGISTRYINDEX, envRef);
+}
+
+/**
+ * Initialize the environment in which scripts will run in.
+ * Upon entry, the Lua stack will have at least one entry, the table which
+ * represents the environment.  Implementing functions will fill this table
+ * with the globals which will be available to the functions which are run
+ * in this environment.  Upon return, this same table must be at the top of
+ * the stack.
+ */
+void Env::InitEnv()
+{
+}
+
+/**
+ * Copy the global environment into the current table at the top of the stack.
+ * This is meant to be called from InitEnv() as a convenience.
+ */
+void Env::CopyGlobals()
+{
+    lua_State *state = scripting->GetState();
+
+    lua_pushnil(state);  // table nil
+    while (lua_next(state, LUA_GLOBALSINDEX) != 0) {
+        // table key value
+        lua_pushvalue(state, -2);  // table key value key
+        lua_insert(state, -2);  // table key key value
+        lua_rawset(state, -4);  // table key
+    }
+    // table
+}
+
+/**
+ * Execute a chunk of code in the current environment.
+ * @param chunk The code to execute.
+ * @throw IncompleteExn If the code does not complete a statement; i.e.,
+ *                      expecting more tokens.  Callers can catch this
+ *                      to keep reading more data to finish the statement.
+ * @throw ScriptExn The code either failed to compile or signaled an error
+ *                  while executing.
+ */
+void Env::Execute(const std::string &chunk)
+{
+    lua_State *state = scripting->GetState();
+
+    // May throw ScriptExn or IncompleteExn, in which case stack will be unchanged.
+    scripting->Compile(chunk);
+
+    if (initialized) {
+        lua_rawgeti(state, LUA_REGISTRYINDEX, envRef);
+    }
+    else {
+        lua_newtable(state);
+        InitEnv();
+        initialized = true;
+        lua_pushvalue(state, -1);
+        lua_rawseti(state, LUA_REGISTRYINDEX, envRef);
+    }
+    lua_setfenv(state, -2);
+
+    // May throw ScriptExn, but the function on the stack will be consumed anyway.
+    scripting->CallAndPrint();
 }
 

trunk/engine/Script/Env.h

@@ -23 +23 @@
 #pragma once
 
-#include "Core.h"
-
 #ifdef _WIN32
 #   ifdef MR_ENGINE
@@ -46 +44 @@
         virtual ~Env();
 
+    protected:
+        Core *GetScripting() const { return scripting; }
+
+        virtual void InitEnv() = 0;
+        void CopyGlobals();
+
+        void Execute(const std::string &chunk);
+
     private:
         Core *scripting;
+        bool initialized;
+        int envRef;
 };