added context for standalone interpreter

CMakeLists.txt

@@ -188,7 +188,8 @@ endif()
 option(BUILD_MWINTERPRETER "build standalone Morrowind script code interpreter" ON)
 
 if (BUILD_MWINTERPRETER)
-set(TOOLS_MWINTERPRETER ${INTERPRETER} apps/mwinterpreter/main.cpp)
+set(TOOLS_MWINTERPRETER ${INTERPRETER} apps/mwinterpreter/main.cpp
+    apps/mwinterpreter/context.cpp apps/mwinterpreter/context.hpp)
 
 add_executable(mwinterpreter ${TOOLS_MWINTERPRETER})
 endif()

apps/mwinterpreter/context.cpp

@@ -0,0 +1,94 @@
+
+#include "context.hpp"
+
+#include <cassert>
+#include <fstream>
+#include <stdexcept>
+#include <iostream>
+
+namespace SAInterpreter
+{
+    Context::Context (const std::string& filename)
+    {
+        std::ifstream file (filename.c_str());
+        
+        if (!file.is_open())
+            throw std::runtime_error ("can't open locals file: " + filename);
+    
+        std::size_t shortSize, longSize, floatSize;
+        
+        file >> shortSize >> longSize >> floatSize;
+        
+        mShorts.resize (shortSize, 0);
+        mLongs.resize (longSize, 0);
+        mFloats.resize (floatSize, 0.0);
+        
+        std::size_t size = shortSize + longSize + floatSize;
+        
+        mNames.resize (size);
+        
+        for (std::size_t i=0; i<size; ++i)
+            file >> mNames[i];
+    }
+
+    int Context::getLocalShort (int index) const
+    {
+        assert (index>=0);
+        return mShorts.at (index);
+    }
+
+    int Context::getLocalLong (int index) const
+    {
+        assert (index>=0);
+        return mLongs.at (index);
+    }
+    
+    float Context::getLocalFloat (int index) const
+    {
+        assert (index>=0);
+        return mFloats.at (index);
+    }
+    
+    void Context::setLocalShort (int index, int value)
+    {
+        assert (index>=0);
+        mShorts.at (index) = value;
+    }    
+
+    void Context::setLocalLong (int index, int value)
+    {
+        assert (index>=0);
+        mLongs.at (index) = value;
+    }    
+
+    void Context::setLocalFloat (int index, float value)
+    {
+        assert (index>=0);
+        mFloats.at (index) = value;
+    }    
+    
+    void Context::report()
+    {
+        std::size_t i = 0;
+        
+        std::cout << "local shorts:" << std::endl;
+        
+        for (std::vector<Interpreter::Type_Short>::const_iterator iter (mShorts.begin());
+            iter!=mShorts.end(); ++iter)
+            std::cout << mNames[i++] << ": " << *iter << std::endl;            
+    
+        std::cout << "local longs:" << std::endl;
+        
+        for (std::vector<Interpreter::Type_Integer>::const_iterator iter (mLongs.begin());
+            iter!=mLongs.end(); ++iter)
+            std::cout << mNames[i++] << ": " << *iter << std::endl;            
+
+        std::cout << "local floats:" << std::endl;        
+
+        for (std::vector<Interpreter::Type_Float>::const_iterator iter (mFloats.begin());
+            iter!=mFloats.end(); ++iter)
+            std::cout << mNames[i++] << ": " << *iter << std::endl;            
+    
+    }
+}
+

apps/mwinterpreter/context.hpp

@@ -0,0 +1,43 @@
+#ifndef SAINTERPRETER_CONTEXT_H_INCLUDED
+#define SAINTERPRETER_CONTEXT_H_INCLUDED
+
+#include <string>
+#include <vector>
+
+#include <components/interpreter/context.hpp>
+#include <components/interpreter/types.hpp>
+
+namespace SAInterpreter
+{
+    class Context : public Interpreter::Context
+    {
+            std::vector<Interpreter::Type_Short> mShorts;
+            std::vector<Interpreter::Type_Integer> mLongs;
+            std::vector<Interpreter::Type_Float> mFloats;
+            std::vector<std::string> mNames;
+            
+        public:
+        
+            Context (const std::string& filename);
+            ///< Create context from file
+            /// \note A context for an integreted interpreter will typically not
+            /// configure at construction, but will offer a separate function.
+    
+            virtual int getLocalShort (int index) const;
+
+            virtual int getLocalLong (int index) const;
+
+            virtual float getLocalFloat (int index) const;
+
+            virtual void setLocalShort (int index, int value);        
+
+            virtual void setLocalLong (int index, int value);        
+
+            virtual void setLocalFloat (int index, float value);    
+            
+            void report();
+            ///< Write state to std::cout   
+    };
+}
+
+#endif

apps/mwinterpreter/main.cpp

@@ -9,15 +9,19 @@
 #include <components/interpreter/context.hpp>
 #include <components/interpreter/types.hpp>
 
+#include "context.hpp"
+
 int main (int argc, char **argv)
 {
     try
     {      
-        Interpreter::Context context;
-        Interpreter::Interpreter interpreter (context);
-        
         std::string filename = argc>1 ? argv[1] : "test.mwscript";
     
+        std::string localfilename = filename + ".locals";
+        
+        SAInterpreter::Context context (localfilename);
+        Interpreter::Interpreter interpreter (context);
+
         std::string codefilename = filename + ".code";
 
         std::ifstream codefile (codefilename.c_str());
@@ -39,6 +43,8 @@ int main (int argc, char **argv)
         codefile.read (reinterpret_cast<char *> (&code[4]), size * sizeof (Interpreter::Type_Code));
     
         interpreter.run (&code[0], size+4);
+        
+        context.report();
     }
     catch (const std::exception &e)
     {

components/interpreter/context.hpp

@@ -5,7 +5,21 @@ namespace Interpreter
 {
     class Context
     {
+        public:
 
+            virtual ~Context() {}
+
+            virtual int getLocalShort (int index) const = 0;
+
+            virtual int getLocalLong (int index) const = 0;
+
+            virtual float getLocalFloat (int index) const = 0;
+
+            virtual void setLocalShort (int index, int value) = 0;        
+
+            virtual void setLocalLong (int index, int value) = 0;        
+
+            virtual void setLocalFloat (int index, float value) = 0;        
     };
 }
 

components/interpreter/types.hpp

@@ -7,6 +7,8 @@ namespace Interpreter
 
     typedef unsigned int Type_Data; // 32 bit
     
+    typedef short Type_Short; // 16 bit
+    
     typedef int Type_Integer; // 32 bit
     
     typedef float Type_Float; // 32 bit