From 106d12906a9b6299f7878be17f3b280074407190 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Sun, 27 Jun 2010 14:17:04 +0200
Subject: [PATCH 01/40] special case handling for script records

---
 components/esm_store/reclists.hpp | 29 +++++++++++++++++++++++++++++
 components/esm_store/store.hpp    |  4 ++--
 2 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/components/esm_store/reclists.hpp b/components/esm_store/reclists.hpp
index 196ce6063..75d4e67ae 100644
--- a/components/esm_store/reclists.hpp
+++ b/components/esm_store/reclists.hpp
@@ -131,6 +131,35 @@ namespace ESMS
         }
     }
   };
+  
+  template <typename X>
+  struct ScriptListT : RecList
+  {
+    typedef std::map<std::string,X> MapType;
+
+    MapType list;
+
+    // Load one object of this type
+    void load(ESMReader &esm, const std::string &id)
+    {
+      X ref;
+      ref.load (esm);
+      
+      std::string realId = ref.data.name.toString();
+      
+      std::swap (list[realId], ref);
+    }
+
+    // Find the given object ID, or return NULL if not found.
+    const X* find(const std::string &id) const
+    {
+      if(list.find(id) == list.end())
+        return NULL;
+      return &list.find(id)->second;
+    }
+
+    int getSize() { return list.size(); }
+  };  
 
   /* We need special lists for:
 
diff --git a/components/esm_store/store.hpp b/components/esm_store/store.hpp
index 44bd87279..7c4971ac4 100644
--- a/components/esm_store/store.hpp
+++ b/components/esm_store/store.hpp
@@ -73,7 +73,7 @@ namespace ESMS
     //RecListT<Land>        lands;
     //RecListT<LandTexture> landTexts;
     //RecListT<MagicEffect> magicEffects;
-    //RecListT<Script>      scripts;
+    ScriptListT<Script>      scripts;
     //RecListT<Skill>       skills;
     //RecListT<PathGrid>    pathgrids;
 
@@ -130,7 +130,7 @@ namespace ESMS
       recLists[REC_RACE] = &races;
       recLists[REC_REGN] = &regions;
       recLists[REC_REPA] = &repairs;
-      //recLists[REC_SCPT] = &scripts;
+      recLists[REC_SCPT] = &scripts;
       //recLists[REC_SKIL] = &skills;
       recLists[REC_SNDG] = &soundGens;
       recLists[REC_SOUN] = &sounds;

From 31e22186ef893699e244b8a48bdb73324a900fdc Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Sun, 27 Jun 2010 14:29:08 +0200
Subject: [PATCH 02/40] added mwscript compiler standalone-executable (doesn't
 do anything yet)

---
 CMakeLists.txt           | 10 ++++++++++
 apps/mwcompiler/main.cpp |  8 ++++++++
 2 files changed, 18 insertions(+)
 create mode 100644 apps/mwcompiler/main.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1de408bb4..3cfdb5f97 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -158,3 +158,13 @@ if (APPLE)
     MACOSX_BUNDLE_BUNDLE_NAME "OpenMW"
   )
 endif (APPLE)
+
+# Tools
+option(BUILD_MWCOMPILER "build standalone Morrowind script compiler" ON)
+
+if (BUILD_MWCOMPILER)
+set(TOOLS_MWCOMPILER apps/mwcompiler/main.cpp)
+
+add_executable(mwcompiler ${TOOLS_MWCOMPILER})
+endif()
+
diff --git a/apps/mwcompiler/main.cpp b/apps/mwcompiler/main.cpp
new file mode 100644
index 000000000..3e42b7caf
--- /dev/null
+++ b/apps/mwcompiler/main.cpp
@@ -0,0 +1,8 @@
+// Stand-alone MW-script compiler
+
+int main (int argc, char **argv)
+{
+
+
+}
+

From ddcbc8cd62adc204e65ee27d09f06bfb7dee2f8f Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Sun, 27 Jun 2010 19:20:21 +0200
Subject: [PATCH 03/40] added tokenizing of MW scripts

---
 CMakeLists.txt                             |  17 +-
 apps/mwcompiler/main.cpp                   |  27 +-
 components/compiler/context.hpp            |  13 +
 components/compiler/errorhandler.cpp       |  65 ++++
 components/compiler/errorhandler.hpp       |  68 ++++
 components/compiler/exception.hpp          |  32 ++
 components/compiler/fileparser.cpp         |  56 +++
 components/compiler/fileparser.hpp         |  40 ++
 components/compiler/parser.cpp             | 126 +++++++
 components/compiler/parser.hpp             |  90 +++++
 components/compiler/scanner.cpp            | 414 +++++++++++++++++++++
 components/compiler/scanner.hpp            |  84 +++++
 components/compiler/streamerrorhandler.cpp |  38 ++
 components/compiler/streamerrorhandler.hpp |  37 ++
 components/compiler/tokenloc.hpp           |  20 +
 15 files changed, 1120 insertions(+), 7 deletions(-)
 create mode 100644 components/compiler/context.hpp
 create mode 100644 components/compiler/errorhandler.cpp
 create mode 100644 components/compiler/errorhandler.hpp
 create mode 100644 components/compiler/exception.hpp
 create mode 100644 components/compiler/fileparser.cpp
 create mode 100644 components/compiler/fileparser.hpp
 create mode 100644 components/compiler/parser.cpp
 create mode 100644 components/compiler/parser.hpp
 create mode 100644 components/compiler/scanner.cpp
 create mode 100644 components/compiler/scanner.hpp
 create mode 100644 components/compiler/streamerrorhandler.cpp
 create mode 100644 components/compiler/streamerrorhandler.hpp
 create mode 100644 components/compiler/tokenloc.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3cfdb5f97..9457acf53 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -65,11 +65,18 @@ set(MISC components/misc/stringops.cpp components/misc/fileops.cpp)
 set(MISC_HEADER components/misc/fileops.hpp components/misc/slice_array.hpp
     components/misc/stringops.hpp)
 source_group(misc FILES ${MISC} ${MISC_HEADER})    
-
-set(COMPONENTS ${BSA} ${NIF} ${NIFOGRE} ${ESM_STORE} ${OGRE} ${INPUT} ${MISC})
-set(COMPONENTS_HEADER ${BSA_HEADER} ${NIF_HEADER} ${NIFOGRE_HEADER} ${ESM_STORE_HEADER}
-    ${ESM_HEADER} ${OGRE_HEADER} ${INPUT_HEADER} ${MISC_HEADER})
     
+set(COMPILER components/compiler/errorhandler.cpp
+    components/compiler/fileparser.cpp
+    components/compiler/parser.cpp components/compiler/scanner.cpp
+    components/compiler/streamerrorhandler.cpp)
+file(GLOB COMPILER_HEADER components/compiler/*.hpp)
+source_group(compiler FILES ${COMPILER} ${COMPILER_HEADER})    
+
+set(COMPONENTS ${BSA} ${NIF} ${NIFOGRE} ${ESM_STORE} ${OGRE} ${INPUT} ${MISC} ${COMPILER})
+set(COMPONENTS_HEADER ${BSA_HEADER} ${NIF_HEADER} ${NIFOGRE_HEADER} ${ESM_STORE_HEADER}
+    ${ESM_HEADER} ${OGRE_HEADER} ${INPUT_HEADER} ${MISC_HEADER} ${COMPILER_HEADER})
+
 # source directory: libs
 
 set(MANGLE_VFS libs/mangle/vfs/servers/ogre_vfs.cpp)
@@ -163,7 +170,7 @@ endif (APPLE)
 option(BUILD_MWCOMPILER "build standalone Morrowind script compiler" ON)
 
 if (BUILD_MWCOMPILER)
-set(TOOLS_MWCOMPILER apps/mwcompiler/main.cpp)
+set(TOOLS_MWCOMPILER ${COMPILER} apps/mwcompiler/main.cpp)
 
 add_executable(mwcompiler ${TOOLS_MWCOMPILER})
 endif()
diff --git a/apps/mwcompiler/main.cpp b/apps/mwcompiler/main.cpp
index 3e42b7caf..4932833a6 100644
--- a/apps/mwcompiler/main.cpp
+++ b/apps/mwcompiler/main.cpp
@@ -1,8 +1,31 @@
 // Stand-alone MW-script compiler
 
-int main (int argc, char **argv)
-{
+#include <exception>
+#include <iostream>
+#include <fstream>
 
+#include <components/compiler/streamerrorhandler.hpp>
+#include <components/compiler/scanner.hpp>
+#include <components/compiler/fileparser.hpp>
+#include <components/compiler/context.hpp>
 
+int main (int argc, char **argv)
+{
+    try
+    {
+        Compiler::Context context;
+        Compiler::StreamErrorHandler errorHandler (std::cout);
+        Compiler::FileParser parser (errorHandler, context);
+        
+        std::ifstream file ("test.mwscript");
+        Compiler::Scanner scanner (errorHandler, file);
+        
+        scanner.scan (parser);
+    }
+    catch (const std::exception &e)
+    {
+        std::cout << "\nERROR: " << e.what() << std::endl;
+        return 1;
+    }
 }
 
diff --git a/components/compiler/context.hpp b/components/compiler/context.hpp
new file mode 100644
index 000000000..795514cfd
--- /dev/null
+++ b/components/compiler/context.hpp
@@ -0,0 +1,13 @@
+#ifndef COMPILER_CONTEXT_H_INCLUDED
+#define COMPILER_CONTEXT_H_INCLUDED
+
+namespace Compiler
+{
+    class Context
+    {
+    
+    };
+}
+
+#endif
+
diff --git a/components/compiler/errorhandler.cpp b/components/compiler/errorhandler.cpp
new file mode 100644
index 000000000..ee13c837d
--- /dev/null
+++ b/components/compiler/errorhandler.cpp
@@ -0,0 +1,65 @@
+
+#include "errorhandler.hpp"
+
+namespace Compiler
+{
+    // constructor
+
+    ErrorHandler::ErrorHandler() : mWarnings (0), mErrors (0) {}
+
+    // destructor
+
+    ErrorHandler::~ErrorHandler() {}
+
+    // Was compiling successful?
+
+    bool ErrorHandler::isGood() const
+    {
+        return mErrors==0;
+    }
+
+    // Return number of errors
+
+    int ErrorHandler::countErrors() const
+    {
+        return mErrors;
+    }
+
+    // Return number of warnings
+
+    int ErrorHandler::countWarnings() const
+    {
+        return mWarnings;
+    }
+
+    // Generate a warning message.
+
+    void ErrorHandler::warning (const std::string& message, const TokenLoc& loc)
+    {
+        ++mWarnings;
+        report (message, loc, WarningMessage);
+    }
+
+    // Generate an error message.
+
+    void ErrorHandler::error (const std::string& message, const TokenLoc& loc)
+    {
+        ++mErrors;
+        report (message, loc, ErrorMessage);
+    }
+
+    // Generate an error message for an unexpected EOF.
+
+    void ErrorHandler::endOfFile()
+    {
+        ++mErrors;
+        report ("unexpected end of file", ErrorMessage);
+    }
+
+    // Remove all previous error/warning events
+
+    void ErrorHandler::reset()
+    {
+        mErrors = mWarnings = 0;
+    }
+}
diff --git a/components/compiler/errorhandler.hpp b/components/compiler/errorhandler.hpp
new file mode 100644
index 000000000..636eb996a
--- /dev/null
+++ b/components/compiler/errorhandler.hpp
@@ -0,0 +1,68 @@
+
+#ifndef COMPILER_ERRORHANDLER_H_INCLUDED
+#define COMPILER_ERRORHANDLER_H_INCLUDED
+
+#include <string>
+
+namespace Compiler
+{
+    struct TokenLoc;
+
+    /// \brief Error handling
+    ///
+    /// This class collects errors and provides an interface for reporting them to the user.
+
+    class ErrorHandler
+    {
+            int mWarnings;
+            int mErrors;
+
+        protected:
+
+            enum Type
+            {
+                WarningMessage, ErrorMessage
+            };
+
+        private:
+
+        // mutators
+
+            virtual void report (const std::string& message, const TokenLoc& loc, Type type) = 0;
+            ///< Report error to the user.
+
+            virtual void report (const std::string& message, Type type) = 0;
+            ///< Report a file related error
+
+        public:
+
+            ErrorHandler();
+		    ///< constructor
+
+            virtual ~ErrorHandler();
+		    ///< destructor
+
+            bool isGood() const;
+            ///< Was compiling successful?
+
+            int countErrors() const;
+            ///< Return number of errors
+
+            int countWarnings() const;
+            ///< Return number of warnings
+
+            void warning (const std::string& message, const TokenLoc& loc);
+            ///< Generate a warning message.
+
+            void error (const std::string& message, const TokenLoc& loc);
+            ///< Generate an error message.
+
+            void endOfFile();
+            ///< Generate an error message for an unexpected EOF.
+
+           virtual void reset();
+            ///< Remove all previous error/warning events
+    };
+}
+
+#endif
diff --git a/components/compiler/exception.hpp b/components/compiler/exception.hpp
new file mode 100644
index 000000000..ab073adfb
--- /dev/null
+++ b/components/compiler/exception.hpp
@@ -0,0 +1,32 @@
+#ifndef COMPILER_EXCEPTION_H_INCLUDED
+#define COMPILER_EXCEPTION_H_INCLUDED
+
+#include <exception>
+
+namespace Compiler
+{
+    /// \brief Exception: Error while parsing the source
+
+    class SourceException : public std::exception
+    {
+            virtual const char *what() const throw() { return "compile error";} 
+            ///< Return error message
+    };
+
+    /// \brief Exception: File error
+
+    class FileException
+    {
+            virtual const char *what() const throw() { return "can't read file"; }
+            ///< Return error message
+    };
+
+    /// \brief Exception: EOF condition encountered
+
+    class EOFException
+    {
            virtual const char *what() const throw() { return "end of file"; }
+            ///< Return error message
+    };
+}
+
+#endif
diff --git a/components/compiler/fileparser.cpp b/components/compiler/fileparser.cpp
new file mode 100644
index 000000000..416854c1c
--- /dev/null
+++ b/components/compiler/fileparser.cpp
@@ -0,0 +1,56 @@
+#include "fileparser.hpp"
+
+#include <iostream>
+
+#include "tokenloc.hpp"
+
+
+#include "scanner.hpp"
+
+namespace Compiler
+{
+    FileParser::FileParser (ErrorHandler& errorHandler, Context& context)
+    : Parser (errorHandler, context)
+    {}
+
+    bool FileParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
+    {
+        std::cout << "integer: " << value << std::endl;
+        return true;
+    }
+
+    bool FileParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
+    {
+        std::cout << "float: " << value << std::endl;
+        return true;
+    }
+
+    bool FileParser::parseName (const std::string& name, const TokenLoc& loc,
+        Scanner& scanner)
+    {
+        std::cout << "name: " << name << std::endl;
+        return true;
+    }
+
+    bool FileParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        std::cout << "keyword: " << loc.mLiteral << std::endl;
+        return true;
+    }
+
+    bool FileParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (code==Scanner::S_newline)
+            std::cout << "newline" << std::endl;
+        else
+            std::cout << "special: " << loc.mLiteral << std::endl;
+            
+        return true;
+    }
+
+    void FileParser::parseEOF (Scanner& scanner)
+    {
+        std::cout << "end of file" << std::endl;
+    }
+}
+
diff --git a/components/compiler/fileparser.hpp b/components/compiler/fileparser.hpp
new file mode 100644
index 000000000..2007c7ef2
--- /dev/null
+++ b/components/compiler/fileparser.hpp
@@ -0,0 +1,40 @@
+#ifndef COMPILER_FILEPARSER_H_INCLUDED
+#define COMPILER_FILEPARSER_H_INCLUDED
+
+#include "parser.hpp"
+
+namespace Compiler
+{
+    class FileParser : public Parser
+    {
+        public:
+        
+            FileParser (ErrorHandler& errorHandler, Context& context);
+
+            virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle an int token.
+            /// \return fetch another token?
+
+            virtual bool parseFloat (float value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a double token.
+            /// \return fetch another token?
+
+            virtual bool parseName (const std::string& name, const TokenLoc& loc,
+                Scanner& scanner);
+            ///< Handle a name token.
+            /// \return fetch another token?
+
+            virtual bool parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a keyword token.
+            /// \return fetch another token?
+
+            virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+
+            virtual void parseEOF (Scanner& scanner);
+            ///< Handle EOF token.    
+    };
+}
+
+#endif
diff --git a/components/compiler/parser.cpp b/components/compiler/parser.cpp
new file mode 100644
index 000000000..d5a7506c5
--- /dev/null
+++ b/components/compiler/parser.cpp
@@ -0,0 +1,126 @@
+
+#include "parser.hpp"
+
+#include "errorhandler.hpp"
+#include "exception.hpp"
+
+namespace Compiler
+{
+    // Report the error and throw an exception.
+
+    void Parser::reportSeriousError (const std::string& message, const TokenLoc& loc)
+    {
+        mErrorHandler.error (message, loc);
+        throw SourceException();
+    }
+
+    // Report the error
+
+    void Parser::reportError (const std::string& message, const TokenLoc& loc)
+    {
+        mErrorHandler.error (message, loc);
+    }
+
+    // Report the warning without throwing an exception.
+
+    void Parser::reportWarning (const std::string& message, const TokenLoc& loc)
+    {
+        mErrorHandler.warning (message, loc);
+    }
+
+    // Report an unexpected EOF condition.
+
+    void Parser::reportEOF()
+    {
+        mErrorHandler.endOfFile();
+        throw EOFException();
+    }
+
+    // Return error handler
+
+    ErrorHandler& Parser::getErrorHandler()
+    {
+        return mErrorHandler;
+    }
+
+    // Return context
+
+    Context& Parser::getContext()
+    {
+        return mContext;
+    }
+
+    Parser::Parser (ErrorHandler& errorHandler, Context& context)
+    : mErrorHandler (errorHandler), mContext (context)
+    {}
+
+    // destructor
+
+    Parser::~Parser() {}
+
+    // Handle an int token.
+    // \return fetch another token?
+    //
+    // - Default-implementation: Report an error.
+
+    bool Parser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
+    {
+        reportSeriousError ("Unexpected numeric value", loc);
+        return false;
+    }
+
+    // Handle a float token.
+    // \return fetch another token?
+    //
+    // - Default-implementation: Report an error.
+
+    bool Parser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
+    {
+        reportSeriousError ("Unexpected floating point value", loc);
+        return false;
+    }
+
+    // Handle a name token.
+    // \return fetch another token?
+    //
+    // - Default-implementation: Report an error.
+
+    bool Parser::parseName (const std::string& name, const TokenLoc& loc,
+        Scanner& scanner)
+    {
+        reportSeriousError ("Unexpected name", loc);
+        return false;
+    }
+
+    // Handle a keyword token.
+    // \return fetch another token?
+    //
+    // - Default-implementation: Report an error.
+
+    bool Parser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        reportSeriousError ("Unexpected keyword", loc);
+        return false;
+    }
+
+    // Handle a special character token.
+    // \return fetch another token?
+    //
+    // - Default-implementation: Report an error.
+
+    bool Parser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        reportSeriousError ("Unexpected special token", loc);
+        return false;
+    }
+
+    // Handle an EOF token.
+    //
+    // - Default-implementation: Report an error.
+
+    void Parser::parseEOF (Scanner& scanner)
+    {
+        reportEOF();
+    }
+}
+
diff --git a/components/compiler/parser.hpp b/components/compiler/parser.hpp
new file mode 100644
index 000000000..e54d17013
--- /dev/null
+++ b/components/compiler/parser.hpp
@@ -0,0 +1,90 @@
+#ifndef COMPILER_PARSER_H_INCLUDED
+#define COMPILER_PARSER_H_INCLUDED
+
+#include <string>
+
+namespace Compiler
+{
+    class Scanner;
+    class TokenLoc;
+    class ErrorHandler;
+    class Context;
+
+    /// \brief Parser base class
+    ///
+    /// This class defines a callback-parser.
+
+    class Parser
+    {
+            ErrorHandler& mErrorHandler;
+            Context& mContext;
+
+        protected:
+
+        // mutators
+
+            void reportSeriousError (const std::string& message, const TokenLoc& loc);
+            ///< Report the error and throw a exception.
+
+            void reportError (const std::string& message, const TokenLoc& loc);
+            ///< Report the error
+
+            void reportWarning (const std::string& message, const TokenLoc& loc);
+            ///< Report the warning without throwing an exception.
+
+            void reportEOF();
+            ///< Report an unexpected EOF condition.
+
+            ErrorHandler& getErrorHandler();
+            ///< Return error handler
+
+            Context& getContext();
+            ///< Return context
+
+        public:
+
+            Parser (ErrorHandler& errorHandler, Context& context);
+            ///< constructor
+
+            virtual ~Parser();
+		    ///< destructor
+
+            virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle an int token.
+            /// \return fetch another token?
+            ///
+            /// - Default-implementation: Report an error.
+
+            virtual bool parseFloat (float value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a double token.
+            /// \return fetch another token?
+            ///
+            /// - Default-implementation: Report an error.
+
+            virtual bool parseName (const std::string& name, const TokenLoc& loc,
+                Scanner& scanner);
+            ///< Handle a name token.
+            /// \return fetch another token?
+            ///
+            /// - Default-implementation: Report an error.
+
+            virtual bool parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a keyword token.
+            /// \return fetch another token?
+            ///
+            /// - Default-implementation: Report an error.
+
+            virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+            ///
+            /// - Default-implementation: Report an error.
+
+            virtual void parseEOF (Scanner& scanner);
+            ///< Handle EOF token.
+            ///
+            /// - Default-implementation: Report an error.
+    };
+}
+
+#endif
diff --git a/components/compiler/scanner.cpp b/components/compiler/scanner.cpp
new file mode 100644
index 000000000..e7bbec385
--- /dev/null
+++ b/components/compiler/scanner.cpp
@@ -0,0 +1,414 @@
+
+#include "scanner.hpp"
+
+#include <cctype>
+#include <sstream>
+#include <algorithm>
+
+#include "exception.hpp"
+#include "errorhandler.hpp"
+#include "parser.hpp"
+
+namespace Compiler
+{
+    bool Scanner::get (char& c)
+    {
+        mStream.get (c);
+
+        if (!mStream.good())
+            return false;
+
+        mPrevLoc =mLoc;
+
+        if (c=='\n')
+        {
+            mLoc.mColumn = 0;
+            ++mLoc.mLine;
+            mLoc.mLiteral.clear();
+        }
+        else
+        {
+            ++mLoc.mColumn;
+            mLoc.mLiteral += c;
+        }
+
+        return true;
+    }
+
+    void Scanner::putback (char c)
+    {
+        mStream.putback (c);
+        mLoc = mPrevLoc;
+    }
+
+    bool Scanner::scanToken (Parser& parser)
+    {
+        char c;
+
+        if (!get (c))
+        {
+            parser.parseEOF (*this);
+            return false;
+        }
+        else if (c==';')
+        {
+            while (get (c) && c!='\n');
+
+            mLoc.mLiteral.clear();
+
+            return true;
+        }
+        else if (isWhitespace (c))
+        {
+            mLoc.mLiteral.clear();
+            return true;
+        }
+        else if (std::isdigit (c) || c=='-')
+        {
+            bool cont = false;
+
+            if (scanInt (c, parser, cont))
+            {
+                mLoc.mLiteral.clear();
+                return cont;
+            }
+        }
+        else if (std::isalpha (c) || c=='_' || c=='"')
+        {
+            bool cont = false;
+
+            if (scanName (c, parser, cont))
+            {
+                mLoc.mLiteral.clear();
+                return cont;
+            }
+        }
+        else if (c==13) // linux compatibility hack
+        {
+            return true;
+        }
+        else
+        {
+            bool cont = false;
+
+            if (scanSpecial (c, parser, cont))
+            {
+                mLoc.mLiteral.clear();
+                return cont;
+            }
+        }
+
+        TokenLoc loc (mLoc);
+        mLoc.mLiteral.clear();
+
+        mErrorHandler.error ("syntax error", loc);
+        throw SourceException();
+    }
+
+    bool Scanner::scanInt (char c, Parser& parser, bool& cont)
+    {
+        std::string value;
+
+        value += c;
+        bool empty = false;
+
+        bool error = false;
+
+        while (get (c))
+        {
+            if (std::isdigit (c))
+            {
+                value += c;
+                empty = false;
+            }
+            else if (std::isalpha (c) || c=='_')
+                error = true;
+            else if (c=='.' && !error)
+            {
+                return scanFloat (value, parser, cont);
+            }
+            else
+            {
+                putback (c);
+                break;
+            }
+        }
+
+        if (empty || error)
+            return false;
+
+        TokenLoc loc (mLoc);
+        mLoc.mLiteral.clear();
+
+        std::istringstream stream (value);
+
+        int intValue = 0;
+        stream >> intValue;
+
+        cont = parser.parseInt (intValue, loc, *this);
+        return true;
+    }
+
+    bool Scanner::scanFloat (const std::string& intValue, Parser& parser, bool& cont)
+    {
+        std::string value = intValue + ".";
+
+        char c;
+
+        bool empty = intValue.empty() || intValue=="-";
+        bool error = false;
+
+        while (get (c))
+        {
+            if (std::isdigit (c))
+            {
+                value += c;
+                empty = false;
+            }
+            else if (std::isalpha (c) || c=='_')
+                error = true;
+            else
+            {
+                putback (c);
+                break;
+            }
+        }
+
+        if (empty || error)
+            return false;
+
+        TokenLoc loc (mLoc);
+        mLoc.mLiteral.clear();
+
+        std::istringstream stream (value);
+
+        float floatValue = 0;
+        stream >> floatValue;
+
+        cont = parser.parseFloat (floatValue, loc, *this);
+        return true;
+    }
+
+    bool Scanner::scanName (char c, Parser& parser, bool& cont)
+    {
+        static const char *keywords[] =
+        {
+            "begin", "end",
+            "short", "long", "float",
+            "if", "endif", "else", "elseif",
+            "while", "endwhile",
+            "return",
+            "messagebox",
+            "set", "to",
+            0
+        };
+
+        std::string name;
+
+        if (!scanName (c, name))
+            return false;
+
+        TokenLoc loc (mLoc);
+        mLoc.mLiteral.clear();
+
+        if (name.size()>=2 && name[0]=='"' && name[name.size()-1]=='"')
+        {
+            name = name.substr (1, name.size()-2);
+            cont = parser.parseName (name, loc, *this);
+            return true;
+        }
+        
+        int i = 0;
+
+        std::string lowerCase;
+        lowerCase.reserve (name.size());
+        
+        std::transform (name.begin(), name.end(), std::back_inserter (lowerCase),
+            (int(*)(int)) std::tolower);
+
+        for (; keywords[i]; ++i)
+            if (lowerCase==keywords[i])
+                break;
+
+        cont =
+            keywords[i] ? parser.parseKeyword (i, loc, *this) : parser.parseName (name, loc, *this);
+
+        return true;
+    }
+
+    bool Scanner::scanName (char c, std::string& name)
+    {
+        bool first = false;
+        bool error = false;
+
+        name.clear();
+
+        putback (c);
+
+        while (get (c))
+        {
+            if (!name.empty() && name[0]=='"')
+            {
+                if (c=='"')
+                {
+                    name += c;
+                    break;
+                }
+                else if (c=='\\')
+                {
+                    if (!get (c))
+                    {
+                        mErrorHandler.error ("incomplete escape sequence", mLoc);
+                        break;
+                    }
+                }
+                else if (c=='\n')
+                {
+                    mErrorHandler.error ("incomplete string or name", mLoc);
+                    break;
+                }                
+            }
+            else if (!(c=='"' && name.empty()))
+            {
+                if (!(std::isalpha (c) || std::isdigit (c) || c=='_'))
+                {
+                    putback (c);
+                    break;
+                }
+
+                if (first && std::isdigit (c))
+                    error = true;
+            }
+                
+            name += c;
+            first = false;
+        }
+
+        return !error;
+    }
+
+    bool Scanner::scanSpecial (char c, Parser& parser, bool& cont)
+    {
+        int special = -1;
+
+        if (c=='\n')
+            special = S_newline;
+        else if (c=='(')
+            special = S_open;
+        else if (c==')')
+            special = S_close;
+        else if (c=='=')
+        {
+            if (get (c))
+            {
+                if (c=='=')
+                    special = S_cmpEQ;
+                else
+                {
+                    putback (c);
+                    return false;
+                }
+            }
+            else
+            {
+                putback (c);
+                return false;           
+            }
+        }
+        else if (c=='!')
+        {
+            if (get (c))
+            {
+                if (c=='=')
+                    special = S_cmpNE;
+                else
+                {
+                    putback (c);
+                    return false;
+                }
+            }
+            else
+                return false;
+        }
+        else if (c=='-')
+        {
+            if (get (c))
+            {
+                if (c=='>')
+                    special = S_ref;
+                else
+                {
+                    putback (c);
+                    special = S_minus;
+                }
+            }
+            else
+                special = S_minus;
+        }
+        else if (c=='<')
+        {
+            if (get (c))
+            {
+                if (c=='=')
+                    special = S_cmpLE;
+                else
+                {
+                    putback (c);
+                    special = S_cmpLT;
+                }
+            }
+            else
+                special = S_cmpLT;
+        }
+        else if (c=='>')
+        {
+            if (get (c))
+            {
+                if (c=='=')
+                    special = S_cmpGE;
+                else
+                {
+                    putback (c);
+                    special = S_cmpGT;
+                }
+            }
+            else
+                special = S_cmpGT;
+        }
+        else if (c==',')
+            special = S_comma;
+        else if (c=='+')
+            special = S_plus;
+        else if (c=='*')
+            special = S_mult;
+        else if (c=='/')
+            special = S_div;
+        else
+            return false;
+
+        TokenLoc loc (mLoc);
+        mLoc.mLiteral.clear();
+
+        cont = parser.parseSpecial (special, loc, *this);
+
+        return true;
+    }
+
+    bool Scanner::isWhitespace (char c)
+    {
+        return c==' ' || c=='\t';
+    }
+
+    // constructor
+
+    Scanner::Scanner (ErrorHandler& errorHandler, std::istream& inputStream)
+    : mErrorHandler (errorHandler), mStream (inputStream)
+    {
+    }
+
+    void Scanner::scan (Parser& parser)
+    {
+        while (scanToken (parser));
+    }
+}
+
diff --git a/components/compiler/scanner.hpp b/components/compiler/scanner.hpp
new file mode 100644
index 000000000..1349a976a
--- /dev/null
+++ b/components/compiler/scanner.hpp
@@ -0,0 +1,84 @@
+#ifndef COMPILER_SCANNER_H_INCLUDED
+#define COMPILER_SCANNER_H_INCLUDED
+
+#include <string>
+#include <iosfwd>
+
+#include "tokenloc.hpp"
+
+namespace Compiler
+{
+    class ErrorHandler;
+    class Parser;
+
+    /// \brief Scanner
+    ///
+    /// This class translate a char-stream to a token stream (delivered via
+    /// parser-callbacks).
+
+    class Scanner
+    {
+            ErrorHandler& mErrorHandler;
+            TokenLoc mLoc;
+            TokenLoc mPrevLoc;
+            std::istream& mStream;
+
+        public:
+
+            enum keyword
+            {
+                K_begin, K_end,
+                K_short, K_long, K_float,
+                K_if, K_endif, K_else, K_elseif,
+                K_while, K_endwhile,
+                K_return,
+                K_messageBox,
+                K_set, K_to
+            };
+
+            enum special
+            {
+                S_newline,
+                S_open, S_close,
+                S_cmpEQ, S_cmpNE, S_cmpLT, S_cmpLE, S_cmpGT, S_cmpGE,
+                S_plus, S_minus, S_mult, S_div,
+                S_comma,
+                S_ref
+            };
+
+        private:
+
+        // not implemented
+
+            Scanner (const Scanner&);
+            Scanner& operator= (const Scanner&);
+
+            bool get (char& c);
+
+            void putback (char c);
+
+            bool scanToken (Parser& parser);
+
+            bool scanInt (char c, Parser& parser, bool& cont);
+
+            bool scanFloat (const std::string& intValue, Parser& parser, bool& cont);
+
+            bool scanName (char c, Parser& parser, bool& cont);
+
+            bool scanName (char c, std::string& name);
+
+            bool scanSpecial (char c, Parser& parser, bool& cont);
+
+            static bool isWhitespace (char c);
+
+        public:
+
+            Scanner (ErrorHandler& errorHandler, std::istream& inputStream);
+		    ///< constructor
+
+            void scan (Parser& parser);
+            ///< Scan a token and deliver it to the parser.
+    };
+}
+
+#endif
diff --git a/components/compiler/streamerrorhandler.cpp b/components/compiler/streamerrorhandler.cpp
new file mode 100644
index 000000000..a0777be68
--- /dev/null
+++ b/components/compiler/streamerrorhandler.cpp
@@ -0,0 +1,38 @@
+
+#include "streamerrorhandler.hpp"
+
+#include "tokenloc.hpp"
+
+namespace Compiler
+{
+    // Report error to the user.
+
+    void StreamErrorHandler::report (const std::string& message, const TokenLoc& loc,
+        Type type)
+    {
+        if (type==ErrorMessage)
+            mStream << "error ";
+        else
+            mStream << "warning ";
+
+        mStream
+            << "line " << loc.mLine << ", column " << loc.mColumn
+            << " (" << loc.mLiteral << ")" << std::endl
+            << "    " << message << std::endl;
+    }
+
+    // Report a file related error
+
+    void StreamErrorHandler::report (const std::string& message, Type type)
+    {
+        if (type==ErrorMessage)
+            mStream << "error ";
+        else
+            mStream << "warning ";
+
+        mStream
+            << "file:" << std::endl
+            << "    " << message << std::endl;
+    }
+
+    StreamErrorHandler::StreamErrorHandler (std::ostream& ErrorStream) : mStream (ErrorStream) {}
}
diff --git a/components/compiler/streamerrorhandler.hpp b/components/compiler/streamerrorhandler.hpp
new file mode 100644
index 000000000..ce4d4c6c6
--- /dev/null
+++ b/components/compiler/streamerrorhandler.hpp
@@ -0,0 +1,37 @@
+
+#ifndef COMPILER_STREAMERRORHANDLER_H_INCLUDED
+#define COMPILER_STREAMERRORHANDLER_H_INCLUDED
+
+#include <ostream>
+
+#include "errorhandler.hpp"
+
+namespace Compiler
+{
+    /// \brief Error handler implementation: Write errors into stream
+
+    class StreamErrorHandler : public ErrorHandler
+    {
+            std::ostream& mStream;
+
+        // not implemented
+
+            StreamErrorHandler (const StreamErrorHandler&);
+            StreamErrorHandler& operator= (const StreamErrorHandler&);
+
+            virtual void report (const std::string& message, const TokenLoc& loc, Type type);
+            ///< Report error to the user.
+
+            virtual void report (const std::string& message, Type type);
+            ///< Report a file related error
+
+        public:
+
+        // constructors
+
+            StreamErrorHandler (std::ostream& ErrorStream);
+		    ///< constructor
+    };
+}
+
+#endif
diff --git a/components/compiler/tokenloc.hpp b/components/compiler/tokenloc.hpp
new file mode 100644
index 000000000..62b5cdee5
--- /dev/null
+++ b/components/compiler/tokenloc.hpp
@@ -0,0 +1,20 @@
+#ifndef COMPILER_TOKENLOC_H_INCLUDED
+#define COMPILER_TOKENLOC_H_INCLUDED
+
+#include <string>
+
+namespace Compiler
+{
+    /// \brief Location of a token in a source file
+
+    struct TokenLoc
+    {
+        int mColumn;
+        int mLine;
+        std::string mLiteral;
+
+        TokenLoc() : mColumn (0), mLine (0), mLiteral ("") {}
+    };
+}
+
+#endif // TOKENLOC_H_INCLUDED

From d20e850d31ffa72428d4e1077f0e67f62eec819d Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Sun, 27 Jun 2010 22:31:03 +0200
Subject: [PATCH 04/40] -> wasn't properly translated into a token

---
 components/compiler/scanner.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/compiler/scanner.cpp b/components/compiler/scanner.cpp
index e7bbec385..f82ee73d0 100644
--- a/components/compiler/scanner.cpp
+++ b/components/compiler/scanner.cpp
@@ -63,7 +63,7 @@ namespace Compiler
             mLoc.mLiteral.clear();
             return true;
         }
-        else if (std::isdigit (c) || c=='-')
+        else if (std::isdigit (c))
         {
             bool cont = false;
 

From d02257ca88fcf63184fa904cf53be4fc9fc32a52 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 00:21:45 +0200
Subject: [PATCH 05/40] read file to be compiled from command line arguments

---
 apps/mwcompiler/main.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/mwcompiler/main.cpp b/apps/mwcompiler/main.cpp
index 4932833a6..03cc5a62c 100644
--- a/apps/mwcompiler/main.cpp
+++ b/apps/mwcompiler/main.cpp
@@ -17,7 +17,7 @@ int main (int argc, char **argv)
         Compiler::StreamErrorHandler errorHandler (std::cout);
         Compiler::FileParser parser (errorHandler, context);
         
-        std::ifstream file ("test.mwscript");
+        std::ifstream file (argc>1 ? argv[1] : "test.mwscript");
         Compiler::Scanner scanner (errorHandler, file);
         
         scanner.scan (parser);

From a068ca78d71571e944848d43372188a2b2a3f78a Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 00:50:48 +0200
Subject: [PATCH 06/40] replaced dummy parser with top level file parser

---
 apps/mwcompiler/main.cpp           |  2 +
 components/compiler/fileparser.cpp | 78 ++++++++++++++++++++++--------
 components/compiler/fileparser.hpp | 23 ++++++---
 3 files changed, 75 insertions(+), 28 deletions(-)

diff --git a/apps/mwcompiler/main.cpp b/apps/mwcompiler/main.cpp
index 03cc5a62c..114315930 100644
--- a/apps/mwcompiler/main.cpp
+++ b/apps/mwcompiler/main.cpp
@@ -21,6 +21,8 @@ int main (int argc, char **argv)
         Compiler::Scanner scanner (errorHandler, file);
         
         scanner.scan (parser);
+        
+        std::cout << "parsed script: " << parser.getName() << std::endl;
     }
     catch (const std::exception &e)
     {
diff --git a/components/compiler/fileparser.cpp b/components/compiler/fileparser.cpp
index 416854c1c..388f8df03 100644
--- a/components/compiler/fileparser.cpp
+++ b/components/compiler/fileparser.cpp
@@ -3,54 +3,90 @@
 #include <iostream>
 
 #include "tokenloc.hpp"
-
-
 #include "scanner.hpp"
 
 namespace Compiler
 {
     FileParser::FileParser (ErrorHandler& errorHandler, Context& context)
-    : Parser (errorHandler, context)
+    : Parser (errorHandler, context), mState (BeginState)
     {}
 
-    bool FileParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
-    {
-        std::cout << "integer: " << value << std::endl;
-        return true;
-    }
-
-    bool FileParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
+    std::string FileParser::getName() const
     {
-        std::cout << "float: " << value << std::endl;
-        return true;
+        return mName;
     }
 
     bool FileParser::parseName (const std::string& name, const TokenLoc& loc,
         Scanner& scanner)
     {
-        std::cout << "name: " << name << std::endl;
-        return true;
+        if (mState==NameState)
+        {
+            mName = name;
+            mState = BeginCompleteState;
+            return true;
+        }
+        
+        if (mState==EndNameState)
+        {
+            // optional repeated name after end statement
+            if (mName!=name)
+                reportWarning ("Names for script " + mName + " do not match", loc);
+            
+            mState = EndCompleteState;
+            return true;
+        }
+        
+        return Parser::parseName (name, loc, scanner);
     }
 
     bool FileParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
     {
-        std::cout << "keyword: " << loc.mLiteral << std::endl;
-        return true;
+        if (mState==BeginState && keyword==Scanner::K_begin)
+        {
+            mState = NameState;
+            return true;
+        }
+        
+        if (mState==EndState && keyword==Scanner::K_end)
+        {
+            mState = EndNameState;
+            return true;
+        }
+        
+        return Parser::parseKeyword (keyword, loc, scanner);
     }
 
     bool FileParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
     {
         if (code==Scanner::S_newline)
-            std::cout << "newline" << std::endl;
-        else
-            std::cout << "special: " << loc.mLiteral << std::endl;
+        {
+            if (mState==BeginCompleteState)
+            {
+                // TODO: add script parser here
+                mState = EndState;
+                return true;
+            }
             
-        return true;
+            if (mState==EndCompleteState || mState==EndNameState)
+            {
+                // we are done here -> ignore the rest of the script
+                return false;
+            }
+        }
+        
+        return Parser::parseSpecial (code, loc, scanner);
     }
 
     void FileParser::parseEOF (Scanner& scanner)
     {
-        std::cout << "end of file" << std::endl;
+        if (mState!=EndNameState && mState!=EndCompleteState)
+            Parser::parseEOF (scanner);
+    }
+    
+    void FileParser::reset()
+    {
+        mState = BeginState;
+        mName.clear();
     }
 }
 
diff --git a/components/compiler/fileparser.hpp b/components/compiler/fileparser.hpp
index 2007c7ef2..6ae086216 100644
--- a/components/compiler/fileparser.hpp
+++ b/components/compiler/fileparser.hpp
@@ -5,19 +5,25 @@
 
 namespace Compiler
 {
+    // Top-level parser, to be used for global scripts, local scripts and targeted scripts
+    
     class FileParser : public Parser
     {
+            enum State
+            {
+                BeginState, NameState, BeginCompleteState, EndState, EndNameState,
+                EndCompleteState
+            };
+            
+            State mState;
+            std::string mName;
+            
         public:
         
             FileParser (ErrorHandler& errorHandler, Context& context);
 
-            virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
-            ///< Handle an int token.
-            /// \return fetch another token?
-
-            virtual bool parseFloat (float value, const TokenLoc& loc, Scanner& scanner);
-            ///< Handle a double token.
-            /// \return fetch another token?
+            std::string getName() const;
+            ///< Return script name.
 
             virtual bool parseName (const std::string& name, const TokenLoc& loc,
                 Scanner& scanner);
@@ -34,6 +40,9 @@ namespace Compiler
 
             virtual void parseEOF (Scanner& scanner);
             ///< Handle EOF token.    
+            
+            void reset();
+            ///< Reset parser to clean state.
     };
 }
 

From de8a651df4e4930bdb1c37f080dccb2d3f02f3cd Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 01:01:48 +0200
Subject: [PATCH 07/40] improved error handling

---
 apps/mwcompiler/main.cpp        | 39 +++++++++++++++++++++++++++++----
 components/compiler/scanner.cpp |  3 +++
 2 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/apps/mwcompiler/main.cpp b/apps/mwcompiler/main.cpp
index 114315930..231496846 100644
--- a/apps/mwcompiler/main.cpp
+++ b/apps/mwcompiler/main.cpp
@@ -8,6 +8,7 @@
 #include <components/compiler/scanner.hpp>
 #include <components/compiler/fileparser.hpp>
 #include <components/compiler/context.hpp>
+#include <components/compiler/exception.hpp>
 
 int main (int argc, char **argv)
 {
@@ -17,12 +18,42 @@ int main (int argc, char **argv)
         Compiler::StreamErrorHandler errorHandler (std::cout);
         Compiler::FileParser parser (errorHandler, context);
         
-        std::ifstream file (argc>1 ? argv[1] : "test.mwscript");
-        Compiler::Scanner scanner (errorHandler, file);
+        try
+        {
+            std::string filename = argc>1 ? argv[1] : "test.mwscript";
         
-        scanner.scan (parser);
+            std::ifstream file (filename.c_str());
+            
+            if (!file.is_open())
+            {
+                std::cout << "can't open script file: " << filename << std::endl;
+                return 1;
+            }
+            
+            Compiler::Scanner scanner (errorHandler, file);
         
-        std::cout << "parsed script: " << parser.getName() << std::endl;
+            scanner.scan (parser);
+        }
+        catch (const Compiler::SourceException&)
+        {
+            // ignore exception (problem has already been reported to the user)
+        }
+        
+        if (errorHandler.countErrors() || errorHandler.countWarnings())
+        {
+            std::cout
+                << errorHandler.countErrors() << " error(s), "
+                << errorHandler.countWarnings() << " warning(s)" << std::endl
+                << std::endl;
+        }
+        
+        if (errorHandler.isGood())
+        {
+            std::cout << "parsed script: " << parser.getName() << std::endl;
+            return 0;
+        }
+        
+        return 1;
     }
     catch (const std::exception &e)
     {
diff --git a/components/compiler/scanner.cpp b/components/compiler/scanner.cpp
index f82ee73d0..83c5b2d17 100644
--- a/components/compiler/scanner.cpp
+++ b/components/compiler/scanner.cpp
@@ -386,6 +386,9 @@ namespace Compiler
         else
             return false;
 
+        if (special==S_newline)
+            mLoc.mLiteral = "<newline>"; 
+            
         TokenLoc loc (mLoc);
         mLoc.mLiteral.clear();
 

From aa99a0dd56401ed650f88881b4a84b5e05cb151a Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 11:38:04 +0200
Subject: [PATCH 08/40] added basic script parser (can only parse empty script
 bodies for now)

---
 CMakeLists.txt                       |  2 +-
 components/compiler/fileparser.cpp   | 19 +++++------
 components/compiler/fileparser.hpp   |  4 ++-
 components/compiler/scriptparser.cpp | 47 ++++++++++++++++++++++++++++
 components/compiler/scriptparser.hpp | 41 ++++++++++++++++++++++++
 5 files changed, 102 insertions(+), 11 deletions(-)
 create mode 100644 components/compiler/scriptparser.cpp
 create mode 100644 components/compiler/scriptparser.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9457acf53..d9e793754 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -67,7 +67,7 @@ set(MISC_HEADER components/misc/fileops.hpp components/misc/slice_array.hpp
 source_group(misc FILES ${MISC} ${MISC_HEADER})    
     
 set(COMPILER components/compiler/errorhandler.cpp
-    components/compiler/fileparser.cpp
+    components/compiler/fileparser.cpp components/compiler/scriptparser.cpp
     components/compiler/parser.cpp components/compiler/scanner.cpp
     components/compiler/streamerrorhandler.cpp)
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
diff --git a/components/compiler/fileparser.cpp b/components/compiler/fileparser.cpp
index 388f8df03..9894bce67 100644
--- a/components/compiler/fileparser.cpp
+++ b/components/compiler/fileparser.cpp
@@ -8,7 +8,9 @@
 namespace Compiler
 {
     FileParser::FileParser (ErrorHandler& errorHandler, Context& context)
-    : Parser (errorHandler, context), mState (BeginState)
+    : Parser (errorHandler, context), 
+      mScriptParser (errorHandler, context, true),
+      mState (BeginState)
     {}
 
     std::string FileParser::getName() const
@@ -47,12 +49,6 @@ namespace Compiler
             return true;
         }
         
-        if (mState==EndState && keyword==Scanner::K_end)
-        {
-            mState = EndNameState;
-            return true;
-        }
-        
         return Parser::parseKeyword (keyword, loc, scanner);
     }
 
@@ -62,8 +58,12 @@ namespace Compiler
         {
             if (mState==BeginCompleteState)
             {
-                // TODO: add script parser here
-                mState = EndState;
+                // parse the script body
+                mScriptParser.reset();
+                
+                scanner.scan (mScriptParser);
+                
+                mState = EndNameState;
                 return true;
             }
             
@@ -87,6 +87,7 @@ namespace Compiler
     {
         mState = BeginState;
         mName.clear();
+        mScriptParser.reset();
     }
 }
 
diff --git a/components/compiler/fileparser.hpp b/components/compiler/fileparser.hpp
index 6ae086216..81b8025ce 100644
--- a/components/compiler/fileparser.hpp
+++ b/components/compiler/fileparser.hpp
@@ -2,6 +2,7 @@
 #define COMPILER_FILEPARSER_H_INCLUDED
 
 #include "parser.hpp"
+#include "scriptparser.hpp"
 
 namespace Compiler
 {
@@ -11,10 +12,11 @@ namespace Compiler
     {
             enum State
             {
-                BeginState, NameState, BeginCompleteState, EndState, EndNameState,
+                BeginState, NameState, BeginCompleteState, EndNameState,
                 EndCompleteState
             };
             
+            ScriptParser mScriptParser;
             State mState;
             std::string mName;
             
diff --git a/components/compiler/scriptparser.cpp b/components/compiler/scriptparser.cpp
new file mode 100644
index 000000000..2247ed408
--- /dev/null
+++ b/components/compiler/scriptparser.cpp
@@ -0,0 +1,47 @@
+
+#include "scriptparser.hpp"
+
+#include "scanner.hpp"
+
+namespace Compiler
+{
+    ScriptParser::ScriptParser (ErrorHandler& errorHandler, Context& context, bool end)
+    : Parser (errorHandler, context), mEnd (end)
+    {}
+
+    bool ScriptParser::parseName (const std::string& name, const TokenLoc& loc,
+        Scanner& scanner)
+    {
+        return Parser::parseName (name, loc, scanner);
+    }
+
+    bool ScriptParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (keyword==Scanner::K_end && mEnd)
+        {
+            return false;
+        }
+    
+        return Parser::parseKeyword (keyword, loc, scanner);
+    }
+
+    bool ScriptParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (code==Scanner::S_newline) // empty line
+            return true;
+            
+        return Parser::parseSpecial (code, loc, scanner);
+    }
+
+    void ScriptParser::parseEOF (Scanner& scanner)
+    {
+        if (mEnd)
+            Parser::parseEOF (scanner);
+    }
+
+    void ScriptParser::reset()
+    {
+    
+    }
+}
+
diff --git a/components/compiler/scriptparser.hpp b/components/compiler/scriptparser.hpp
new file mode 100644
index 000000000..1a726b86e
--- /dev/null
+++ b/components/compiler/scriptparser.hpp
@@ -0,0 +1,41 @@
+#ifndef COMPILER_SCRIPTPARSER_H_INCLUDED
+#define COMPILER_SCRIPTPARSER_H_INCLUDED
+
+#include "parser.hpp"
+
+namespace Compiler
+{
+    // Script parser, to be used in dialogue scripts and as part of FileParser
+    
+    class ScriptParser : public Parser
+    {
+            bool mEnd;
+            
+        public:
+        
+            /// \param end of script is marked by end keyword.
+            ScriptParser (ErrorHandler& errorHandler, Context& context, bool end = false);
+    
+            virtual bool parseName (const std::string& name, const TokenLoc& loc,
+                Scanner& scanner);
+            ///< Handle a name token.
+            /// \return fetch another token?
+
+            virtual bool parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a keyword token.
+            /// \return fetch another token?
+
+            virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+
+            virtual void parseEOF (Scanner& scanner);
+            ///< Handle EOF token.  
+            
+            void reset();
+            ///< Reset parser to clean state.
+    };
+}
+
+#endif
+

From 8930134d82c1efe9b27aa45a2a70cea5df63e3aa Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 11:38:21 +0200
Subject: [PATCH 09/40] exception class fix

---
 components/compiler/exception.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/compiler/exception.hpp b/components/compiler/exception.hpp
index ab073adfb..3f0ff4c55 100644
--- a/components/compiler/exception.hpp
+++ b/components/compiler/exception.hpp
@@ -15,7 +15,7 @@ namespace Compiler
 
     /// \brief Exception: File error
 
-    class FileException
+    class FileException : public SourceException
     {
             virtual const char *what() const throw() { return "can't read file"; }
             ///< Return error message
@@ -23,7 +23,7 @@ namespace Compiler
 
     /// \brief Exception: EOF condition encountered
 
-    class EOFException
+    class EOFException : public SourceException
     {
            virtual const char *what() const throw() { return "end of file"; }
             ///< Return error message
     };

From fda7077cf2f046064fe7ab26dd962d4b25fd75b5 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 11:40:48 +0200
Subject: [PATCH 10/40] bug-fix: comments were eating up newlines

---
 components/compiler/scanner.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/components/compiler/scanner.cpp b/components/compiler/scanner.cpp
index 83c5b2d17..a202eca5c 100644
--- a/components/compiler/scanner.cpp
+++ b/components/compiler/scanner.cpp
@@ -52,7 +52,14 @@ namespace Compiler
         }
         else if (c==';')
         {
-            while (get (c) && c!='\n');
+            while (get (c))
+            {
+                if (c=='\n')
+                {
+                    putback (c);
+                    break;
+                }
+            }
 
             mLoc.mLiteral.clear();
 

From 16f6f27a900300a54d72fc6d94569117b3db5855 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 12:12:47 +0200
Subject: [PATCH 11/40] added line parser (doesn't parse anything yet)

---
 CMakeLists.txt                       |  1 +
 components/compiler/lineparser.cpp   | 43 ++++++++++++++++++++++++++++
 components/compiler/lineparser.hpp   | 42 +++++++++++++++++++++++++++
 components/compiler/parser.hpp       |  2 +-
 components/compiler/scriptparser.cpp | 22 ++++++++++----
 components/compiler/scriptparser.hpp |  2 ++
 6 files changed, 106 insertions(+), 6 deletions(-)
 create mode 100644 components/compiler/lineparser.cpp
 create mode 100644 components/compiler/lineparser.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d9e793754..8e044d3d0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -68,6 +68,7 @@ source_group(misc FILES ${MISC} ${MISC_HEADER})
     
 set(COMPILER components/compiler/errorhandler.cpp
     components/compiler/fileparser.cpp components/compiler/scriptparser.cpp
+    components/compiler/lineparser.cpp
     components/compiler/parser.cpp components/compiler/scanner.cpp
     components/compiler/streamerrorhandler.cpp)
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
new file mode 100644
index 000000000..8d1fa70aa
--- /dev/null
+++ b/components/compiler/lineparser.cpp
@@ -0,0 +1,43 @@
+
+#include "lineparser.hpp"
+
+#include "scanner.hpp"
+
+namespace Compiler
+{
+    LineParser::LineParser (ErrorHandler& errorHandler, Context& context)
+    : Parser (errorHandler, context)
+    {}
+
+    bool LineParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
+    {
+        return Parser::parseInt (value, loc, scanner);
+    }
+
+    bool LineParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
+    {
+        return Parser::parseFloat (value, loc, scanner);
+    }
+
+    bool LineParser::parseName (const std::string& name, const TokenLoc& loc,
+        Scanner& scanner)
+    {
+        return Parser::parseName (name, loc, scanner);
+    }
+
+    bool LineParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        return Parser::parseKeyword (keyword, loc, scanner);
+    }
+
+    bool LineParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        return Parser::parseSpecial (code, loc, scanner);
+    }
+    
+    void LineParser::reset()
+    {
+    
+    }
+}
+
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
new file mode 100644
index 000000000..8b11dcf4a
--- /dev/null
+++ b/components/compiler/lineparser.hpp
@@ -0,0 +1,42 @@
+#ifndef COMPILER_LINEPARSER_H_INCLUDED
+#define COMPILER_LINEPARSER_H_INCLUDED
+
+#include "parser.hpp"
+
+namespace Compiler
+{
+    /// \brief Line parser, to be used in console scripts and as part of ScriptParser
+    
+    class LineParser : public Parser
+    {
+        public:
+        
+            LineParser (ErrorHandler& errorHandler, Context& context);
+    
+            virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle an int token.
+            /// \return fetch another token?
+
+            virtual bool parseFloat (float value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a float token.
+            /// \return fetch another token?
+
+            virtual bool parseName (const std::string& name, const TokenLoc& loc,
+                Scanner& scanner);
+            ///< Handle a name token.
+            /// \return fetch another token?
+
+            virtual bool parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a keyword token.
+            /// \return fetch another token?
+
+            virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+            
+            void reset();
+            ///< Reset parser to clean state.            
+    };
+}
+
+#endif
diff --git a/components/compiler/parser.hpp b/components/compiler/parser.hpp
index e54d17013..5bb541f92 100644
--- a/components/compiler/parser.hpp
+++ b/components/compiler/parser.hpp
@@ -56,7 +56,7 @@ namespace Compiler
             /// - Default-implementation: Report an error.
 
             virtual bool parseFloat (float value, const TokenLoc& loc, Scanner& scanner);
-            ///< Handle a double token.
+            ///< Handle a float token.
             /// \return fetch another token?
             ///
             /// - Default-implementation: Report an error.
diff --git a/components/compiler/scriptparser.cpp b/components/compiler/scriptparser.cpp
index 2247ed408..769cc5ab2 100644
--- a/components/compiler/scriptparser.cpp
+++ b/components/compiler/scriptparser.cpp
@@ -6,13 +6,17 @@
 namespace Compiler
 {
     ScriptParser::ScriptParser (ErrorHandler& errorHandler, Context& context, bool end)
-    : Parser (errorHandler, context), mEnd (end)
+    : Parser (errorHandler, context), mLineParser (errorHandler, context), mEnd (end)
     {}
 
     bool ScriptParser::parseName (const std::string& name, const TokenLoc& loc,
         Scanner& scanner)
     {
-        return Parser::parseName (name, loc, scanner);
+        mLineParser.reset();
+        if (mLineParser.parseName (name, loc, scanner))
+            scanner.scan (mLineParser);
+        
+        return true;
     }
 
     bool ScriptParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
@@ -22,7 +26,11 @@ namespace Compiler
             return false;
         }
     
-        return Parser::parseKeyword (keyword, loc, scanner);
+        mLineParser.reset();
+        if (mLineParser.parseKeyword (keyword, loc, scanner))
+            scanner.scan (mLineParser);
+            
+        return true;
     }
 
     bool ScriptParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
@@ -30,7 +38,11 @@ namespace Compiler
         if (code==Scanner::S_newline) // empty line
             return true;
             
-        return Parser::parseSpecial (code, loc, scanner);
+        mLineParser.reset();
+        if (mLineParser.parseSpecial (code, loc, scanner))
+            scanner.scan (mLineParser);
+            
+        return true;
     }
 
     void ScriptParser::parseEOF (Scanner& scanner)
@@ -41,7 +53,7 @@ namespace Compiler
 
     void ScriptParser::reset()
     {
-    
+        mLineParser.reset();
     }
 }
 
diff --git a/components/compiler/scriptparser.hpp b/components/compiler/scriptparser.hpp
index 1a726b86e..6933b7d08 100644
--- a/components/compiler/scriptparser.hpp
+++ b/components/compiler/scriptparser.hpp
@@ -2,6 +2,7 @@
 #define COMPILER_SCRIPTPARSER_H_INCLUDED
 
 #include "parser.hpp"
+#include "lineparser.hpp"
 
 namespace Compiler
 {
@@ -9,6 +10,7 @@ namespace Compiler
     
     class ScriptParser : public Parser
     {
+            LineParser mLineParser;
             bool mEnd;
             
         public:

From bff0855af094c6d2bc5c67a766d8dfa7f00f9af1 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 12:32:08 +0200
Subject: [PATCH 12/40] added parsing for local variable declarations

---
 CMakeLists.txt                     |  3 ++-
 apps/mwcompiler/context.cpp        | 11 +++++++++++
 apps/mwcompiler/context.hpp        | 18 +++++++++++++++++
 apps/mwcompiler/main.cpp           |  5 +++--
 components/compiler/context.hpp    |  7 ++++++-
 components/compiler/lineparser.cpp | 31 ++++++++++++++++++++++++++++--
 components/compiler/lineparser.hpp |  9 +++++++++
 7 files changed, 78 insertions(+), 6 deletions(-)
 create mode 100644 apps/mwcompiler/context.cpp
 create mode 100644 apps/mwcompiler/context.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8e044d3d0..52704c2bc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -171,7 +171,8 @@ endif (APPLE)
 option(BUILD_MWCOMPILER "build standalone Morrowind script compiler" ON)
 
 if (BUILD_MWCOMPILER)
-set(TOOLS_MWCOMPILER ${COMPILER} apps/mwcompiler/main.cpp)
+set(TOOLS_MWCOMPILER ${COMPILER} apps/mwcompiler/main.cpp apps/mwcompiler/context.cpp
+    apps/mwcompiler/context.hpp)
 
 add_executable(mwcompiler ${TOOLS_MWCOMPILER})
 endif()
diff --git a/apps/mwcompiler/context.cpp b/apps/mwcompiler/context.cpp
new file mode 100644
index 000000000..72e3aa490
--- /dev/null
+++ b/apps/mwcompiler/context.cpp
@@ -0,0 +1,11 @@
+
+#include "context.hpp"
+
+namespace SACompiler
+{
+    bool Context::canDeclareLocals() const
+    {
+        return true;
+    }
+}
+
diff --git a/apps/mwcompiler/context.hpp b/apps/mwcompiler/context.hpp
new file mode 100644
index 000000000..23188ecf2
--- /dev/null
+++ b/apps/mwcompiler/context.hpp
@@ -0,0 +1,18 @@
+#ifndef MWCOMPILER_CONTEXT_H_INCLUDED
+#define MWCOMPILER_CONTEXT_H_INCLUDED
+
+#include <components/compiler/context.hpp>
+
+namespace SACompiler
+{
+    class Context : public Compiler::Context
+    {
+        public:
+        
+            virtual bool canDeclareLocals() const;
+            ///< Is the compiler allowed to declare local variables?    
+    };
+}
+
+#endif
+
diff --git a/apps/mwcompiler/main.cpp b/apps/mwcompiler/main.cpp
index 231496846..a4ec9a573 100644
--- a/apps/mwcompiler/main.cpp
+++ b/apps/mwcompiler/main.cpp
@@ -7,14 +7,15 @@
 #include <components/compiler/streamerrorhandler.hpp>
 #include <components/compiler/scanner.hpp>
 #include <components/compiler/fileparser.hpp>
-#include <components/compiler/context.hpp>
 #include <components/compiler/exception.hpp>
 
+#include "context.hpp"
+
 int main (int argc, char **argv)
 {
     try
     {
-        Compiler::Context context;
+        SACompiler::Context context;
         Compiler::StreamErrorHandler errorHandler (std::cout);
         Compiler::FileParser parser (errorHandler, context);
         
diff --git a/components/compiler/context.hpp b/components/compiler/context.hpp
index 795514cfd..d5284ffc9 100644
--- a/components/compiler/context.hpp
+++ b/components/compiler/context.hpp
@@ -5,7 +5,12 @@ namespace Compiler
 {
     class Context
     {
-    
+        public:
+        
+            virtual ~Context() {}
+            
+            virtual bool canDeclareLocals() const = 0;
+            ///< Is the compiler allowed to declare local variables?
     };
 }
 
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 8d1fa70aa..f90352559 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -1,12 +1,16 @@
 
 #include "lineparser.hpp"
 
+#include <iostream>
+
 #include "scanner.hpp"
+#include "context.hpp"
+#include "errorhandler.hpp"
 
 namespace Compiler
 {
     LineParser::LineParser (ErrorHandler& errorHandler, Context& context)
-    : Parser (errorHandler, context)
+    : Parser (errorHandler, context), mState (BeginState)
     {}
 
     bool LineParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
@@ -22,22 +26,45 @@ namespace Compiler
     bool LineParser::parseName (const std::string& name, const TokenLoc& loc,
         Scanner& scanner)
     {
+        if (mState==ShortState || mState==LongState || mState==FloatState)
+        {
+            if (!getContext().canDeclareLocals())
+                getErrorHandler().error ("local variables can't be declared in this context", loc);
+            
+            std::cout << "declaring local variable: " << name << std::endl;
+            mState = EndState;
+            return true;
+        }
+        
         return Parser::parseName (name, loc, scanner);
     }
 
     bool LineParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
     {
+        if (mState==BeginState)
+        {
+            switch (keyword)
+            {
+                case Scanner::K_short: mState = ShortState; return true;
+                case Scanner::K_long: mState = LongState; return true;
+                case Scanner::K_float: mState = FloatState; return true;
+            }
+        }
+        
         return Parser::parseKeyword (keyword, loc, scanner);
     }
 
     bool LineParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
     {
+        if (code==Scanner::S_newline && mState==EndState)
+            return false;
+            
         return Parser::parseSpecial (code, loc, scanner);
     }
     
     void LineParser::reset()
     {
-    
+        mState = BeginState;
     }
 }
 
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
index 8b11dcf4a..420315551 100644
--- a/components/compiler/lineparser.hpp
+++ b/components/compiler/lineparser.hpp
@@ -9,6 +9,15 @@ namespace Compiler
     
     class LineParser : public Parser
     {
+            enum State
+            {
+                BeginState,
+                ShortState, LongState, FloatState,
+                EndState
+            };
+            
+            State mState;
+    
         public:
         
             LineParser (ErrorHandler& errorHandler, Context& context);

From 21e0182ae258f95c27c5b0a09934d103ce3b600e Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 12:47:11 +0200
Subject: [PATCH 13/40] added skip parser for skipping faulty lines

---
 CMakeLists.txt                     |  2 +-
 components/compiler/lineparser.cpp |  6 +++++
 components/compiler/skipparser.cpp | 41 +++++++++++++++++++++++++++++
 components/compiler/skipparser.hpp | 42 ++++++++++++++++++++++++++++++
 4 files changed, 90 insertions(+), 1 deletion(-)
 create mode 100644 components/compiler/skipparser.cpp
 create mode 100644 components/compiler/skipparser.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 52704c2bc..5377ea920 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -68,7 +68,7 @@ source_group(misc FILES ${MISC} ${MISC_HEADER})
     
 set(COMPILER components/compiler/errorhandler.cpp
     components/compiler/fileparser.cpp components/compiler/scriptparser.cpp
-    components/compiler/lineparser.cpp
+    components/compiler/lineparser.cpp components/compiler/skipparser.cpp
     components/compiler/parser.cpp components/compiler/scanner.cpp
     components/compiler/streamerrorhandler.cpp)
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index f90352559..6c8c3f735 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -6,6 +6,7 @@
 #include "scanner.hpp"
 #include "context.hpp"
 #include "errorhandler.hpp"
+#include "skipparser.hpp"
 
 namespace Compiler
 {
@@ -29,7 +30,12 @@ namespace Compiler
         if (mState==ShortState || mState==LongState || mState==FloatState)
         {
             if (!getContext().canDeclareLocals())
+            {
                 getErrorHandler().error ("local variables can't be declared in this context", loc);
+                SkipParser skip (getErrorHandler(), getContext());
+                scanner.scan (skip);
+                return false;
+            }
             
             std::cout << "declaring local variable: " << name << std::endl;
             mState = EndState;
diff --git a/components/compiler/skipparser.cpp b/components/compiler/skipparser.cpp
new file mode 100644
index 000000000..2d09b63ba
--- /dev/null
+++ b/components/compiler/skipparser.cpp
@@ -0,0 +1,41 @@
+
+#include "skipparser.hpp"
+
+#include "scanner.hpp"
+
+namespace Compiler
+{
+    SkipParser::SkipParser (ErrorHandler& errorHandler, Context& context)
+    : Parser (errorHandler, context)
+    {}
+
+    bool SkipParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
+    {
+        return true;
+    }
+
+    bool SkipParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
+    {
+        return true;
+    }
+
+    bool SkipParser::parseName (const std::string& name, const TokenLoc& loc,
+        Scanner& scanner)
+    {
+        return true;
+    }
+
+    bool SkipParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        return true;
+    }
+
+    bool SkipParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (code==Scanner::S_newline)
+            return false;
+            
+        return true;
+    }
+}
+
diff --git a/components/compiler/skipparser.hpp b/components/compiler/skipparser.hpp
new file mode 100644
index 000000000..17f1c8d98
--- /dev/null
+++ b/components/compiler/skipparser.hpp
@@ -0,0 +1,42 @@
+#ifndef COMPILER_SKIPPARSER_H_INCLUDED
+#define COMPILER_SKIPPARSER_H_INCLUDED
+
+#include "parser.hpp"
+
+namespace Compiler
+{
+    // \brief Skip parser for skipping a line
+    //
+    // This parser is mainly intended for skipping the rest of a faulty line.
+    
+    class SkipParser : public Parser
+    {
+        public:
+           
+            SkipParser (ErrorHandler& errorHandler, Context& context);
+    
+            virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle an int token.
+            /// \return fetch another token?
+
+            virtual bool parseFloat (float value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a float token.
+            /// \return fetch another token?
+
+            virtual bool parseName (const std::string& name, const TokenLoc& loc,
+                Scanner& scanner);
+            ///< Handle a name token.
+            /// \return fetch another token?
+
+            virtual bool parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a keyword token.
+            /// \return fetch another token?
+
+            virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+    };
+}
+
+#endif
+

From 0cfeab622d6c22782ab208ba4714d101b6033751 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 13:28:50 +0200
Subject: [PATCH 14/40] added storage class for local variable declarations;
 added checks for variable re-declaration

---
 CMakeLists.txt                       |  3 +-
 components/compiler/fileparser.cpp   |  3 +-
 components/compiler/fileparser.hpp   |  2 +
 components/compiler/lineparser.cpp   | 18 +++++++-
 components/compiler/lineparser.hpp   |  7 ++-
 components/compiler/locals.cpp       | 67 ++++++++++++++++++++++++++++
 components/compiler/locals.hpp       | 36 +++++++++++++++
 components/compiler/scriptparser.cpp |  6 ++-
 components/compiler/scriptparser.hpp |  6 ++-
 9 files changed, 139 insertions(+), 9 deletions(-)
 create mode 100644 components/compiler/locals.cpp
 create mode 100644 components/compiler/locals.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5377ea920..a3944ba57 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -70,7 +70,8 @@ set(COMPILER components/compiler/errorhandler.cpp
     components/compiler/fileparser.cpp components/compiler/scriptparser.cpp
     components/compiler/lineparser.cpp components/compiler/skipparser.cpp
     components/compiler/parser.cpp components/compiler/scanner.cpp
-    components/compiler/streamerrorhandler.cpp)
+    components/compiler/streamerrorhandler.cpp
+    components/compiler/locals.cpp)
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
 source_group(compiler FILES ${COMPILER} ${COMPILER_HEADER})    
 
diff --git a/components/compiler/fileparser.cpp b/components/compiler/fileparser.cpp
index 9894bce67..676bbec95 100644
--- a/components/compiler/fileparser.cpp
+++ b/components/compiler/fileparser.cpp
@@ -9,7 +9,7 @@ namespace Compiler
 {
     FileParser::FileParser (ErrorHandler& errorHandler, Context& context)
     : Parser (errorHandler, context), 
-      mScriptParser (errorHandler, context, true),
+      mScriptParser (errorHandler, context, mLocals, true),
       mState (BeginState)
     {}
 
@@ -88,6 +88,7 @@ namespace Compiler
         mState = BeginState;
         mName.clear();
         mScriptParser.reset();
+        mLocals.clear();
     }
 }
 
diff --git a/components/compiler/fileparser.hpp b/components/compiler/fileparser.hpp
index 81b8025ce..dc0353ea4 100644
--- a/components/compiler/fileparser.hpp
+++ b/components/compiler/fileparser.hpp
@@ -3,6 +3,7 @@
 
 #include "parser.hpp"
 #include "scriptparser.hpp"
+#include "locals.hpp"
 
 namespace Compiler
 {
@@ -19,6 +20,7 @@ namespace Compiler
             ScriptParser mScriptParser;
             State mState;
             std::string mName;
+            Locals mLocals;
             
         public:
         
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 6c8c3f735..6eda26748 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -7,11 +7,12 @@
 #include "context.hpp"
 #include "errorhandler.hpp"
 #include "skipparser.hpp"
+#include "locals.hpp"
 
 namespace Compiler
 {
-    LineParser::LineParser (ErrorHandler& errorHandler, Context& context)
-    : Parser (errorHandler, context), mState (BeginState)
+    LineParser::LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals)
+    : Parser (errorHandler, context), mLocals (locals), mState (BeginState)
     {}
 
     bool LineParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
@@ -37,7 +38,20 @@ namespace Compiler
                 return false;
             }
             
+            char type = mLocals.getType (name);
+            
+            if (type!=' ')
+            {
+                getErrorHandler().error ("can't re-declare local variable", loc);
+                SkipParser skip (getErrorHandler(), getContext());
+                scanner.scan (skip);
+                return false;
+            }
+            
             std::cout << "declaring local variable: " << name << std::endl;
+            mLocals.declare (mState==ShortState ? 's' : (mState==LongState ? 'l' : 'f'),
+                name);
+            
             mState = EndState;
             return true;
         }
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
index 420315551..3c2ed309f 100644
--- a/components/compiler/lineparser.hpp
+++ b/components/compiler/lineparser.hpp
@@ -5,6 +5,8 @@
 
 namespace Compiler
 {
+    class Locals;
+    
     /// \brief Line parser, to be used in console scripts and as part of ScriptParser
     
     class LineParser : public Parser
@@ -15,12 +17,13 @@ namespace Compiler
                 ShortState, LongState, FloatState,
                 EndState
             };
-            
+
+            Locals& mLocals;            
             State mState;
     
         public:
         
-            LineParser (ErrorHandler& errorHandler, Context& context);
+            LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals);
     
             virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
             ///< Handle an int token.
diff --git a/components/compiler/locals.cpp b/components/compiler/locals.cpp
new file mode 100644
index 000000000..fe0974cf3
--- /dev/null
+++ b/components/compiler/locals.cpp
@@ -0,0 +1,67 @@
+
+#include "locals.hpp"
+
+#include <cassert>
+#include <stdexcept>
+#include <algorithm>
+
+namespace Compiler
+{
+    const std::vector<std::string>& Locals::get (char type) const
+    {
+        switch (type)
+        {
+            case 's': return mShorts;
+            case 'l': return mLongs;
+            case 'f': return mFloats;        
+        }
+        
+        throw std::logic_error ("unknown variable type");
+    }
+    
+    bool Locals::search (char type, const std::string& name) const
+    {
+        const std::vector<std::string>& collection = get (type);
+        
+        return std::find (collection.begin(), collection.end(), name)!=collection.end();
+    }
+
+    std::vector<std::string>& Locals::get (char type)
+    {
+        switch (type)
+        {
+            case 's': return mShorts;
+            case 'l': return mLongs;
+            case 'f': return mFloats;        
+        }
+        
+        throw std::logic_error ("unknown variable type");    
+    }
+
+    char Locals::getType (const std::string& name) const
+    {
+        if (search ('s', name))
+            return 's';
+
+        if (search ('l', name))
+            return 'l';
+        
+        if (search ('f', name))
+            return 'f';
+        
+        return ' ';
+    }
+    
+    void Locals::declare (char type, const std::string& name)
+    {
+        get (type).push_back (name);
+    }
+    
+    void Locals::clear()
+    {
+        get ('s').clear();
+        get ('l').clear();
+        get ('f').clear();
+    }
+}
+
diff --git a/components/compiler/locals.hpp b/components/compiler/locals.hpp
new file mode 100644
index 000000000..4e4d5c765
--- /dev/null
+++ b/components/compiler/locals.hpp
@@ -0,0 +1,36 @@
+#ifndef COMPILER_LOCALS_H_INCLUDED
+#define COMPILER_LOCALS_H_INCLUDED
+
+#include <vector>
+#include <string>
+
+namespace Compiler
+{
+    /// \brief Local variable declarations
+    
+    class Locals
+    {
+            std::vector<std::string> mShorts;
+            std::vector<std::string> mLongs;
+            std::vector<std::string> mFloats;
+    
+            const std::vector<std::string>& get (char type) const;
+
+            bool search (char type, const std::string& name) const;
+            
+            std::vector<std::string>& get (char type);   
+    
+        public:
+    
+            char getType (const std::string& name) const;
+            ///< 's': short, 'l': long, 'f': float, ' ': does not exist.
+            
+            void declare (char type, const std::string& name);
+            ///< declares a variable.
+            
+            void clear();
+            ///< remove all declarations.
+    };
+}
+
+#endif
diff --git a/components/compiler/scriptparser.cpp b/components/compiler/scriptparser.cpp
index 769cc5ab2..fb3d47e66 100644
--- a/components/compiler/scriptparser.cpp
+++ b/components/compiler/scriptparser.cpp
@@ -5,8 +5,10 @@
 
 namespace Compiler
 {
-    ScriptParser::ScriptParser (ErrorHandler& errorHandler, Context& context, bool end)
-    : Parser (errorHandler, context), mLineParser (errorHandler, context), mEnd (end)
+    ScriptParser::ScriptParser (ErrorHandler& errorHandler, Context& context,
+        Locals& locals, bool end)
+    : Parser (errorHandler, context), mLineParser (errorHandler, context, locals),
+        mLocals (locals), mEnd (end)
     {}
 
     bool ScriptParser::parseName (const std::string& name, const TokenLoc& loc,
diff --git a/components/compiler/scriptparser.hpp b/components/compiler/scriptparser.hpp
index 6933b7d08..45c637947 100644
--- a/components/compiler/scriptparser.hpp
+++ b/components/compiler/scriptparser.hpp
@@ -6,17 +6,21 @@
 
 namespace Compiler
 {
+    class Locals;
+
     // Script parser, to be used in dialogue scripts and as part of FileParser
     
     class ScriptParser : public Parser
     {
             LineParser mLineParser;
+            Locals& mLocals;
             bool mEnd;
             
         public:
         
             /// \param end of script is marked by end keyword.
-            ScriptParser (ErrorHandler& errorHandler, Context& context, bool end = false);
+            ScriptParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
+                bool end = false);
     
             virtual bool parseName (const std::string& name, const TokenLoc& loc,
                 Scanner& scanner);

From a3ad61b4d06001066c96534520006753fdf4fe9a Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 14:07:55 +0200
Subject: [PATCH 15/40] write code file after successfull parsing

---
 CMakeLists.txt                       |  6 +++++-
 apps/mwcompiler/main.cpp             | 17 +++++++++++++----
 components/compiler/fileparser.cpp   |  5 +++++
 components/compiler/fileparser.hpp   |  3 +++
 components/compiler/lineparser.cpp   |  8 +++-----
 components/compiler/lineparser.hpp   | 10 ++++++++--
 components/compiler/scriptparser.cpp |  8 +++++++-
 components/compiler/scriptparser.hpp |  8 ++++++++
 components/interpreter/types.hpp     | 11 +++++++++++
 9 files changed, 63 insertions(+), 13 deletions(-)
 create mode 100644 components/interpreter/types.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a3944ba57..c3a14278e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,9 +75,13 @@ set(COMPILER components/compiler/errorhandler.cpp
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
 source_group(compiler FILES ${COMPILER} ${COMPILER_HEADER})    
 
+file(GLOB INTERPRETER_HEADER components/interpreter/*.hpp)
+source_group(interpreter FILES ${INTERPRETER_HEADER})    
+
 set(COMPONENTS ${BSA} ${NIF} ${NIFOGRE} ${ESM_STORE} ${OGRE} ${INPUT} ${MISC} ${COMPILER})
 set(COMPONENTS_HEADER ${BSA_HEADER} ${NIF_HEADER} ${NIFOGRE_HEADER} ${ESM_STORE_HEADER}
-    ${ESM_HEADER} ${OGRE_HEADER} ${INPUT_HEADER} ${MISC_HEADER} ${COMPILER_HEADER})
+    ${ESM_HEADER} ${OGRE_HEADER} ${INPUT_HEADER} ${MISC_HEADER} ${COMPILER_HEADER}
+    ${INTERPRETER_HEADER})
 
 # source directory: libs
 
diff --git a/apps/mwcompiler/main.cpp b/apps/mwcompiler/main.cpp
index a4ec9a573..d55fe3a42 100644
--- a/apps/mwcompiler/main.cpp
+++ b/apps/mwcompiler/main.cpp
@@ -3,7 +3,9 @@
 #include <exception>
 #include <iostream>
 #include <fstream>
+#include <vector>
 
+#include <components/interpreter/types.hpp>
 #include <components/compiler/streamerrorhandler.hpp>
 #include <components/compiler/scanner.hpp>
 #include <components/compiler/fileparser.hpp>
@@ -18,11 +20,11 @@ int main (int argc, char **argv)
         SACompiler::Context context;
         Compiler::StreamErrorHandler errorHandler (std::cout);
         Compiler::FileParser parser (errorHandler, context);
-        
+
+        std::string filename = argc>1 ? argv[1] : "test.mwscript";
+
         try
         {
-            std::string filename = argc>1 ? argv[1] : "test.mwscript";
-        
             std::ifstream file (filename.c_str());
             
             if (!file.is_open())
@@ -50,7 +52,14 @@ int main (int argc, char **argv)
         
         if (errorHandler.isGood())
         {
-            std::cout << "parsed script: " << parser.getName() << std::endl;
+            std::vector<Interpreter::Type_Code> code;
+            parser.getCode (code);
+            
+            std::ofstream codeFile ((filename + ".code").c_str());
+            
+            codeFile.write (reinterpret_cast<const char *> (&code[0]),
+                code.size()*sizeof (Interpreter::Type_Code));
+            
             return 0;
         }
         
diff --git a/components/compiler/fileparser.cpp b/components/compiler/fileparser.cpp
index 676bbec95..59ec90286 100644
--- a/components/compiler/fileparser.cpp
+++ b/components/compiler/fileparser.cpp
@@ -17,6 +17,11 @@ namespace Compiler
     {
         return mName;
     }
+    
+    void FileParser::getCode (std::vector<Interpreter::Type_Code>& code) const
+    {
+        mScriptParser.getCode (code);
+    }
 
     bool FileParser::parseName (const std::string& name, const TokenLoc& loc,
         Scanner& scanner)
diff --git a/components/compiler/fileparser.hpp b/components/compiler/fileparser.hpp
index dc0353ea4..55b5a1509 100644
--- a/components/compiler/fileparser.hpp
+++ b/components/compiler/fileparser.hpp
@@ -29,6 +29,9 @@ namespace Compiler
             std::string getName() const;
             ///< Return script name.
 
+            void getCode (std::vector<Interpreter::Type_Code>& code) const;
+            ///< store generated code in \æ code.
+
             virtual bool parseName (const std::string& name, const TokenLoc& loc,
                 Scanner& scanner);
             ///< Handle a name token.
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 6eda26748..7baf81f24 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -1,8 +1,6 @@
 
 #include "lineparser.hpp"
 
-#include <iostream>
-
 #include "scanner.hpp"
 #include "context.hpp"
 #include "errorhandler.hpp"
@@ -11,8 +9,9 @@
 
 namespace Compiler
 {
-    LineParser::LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals)
-    : Parser (errorHandler, context), mLocals (locals), mState (BeginState)
+    LineParser::LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
+        std::vector<Interpreter::Type_Code>& code)
+    : Parser (errorHandler, context), mLocals (locals), mCode (code), mState (BeginState)
     {}
 
     bool LineParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
@@ -48,7 +47,6 @@ namespace Compiler
                 return false;
             }
             
-            std::cout << "declaring local variable: " << name << std::endl;
             mLocals.declare (mState==ShortState ? 's' : (mState==LongState ? 'l' : 'f'),
                 name);
             
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
index 3c2ed309f..d7840af71 100644
--- a/components/compiler/lineparser.hpp
+++ b/components/compiler/lineparser.hpp
@@ -1,6 +1,10 @@
 #ifndef COMPILER_LINEPARSER_H_INCLUDED
 #define COMPILER_LINEPARSER_H_INCLUDED
 
+#include <vector>
+
+#include <components/interpreter/types.hpp>
+
 #include "parser.hpp"
 
 namespace Compiler
@@ -18,12 +22,14 @@ namespace Compiler
                 EndState
             };
 
-            Locals& mLocals;            
+            Locals& mLocals;  
+            std::vector<Interpreter::Type_Code>& mCode;
             State mState;
     
         public:
         
-            LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals);
+            LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
+                std::vector<Interpreter::Type_Code>& code);
     
             virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
             ///< Handle an int token.
diff --git a/components/compiler/scriptparser.cpp b/components/compiler/scriptparser.cpp
index fb3d47e66..338f4aecf 100644
--- a/components/compiler/scriptparser.cpp
+++ b/components/compiler/scriptparser.cpp
@@ -7,10 +7,15 @@ namespace Compiler
 {
     ScriptParser::ScriptParser (ErrorHandler& errorHandler, Context& context,
         Locals& locals, bool end)
-    : Parser (errorHandler, context), mLineParser (errorHandler, context, locals),
+    : Parser (errorHandler, context), mLineParser (errorHandler, context, locals, mCode),
         mLocals (locals), mEnd (end)
     {}
 
+    void ScriptParser::getCode (std::vector<Interpreter::Type_Code>& code) const
+    {
+        code = mCode;
+    }
+
     bool ScriptParser::parseName (const std::string& name, const TokenLoc& loc,
         Scanner& scanner)
     {
@@ -56,6 +61,7 @@ namespace Compiler
     void ScriptParser::reset()
     {
         mLineParser.reset();
+        mCode.clear();
     }
 }
 
diff --git a/components/compiler/scriptparser.hpp b/components/compiler/scriptparser.hpp
index 45c637947..dd31f0217 100644
--- a/components/compiler/scriptparser.hpp
+++ b/components/compiler/scriptparser.hpp
@@ -1,6 +1,10 @@
 #ifndef COMPILER_SCRIPTPARSER_H_INCLUDED
 #define COMPILER_SCRIPTPARSER_H_INCLUDED
 
+#include <vector>
+
+#include <components/interpreter/types.hpp>
+
 #include "parser.hpp"
 #include "lineparser.hpp"
 
@@ -15,6 +19,7 @@ namespace Compiler
             LineParser mLineParser;
             Locals& mLocals;
             bool mEnd;
+            std::vector<Interpreter::Type_Code> mCode;
             
         public:
         
@@ -22,6 +27,9 @@ namespace Compiler
             ScriptParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
                 bool end = false);
     
+            void getCode (std::vector<Interpreter::Type_Code>& code) const;
+            ///< store generated code in \æ code.
+    
             virtual bool parseName (const std::string& name, const TokenLoc& loc,
                 Scanner& scanner);
             ///< Handle a name token.
diff --git a/components/interpreter/types.hpp b/components/interpreter/types.hpp
new file mode 100644
index 000000000..8ae59b115
--- /dev/null
+++ b/components/interpreter/types.hpp
@@ -0,0 +1,11 @@
+#ifndef INTERPRETER_TYPES_H_INCLUDED
+#define INTERPRETER_TYPES_H_INCLUDED
+
+namespace Interpreter
+{
+    typedef unsigned int Type_Code; // 32 bit
+
+}
+
+#endif
+

From ba847ae9d85f966f2d78d443301900631b71a48e Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 14:17:50 +0200
Subject: [PATCH 16/40] write local variable declarations into a separate file

---
 apps/mwcompiler/main.cpp           |  4 ++++
 components/compiler/fileparser.cpp |  5 +++++
 components/compiler/fileparser.hpp |  3 +++
 components/compiler/locals.cpp     | 17 +++++++++++++++++
 components/compiler/locals.hpp     |  4 ++++
 5 files changed, 33 insertions(+)

diff --git a/apps/mwcompiler/main.cpp b/apps/mwcompiler/main.cpp
index d55fe3a42..a19a50ab3 100644
--- a/apps/mwcompiler/main.cpp
+++ b/apps/mwcompiler/main.cpp
@@ -60,6 +60,10 @@ int main (int argc, char **argv)
             codeFile.write (reinterpret_cast<const char *> (&code[0]),
                 code.size()*sizeof (Interpreter::Type_Code));
             
+            std::ofstream localFile ((filename + ".locals").c_str());
+            
+            parser.getLocals().write (localFile);
+            
             return 0;
         }
         
diff --git a/components/compiler/fileparser.cpp b/components/compiler/fileparser.cpp
index 59ec90286..caf44f749 100644
--- a/components/compiler/fileparser.cpp
+++ b/components/compiler/fileparser.cpp
@@ -22,6 +22,11 @@ namespace Compiler
     {
         mScriptParser.getCode (code);
     }
+    
+    const Locals& FileParser::getLocals() const
+    {
+        return mLocals;
+    }
 
     bool FileParser::parseName (const std::string& name, const TokenLoc& loc,
         Scanner& scanner)
diff --git a/components/compiler/fileparser.hpp b/components/compiler/fileparser.hpp
index 55b5a1509..b9239841f 100644
--- a/components/compiler/fileparser.hpp
+++ b/components/compiler/fileparser.hpp
@@ -31,6 +31,9 @@ namespace Compiler
 
             void getCode (std::vector<Interpreter::Type_Code>& code) const;
             ///< store generated code in \æ code.
+            
+            const Locals& getLocals() const;
+            ///< get local variable declarations.
 
             virtual bool parseName (const std::string& name, const TokenLoc& loc,
                 Scanner& scanner);
diff --git a/components/compiler/locals.cpp b/components/compiler/locals.cpp
index fe0974cf3..eefe27a03 100644
--- a/components/compiler/locals.cpp
+++ b/components/compiler/locals.cpp
@@ -4,6 +4,8 @@
 #include <cassert>
 #include <stdexcept>
 #include <algorithm>
+#include <ostream>
+#include <iterator>
 
 namespace Compiler
 {
@@ -52,6 +54,21 @@ namespace Compiler
         return ' ';
     }
     
+    void Locals::write (std::ostream& localFile) const
+    {
+        localFile
+            << get ('s').size() << ' '
+            << get ('l').size() << ' '
+            << get ('f').size() << std::endl;
+            
+        std::copy (get ('s').begin(), get ('s').end(),
+            std::ostream_iterator<std::string> (localFile, " "));
+        std::copy (get ('l').begin(), get ('l').end(),
+            std::ostream_iterator<std::string> (localFile, " "));
+        std::copy (get ('f').begin(), get ('f').end(),
+            std::ostream_iterator<std::string> (localFile, " "));
+    }
+    
     void Locals::declare (char type, const std::string& name)
     {
         get (type).push_back (name);
diff --git a/components/compiler/locals.hpp b/components/compiler/locals.hpp
index 4e4d5c765..c12ba371a 100644
--- a/components/compiler/locals.hpp
+++ b/components/compiler/locals.hpp
@@ -3,6 +3,7 @@
 
 #include <vector>
 #include <string>
+#include <iosfwd>
 
 namespace Compiler
 {
@@ -25,6 +26,9 @@ namespace Compiler
             char getType (const std::string& name) const;
             ///< 's': short, 'l': long, 'f': float, ' ': does not exist.
             
+            void write (std::ostream& localFile) const;
+            ///< write declarations to file.
+            
             void declare (char type, const std::string& name);
             ///< declares a variable.
             

From 5cf3264bd376edc77c2226bf585d85bd7e7acaaf Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 16:48:19 +0200
Subject: [PATCH 17/40] added literal container and reworked output container
 handling

---
 CMakeLists.txt                       |  3 +-
 components/compiler/fileparser.cpp   |  1 -
 components/compiler/fileparser.hpp   |  3 +-
 components/compiler/lineparser.cpp   |  5 +-
 components/compiler/lineparser.hpp   |  4 +-
 components/compiler/literals.cpp     | 94 ++++++++++++++++++++++++++++
 components/compiler/literals.hpp     | 49 +++++++++++++++
 components/compiler/output.cpp       | 74 ++++++++++++++++++++++
 components/compiler/output.hpp       | 44 +++++++++++++
 components/compiler/scriptparser.cpp |  9 +--
 components/compiler/scriptparser.hpp |  9 +--
 components/interpreter/types.hpp     |  5 ++
 12 files changed, 284 insertions(+), 16 deletions(-)
 create mode 100644 components/compiler/literals.cpp
 create mode 100644 components/compiler/literals.hpp
 create mode 100644 components/compiler/output.cpp
 create mode 100644 components/compiler/output.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c3a14278e..98a0b5d52 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,7 +71,8 @@ set(COMPILER components/compiler/errorhandler.cpp
     components/compiler/lineparser.cpp components/compiler/skipparser.cpp
     components/compiler/parser.cpp components/compiler/scanner.cpp
     components/compiler/streamerrorhandler.cpp
-    components/compiler/locals.cpp)
+    components/compiler/locals.cpp components/compiler/literals.cpp
+    components/compiler/output.cpp)
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
 source_group(compiler FILES ${COMPILER} ${COMPILER_HEADER})    
 
diff --git a/components/compiler/fileparser.cpp b/components/compiler/fileparser.cpp
index caf44f749..f8b3d0e61 100644
--- a/components/compiler/fileparser.cpp
+++ b/components/compiler/fileparser.cpp
@@ -98,7 +98,6 @@ namespace Compiler
         mState = BeginState;
         mName.clear();
         mScriptParser.reset();
-        mLocals.clear();
     }
 }
 
diff --git a/components/compiler/fileparser.hpp b/components/compiler/fileparser.hpp
index b9239841f..13c7fb537 100644
--- a/components/compiler/fileparser.hpp
+++ b/components/compiler/fileparser.hpp
@@ -4,6 +4,7 @@
 #include "parser.hpp"
 #include "scriptparser.hpp"
 #include "locals.hpp"
+#include "literals.hpp"
 
 namespace Compiler
 {
@@ -21,7 +22,7 @@ namespace Compiler
             State mState;
             std::string mName;
             Locals mLocals;
-            
+
         public:
         
             FileParser (ErrorHandler& errorHandler, Context& context);
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 7baf81f24..d88680edc 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -10,8 +10,9 @@
 namespace Compiler
 {
     LineParser::LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
-        std::vector<Interpreter::Type_Code>& code)
-    : Parser (errorHandler, context), mLocals (locals), mCode (code), mState (BeginState)
+        Literals& literals, std::vector<Interpreter::Type_Code>& code)
+    : Parser (errorHandler, context), mLocals (locals), mLiterals (literals), mCode (code),
+       mState (BeginState)
     {}
 
     bool LineParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
index d7840af71..43d79883d 100644
--- a/components/compiler/lineparser.hpp
+++ b/components/compiler/lineparser.hpp
@@ -10,6 +10,7 @@
 namespace Compiler
 {
     class Locals;
+    class Literals;
     
     /// \brief Line parser, to be used in console scripts and as part of ScriptParser
     
@@ -23,13 +24,14 @@ namespace Compiler
             };
 
             Locals& mLocals;  
+            Literals& mLiterals;
             std::vector<Interpreter::Type_Code>& mCode;
             State mState;
     
         public:
         
             LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
-                std::vector<Interpreter::Type_Code>& code);
+                Literals& literals, std::vector<Interpreter::Type_Code>& code);
     
             virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
             ///< Handle an int token.
diff --git a/components/compiler/literals.cpp b/components/compiler/literals.cpp
new file mode 100644
index 000000000..626b03afb
--- /dev/null
+++ b/components/compiler/literals.cpp
@@ -0,0 +1,94 @@
+
+#include "literals.hpp"
+
+#include <algorithm>
+
+namespace Compiler
+{
+    int Literals::getIntegerSize() const
+    {
+        return mIntegers.size() * sizeof (Interpreter::Type_Integer);
+    }
+
+    int Literals::getFloatSize() const
+    {
+        return mFloats.size() * sizeof (Interpreter::Type_Float);
+    }
+
+    int Literals::getStringSize() const
+    {
+        int size = 0;
+        
+        for (std::vector<std::string>::const_iterator iter (mStrings.begin());
+            iter!=mStrings.end(); ++iter)
+            size += static_cast<int> (iter->size()) + 1;
+            
+        if (size % 4) // padding
+            size += 4 - size % 4;
+            
+        return size;
+    }
+
+    void Literals::append (std::vector<Interpreter::Type_Code>& code) const
+    {
+        for (std::vector<Interpreter::Type_Integer>::const_iterator iter (mIntegers.begin());
+            iter!=mIntegers.end(); ++iter)
+            code.push_back (*reinterpret_cast<const Interpreter::Type_Code *> (&*iter));
+            
+        for (std::vector<Interpreter::Type_Float>::const_iterator iter (mFloats.begin());
+            iter!=mFloats.end(); ++iter)
+            code.push_back (*reinterpret_cast<const Interpreter::Type_Code *> (&*iter));
+            
+        int stringBlockSize = getStringSize();
+        int size = static_cast<int> (code.size());
+        
+        code.resize (size+stringBlockSize/4);
+        
+        int offset = 0;
+        
+        for (std::vector<std::string>::const_iterator iter (mStrings.begin());
+            iter!=mStrings.end(); ++iter)        
+        {
+            int stringSize = iter->size()+1;
+            
+            std::copy (iter->c_str(), iter->c_str()+stringSize,
+                reinterpret_cast<char *> (&code[size]) + offset);
+            offset += stringSize;
+        }
+    }
+
+    int Literals::addInteger (Interpreter::Type_Integer value)
+    {
+        int index = static_cast<int> (mIntegers.size());
+        
+        mIntegers.push_back (value);
+        
+        return index;    
+    }
+
+    int Literals::addFloat (Interpreter::Type_Float value)
+    {
+        int index = static_cast<int> (mFloats.size());
+        
+        mFloats.push_back (value);
+        
+        return index;    
+    }
+
+    int Literals::addString (const std::string& value)
+    {
+        int index = static_cast<int> (mStrings.size());
+        
+        mStrings.push_back (value);
+        
+        return index;
+    }
+
+    void Literals::clear()
+    {
+        mIntegers.clear();
+        mFloats.clear();
+        mStrings.clear();
+    }
+}
+
diff --git a/components/compiler/literals.hpp b/components/compiler/literals.hpp
new file mode 100644
index 000000000..b18c86479
--- /dev/null
+++ b/components/compiler/literals.hpp
@@ -0,0 +1,49 @@
+#ifndef COMPILER_LITERALS_H_INCLUDED
+#define COMPILER_LITERALS_H_INCLUDED
+
+#include <string>
+#include <vector>
+
+#include <components/interpreter/types.hpp>
+
+namespace Compiler
+{
+    /// \brief Literal values.
+    
+    class Literals
+    {
+            std::vector<Interpreter::Type_Integer> mIntegers;
+            std::vector<Interpreter::Type_Float> mFloats;
+            std::vector<std::string> mStrings;
+    
+        public:
+        
+            int getIntegerSize() const;
+            ///< Return size of integer block (in bytes).
+
+            int getFloatSize() const;
+            ///< Return size of float block (in bytes).
+        
+            int getStringSize() const;
+            ///< Return size of string block (in bytes).
+        
+            void append (std::vector<Interpreter::Type_Code>& code) const;
+            ///< Apepnd literal blocks to code.
+            /// \note code blocks will be padded for 32-bit alignment.
+        
+            int addInteger (Interpreter::Type_Integer value);
+            ///< add integer liternal and return index.
+            
+            int addFloat (Interpreter::Type_Float value);
+            ///< add float literal and return value.
+            
+            int addString (const std::string& value);
+            ///< add string literal and return value.
+        
+            void clear();
+            ///< remove all literals.
+    };
+}
+
+#endif
+
diff --git a/components/compiler/output.cpp b/components/compiler/output.cpp
new file mode 100644
index 000000000..46e04b8dc
--- /dev/null
+++ b/components/compiler/output.cpp
@@ -0,0 +1,74 @@
+
+#include "output.hpp"
+
+#include <cassert>
+#include <algorithm>
+#include <iterator>
+
+#include "locals.hpp"
+
+namespace Compiler
+{
+    Output::Output (Locals& locals) : mLocals (locals) {}
+
+    void Output::getCode (std::vector<Interpreter::Type_Code>& code) const
+    {
+        code.clear();
+        
+        // header
+        code.push_back (static_cast<Interpreter::Type_Code> (mCode.size()));
+        
+        assert (mLiterals.getIntegerSize()%4==0);
+        code.push_back (static_cast<Interpreter::Type_Code> (mLiterals.getIntegerSize()/4));
+        
+        assert (mLiterals.getFloatSize()%4==0);
+        code.push_back (static_cast<Interpreter::Type_Code> (mLiterals.getFloatSize()/4));
+        
+        assert (mLiterals.getStringSize()%4==0);
+        code.push_back (static_cast<Interpreter::Type_Code> (mLiterals.getStringSize()/4));
+        
+        // code
+        std::copy (mCode.begin(), mCode.end(), std::back_inserter (code));
+        
+        // literals
+        mLiterals.append (code);
+    }
+
+    const Literals& Output::getLiterals() const
+    {
+        return mLiterals;
+    }
+            
+    const std::vector<Interpreter::Type_Code>& Output::getCode() const
+    {
+        return mCode;
+    }
+            
+    const Locals& Output::getLocals() const
+    {
+        return mLocals;
+    }
+
+    Literals& Output::getLiterals()
+    {
+        return mLiterals;
+    }
+    
+    std::vector<Interpreter::Type_Code>& Output::getCode()
+    {
+        return mCode;
+    }
+    
+    Locals& Output::getLocals()
+    {
+        return mLocals;
+    }
+    
+    void Output::clear()
+    {
+        mLiterals.clear();
+        mCode.clear();
+        mLocals.clear();
+    }
+}
+
diff --git a/components/compiler/output.hpp b/components/compiler/output.hpp
new file mode 100644
index 000000000..37b88cee9
--- /dev/null
+++ b/components/compiler/output.hpp
@@ -0,0 +1,44 @@
+#ifndef COMPILER_OUTPUT_H_INCLUDED
+#define COMPILER_OUTPUT_H_INCLUDED
+
+#include "literals.hpp"
+
+#include <vector>
+
+#include <components/interpreter/types.hpp>
+
+namespace Compiler
+{
+    class Locals;
+
+    class Output
+    {
+            Literals mLiterals;
+            std::vector<Interpreter::Type_Code> mCode;            
+            Locals& mLocals;
+                
+        public:
+        
+            Output (Locals& locals);
+    
+            void getCode (std::vector<Interpreter::Type_Code>& code) const;
+            ///< store generated code in \æ code.
+
+            const Literals& getLiterals() const;
+
+            const Locals& getLocals() const;
+            
+            const std::vector<Interpreter::Type_Code>& getCode() const;
+            
+            Literals& getLiterals();
+
+            std::vector<Interpreter::Type_Code>& getCode();
+            
+            Locals& getLocals();
+            
+            void clear();
+    };
+}
+
+#endif
+
diff --git a/components/compiler/scriptparser.cpp b/components/compiler/scriptparser.cpp
index 338f4aecf..d3d32af89 100644
--- a/components/compiler/scriptparser.cpp
+++ b/components/compiler/scriptparser.cpp
@@ -7,13 +7,14 @@ namespace Compiler
 {
     ScriptParser::ScriptParser (ErrorHandler& errorHandler, Context& context,
         Locals& locals, bool end)
-    : Parser (errorHandler, context), mLineParser (errorHandler, context, locals, mCode),
-        mLocals (locals), mEnd (end)
+    : Parser (errorHandler, context), mOutput (locals),
+      mLineParser (errorHandler, context, locals, mOutput.getLiterals(), mOutput.getCode()),
+      mEnd (end)
     {}
 
     void ScriptParser::getCode (std::vector<Interpreter::Type_Code>& code) const
     {
-        code = mCode;
+        mOutput.getCode (code);
     }
 
     bool ScriptParser::parseName (const std::string& name, const TokenLoc& loc,
@@ -61,7 +62,7 @@ namespace Compiler
     void ScriptParser::reset()
     {
         mLineParser.reset();
-        mCode.clear();
+        mOutput.clear();
     }
 }
 
diff --git a/components/compiler/scriptparser.hpp b/components/compiler/scriptparser.hpp
index dd31f0217..dd4e38511 100644
--- a/components/compiler/scriptparser.hpp
+++ b/components/compiler/scriptparser.hpp
@@ -1,12 +1,10 @@
 #ifndef COMPILER_SCRIPTPARSER_H_INCLUDED
 #define COMPILER_SCRIPTPARSER_H_INCLUDED
 
-#include <vector>
-
-#include <components/interpreter/types.hpp>
 
 #include "parser.hpp"
 #include "lineparser.hpp"
+#include "output.hpp"
 
 namespace Compiler
 {
@@ -16,11 +14,10 @@ namespace Compiler
     
     class ScriptParser : public Parser
     {
+            Output mOutput;
             LineParser mLineParser;
-            Locals& mLocals;
             bool mEnd;
-            std::vector<Interpreter::Type_Code> mCode;
-            
+
         public:
         
             /// \param end of script is marked by end keyword.
diff --git a/components/interpreter/types.hpp b/components/interpreter/types.hpp
index 8ae59b115..4189914d6 100644
--- a/components/interpreter/types.hpp
+++ b/components/interpreter/types.hpp
@@ -5,6 +5,11 @@ namespace Interpreter
 {
     typedef unsigned int Type_Code; // 32 bit
 
+    typedef unsigned int Type_Data; // 32 bit
+    
+    typedef unsigned int Type_Integer; // 32 bit
+    
+    typedef unsigned int Type_Float; // 32 bit
 }
 
 #endif

From fdcd34941b6462bc286441955f2c2a243c5e4104 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 18:27:45 +0200
Subject: [PATCH 18/40] added parsing for set statement (only integer values so
 far); added code generator

---
 CMakeLists.txt                           |   2 +-
 components/compiler/generator.cpp        | 120 +++++++++++++++++++++++
 components/compiler/generator.hpp        |  22 +++++
 components/compiler/lineparser.cpp       |  36 +++++++
 components/compiler/lineparser.hpp       |   2 +
 components/compiler/locals.cpp           |  30 +++++-
 components/compiler/locals.hpp           |   5 +
 components/interpreter/docs/vmformat.txt |  62 ++++++++++++
 components/interpreter/types.hpp         |   4 +-
 9 files changed, 278 insertions(+), 5 deletions(-)
 create mode 100644 components/compiler/generator.cpp
 create mode 100644 components/compiler/generator.hpp
 create mode 100644 components/interpreter/docs/vmformat.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 98a0b5d52..1ffaca590 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -72,7 +72,7 @@ set(COMPILER components/compiler/errorhandler.cpp
     components/compiler/parser.cpp components/compiler/scanner.cpp
     components/compiler/streamerrorhandler.cpp
     components/compiler/locals.cpp components/compiler/literals.cpp
-    components/compiler/output.cpp)
+    components/compiler/output.cpp components/compiler/generator.cpp)
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
 source_group(compiler FILES ${COMPILER} ${COMPILER_HEADER})    
 
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
new file mode 100644
index 000000000..e73909d90
--- /dev/null
+++ b/components/compiler/generator.cpp
@@ -0,0 +1,120 @@
+
+#include "generator.hpp"
+
+#include <cassert>
+
+#include "literals.hpp"
+
+namespace
+{
+    Interpreter::Type_Code segment0 (unsigned int c, unsigned int arg0)
+    {
+        assert (c<64);
+        return (c<<24) | (arg0 & 0xffffff);
+    }
+
+    Interpreter::Type_Code segment1 (unsigned int c, unsigned int arg0, unsigned int arg1)
+    {
+        assert (c<64);
+        return 0x40000000 | (c<<24) | ((arg0 & 0xfff)<<12) | (arg1 & 0xfff);
+    }
+
+    Interpreter::Type_Code segment2 (unsigned int c, unsigned int arg0)
+    {
+        assert (c<1024);
+        return 0x80000000 | (c<<20) | (arg0 & 0xfffff);
+    }
+
+    Interpreter::Type_Code segment3 (unsigned int c, unsigned int arg0)
+    {
+        assert (c<1024);
+        return 0xc0000000 | (c<<20) | (arg0 & 0xffff);    
+    }
+
+    Interpreter::Type_Code segment4 (unsigned int c, unsigned int arg0, unsigned int arg1)
+    {
+        assert (c<1024);
+        return 0xc4000000 | (c<<16) | ((arg0 & 0xff)<<8) | (arg1 & 0xff);
+    }
+
+    Interpreter::Type_Code segment5 (unsigned int c)
+    {
+        assert (c<67108864);
+        return 0xc8000000 | c;
+    }
+    
+    void opPushInt (Compiler::Generator::CodeContainer& code, int value)
+    {
+        code.push_back (segment0 (0, value));
+    }
+    
+    void opFetchIntLiteral (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (4));
+    }
+    
+    void opFetchFloatLiteral (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (5));
+    }
+    
+    void opIntToFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (3));    
+    }
+    
+    void opStoreLocalShort (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (0));    
+    }
+    
+    void opStoreLocalLong (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (1));
+    }
+    
+    void opStoreLocalFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (2));
+    }        
+}
+
+namespace Compiler
+{
+    namespace Generator
+    {
+        void assignIntToLocal (CodeContainer& code, Literals& literals, char localType,
+            int localIndex, int value)
+        {
+            int index = literals.addInteger (value);
+                
+            opPushInt (code, localIndex);
+            opPushInt (code, index);
+            opFetchIntLiteral (code);
+            
+            switch (localType)
+            {
+                case 'f':
+                
+                    opIntToFloat (code);
+                    opStoreLocalFloat (code);
+                    break;
+                
+                case 's':
+
+                    opStoreLocalShort (code);
+                    break;
+                
+                case 'l':
+
+                    opStoreLocalLong (code);
+                    break;
+            
+                default:
+                
+                    assert (0);
+            }               
+        }
+    }
+}
+
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
new file mode 100644
index 000000000..cab5f3bda
--- /dev/null
+++ b/components/compiler/generator.hpp
@@ -0,0 +1,22 @@
+#ifndef COMPILER_GENERATOR_H_INCLUDED
+#define COMPILER_GENERATOR_H_INCLUDED
+
+#include <vector>
+
+#include <components/interpreter/types.hpp>
+
+namespace Compiler
+{
+    class Literals;
+
+    namespace Generator
+    {
+        typedef std::vector<Interpreter::Type_Code> CodeContainer;
+    
+        void assignIntToLocal (CodeContainer& code, Literals& literals, char localType,
+            int localIndex, int value);
+    }
+}
+
+#endif
+
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index d88680edc..35c79ff60 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -6,6 +6,7 @@
 #include "errorhandler.hpp"
 #include "skipparser.hpp"
 #include "locals.hpp"
+#include "generator.hpp"
 
 namespace Compiler
 {
@@ -17,6 +18,17 @@ namespace Compiler
 
     bool LineParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
     {
+        if (mState==SetLocalToState)
+        {
+            Generator::assignIntToLocal (mCode, mLiterals, mLocals.getType (mName),
+                mLocals.getIndex (mName), value);
+        
+            mState = EndState;
+            mName.clear();
+        
+            return true;
+        }
+    
         return Parser::parseInt (value, loc, scanner);
     }
 
@@ -55,6 +67,23 @@ namespace Compiler
             return true;
         }
         
+        if (mState==SetState)
+        {
+            // local variable?
+            char type = mLocals.getType (name);        
+            if (type!=' ')
+            {
+                mName = name;
+                mState = SetLocalVarState;
+                return true;
+            }
+            
+            getErrorHandler().error ("unknown variable", loc);
+            SkipParser skip (getErrorHandler(), getContext());
+            scanner.scan (skip);
+            return false;            
+        }
+        
         return Parser::parseName (name, loc, scanner);
     }
 
@@ -67,8 +96,14 @@ namespace Compiler
                 case Scanner::K_short: mState = ShortState; return true;
                 case Scanner::K_long: mState = LongState; return true;
                 case Scanner::K_float: mState = FloatState; return true;
+                case Scanner::K_set: mState = SetState; return true;
             }
         }
+        else if (mState==SetLocalVarState && keyword==Scanner::K_to)
+        {
+            mState = SetLocalToState;
+            return true;
+        }
         
         return Parser::parseKeyword (keyword, loc, scanner);
     }
@@ -84,6 +119,7 @@ namespace Compiler
     void LineParser::reset()
     {
         mState = BeginState;
+        mName.clear();
     }
 }
 
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
index 43d79883d..b69ac803e 100644
--- a/components/compiler/lineparser.hpp
+++ b/components/compiler/lineparser.hpp
@@ -20,6 +20,7 @@ namespace Compiler
             {
                 BeginState,
                 ShortState, LongState, FloatState,
+                SetState, SetLocalVarState, SetLocalToState,
                 EndState
             };
 
@@ -27,6 +28,7 @@ namespace Compiler
             Literals& mLiterals;
             std::vector<Interpreter::Type_Code>& mCode;
             State mState;
+            std::string mName;
     
         public:
         
diff --git a/components/compiler/locals.cpp b/components/compiler/locals.cpp
index eefe27a03..d93e73849 100644
--- a/components/compiler/locals.cpp
+++ b/components/compiler/locals.cpp
@@ -21,11 +21,22 @@ namespace Compiler
         throw std::logic_error ("unknown variable type");
     }
     
-    bool Locals::search (char type, const std::string& name) const
+    int Locals::searchIndex (char type, const std::string& name) const
     {
         const std::vector<std::string>& collection = get (type);
         
-        return std::find (collection.begin(), collection.end(), name)!=collection.end();
+        std::vector<std::string>::const_iterator iter =
+            std::find (collection.begin(), collection.end(), name);
+            
+        if (iter==collection.end())
+            return -1;
+            
+        return iter-collection.begin();
+    }
+    
+    bool Locals::search (char type, const std::string& name) const
+    {        
+        return searchIndex (type, name)!=-1;
     }
 
     std::vector<std::string>& Locals::get (char type)
@@ -54,6 +65,21 @@ namespace Compiler
         return ' ';
     }
     
+    int Locals::getIndex (const std::string& name) const
+    {
+        int index = searchIndex ('s', name);
+        
+        if (index!=-1)
+            return index;
+        
+        index = searchIndex ('l', name);
+
+        if (index!=-1)
+            return index;
+
+        return searchIndex ('f', name);        
+    }
+    
     void Locals::write (std::ostream& localFile) const
     {
         localFile
diff --git a/components/compiler/locals.hpp b/components/compiler/locals.hpp
index c12ba371a..fdd0a6b29 100644
--- a/components/compiler/locals.hpp
+++ b/components/compiler/locals.hpp
@@ -17,6 +17,8 @@ namespace Compiler
     
             const std::vector<std::string>& get (char type) const;
 
+            int searchIndex (char type, const std::string& name) const;
+
             bool search (char type, const std::string& name) const;
             
             std::vector<std::string>& get (char type);   
@@ -26,6 +28,9 @@ namespace Compiler
             char getType (const std::string& name) const;
             ///< 's': short, 'l': long, 'f': float, ' ': does not exist.
             
+            int getIndex (const std::string& name) const;
+            ///< return index for local variable \a name (-1: does not exist).
+            
             void write (std::ostream& localFile) const;
             ///< write declarations to file.
             
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
new file mode 100644
index 000000000..1449a6194
--- /dev/null
+++ b/components/interpreter/docs/vmformat.txt
@@ -0,0 +1,62 @@
+Note: a word is considered to be 32 bit long.
+
+Header (4 words):
+word: number of words in code block
+word: number of words in integer literal block
+word: number of words in float literal block
+word: number of words in string literal block
+
+Body (variable length):
+code block
+integer literal block (contains a collection of 1 word long integers)
+float literal block (contains a collection of 1 word long floating point numbers)
+string literal block (contains a collection of strings of variable length, word-padded)
+
+Code bit-patterns:
+
+3322222222221111111111
+10987654321098765432109876543210
+00ccccccAAAAAAAAAAAAAAAAAAAAAAAA segment 0: 64 opcodes, 1 24-bit argument
+01ccccccAAAAAAAAAAAABBBBBBBBBBBB segment 1: 64 opcodes, 2 12-bit arguments
+10ccccccccccAAAAAAAAAAAAAAAAAAAA segment 2: 1024 opcodes, 1 20-bit argument
+110000ccccccccccAAAAAAAAAAAAAAAA segment 3: 1024 opcodes, 1 16-bit argument
+110001ccccccccccAAAAAAAABBBBBBBB segment 4: 1024 opcodes, 2 8-bit arguments
+110010cccccccccccccccccccccccccc segment 5: 67108864 opcodes, no arguments
+other bit-patterns reserved
+
+legent:
+c: code
+A: argument 0
+B: argument 1
+
+Segment 0:
+op  0: push A
+opcodes 1-31 unused
+opcodes 32-63 reserved for extensions
+
+Segment 1:
+opcodes 0-31 unused
+opcodes 32-63 reserved for extensions
+
+Segment 2:
+opcodes 0-511 unused
+opcodes 512-1023 reserved for extensions
+
+Segment 3:
+opcodes 0-511 unused
+opcodes 512-1023 reserved for extensions
+
+Segment 4:
+opcodes 0-511 unused
+opcodes 512-1023 reserved for extensions
+
+Segment 5:
+op   0: store stack[0] in local short stack[1] and pop twice
+op   1: store stack[0] in local long stack[1] and pop twice
+op   2: store stack[0] in local float stack[1] and pop twice
+op   3: convert stack[0] from integer to float
+op   4: replace stack[0] with integer literal index stack[0]
+op   5: replace stack[0] with float literal index stack[0]
+opcodes 6-33554431 unused
+opcodes 33554432-67108863 reserved for extensions
+
diff --git a/components/interpreter/types.hpp b/components/interpreter/types.hpp
index 4189914d6..28ad51dd1 100644
--- a/components/interpreter/types.hpp
+++ b/components/interpreter/types.hpp
@@ -7,9 +7,9 @@ namespace Interpreter
 
     typedef unsigned int Type_Data; // 32 bit
     
-    typedef unsigned int Type_Integer; // 32 bit
+    typedef int Type_Integer; // 32 bit
     
-    typedef unsigned int Type_Float; // 32 bit
+    typedef float Type_Float; // 32 bit
 }
 
 #endif

From 487a70388fc4befe8c683640ce1b7a850dd4bcfb Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 19:20:45 +0200
Subject: [PATCH 19/40] added interpreter framework

---
 CMakeLists.txt                         | 13 +++++--
 apps/mwinterpreter/main.cpp            | 49 ++++++++++++++++++++++++++
 components/interpreter/context.hpp     | 14 ++++++++
 components/interpreter/interpreter.cpp | 22 ++++++++++++
 components/interpreter/interpreter.hpp | 28 +++++++++++++++
 components/interpreter/opcodes.hpp     | 40 +++++++++++++++++++++
 components/interpreter/runtime.cpp     | 22 ++++++++++++
 components/interpreter/runtime.hpp     | 31 ++++++++++++++++
 8 files changed, 217 insertions(+), 2 deletions(-)
 create mode 100644 apps/mwinterpreter/main.cpp
 create mode 100644 components/interpreter/context.hpp
 create mode 100644 components/interpreter/interpreter.cpp
 create mode 100644 components/interpreter/interpreter.hpp
 create mode 100644 components/interpreter/opcodes.hpp
 create mode 100644 components/interpreter/runtime.cpp
 create mode 100644 components/interpreter/runtime.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1ffaca590..17d54e241 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -76,10 +76,12 @@ set(COMPILER components/compiler/errorhandler.cpp
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
 source_group(compiler FILES ${COMPILER} ${COMPILER_HEADER})    
 
+set(INTERPRETER components/interpreter/runtime.cpp components/interpreter/interpreter.cpp)
 file(GLOB INTERPRETER_HEADER components/interpreter/*.hpp)
-source_group(interpreter FILES ${INTERPRETER_HEADER})    
+source_group(interpreter FILES ${INTERPRETER} ${INTERPRETER_HEADER})    
 
-set(COMPONENTS ${BSA} ${NIF} ${NIFOGRE} ${ESM_STORE} ${OGRE} ${INPUT} ${MISC} ${COMPILER})
+set(COMPONENTS ${BSA} ${NIF} ${NIFOGRE} ${ESM_STORE} ${OGRE} ${INPUT} ${MISC} ${COMPILER}
+    ${INTERPRETER})
 set(COMPONENTS_HEADER ${BSA_HEADER} ${NIF_HEADER} ${NIFOGRE_HEADER} ${ESM_STORE_HEADER}
     ${ESM_HEADER} ${OGRE_HEADER} ${INPUT_HEADER} ${MISC_HEADER} ${COMPILER_HEADER}
     ${INTERPRETER_HEADER})
@@ -183,3 +185,10 @@ set(TOOLS_MWCOMPILER ${COMPILER} apps/mwcompiler/main.cpp apps/mwcompiler/contex
 add_executable(mwcompiler ${TOOLS_MWCOMPILER})
 endif()
 
+option(BUILD_MWINTERPRETER "build standalone Morrowind script code interpreter" ON)
+
+if (BUILD_MWINTERPRETER)
+set(TOOLS_MWINTERPRETER ${INTERPRETER} apps/mwinterpreter/main.cpp)
+
+add_executable(mwinterpreter ${TOOLS_MWINTERPRETER})
+endif()
diff --git a/apps/mwinterpreter/main.cpp b/apps/mwinterpreter/main.cpp
new file mode 100644
index 000000000..c0b0b4718
--- /dev/null
+++ b/apps/mwinterpreter/main.cpp
@@ -0,0 +1,49 @@
+// Stand-alone MW-script code interpreter
+
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include <components/interpreter/interpreter.hpp>
+#include <components/interpreter/context.hpp>
+#include <components/interpreter/types.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 codefilename = filename + ".code";
+
+        std::ifstream codefile (codefilename.c_str());
+
+        if (!codefile.is_open())
+        {
+            std::cout << "can't open code file: " << codefilename << std::endl;
+            return 1;
+        }        
+
+        std::vector<Interpreter::Type_Code> code (4);
+        
+        codefile.read (reinterpret_cast<char *> (&code[0]), 4 * sizeof (Interpreter::Type_Code));
+        
+        unsigned int size = code[0] + code[1] + code[2] + code[3];
+
+        code.resize (4+size);
+
+        codefile.read (reinterpret_cast<char *> (&code[4]), size * sizeof (Interpreter::Type_Code));
+    
+        interpreter.run (&code[0], size+4);
+    }
+    catch (const std::exception &e)
+    {
+        std::cout << "\nERROR: " << e.what() << std::endl;
+        return 1;
+    }    
+}
+
diff --git a/components/interpreter/context.hpp b/components/interpreter/context.hpp
new file mode 100644
index 000000000..922dc0c70
--- /dev/null
+++ b/components/interpreter/context.hpp
@@ -0,0 +1,14 @@
+#ifndef INTERPRETER_CONTEXT_H_INCLUDED
+#define INTERPRETER_CONTEXT_H_INCLUDED
+
+namespace Interpreter
+{
+    class Context
+    {
+    
+    };
+}
+
+#endif
+
+
diff --git a/components/interpreter/interpreter.cpp b/components/interpreter/interpreter.cpp
new file mode 100644
index 000000000..1db683e3c
--- /dev/null
+++ b/components/interpreter/interpreter.cpp
@@ -0,0 +1,22 @@
+
+#include "interpreter.hpp"
+
+namespace Interpreter
+{
+    Interpreter::Interpreter (Context& context)
+    : mRuntime (context)
+    {}
+    
+    Interpreter::~Interpreter()
+    {
+    
+    }
+    
+    void Interpreter::run (const Type_Code *code, int codeSize)
+    {
+        mRuntime.configure (code, codeSize);
+        
+        
+        mRuntime.clear();
+    }
+}
diff --git a/components/interpreter/interpreter.hpp b/components/interpreter/interpreter.hpp
new file mode 100644
index 000000000..fb26aaece
--- /dev/null
+++ b/components/interpreter/interpreter.hpp
@@ -0,0 +1,28 @@
+#ifndef INTERPRETER_INTERPRETER_H_INCLUDED
+#define INTERPRETER_INTERPRETER_H_INCLUDED
+
+#include "runtime.hpp"
+#include "types.hpp"
+
+namespace Interpreter
+{
+    class Interpreter
+    {
+            Runtime mRuntime;
+            
+            // not implemented
+            Interpreter (const Interpreter&);
+            Interpreter& operator= (const Interpreter&);
+            
+        public:
+        
+            Interpreter (Context& context);
+            
+            ~Interpreter();
+            
+            void run (const Type_Code *code, int codeSize);
+    };
+}
+
+#endif
+
diff --git a/components/interpreter/opcodes.hpp b/components/interpreter/opcodes.hpp
new file mode 100644
index 000000000..d24e8c62c
--- /dev/null
+++ b/components/interpreter/opcodes.hpp
@@ -0,0 +1,40 @@
+#ifndef INTERPRETER_OPCODES_H_INCLUDED
+#define INTERPRETER_OPCODES_H_INCLUDED
+
+namespace Interpreter
+{
+    class Runtime;
+
+    /// opcode for 0 arguments
+    class Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime) = 0;
+            
+            virtual ~Opcode0() {}
+    };
+
+    /// opcode for 1 argument
+    class Opcode1
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime, unsigned int arg0) = 0;
+            
+            virtual ~Opcode0() {}
+    };
+
+    /// opcode for 2 arguments
+    class Opcode2
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime, unsigned int arg1, unsigned int arg2) = 0;
+            
+            virtual ~Opcode0() {}
+    };
+
+}
+
+#endif
diff --git a/components/interpreter/runtime.cpp b/components/interpreter/runtime.cpp
new file mode 100644
index 000000000..33f1e3780
--- /dev/null
+++ b/components/interpreter/runtime.cpp
@@ -0,0 +1,22 @@
+
+#include "runtime.hpp"
+
+namespace Interpreter
+{
+    Runtime::Runtime (Context& context) : mContext (context), mCode (0) {}
+
+    void Runtime::configure (const Interpreter::Type_Code *code, int codeSize)
+    {    
+        clear();
+        
+        mCode = code;
+        mCodeSize = codeSize;
+    }
+
+    void Runtime::clear()
+    {
+        mCode = 0;
+        mCodeSize = 0;
+    }
+}
+
diff --git a/components/interpreter/runtime.hpp b/components/interpreter/runtime.hpp
new file mode 100644
index 000000000..2166e3cc7
--- /dev/null
+++ b/components/interpreter/runtime.hpp
@@ -0,0 +1,31 @@
+#ifndef INTERPRETER_RUNTIME_H_INCLUDED
+#define INTERPRETER_RUNTIME_H_INCLUDED
+
+#include "types.hpp"
+
+namespace Interpreter
+{
+    class Context;
+
+    /// Runtime data and engine interface
+    
+    class Runtime
+    {
+            Context& mContext;
+            const Interpreter::Type_Code *mCode;
+            int mCodeSize;
+            
+        public:
+        
+            Runtime (Context& context);
+        
+            void configure (const Interpreter::Type_Code *code, int codeSize);
+            ///< \a context and \a code must exist as least until either configure, clear or
+            /// the destructor is called. \a codeSize is given in 32-bit words.
+            
+            void clear();
+    
+    };
+}
+
+#endif

From 770eb14d9521ae7b5f258fba2a2b88a556b19d45 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 20:07:17 +0200
Subject: [PATCH 20/40] added context for standalone interpreter

---
 CMakeLists.txt                     |  3 +-
 apps/mwinterpreter/context.cpp     | 94 ++++++++++++++++++++++++++++++
 apps/mwinterpreter/context.hpp     | 43 ++++++++++++++
 apps/mwinterpreter/main.cpp        | 14 +++--
 components/interpreter/context.hpp | 16 ++++-
 components/interpreter/types.hpp   |  2 +
 6 files changed, 166 insertions(+), 6 deletions(-)
 create mode 100644 apps/mwinterpreter/context.cpp
 create mode 100644 apps/mwinterpreter/context.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 17d54e241..ff8340fd6 100644
--- a/CMakeLists.txt
+++ b/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()
diff --git a/apps/mwinterpreter/context.cpp b/apps/mwinterpreter/context.cpp
new file mode 100644
index 000000000..618abaf83
--- /dev/null
+++ b/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;            
+    
+    }
+}
+
diff --git a/apps/mwinterpreter/context.hpp b/apps/mwinterpreter/context.hpp
new file mode 100644
index 000000000..c3ab9bad7
--- /dev/null
+++ b/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
diff --git a/apps/mwinterpreter/main.cpp b/apps/mwinterpreter/main.cpp
index c0b0b4718..df1cbc1c5 100644
--- a/apps/mwinterpreter/main.cpp
+++ b/apps/mwinterpreter/main.cpp
@@ -9,14 +9,18 @@
 #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";
 
@@ -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)
     {
diff --git a/components/interpreter/context.hpp b/components/interpreter/context.hpp
index 922dc0c70..582606c9c 100644
--- a/components/interpreter/context.hpp
+++ b/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;        
     };
 }
 
diff --git a/components/interpreter/types.hpp b/components/interpreter/types.hpp
index 28ad51dd1..2747d1447 100644
--- a/components/interpreter/types.hpp
+++ b/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

From d80cb3461c431f48d37a21cfe9aea1ddb3ec81de Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 20:46:15 +0200
Subject: [PATCH 21/40] added code execution main loop

---
 components/interpreter/interpreter.cpp | 167 ++++++++++++++++++++++++-
 components/interpreter/interpreter.hpp |  18 +++
 components/interpreter/opcodes.hpp     |   4 +-
 components/interpreter/runtime.cpp     |  15 ++-
 components/interpreter/runtime.hpp     |   9 +-
 5 files changed, 207 insertions(+), 6 deletions(-)

diff --git a/components/interpreter/interpreter.cpp b/components/interpreter/interpreter.cpp
index 1db683e3c..8b3159846 100644
--- a/components/interpreter/interpreter.cpp
+++ b/components/interpreter/interpreter.cpp
@@ -1,21 +1,186 @@
 
 #include "interpreter.hpp"
 
+#include <cassert>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+
+#include "opcodes.hpp"
+
 namespace Interpreter
 {
+    void Interpreter::execute (Type_Code code)
+    {
+        unsigned int segSpec = code>>30;
+        
+        switch (segSpec)
+        {
+            case 0:
+            {
+                int opcode = code>>24;
+                unsigned int arg0 = code & 0xffffff;
+                
+                std::map<int, Opcode1 *>::iterator iter = mSegment0.find (opcode);
+                
+                if (iter==mSegment0.end())
+                    abortUnknownCode (0, opcode);
+                
+                iter->second->execute (mRuntime, arg0);
+                
+                return;
+            }
+                        
+            case 1:
+            {
+                int opcode = (code>>24) & 0x3f;
+                unsigned int arg0 = (code>>16) & 0xfff;
+                unsigned int arg1 = code & 0xfff;
+                
+                std::map<int, Opcode2 *>::iterator iter = mSegment1.find (opcode);
+                
+                if (iter==mSegment1.end())
+                    abortUnknownCode (1, opcode);
+                
+                iter->second->execute (mRuntime, arg0, arg1);
+                
+                return;
+            }
+                        
+            case 2:
+            {
+                int opcode = (code>>20) & 0x3ff;
+                unsigned int arg0 = code & 0xfffff;
+                
+                std::map<int, Opcode1 *>::iterator iter = mSegment2.find (opcode);
+                
+                if (iter==mSegment2.end())
+                    abortUnknownCode (2, opcode);
+                
+                iter->second->execute (mRuntime, arg0);
+                
+                return;
+            }                    
+        }
+        
+        segSpec = code>>26;
+        
+        switch (segSpec)
+        { 
+            case 0x30:
+            {
+                int opcode = (code>>16) & 0x3ff;
+                unsigned int arg0 = code & 0xffff;
+                
+                std::map<int, Opcode1 *>::iterator iter = mSegment3.find (opcode);
+                
+                if (iter==mSegment3.end())
+                    abortUnknownCode (3, opcode);
+                
+                iter->second->execute (mRuntime, arg0);
+                
+                return;
+            }        
+        
+            case 0x31:
+            {
+                int opcode = (code>>16) & 0x3ff;
+                unsigned int arg0 = (code>>8) & 0xff;
+                unsigned int arg1 = code & 0xff;
+                
+                std::map<int, Opcode2 *>::iterator iter = mSegment4.find (opcode);
+                
+                if (iter==mSegment4.end())
+                    abortUnknownCode (4, opcode);
+                
+                iter->second->execute (mRuntime, arg0, arg1);
+                
+                return;
+            }            
+            
+            case 0x32:
+            {
+                int opcode = code & 0x3ffffff;
+                
+                std::map<int, Opcode0 *>::iterator iter = mSegment5.find (opcode);
+                
+                if (iter==mSegment5.end())
+                    abortUnknownCode (5, opcode);
+                
+                iter->second->execute (mRuntime);
+                
+                return;
+            }
+        }
+        
+        abortUnknownSegment (code);
+    }
+
+    void Interpreter::abortUnknownCode (int segment, int opcode)
+    {
+        std::ostringstream error;
+        
+        error << "unknown opcode " << opcode << " in segment " << segment;
+        
+        throw std::runtime_error (error.str());
+    }
+    
+    void Interpreter::abortUnknownSegment (Type_Code code)
+    {
+        std::ostringstream error;
+        
+        error << "opcode outside of the allocated segment range: " << code;
+        
+        throw std::runtime_error (error.str());
+    }
+            
     Interpreter::Interpreter (Context& context)
     : mRuntime (context)
     {}
     
     Interpreter::~Interpreter()
     {
-    
+        for (std::map<int, Opcode1 *>::iterator iter (mSegment0.begin());
+            iter!=mSegment0.end(); ++iter)
+            delete iter->second;
+
+        for (std::map<int, Opcode2 *>::iterator iter (mSegment1.begin());
+            iter!=mSegment1.end(); ++iter)
+            delete iter->second;
+
+        for (std::map<int, Opcode1 *>::iterator iter (mSegment2.begin());
+            iter!=mSegment2.end(); ++iter)
+            delete iter->second;
+
+        for (std::map<int, Opcode1 *>::iterator iter (mSegment3.begin());
+            iter!=mSegment3.end(); ++iter)
+            delete iter->second;
+
+        for (std::map<int, Opcode2 *>::iterator iter (mSegment4.begin());
+            iter!=mSegment4.end(); ++iter)
+            delete iter->second;
+            
+        for (std::map<int, Opcode0 *>::iterator iter (mSegment5.begin());
+            iter!=mSegment5.end(); ++iter)
+            delete iter->second;            
     }
     
     void Interpreter::run (const Type_Code *code, int codeSize)
     {
+        assert (codeSize>=4);
+        
         mRuntime.configure (code, codeSize);
         
+        int opcodes = static_cast<int> (code[0]);
+        
+        const Type_Code *codeBlock = code + 4;
+        
+        while (mRuntime.getPC()>=0 && mRuntime.getPC()<opcodes)
+        {
+            Type_Code code = codeBlock[mRuntime.getPC()];
+            mRuntime.setPC (mRuntime.getPC()+1);
+            execute (code);
+        }
         
         mRuntime.clear();
     }
diff --git a/components/interpreter/interpreter.hpp b/components/interpreter/interpreter.hpp
index fb26aaece..51a7ac90e 100644
--- a/components/interpreter/interpreter.hpp
+++ b/components/interpreter/interpreter.hpp
@@ -1,19 +1,37 @@
 #ifndef INTERPRETER_INTERPRETER_H_INCLUDED
 #define INTERPRETER_INTERPRETER_H_INCLUDED
 
+#include <map>
+
 #include "runtime.hpp"
 #include "types.hpp"
 
 namespace Interpreter
 {
+    class Opcode0;
+    class Opcode1;
+    class Opcode2;
+
     class Interpreter
     {
             Runtime mRuntime;
+            std::map<int, Opcode1 *> mSegment0;
+            std::map<int, Opcode2 *> mSegment1;
+            std::map<int, Opcode1 *> mSegment2;
+            std::map<int, Opcode1 *> mSegment3;
+            std::map<int, Opcode2 *> mSegment4;
+            std::map<int, Opcode0 *> mSegment5;
             
             // not implemented
             Interpreter (const Interpreter&);
             Interpreter& operator= (const Interpreter&);
             
+            void execute (Type_Code code);
+            
+            void abortUnknownCode (int segment, int opcode);
+            
+            void abortUnknownSegment (Type_Code code);
+            
         public:
         
             Interpreter (Context& context);
diff --git a/components/interpreter/opcodes.hpp b/components/interpreter/opcodes.hpp
index d24e8c62c..c447e1f10 100644
--- a/components/interpreter/opcodes.hpp
+++ b/components/interpreter/opcodes.hpp
@@ -22,7 +22,7 @@ namespace Interpreter
         
             virtual void execute (Runtime& runtime, unsigned int arg0) = 0;
             
-            virtual ~Opcode0() {}
+            virtual ~Opcode1() {}
     };
 
     /// opcode for 2 arguments
@@ -32,7 +32,7 @@ namespace Interpreter
         
             virtual void execute (Runtime& runtime, unsigned int arg1, unsigned int arg2) = 0;
             
-            virtual ~Opcode0() {}
+            virtual ~Opcode2() {}
     };
 
 }
diff --git a/components/interpreter/runtime.cpp b/components/interpreter/runtime.cpp
index 33f1e3780..24048eb5a 100644
--- a/components/interpreter/runtime.cpp
+++ b/components/interpreter/runtime.cpp
@@ -3,14 +3,20 @@
 
 namespace Interpreter
 {
-    Runtime::Runtime (Context& context) : mContext (context), mCode (0) {}
-
+    Runtime::Runtime (Context& context) : mContext (context), mCode (0), mPC (0) {}
+    
+    int Runtime::getPC() const
+    {
+        return mPC;
+    }
+    
     void Runtime::configure (const Interpreter::Type_Code *code, int codeSize)
     {    
         clear();
         
         mCode = code;
         mCodeSize = codeSize;
+        mPC = 0;
     }
 
     void Runtime::clear()
@@ -18,5 +24,10 @@ namespace Interpreter
         mCode = 0;
         mCodeSize = 0;
     }
+    
+    void Runtime::setPC (int PC)
+    {
+        mPC = PC;
+    }    
 }
 
diff --git a/components/interpreter/runtime.hpp b/components/interpreter/runtime.hpp
index 2166e3cc7..e45789f16 100644
--- a/components/interpreter/runtime.hpp
+++ b/components/interpreter/runtime.hpp
@@ -12,18 +12,25 @@ namespace Interpreter
     class Runtime
     {
             Context& mContext;
-            const Interpreter::Type_Code *mCode;
+            const Type_Code *mCode;
             int mCodeSize;
+            int mPC;
             
         public:
         
             Runtime (Context& context);
         
+            int getPC() const;
+            ///< return program counter.
+        
             void configure (const Interpreter::Type_Code *code, int codeSize);
             ///< \a context and \a code must exist as least until either configure, clear or
             /// the destructor is called. \a codeSize is given in 32-bit words.
             
             void clear();
+            
+            void setPC (int PC);
+            ///< set program counter.
     
     };
 }

From c6a37b2e18b2ce478c231665f96dd031282be7e2 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Mon, 28 Jun 2010 21:49:48 +0200
Subject: [PATCH 22/40] added first batch of opcodes

---
 CMakeLists.txt                            |  3 +-
 apps/mwinterpreter/main.cpp               |  2 +
 components/interpreter/genericopcodes.hpp | 33 +++++++++
 components/interpreter/installopcodes.cpp | 24 +++++++
 components/interpreter/installopcodes.hpp | 11 +++
 components/interpreter/interpreter.cpp    | 32 ++++++++-
 components/interpreter/interpreter.hpp    | 18 +++++
 components/interpreter/localopcodes.hpp   | 82 +++++++++++++++++++++++
 components/interpreter/runtime.cpp        | 48 +++++++++++++
 components/interpreter/runtime.hpp        | 21 +++++-
 10 files changed, 270 insertions(+), 4 deletions(-)
 create mode 100644 components/interpreter/genericopcodes.hpp
 create mode 100644 components/interpreter/installopcodes.cpp
 create mode 100644 components/interpreter/installopcodes.hpp
 create mode 100644 components/interpreter/localopcodes.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ff8340fd6..b9815041f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -76,7 +76,8 @@ set(COMPILER components/compiler/errorhandler.cpp
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
 source_group(compiler FILES ${COMPILER} ${COMPILER_HEADER})    
 
-set(INTERPRETER components/interpreter/runtime.cpp components/interpreter/interpreter.cpp)
+set(INTERPRETER components/interpreter/runtime.cpp components/interpreter/interpreter.cpp
+    components/interpreter/installopcodes.cpp)
 file(GLOB INTERPRETER_HEADER components/interpreter/*.hpp)
 source_group(interpreter FILES ${INTERPRETER} ${INTERPRETER_HEADER})    
 
diff --git a/apps/mwinterpreter/main.cpp b/apps/mwinterpreter/main.cpp
index df1cbc1c5..e8f0c8783 100644
--- a/apps/mwinterpreter/main.cpp
+++ b/apps/mwinterpreter/main.cpp
@@ -8,6 +8,7 @@
 #include <components/interpreter/interpreter.hpp>
 #include <components/interpreter/context.hpp>
 #include <components/interpreter/types.hpp>
+#include <components/interpreter/installopcodes.hpp>
 
 #include "context.hpp"
 
@@ -21,6 +22,7 @@ int main (int argc, char **argv)
         
         SAInterpreter::Context context (localfilename);
         Interpreter::Interpreter interpreter (context);
+        Interpreter::installOpcodes (interpreter);
 
         std::string codefilename = filename + ".code";
 
diff --git a/components/interpreter/genericopcodes.hpp b/components/interpreter/genericopcodes.hpp
new file mode 100644
index 000000000..f5849676c
--- /dev/null
+++ b/components/interpreter/genericopcodes.hpp
@@ -0,0 +1,33 @@
+#ifndef INTERPRETER_GENERICOPCODES_H_INCLUDED
+#define INTERPRETER_GENERICOPCODES_H_INCLUDED
+
+#include "opcodes.hpp"
+#include "runtime.hpp"
+
+namespace Interpreter
+{
+    class OpPushInt : public Opcode1
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime, unsigned int arg0)
+            {
+                runtime.push (arg0);
+            }        
+    };
+    
+    class OpIntToFloat : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Data data = runtime[0];
+                Type_Float floatValue = static_cast<Type_Float> (data);
+                runtime[0] = *reinterpret_cast<Type_Data *> (&floatValue);
+            }           
+    };
+}
+
+#endif
+
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
new file mode 100644
index 000000000..44206696f
--- /dev/null
+++ b/components/interpreter/installopcodes.cpp
@@ -0,0 +1,24 @@
+
+#include "installopcodes.hpp"
+
+#include "interpreter.hpp"
+#include "genericopcodes.hpp"
+#include "localopcodes.hpp"
+
+namespace Interpreter
+{
+    void installOpcodes (Interpreter& interpreter)
+    {
+        // generic
+        interpreter.installSegment0 (0, new OpPushInt);
+        interpreter.installSegment5 (3, new OpIntToFloat);
+    
+        // local variables
+        interpreter.installSegment5 (0, new OpStoreLocalShort);
+        interpreter.installSegment5 (1, new OpStoreLocalLong);
+        interpreter.installSegment5 (2, new OpStoreLocalFloat);        
+        interpreter.installSegment5 (4, new OpFetchIntLiteral);            
+        interpreter.installSegment5 (5, new OpFetchFloatLiteral);  
+    }
+}
+
diff --git a/components/interpreter/installopcodes.hpp b/components/interpreter/installopcodes.hpp
new file mode 100644
index 000000000..8020490dd
--- /dev/null
+++ b/components/interpreter/installopcodes.hpp
@@ -0,0 +1,11 @@
+#ifndef INTERPRETER_INSTALLOPCODES_H_INCLUDED
+#define INTERPRETER_INSTALLOPCODES_H_INCLUDED
+
+namespace Interpreter
+{
+    class Interpreter;
+    
+    void installOpcodes (Interpreter& interpreter);
+}
+
+#endif
diff --git a/components/interpreter/interpreter.cpp b/components/interpreter/interpreter.cpp
index 8b3159846..3654d209b 100644
--- a/components/interpreter/interpreter.cpp
+++ b/components/interpreter/interpreter.cpp
@@ -165,7 +165,37 @@ namespace Interpreter
             delete iter->second;            
     }
     
-    void Interpreter::run (const Type_Code *code, int codeSize)
+    void Interpreter::installSegment0 (int code, Opcode1 *opcode)
+    {
+        mSegment0.insert (std::make_pair (code, opcode));
+    }
+
+    void Interpreter::installSegment1 (int code, Opcode2 *opcode)
+    {
+        mSegment1.insert (std::make_pair (code, opcode));
+    }
+
+    void Interpreter::installSegment2 (int code, Opcode1 *opcode)
+    {
+        mSegment2.insert (std::make_pair (code, opcode));
+    }
+
+    void Interpreter::installSegment3 (int code, Opcode1 *opcode)
+    {
+        mSegment3.insert (std::make_pair (code, opcode));
+    }
+
+    void Interpreter::installSegment4 (int code, Opcode2 *opcode)
+    {
+        mSegment4.insert (std::make_pair (code, opcode));
+    }
+
+    void Interpreter::installSegment5 (int code, Opcode0 *opcode)
+    {
+        mSegment5.insert (std::make_pair (code, opcode));
+    }
+            
+    void Interpreter::Interpreter::run (const Type_Code *code, int codeSize)
     {
         assert (codeSize>=4);
         
diff --git a/components/interpreter/interpreter.hpp b/components/interpreter/interpreter.hpp
index 51a7ac90e..c67273707 100644
--- a/components/interpreter/interpreter.hpp
+++ b/components/interpreter/interpreter.hpp
@@ -38,6 +38,24 @@ namespace Interpreter
             
             ~Interpreter();
             
+            void installSegment0 (int code, Opcode1 *opcode);
+            ///< ownership of \a opcode is transferred to *this.
+
+            void installSegment1 (int code, Opcode2 *opcode);
+            ///< ownership of \a opcode is transferred to *this.
+
+            void installSegment2 (int code, Opcode1 *opcode);
+            ///< ownership of \a opcode is transferred to *this.
+
+            void installSegment3 (int code, Opcode1 *opcode);
+            ///< ownership of \a opcode is transferred to *this.
+
+            void installSegment4 (int code, Opcode2 *opcode);
+            ///< ownership of \a opcode is transferred to *this.
+
+            void installSegment5 (int code, Opcode0 *opcode);
+            ///< ownership of \a opcode is transferred to *this.
+            
             void run (const Type_Code *code, int codeSize);
     };
 }
diff --git a/components/interpreter/localopcodes.hpp b/components/interpreter/localopcodes.hpp
new file mode 100644
index 000000000..d15635967
--- /dev/null
+++ b/components/interpreter/localopcodes.hpp
@@ -0,0 +1,82 @@
+#ifndef INTERPRETER_LOCALOPCODES_H_INCLUDED
+#define INTERPRETER_LOCALOPCODES_H_INCLUDED
+
+#include "opcodes.hpp"
+#include "runtime.hpp"
+#include "context.hpp"
+
+namespace Interpreter
+{   
+    class OpStoreLocalShort : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Data data = runtime[0];
+                int index = runtime[1];
+
+                runtime.getContext().setLocalShort (index, *reinterpret_cast<int *> (&data));
+
+                runtime.pop();
+                runtime.pop();
+            }           
+    };
+    
+    class OpStoreLocalLong : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Data data = runtime[0];
+                int index = runtime[1];
+
+                runtime.getContext().setLocalLong (index, *reinterpret_cast<int *> (&data));
+
+                runtime.pop();
+                runtime.pop();
+            }           
+    };    
+    
+    class OpStoreLocalFloat : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Data data = runtime[0];
+                int index = runtime[1];
+
+                runtime.getContext().setLocalFloat (index, *reinterpret_cast<float *> (&data));
+
+                runtime.pop();
+                runtime.pop();
+            }           
+    };
+    
+    class OpFetchIntLiteral : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                int intValue = runtime.getIntegerLiteral (runtime[0]);
+                runtime[0] = intValue;
+            }           
+    };    
+    
+    class OpFetchFloatLiteral : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                float floatValue = runtime.getFloatLiteral (runtime[0]);
+                runtime[0] = *reinterpret_cast<Type_Data *> (&floatValue);
+            }           
+    };     
+}
+
+#endif
+
diff --git a/components/interpreter/runtime.cpp b/components/interpreter/runtime.cpp
index 24048eb5a..bde4d6b9f 100644
--- a/components/interpreter/runtime.cpp
+++ b/components/interpreter/runtime.cpp
@@ -1,6 +1,9 @@
 
 #include "runtime.hpp"
 
+#include <stdexcept>
+#include <cassert>
+
 namespace Interpreter
 {
     Runtime::Runtime (Context& context) : mContext (context), mCode (0), mPC (0) {}
@@ -10,6 +13,24 @@ namespace Interpreter
         return mPC;
     }
     
+    int Runtime::getIntegerLiteral (int index) const
+    {
+        assert (index>=0 && index<static_cast<int> (mCode[1]));
+    
+        const Type_Code *literalBlock = mCode + 4 + mCode[0];
+        
+        return *reinterpret_cast<const int *> (&literalBlock[index]);
+    }
+            
+    float Runtime::getFloatLiteral (int index) const
+    {
+        assert (index>=0 && index<static_cast<int> (mCode[2]));
+    
+        const Type_Code *literalBlock = mCode + 4 + mCode[0] + mCode[1];
+        
+        return *reinterpret_cast<const float *> (&literalBlock[index]);
+    }
+                    
     void Runtime::configure (const Interpreter::Type_Code *code, int codeSize)
     {    
         clear();
@@ -23,11 +44,38 @@ namespace Interpreter
     {
         mCode = 0;
         mCodeSize = 0;
+        mStack.clear();
     }
     
     void Runtime::setPC (int PC)
     {
         mPC = PC;
     }    
+    
+    void Runtime::push (Type_Data data)
+    {
+        mStack.push_back (data);
+    }
+    
+    void Runtime::pop()
+    {
+        if (mStack.empty())
+            throw std::runtime_error ("stack underflow");
+            
+        mStack.resize (mStack.size()-1);
+    }
+    
+    Type_Data& Runtime::operator[] (int Index)
+    {
+        if (Index<0 || Index>=static_cast<int> (mStack.size()))
+            throw std::runtime_error ("stack index out of range");
+            
+        return mStack[mStack.size()-Index-1];
+    }
+    
+    Context& Runtime::getContext()
+    {
+        return mContext;
+    }
 }
 
diff --git a/components/interpreter/runtime.hpp b/components/interpreter/runtime.hpp
index e45789f16..a683a0f0f 100644
--- a/components/interpreter/runtime.hpp
+++ b/components/interpreter/runtime.hpp
@@ -1,6 +1,8 @@
 #ifndef INTERPRETER_RUNTIME_H_INCLUDED
 #define INTERPRETER_RUNTIME_H_INCLUDED
 
+#include <vector>
+
 #include "types.hpp"
 
 namespace Interpreter
@@ -15,6 +17,7 @@ namespace Interpreter
             const Type_Code *mCode;
             int mCodeSize;
             int mPC;
+            std::vector<Type_Data> mStack;
             
         public:
         
@@ -23,7 +26,11 @@ namespace Interpreter
             int getPC() const;
             ///< return program counter.
         
-            void configure (const Interpreter::Type_Code *code, int codeSize);
+            int getIntegerLiteral (int index) const;
+        
+            float getFloatLiteral (int index) const;
+                    
+            void configure (const Type_Code *code, int codeSize);
             ///< \a context and \a code must exist as least until either configure, clear or
             /// the destructor is called. \a codeSize is given in 32-bit words.
             
@@ -31,7 +38,17 @@ namespace Interpreter
             
             void setPC (int PC);
             ///< set program counter.
-    
+            
+            void push (Type_Data data);
+            ///< push data on stack
+            
+            void pop();
+            ///< pop stack
+            
+            Type_Data& operator[] (int Index);
+            ///< Access stack member, counted from the top.
+            
+            Context& getContext();
     };
 }
 

From 10cb9d3dab1de631ccbab6d2323b7352edfa87da Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Tue, 29 Jun 2010 08:09:12 +0200
Subject: [PATCH 23/40] made local variable names case-insensitive

---
 components/compiler/lineparser.cpp | 11 +++++++----
 components/compiler/parser.cpp     | 13 +++++++++++++
 components/compiler/parser.hpp     |  4 ++--
 3 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 35c79ff60..47346b814 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -49,8 +49,10 @@ namespace Compiler
                 scanner.scan (skip);
                 return false;
             }
+         
+            std::string name2 = toLower (name);
             
-            char type = mLocals.getType (name);
+            char type = mLocals.getType (name2);
             
             if (type!=' ')
             {
@@ -61,7 +63,7 @@ namespace Compiler
             }
             
             mLocals.declare (mState==ShortState ? 's' : (mState==LongState ? 'l' : 'f'),
-                name);
+                name2);
             
             mState = EndState;
             return true;
@@ -70,10 +72,11 @@ namespace Compiler
         if (mState==SetState)
         {
             // local variable?
-            char type = mLocals.getType (name);        
+            std::string name2 = toLower (name);
+            char type = mLocals.getType (name2);
             if (type!=' ')
             {
-                mName = name;
+                mName = name2;
                 mState = SetLocalVarState;
                 return true;
             }
diff --git a/components/compiler/parser.cpp b/components/compiler/parser.cpp
index d5a7506c5..2c7686589 100644
--- a/components/compiler/parser.cpp
+++ b/components/compiler/parser.cpp
@@ -1,6 +1,9 @@
 
 #include "parser.hpp"
 
+#include <cctype>
+#include <algorithm>
+
 #include "errorhandler.hpp"
 #include "exception.hpp"
 
@@ -50,6 +53,16 @@ namespace Compiler
         return mContext;
     }
 
+    std::string Parser::toLower (const std::string& name)
+    {
+        std::string lowerCase;
+        
+        std::transform (name.begin(), name.end(), std::back_inserter (lowerCase),
+            (int(*)(int)) std::tolower);
+            
+        return lowerCase;
+    }
+
     Parser::Parser (ErrorHandler& errorHandler, Context& context)
     : mErrorHandler (errorHandler), mContext (context)
     {}
diff --git a/components/compiler/parser.hpp b/components/compiler/parser.hpp
index 5bb541f92..88268eb22 100644
--- a/components/compiler/parser.hpp
+++ b/components/compiler/parser.hpp
@@ -21,8 +21,6 @@ namespace Compiler
 
         protected:
 
-        // mutators
-
             void reportSeriousError (const std::string& message, const TokenLoc& loc);
             ///< Report the error and throw a exception.
 
@@ -41,6 +39,8 @@ namespace Compiler
             Context& getContext();
             ///< Return context
 
+            static std::string toLower (const std::string& name);
+
         public:
 
             Parser (ErrorHandler& errorHandler, Context& context);

From bceb7ebcbd61047dc68b220b6c1d6985229e0f2b Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Tue, 29 Jun 2010 10:22:55 +0200
Subject: [PATCH 24/40] reimplemented expression parsing as a separate parser
 (still only handling non-negative integers)

---
 CMakeLists.txt                     | 11 +----
 components/compiler/exprparser.cpp | 65 +++++++++++++++++++++++++++++
 components/compiler/exprparser.hpp | 67 ++++++++++++++++++++++++++++++
 components/compiler/generator.cpp  | 37 +++++++++++++----
 components/compiler/generator.hpp  |  8 ++--
 components/compiler/lineparser.cpp | 26 ++++++------
 components/compiler/lineparser.hpp |  2 +
 7 files changed, 183 insertions(+), 33 deletions(-)
 create mode 100644 components/compiler/exprparser.cpp
 create mode 100644 components/compiler/exprparser.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b9815041f..97b34058b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -66,18 +66,11 @@ set(MISC_HEADER components/misc/fileops.hpp components/misc/slice_array.hpp
     components/misc/stringops.hpp)
 source_group(misc FILES ${MISC} ${MISC_HEADER})    
     
-set(COMPILER components/compiler/errorhandler.cpp
-    components/compiler/fileparser.cpp components/compiler/scriptparser.cpp
-    components/compiler/lineparser.cpp components/compiler/skipparser.cpp
-    components/compiler/parser.cpp components/compiler/scanner.cpp
-    components/compiler/streamerrorhandler.cpp
-    components/compiler/locals.cpp components/compiler/literals.cpp
-    components/compiler/output.cpp components/compiler/generator.cpp)
+file(GLOB COMPILER components/compiler/*.cpp)
 file(GLOB COMPILER_HEADER components/compiler/*.hpp)
 source_group(compiler FILES ${COMPILER} ${COMPILER_HEADER})    
 
-set(INTERPRETER components/interpreter/runtime.cpp components/interpreter/interpreter.cpp
-    components/interpreter/installopcodes.cpp)
+file(GLOB INTERPRETER components/interpreter/*.cpp)
 file(GLOB INTERPRETER_HEADER components/interpreter/*.hpp)
 source_group(interpreter FILES ${INTERPRETER} ${INTERPRETER_HEADER})    
 
diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
new file mode 100644
index 000000000..117da6b75
--- /dev/null
+++ b/components/compiler/exprparser.cpp
@@ -0,0 +1,65 @@
+
+#include "exprparser.hpp"
+
+#include <stdexcept>
+
+#include "generator.hpp"
+
+namespace Compiler
+{
+    ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
+        Literals& literals)
+    : Parser (errorHandler, context), mLocals (locals), mLiterals (literals)
+    {}
+
+    bool ExprParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
+    {
+        Operand operand;
+        operand.mType = 'l';
+        operand.mInteger = value;
+        
+        mOperands.push_back (operand);
+        
+        return false;
+    }
+
+    bool ExprParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
+    {
+        return Parser::parseFloat (value, loc, scanner);
+    }
+
+    bool ExprParser::parseName (const std::string& name, const TokenLoc& loc,
+        Scanner& scanner)
+    {
+        return Parser::parseName (name, loc, scanner);
+    }
+
+    bool ExprParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        return Parser::parseKeyword (keyword, loc, scanner);
+    }
+
+    bool ExprParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        return Parser::parseSpecial (code, loc, scanner);
+    }
+    
+    void ExprParser::reset()
+    {
+        mOperands.clear();
+    }
+    
+    char ExprParser::write (std::vector<Interpreter::Type_Code>& code)
+    {
+        if (mOperands.empty())
+            throw std::logic_error ("empty expression");
+            
+        Operand operand = mOperands[mOperands.size()-1];
+        mOperands.clear();
+        
+        Generator::pushInt (code, mLiterals, operand.mInteger);
+        
+        return operand.mType;
+    }    
+}
+
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
new file mode 100644
index 000000000..5f58930f4
--- /dev/null
+++ b/components/compiler/exprparser.hpp
@@ -0,0 +1,67 @@
+#ifndef COMPILER_EXPRPARSER_H_INCLUDED
+#define COMPILER_EXPRPARSER_H_INCLUDED
+
+#include <vector>
+
+#include <components/interpreter/types.hpp>
+
+#include "parser.hpp"
+
+namespace Compiler
+{
+    class Locals;
+    class Literals;
+
+    class ExprParser : public Parser
+    {
+            struct Operand
+            {
+                char mType;
+                int mInteger;
+                float mFloat;
+            };
+            
+            Locals& mLocals;  
+            Literals& mLiterals;
+            std::vector<Operand> mOperands;
+            
+        public:
+    
+            ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
+                Literals& literals);
+            ///< constructor
+
+            char getType() const;
+            ///< Return type of parsed expression ('l' integer, 'f' float)
+
+            virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle an int token.
+            /// \return fetch another token?
+
+            virtual bool parseFloat (float value, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a float token.
+            /// \return fetch another token?
+
+            virtual bool parseName (const std::string& name, const TokenLoc& loc,
+                Scanner& scanner);
+            ///< Handle a name token.
+            /// \return fetch another token?
+
+            virtual bool parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a keyword token.
+            /// \return fetch another token?
+
+            virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+            
+            void reset();
+            ///< Reset parser to clean state.
+            
+            char write (std::vector<Interpreter::Type_Code>& code);
+            ///< Generate code for parsed expression.
+            /// \return Type ('l': integer, 'f': float)
+    };
+}
+
+#endif
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index e73909d90..8f70a7863 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -2,6 +2,8 @@
 #include "generator.hpp"
 
 #include <cassert>
+#include <algorithm>
+#include <iterator>
 
 #include "literals.hpp"
 
@@ -63,6 +65,11 @@ namespace
         code.push_back (segment5 (3));    
     }
     
+    void opFloatToInt (Compiler::Generator::CodeContainer& code)
+    {
+        assert (0); // not implemented
+    }
+        
     void opStoreLocalShort (Compiler::Generator::CodeContainer& code)
     {
         code.push_back (segment5 (0));    
@@ -83,20 +90,36 @@ namespace Compiler
 {
     namespace Generator
     {
-        void assignIntToLocal (CodeContainer& code, Literals& literals, char localType,
-            int localIndex, int value)
+        void pushInt (CodeContainer& code, Literals& literals, int value)
         {
-            int index = literals.addInteger (value);
+            int index = literals.addInteger (value);               
+            opPushInt (code, index);
+            opFetchIntLiteral (code);   
+        }
                 
+        void assignToLocal (CodeContainer& code, char localType,
+            int localIndex, const CodeContainer& value, char valueType)
+        {               
             opPushInt (code, localIndex);
-            opPushInt (code, index);
-            opFetchIntLiteral (code);
+
+            std::copy (value.begin(), value.end(), std::back_inserter (code));
+            
+            if (localType!=valueType)
+            {
+                if (localType=='f' && valueType=='l')
+                {
+                    opIntToFloat (code);
+                }
+                else if ((localType=='l' || localType=='s') && valueType=='f')
+                {
+                    opFloatToInt (code);
+                }
+            }
             
             switch (localType)
             {
                 case 'f':
                 
-                    opIntToFloat (code);
                     opStoreLocalFloat (code);
                     break;
                 
@@ -113,7 +136,7 @@ namespace Compiler
                 default:
                 
                     assert (0);
-            }               
+            }
         }
     }
 }
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index cab5f3bda..a055b3c71 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -12,9 +12,11 @@ namespace Compiler
     namespace Generator
     {
         typedef std::vector<Interpreter::Type_Code> CodeContainer;
-    
-        void assignIntToLocal (CodeContainer& code, Literals& literals, char localType,
-            int localIndex, int value);
+
+        void pushInt (CodeContainer& code, Literals& literals, int value);
+
+        void assignToLocal (CodeContainer& code, char localType,
+            int localIndex, const CodeContainer& value, char valueType);
     }
 }
 
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 47346b814..1685af848 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -13,22 +13,11 @@ namespace Compiler
     LineParser::LineParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
         Literals& literals, std::vector<Interpreter::Type_Code>& code)
     : Parser (errorHandler, context), mLocals (locals), mLiterals (literals), mCode (code),
-       mState (BeginState)
+       mState (BeginState), mExprParser (errorHandler, context, locals, literals)
     {}
 
     bool LineParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
-    {
-        if (mState==SetLocalToState)
-        {
-            Generator::assignIntToLocal (mCode, mLiterals, mLocals.getType (mName),
-                mLocals.getIndex (mName), value);
-        
-            mState = EndState;
-            mName.clear();
-        
-            return true;
-        }
-    
+    {   
         return Parser::parseInt (value, loc, scanner);
     }
 
@@ -104,7 +93,16 @@ namespace Compiler
         }
         else if (mState==SetLocalVarState && keyword==Scanner::K_to)
         {
-            mState = SetLocalToState;
+            mExprParser.reset();
+            scanner.scan (mExprParser);
+            
+            std::vector<Interpreter::Type_Code> code;
+            char type = mExprParser.write (code);
+            
+            Generator::assignToLocal (mCode, mLocals.getType (mName),
+                mLocals.getIndex (mName), code, type);
+                        
+            mState = EndState;
             return true;
         }
         
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
index b69ac803e..2f195902d 100644
--- a/components/compiler/lineparser.hpp
+++ b/components/compiler/lineparser.hpp
@@ -6,6 +6,7 @@
 #include <components/interpreter/types.hpp>
 
 #include "parser.hpp"
+#include "exprparser.hpp"
 
 namespace Compiler
 {
@@ -29,6 +30,7 @@ namespace Compiler
             std::vector<Interpreter::Type_Code>& mCode;
             State mState;
             std::string mName;
+            ExprParser mExprParser;
     
         public:
         

From 6ebe2cff5fac1654e5b14f5d2ba03e7552bb2e8e Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Tue, 29 Jun 2010 10:36:42 +0200
Subject: [PATCH 25/40] extended expression parser for non-negative floats

---
 components/compiler/exprparser.cpp        | 15 +++++++++++++--
 components/compiler/generator.cpp         |  9 ++++++++-
 components/compiler/generator.hpp         |  2 ++
 components/compiler/lineparser.hpp        |  2 +-
 components/interpreter/docs/vmformat.txt  |  3 ++-
 components/interpreter/genericopcodes.hpp | 14 +++++++++++++-
 components/interpreter/installopcodes.cpp |  1 +
 7 files changed, 40 insertions(+), 6 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index 117da6b75..1b5e36b6d 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -25,7 +25,13 @@ namespace Compiler
 
     bool ExprParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
     {
-        return Parser::parseFloat (value, loc, scanner);
+        Operand operand;
+        operand.mType = 'f';
+        operand.mFloat = value;
+        
+        mOperands.push_back (operand);
+            
+        return false;
     }
 
     bool ExprParser::parseName (const std::string& name, const TokenLoc& loc,
@@ -57,7 +63,12 @@ namespace Compiler
         Operand operand = mOperands[mOperands.size()-1];
         mOperands.clear();
         
-        Generator::pushInt (code, mLiterals, operand.mInteger);
+        if (operand.mType=='l')
+            Generator::pushInt (code, mLiterals, operand.mInteger);
+        else if (operand.mType=='f')
+            Generator::pushFloat (code, mLiterals, operand.mFloat);
+        else
+            throw std::logic_error ("unknown expression type");
         
         return operand.mType;
     }    
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index 8f70a7863..8d37f57a9 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -67,7 +67,7 @@ namespace
     
     void opFloatToInt (Compiler::Generator::CodeContainer& code)
     {
-        assert (0); // not implemented
+        code.push_back (segment5 (6));
     }
         
     void opStoreLocalShort (Compiler::Generator::CodeContainer& code)
@@ -96,6 +96,13 @@ namespace Compiler
             opPushInt (code, index);
             opFetchIntLiteral (code);   
         }
+        
+        void pushFloat (CodeContainer& code, Literals& literals, float value)
+        {
+            int index = literals.addFloat (value);               
+            opPushInt (code, index);
+            opFetchFloatLiteral (code);
+        }
                 
         void assignToLocal (CodeContainer& code, char localType,
             int localIndex, const CodeContainer& value, char valueType)
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index a055b3c71..061a30df4 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -15,6 +15,8 @@ namespace Compiler
 
         void pushInt (CodeContainer& code, Literals& literals, int value);
 
+        void pushFloat (CodeContainer& code, Literals& literals, float value);
+
         void assignToLocal (CodeContainer& code, char localType,
             int localIndex, const CodeContainer& value, char valueType);
     }
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
index 2f195902d..e9fae92b7 100644
--- a/components/compiler/lineparser.hpp
+++ b/components/compiler/lineparser.hpp
@@ -21,7 +21,7 @@ namespace Compiler
             {
                 BeginState,
                 ShortState, LongState, FloatState,
-                SetState, SetLocalVarState, SetLocalToState,
+                SetState, SetLocalVarState,
                 EndState
             };
 
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
index 1449a6194..ca76d00f3 100644
--- a/components/interpreter/docs/vmformat.txt
+++ b/components/interpreter/docs/vmformat.txt
@@ -57,6 +57,7 @@ op   2: store stack[0] in local float stack[1] and pop twice
 op   3: convert stack[0] from integer to float
 op   4: replace stack[0] with integer literal index stack[0]
 op   5: replace stack[0] with float literal index stack[0]
-opcodes 6-33554431 unused
+op   6: convert stack[0] from float to integer
+opcodes 7-33554431 unused
 opcodes 33554432-67108863 reserved for extensions
 
diff --git a/components/interpreter/genericopcodes.hpp b/components/interpreter/genericopcodes.hpp
index f5849676c..44e1e9cb4 100644
--- a/components/interpreter/genericopcodes.hpp
+++ b/components/interpreter/genericopcodes.hpp
@@ -22,11 +22,23 @@ namespace Interpreter
         
             virtual void execute (Runtime& runtime)
             {
-                Type_Data data = runtime[0];
+                Type_Integer data = *reinterpret_cast<Type_Integer *> (&runtime[0]);
                 Type_Float floatValue = static_cast<Type_Float> (data);
                 runtime[0] = *reinterpret_cast<Type_Data *> (&floatValue);
             }           
     };
+    
+    class OpFloatToInt : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Float data = *reinterpret_cast<Type_Float *> (&runtime[0]);
+                Type_Integer integerValue = static_cast<Type_Integer> (data);
+                runtime[0] = *reinterpret_cast<Type_Data *> (&integerValue);
+            }           
+    };    
 }
 
 #endif
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
index 44206696f..df3f69201 100644
--- a/components/interpreter/installopcodes.cpp
+++ b/components/interpreter/installopcodes.cpp
@@ -12,6 +12,7 @@ namespace Interpreter
         // generic
         interpreter.installSegment0 (0, new OpPushInt);
         interpreter.installSegment5 (3, new OpIntToFloat);
+        interpreter.installSegment5 (6, new OpFloatToInt);
     
         // local variables
         interpreter.installSegment5 (0, new OpStoreLocalShort);

From ab33234027eb78517e4cc5d069608ad99099b5d3 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Tue, 29 Jun 2010 11:24:07 +0200
Subject: [PATCH 26/40] prepared expression parser for implementation of more
 complex expressions

---
 components/compiler/exprparser.cpp | 63 ++++++++++++++++++++++++------
 components/compiler/exprparser.hpp |  4 ++
 components/compiler/scanner.cpp    | 15 ++++++-
 components/compiler/scanner.hpp    |  5 +++
 4 files changed, 73 insertions(+), 14 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index 1b5e36b6d..1268f602b 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -4,34 +4,51 @@
 #include <stdexcept>
 
 #include "generator.hpp"
+#include "scanner.hpp"
+#include "errorhandler.hpp"
 
 namespace Compiler
 {
     ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
         Literals& literals)
-    : Parser (errorHandler, context), mLocals (locals), mLiterals (literals)
+    : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
+      mNextOperand (true)
     {}
 
     bool ExprParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
     {
-        Operand operand;
-        operand.mType = 'l';
-        operand.mInteger = value;
+        if (mNextOperand)
+        {
+            Operand operand;
+            operand.mType = 'l';
+            operand.mInteger = value;
         
-        mOperands.push_back (operand);
+            mOperands.push_back (operand);
+            
+            mNextOperand = false;
+            mTokenLoc = loc;
+            return true;
+        }
         
-        return false;
+        return Parser::parseInt (value, loc, scanner);
     }
 
     bool ExprParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
     {
-        Operand operand;
-        operand.mType = 'f';
-        operand.mFloat = value;
+        if (mNextOperand)
+        {    
+            Operand operand;
+            operand.mType = 'f';
+            operand.mFloat = value;
         
-        mOperands.push_back (operand);
+            mOperands.push_back (operand);
+            
+            mNextOperand = false;
+            mTokenLoc = loc;
+            return true;
+        }            
             
-        return false;
+        return Parser::parseFloat (value, loc, scanner);
     }
 
     bool ExprParser::parseName (const std::string& name, const TokenLoc& loc,
@@ -47,19 +64,39 @@ namespace Compiler
 
     bool ExprParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
     {
+        if (code==Scanner::S_comma)
+        {
+            // end marker
+            mTokenLoc = loc;
+            return false;
+        }
+        
+        if (code==Scanner::S_newline)
+        {
+            // end marker
+            mTokenLoc = loc;
+            scanner.putbackNewline (loc);
+            return false;
+        }
+        
         return Parser::parseSpecial (code, loc, scanner);
     }
     
     void ExprParser::reset()
     {
         mOperands.clear();
+        mOperators.clear();
+        mNextOperand = true;
     }
     
     char ExprParser::write (std::vector<Interpreter::Type_Code>& code)
     {
-        if (mOperands.empty())
-            throw std::logic_error ("empty expression");
+        if (mOperands.empty() && mOperators.empty())
+            getErrorHandler().error ("missing expression", mTokenLoc);
             
+        if (mNextOperand)
+            getErrorHandler().error ("syntax error in expression", mTokenLoc);
+
         Operand operand = mOperands[mOperands.size()-1];
         mOperands.clear();
         
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index 5f58930f4..0370e35e2 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -6,6 +6,7 @@
 #include <components/interpreter/types.hpp>
 
 #include "parser.hpp"
+#include "tokenloc.hpp"
 
 namespace Compiler
 {
@@ -24,6 +25,9 @@ namespace Compiler
             Locals& mLocals;  
             Literals& mLiterals;
             std::vector<Operand> mOperands;
+            std::vector<char> mOperators;
+            bool mNextOperand;
+            TokenLoc mTokenLoc;
             
         public:
     
diff --git a/components/compiler/scanner.cpp b/components/compiler/scanner.cpp
index a202eca5c..17b2dc305 100644
--- a/components/compiler/scanner.cpp
+++ b/components/compiler/scanner.cpp
@@ -43,6 +43,12 @@ namespace Compiler
 
     bool Scanner::scanToken (Parser& parser)
     {
+        if (mNewline)
+        {
+            mNewline = false;
+            return parser.parseSpecial (S_newline, mPutbackLoc, *this);
+        }
+    
         char c;
 
         if (!get (c))
@@ -412,13 +418,20 @@ namespace Compiler
     // constructor
 
     Scanner::Scanner (ErrorHandler& errorHandler, std::istream& inputStream)
-    : mErrorHandler (errorHandler), mStream (inputStream)
+    : mErrorHandler (errorHandler), mStream (inputStream), mNewline (false)
     {
     }
 
     void Scanner::scan (Parser& parser)
     {
+        mNewline = false;
         while (scanToken (parser));
     }
+    
+    void Scanner::putbackNewline (const TokenLoc& loc)
+    {
+        mNewline = true;
+        mPutbackLoc = loc;
+    }
 }
 
diff --git a/components/compiler/scanner.hpp b/components/compiler/scanner.hpp
index 1349a976a..63a0dbb4d 100644
--- a/components/compiler/scanner.hpp
+++ b/components/compiler/scanner.hpp
@@ -22,6 +22,8 @@ namespace Compiler
             TokenLoc mLoc;
             TokenLoc mPrevLoc;
             std::istream& mStream;
+            bool mNewline;
+            TokenLoc mPutbackLoc;
 
         public:
 
@@ -78,6 +80,9 @@ namespace Compiler
 
             void scan (Parser& parser);
             ///< Scan a token and deliver it to the parser.
+            
+            void putbackNewline (const TokenLoc& loc);
+            ///< put back a newline token
     };
 }
 

From ca8002e5333bdca649000010f33117ab0cda3918 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Tue, 29 Jun 2010 12:05:22 +0200
Subject: [PATCH 27/40] added parsing for signed integers and floats

---
 components/compiler/exprparser.cpp        | 70 +++++++++++++++++++----
 components/compiler/exprparser.hpp        |  5 ++
 components/compiler/generator.cpp         | 30 ++++++++++
 components/compiler/generator.hpp         |  2 +
 components/interpreter/docs/vmformat.txt  |  4 +-
 components/interpreter/genericopcodes.hpp | 24 ++++++++
 components/interpreter/installopcodes.cpp |  4 +-
 7 files changed, 126 insertions(+), 13 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index 1268f602b..516879c40 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -9,6 +9,36 @@
 
 namespace Compiler
 {
+    char ExprParser::popUnaryOperator()
+    {
+        if (mOperators.empty())
+            return 0;
+    
+        char op = mOperators[mOperators.size()-1];
+        
+        if (op!='m') // unary -
+            return 0;
+            
+        mOperators.resize (mOperators.size()-1);
+            
+        return op;
+    }
+    
+    char ExprParser::popOperand (std::vector<Interpreter::Type_Code>& code)
+    {
+        Operand operand = mOperands[mOperands.size()-1];
+        mOperands.resize (mOperands.size()-1);
+    
+        if (operand.mType=='l')
+            Generator::pushInt (code, mLiterals, operand.mInteger);
+        else if (operand.mType=='f')
+            Generator::pushFloat (code, mLiterals, operand.mFloat);
+        else
+            throw std::logic_error ("unknown expression type");     
+            
+       return operand.mType;       
+    }
+
     ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
         Literals& literals)
     : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
@@ -18,7 +48,7 @@ namespace Compiler
     bool ExprParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
     {
         if (mNextOperand)
-        {
+        {       
             Operand operand;
             operand.mType = 'l';
             operand.mInteger = value;
@@ -79,6 +109,17 @@ namespace Compiler
             return false;
         }
         
+        if (code==Scanner::S_minus)
+        {
+            if (mNextOperand)            
+            {
+                // unary
+                mOperators.push_back ('m');
+                mTokenLoc = loc;
+                return true;
+            }
+        }
+        
         return Parser::parseSpecial (code, loc, scanner);
     }
     
@@ -97,17 +138,24 @@ namespace Compiler
         if (mNextOperand)
             getErrorHandler().error ("syntax error in expression", mTokenLoc);
 
-        Operand operand = mOperands[mOperands.size()-1];
-        mOperands.clear();
-        
-        if (operand.mType=='l')
-            Generator::pushInt (code, mLiterals, operand.mInteger);
-        else if (operand.mType=='f')
-            Generator::pushFloat (code, mLiterals, operand.mFloat);
-        else
-            throw std::logic_error ("unknown expression type");
+        char type = ' ';
+
+        while (!mOperands.empty())
+        {
+            type = popOperand (code);
+                
+            while (char op = popUnaryOperator())
+            {
+                if (op=='m')
+                {
+                    Generator::negate (code, type);
+                }
+                else
+                    throw std::logic_error ("unknown unary operator");
+            }
+        }
         
-        return operand.mType;
+        return type;
     }    
 }
 
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index 0370e35e2..93f5db478 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -29,6 +29,11 @@ namespace Compiler
             bool mNextOperand;
             TokenLoc mTokenLoc;
             
+            char popUnaryOperator();
+            ///< returns 0 and not popping, if the next operator isn't unary
+            
+            char popOperand (std::vector<Interpreter::Type_Code>& code);
+            
         public:
     
             ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index 8d37f57a9..cf9f68eef 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -84,6 +84,16 @@ namespace
     {
         code.push_back (segment5 (2));
     }        
+
+    void opNegateInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (7));
+    }
+
+    void opNegateFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (8));
+    }
 }
 
 namespace Compiler
@@ -145,6 +155,26 @@ namespace Compiler
                     assert (0);
             }
         }
+
+        void negate (CodeContainer& code, char valueType)
+        {
+            switch (valueType)
+            {
+                case 'l':
+                
+                    opNegateInt (code);
+                    break;
+                
+                case 'f':
+                
+                    opNegateFloat (code);
+                    break;
+                
+                default:
+                
+                    assert (0);
+            }
+        }
     }
 }
 
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index 061a30df4..42117eecb 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -19,6 +19,8 @@ namespace Compiler
 
         void assignToLocal (CodeContainer& code, char localType,
             int localIndex, const CodeContainer& value, char valueType);
+            
+        void negate (CodeContainer& code, char valueType);
     }
 }
 
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
index ca76d00f3..1a4db8b56 100644
--- a/components/interpreter/docs/vmformat.txt
+++ b/components/interpreter/docs/vmformat.txt
@@ -58,6 +58,8 @@ op   3: convert stack[0] from integer to float
 op   4: replace stack[0] with integer literal index stack[0]
 op   5: replace stack[0] with float literal index stack[0]
 op   6: convert stack[0] from float to integer
-opcodes 7-33554431 unused
+op   7: invert sign of int value stack[0]
+op   8: invert sign of float value stack[0]
+opcodes 9-33554431 unused
 opcodes 33554432-67108863 reserved for extensions
 
diff --git a/components/interpreter/genericopcodes.hpp b/components/interpreter/genericopcodes.hpp
index 44e1e9cb4..db22ac089 100644
--- a/components/interpreter/genericopcodes.hpp
+++ b/components/interpreter/genericopcodes.hpp
@@ -39,6 +39,30 @@ namespace Interpreter
                 runtime[0] = *reinterpret_cast<Type_Data *> (&integerValue);
             }           
     };    
+    
+    class OpNegateInt : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Integer data = *reinterpret_cast<Type_Integer *> (&runtime[0]);
+                data = -data;
+                runtime[0] = *reinterpret_cast<Type_Data *> (&data);
+            }           
+    };    
+    
+    class OpNegateFloat : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Float data = *reinterpret_cast<Type_Float *> (&runtime[0]);
+                data = -data;
+                runtime[0] = *reinterpret_cast<Type_Data *> (&data);
+            }           
+    };    
 }
 
 #endif
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
index df3f69201..15755a38a 100644
--- a/components/interpreter/installopcodes.cpp
+++ b/components/interpreter/installopcodes.cpp
@@ -13,7 +13,9 @@ namespace Interpreter
         interpreter.installSegment0 (0, new OpPushInt);
         interpreter.installSegment5 (3, new OpIntToFloat);
         interpreter.installSegment5 (6, new OpFloatToInt);
-    
+        interpreter.installSegment5 (7, new OpNegateInt);
+        interpreter.installSegment5 (8, new OpNegateFloat);
+            
         // local variables
         interpreter.installSegment5 (0, new OpStoreLocalShort);
         interpreter.installSegment5 (1, new OpStoreLocalLong);

From 48f6ad0f898cc6d4efbb2e11e74ac020cbca4be9 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Tue, 29 Jun 2010 16:11:19 +0200
Subject: [PATCH 28/40] added basic arithmetic

---
 components/compiler/exprparser.cpp        | 213 ++++++++++++++++------
 components/compiler/exprparser.hpp        |  33 ++--
 components/compiler/generator.cpp         | 122 +++++++++++++
 components/compiler/generator.hpp         |   8 +
 components/compiler/lineparser.cpp        |   2 +-
 components/interpreter/docs/vmformat.txt  |  12 +-
 components/interpreter/genericopcodes.hpp |  26 ++-
 components/interpreter/installopcodes.cpp |  15 +-
 components/interpreter/mathopcodes.hpp    |  90 +++++++++
 9 files changed, 446 insertions(+), 75 deletions(-)
 create mode 100644 components/interpreter/mathopcodes.hpp

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index 516879c40..11347e3e4 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -2,6 +2,7 @@
 #include "exprparser.hpp"
 
 #include <stdexcept>
+#include <cassert>
 
 #include "generator.hpp"
 #include "scanner.hpp"
@@ -9,36 +10,139 @@
 
 namespace Compiler
 {
-    char ExprParser::popUnaryOperator()
+    int ExprParser::getPriority (char op) const
     {
-        if (mOperators.empty())
-            return 0;
-    
-        char op = mOperators[mOperators.size()-1];
+        switch (op)
+        {
+            case '+':
+            case '-':
+            
+                return 1;
         
-        if (op!='m') // unary -
-            return 0;
+            case '*':
+            case '/':
             
-        mOperators.resize (mOperators.size()-1);
+                return 2;
+                
+            case 'm':
             
-        return op;
+                return 3;
+        }
+    
+        return 0;
+    }
+
+    char ExprParser::getOperandType (int Index) const
+    {
+        assert (!mOperands.empty());
+        assert (Index>=0);
+        assert (Index<static_cast<int> (mOperands.size()));
+        return mOperands[mOperands.size()-1-Index];
     }
     
-    char ExprParser::popOperand (std::vector<Interpreter::Type_Code>& code)
+    char ExprParser::getOperator() const
+    {
+        assert (!mOperators.empty());
+        return mOperators[mOperators.size()-1];
+    }
+
+    void ExprParser::popOperator()
     {
-        Operand operand = mOperands[mOperands.size()-1];
-        mOperands.resize (mOperands.size()-1);
+        assert (!mOperators.empty());
+        mOperators.resize (mOperators.size()-1);        
+    }
     
-        if (operand.mType=='l')
-            Generator::pushInt (code, mLiterals, operand.mInteger);
-        else if (operand.mType=='f')
-            Generator::pushFloat (code, mLiterals, operand.mFloat);
+    void ExprParser::popOperand()
+    {
+        assert (!mOperands.empty());
+        mOperands.resize (mOperands.size()-1);    
+    }
+
+    void ExprParser::replaceBinaryOperands()
+    {
+        char t1 = getOperandType (1);
+        char t2 = getOperandType();
+        
+        popOperand();
+        popOperand();
+        
+        if (t1==t2)
+            mOperands.push_back (t1);
+        else if (t1=='f' || t2=='f')
+            mOperands.push_back ('f');
         else
-            throw std::logic_error ("unknown expression type");     
+            std::logic_error ("failed to determine result operand type");
+    }
+
+    void ExprParser::pop()
+    {
+        char op = getOperator();
+        
+        switch (op)
+        {
+            case 'm':
+            
+                Generator::negate (mCode, getOperandType());
+                popOperator();
+                break;
+
+            case '+':
+                
+                Generator::add (mCode, getOperandType (1), getOperandType());
+                popOperator();
+                replaceBinaryOperands();
+                break;
+
+            case '-':
+                
+                Generator::sub (mCode, getOperandType (1), getOperandType());
+                popOperator();
+                replaceBinaryOperands();
+                break;
+                
+            case '*':
+                
+                Generator::mul (mCode, getOperandType (1), getOperandType());
+                popOperator();
+                replaceBinaryOperands();
+                break;                
+                
+            case '/':
+                
+                Generator::div (mCode, getOperandType (1), getOperandType());
+                popOperator();
+                replaceBinaryOperands();
+                break;
+                            
+            default:
             
-       return operand.mType;       
+                throw std::logic_error ("unknown operator");
+        }
     }
 
+    void ExprParser::pushIntegerLiteral (int value)
+    {
+        mNextOperand = false;
+        mOperands.push_back ('l');
+        Generator::pushInt (mCode, mLiterals, value);
+    }
+    
+    void ExprParser::pushFloatLiteral (float value)
+    {
+        mNextOperand = false;
+        mOperands.push_back ('f');
+        Generator::pushFloat (mCode, mLiterals, value);    
+    }
+            
+    void ExprParser::pushBinaryOperator (char c)
+    {
+        while (!mOperators.empty() && getPriority (getOperator())>=getPriority (c))
+            pop();
+    
+        mOperators.push_back (c);
+        mNextOperand = true;
+    }
+            
     ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
         Literals& literals)
     : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
@@ -49,13 +153,7 @@ namespace Compiler
     {
         if (mNextOperand)
         {       
-            Operand operand;
-            operand.mType = 'l';
-            operand.mInteger = value;
-        
-            mOperands.push_back (operand);
-            
-            mNextOperand = false;
+            pushIntegerLiteral (value);
             mTokenLoc = loc;
             return true;
         }
@@ -67,13 +165,7 @@ namespace Compiler
     {
         if (mNextOperand)
         {    
-            Operand operand;
-            operand.mType = 'f';
-            operand.mFloat = value;
-        
-            mOperands.push_back (operand);
-            
-            mNextOperand = false;
+            pushFloatLiteral (value);
             mTokenLoc = loc;
             return true;
         }            
@@ -109,15 +201,22 @@ namespace Compiler
             return false;
         }
         
-        if (code==Scanner::S_minus)
+        if (code==Scanner::S_minus && mNextOperand)
+        {
+            // unary
+            mOperators.push_back ('m');
+            mTokenLoc = loc;
+            return true;
+        }
+        
+        mTokenLoc = loc;
+   
+        switch (code)
         {
-            if (mNextOperand)            
-            {
-                // unary
-                mOperators.push_back ('m');
-                mTokenLoc = loc;
-                return true;
-            }
+            case Scanner::S_plus: pushBinaryOperator ('+'); return true;
+            case Scanner::S_minus: pushBinaryOperator ('-'); return true;
+            case Scanner::S_mult: pushBinaryOperator ('*'); return true;
+            case Scanner::S_div: pushBinaryOperator ('/'); return true;
         }
         
         return Parser::parseSpecial (code, loc, scanner);
@@ -128,34 +227,30 @@ namespace Compiler
         mOperands.clear();
         mOperators.clear();
         mNextOperand = true;
+        mCode.clear();
     }
     
-    char ExprParser::write (std::vector<Interpreter::Type_Code>& code)
+    char ExprParser::append (std::vector<Interpreter::Type_Code>& code)
     {
         if (mOperands.empty() && mOperators.empty())
+        {
             getErrorHandler().error ("missing expression", mTokenLoc);
+            return 'l';
+        }
             
-        if (mNextOperand)
+        if (mNextOperand || mOperands.empty())
+        {
             getErrorHandler().error ("syntax error in expression", mTokenLoc);
+            return 'l';
+        }
 
-        char type = ' ';
+        while (!mOperators.empty())
+            pop();
 
-        while (!mOperands.empty())
-        {
-            type = popOperand (code);
-                
-            while (char op = popUnaryOperator())
-            {
-                if (op=='m')
-                {
-                    Generator::negate (code, type);
-                }
-                else
-                    throw std::logic_error ("unknown unary operator");
-            }
-        }
-        
-        return type;
+        std::copy (mCode.begin(), mCode.end(), std::back_inserter (code));
+
+        assert (mOperands.size()==1);
+        return mOperands[0];
     }    
 }
 
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index 93f5db478..73d6b82d7 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -15,25 +15,34 @@ namespace Compiler
 
     class ExprParser : public Parser
     {
-            struct Operand
-            {
-                char mType;
-                int mInteger;
-                float mFloat;
-            };
-            
             Locals& mLocals;  
             Literals& mLiterals;
-            std::vector<Operand> mOperands;
+            std::vector<char> mOperands;
             std::vector<char> mOperators;
             bool mNextOperand;
             TokenLoc mTokenLoc;
+            std::vector<Interpreter::Type_Code> mCode;
+            
+            int getPriority (char op) const;
+            
+            char getOperandType (int Index = 0) const;           
+
+            char getOperator() const;
+                
+            void popOperator();
+            
+            void popOperand();
+            
+            void replaceBinaryOperands();
+   
+            void pop();
             
-            char popUnaryOperator();
-            ///< returns 0 and not popping, if the next operator isn't unary
+            void pushIntegerLiteral (int value);
             
-            char popOperand (std::vector<Interpreter::Type_Code>& code);
+            void pushFloatLiteral (float value);
             
+            void pushBinaryOperator (char c);
+                        
         public:
     
             ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
@@ -67,7 +76,7 @@ namespace Compiler
             void reset();
             ///< Reset parser to clean state.
             
-            char write (std::vector<Interpreter::Type_Code>& code);
+            char append (std::vector<Interpreter::Type_Code>& code);
             ///< Generate code for parsed expression.
             /// \return Type ('l': integer, 'f': float)
     };
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index cf9f68eef..971fd81b3 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -94,6 +94,56 @@ namespace
     {
         code.push_back (segment5 (8));
     }
+
+    void opAddInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (9));
+    }
+
+    void opAddFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (10));
+    }
+
+    void opSubInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (11));
+    }
+
+    void opSubFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (12));
+    }
+
+    void opMulInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (13));
+    }
+
+    void opMulFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (14));
+    }
+
+    void opDivInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (15));
+    }
+
+    void opDivFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (16));
+    }
+    
+    void opIntToFloat1 (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (17));    
+    }
+    
+    void opFloatToInt1 (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (18));
+    }    
 }
 
 namespace Compiler
@@ -175,6 +225,78 @@ namespace Compiler
                     assert (0);
             }
         }
+        
+        void add (CodeContainer& code, char valueType1, char valueType2)
+        {
+            if (valueType1=='l' && valueType2=='l')
+            {
+                opAddInt (code);
+            }
+            else
+            {
+                if (valueType1=='l')
+                    opIntToFloat1 (code);
+
+                if (valueType2=='l')
+                    opIntToFloat (code);
+            
+                opAddFloat (code);
+            }
+        }
+
+        void sub (CodeContainer& code, char valueType1, char valueType2)
+        {
+            if (valueType1=='l' && valueType2=='l')
+            {
+                opSubInt (code);
+            }
+            else
+            {
+                if (valueType1=='l')
+                    opIntToFloat1 (code);
+
+                if (valueType2=='l')
+                    opIntToFloat (code);
+            
+                opSubFloat (code);
+            }
+        }
+        
+        void mul (CodeContainer& code, char valueType1, char valueType2)
+        {
+            if (valueType1=='l' && valueType2=='l')
+            {
+                opMulInt (code);
+            }
+            else
+            {
+                if (valueType1=='l')
+                    opIntToFloat1 (code);
+
+                if (valueType2=='l')
+                    opIntToFloat (code);
+            
+                opMulFloat (code);
+            }        
+        }      
+        
+        void div (CodeContainer& code, char valueType1, char valueType2)
+        {
+            if (valueType1=='l' && valueType2=='l')
+            {
+                opDivInt (code);
+            }
+            else
+            {
+                if (valueType1=='l')
+                    opIntToFloat1 (code);
+
+                if (valueType2=='l')
+                    opIntToFloat (code);
+            
+                opDivFloat (code);
+            }        
+        }
     }
 }
 
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index 42117eecb..cea8a8636 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -21,6 +21,14 @@ namespace Compiler
             int localIndex, const CodeContainer& value, char valueType);
             
         void negate (CodeContainer& code, char valueType);
+        
+        void add (CodeContainer& code, char valueType1, char valueType2);
+
+        void sub (CodeContainer& code, char valueType1, char valueType2);        
+        
+        void mul (CodeContainer& code, char valueType1, char valueType2);        
+        
+        void div (CodeContainer& code, char valueType1, char valueType2);        
     }
 }
 
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 1685af848..92c9aad57 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -97,7 +97,7 @@ namespace Compiler
             scanner.scan (mExprParser);
             
             std::vector<Interpreter::Type_Code> code;
-            char type = mExprParser.write (code);
+            char type = mExprParser.append (code);
             
             Generator::assignToLocal (mCode, mLocals.getType (mName),
                 mLocals.getIndex (mName), code, type);
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
index 1a4db8b56..db85e6af8 100644
--- a/components/interpreter/docs/vmformat.txt
+++ b/components/interpreter/docs/vmformat.txt
@@ -60,6 +60,16 @@ op   5: replace stack[0] with float literal index stack[0]
 op   6: convert stack[0] from float to integer
 op   7: invert sign of int value stack[0]
 op   8: invert sign of float value stack[0]
-opcodes 9-33554431 unused
+op   9: add (integer) stack[0] to stack[1], pop twice, push result
+op  10: add (float) stack[0] to stack[1], pop twice, push result
+op  11: sub (integer) stack[1] from stack[0], pop twice, push result
+op  12: sub (float) stack[1] from stack[0], pop twice, push result
+op  13: mul (integer) stack[0] with stack[1], pop twice, push result
+op  14: mul (float) stack[0] with stack[1], pop twice, push result
+op  15: div (integer) stack[1] by stack[0], pop twice, push result
+op  16: div (float) stack[1] by stack[0], pop twice, push result
+op  17: convert stack[1] from integer to float
+op  18: convert stack[1] from float to integer
+opcodes 19-33554431 unused
 opcodes 33554432-67108863 reserved for extensions
 
diff --git a/components/interpreter/genericopcodes.hpp b/components/interpreter/genericopcodes.hpp
index db22ac089..116b586e4 100644
--- a/components/interpreter/genericopcodes.hpp
+++ b/components/interpreter/genericopcodes.hpp
@@ -62,7 +62,31 @@ namespace Interpreter
                 data = -data;
                 runtime[0] = *reinterpret_cast<Type_Data *> (&data);
             }           
-    };    
+    };
+    
+    class OpIntToFloat1 : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Integer data = *reinterpret_cast<Type_Integer *> (&runtime[1]);
+                Type_Float floatValue = static_cast<Type_Float> (data);
+                runtime[1] = *reinterpret_cast<Type_Data *> (&floatValue);
+            }           
+    };
+    
+    class OpFloatToInt1 : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Float data = *reinterpret_cast<Type_Float *> (&runtime[1]);
+                Type_Integer integerValue = static_cast<Type_Integer> (data);
+                runtime[1] = *reinterpret_cast<Type_Data *> (&integerValue);
+            }           
+    };            
 }
 
 #endif
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
index 15755a38a..a0f90b98e 100644
--- a/components/interpreter/installopcodes.cpp
+++ b/components/interpreter/installopcodes.cpp
@@ -4,6 +4,7 @@
 #include "interpreter.hpp"
 #include "genericopcodes.hpp"
 #include "localopcodes.hpp"
+#include "mathopcodes.hpp"
 
 namespace Interpreter
 {
@@ -15,13 +16,25 @@ namespace Interpreter
         interpreter.installSegment5 (6, new OpFloatToInt);
         interpreter.installSegment5 (7, new OpNegateInt);
         interpreter.installSegment5 (8, new OpNegateFloat);
-            
+        interpreter.installSegment5 (17, new OpIntToFloat1);
+        interpreter.installSegment5 (18, new OpFloatToInt1);
+                    
         // local variables
         interpreter.installSegment5 (0, new OpStoreLocalShort);
         interpreter.installSegment5 (1, new OpStoreLocalLong);
         interpreter.installSegment5 (2, new OpStoreLocalFloat);        
         interpreter.installSegment5 (4, new OpFetchIntLiteral);            
         interpreter.installSegment5 (5, new OpFetchFloatLiteral);  
+        
+        // math
+        interpreter.installSegment5 (9, new OpAddInt<Type_Integer>);
+        interpreter.installSegment5 (10, new OpAddInt<Type_Float>);
+        interpreter.installSegment5 (11, new OpSubInt<Type_Integer>);
+        interpreter.installSegment5 (12, new OpSubInt<Type_Float>);
+        interpreter.installSegment5 (13, new OpMulInt<Type_Integer>);
+        interpreter.installSegment5 (14, new OpMulInt<Type_Float>);
+        interpreter.installSegment5 (15, new OpDivInt<Type_Integer>);
+        interpreter.installSegment5 (16, new OpDivInt<Type_Float>);
     }
 }
 
diff --git a/components/interpreter/mathopcodes.hpp b/components/interpreter/mathopcodes.hpp
new file mode 100644
index 000000000..4cec3bfc9
--- /dev/null
+++ b/components/interpreter/mathopcodes.hpp
@@ -0,0 +1,90 @@
+#ifndef INTERPRETER_MATHOPCODES_H_INCLUDED
+#define INTERPRETER_MATHOPCODES_H_INCLUDED
+
+#include <stdexcept>
+
+#include "opcodes.hpp"
+#include "runtime.hpp"
+
+namespace Interpreter
+{
+    template<typename T>
+    class OpAddInt : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                T result =
+                    *reinterpret_cast<T *> (&runtime[1])
+                    + 
+                    *reinterpret_cast<T *> (&runtime[0]);
+                
+                runtime.pop();
+                
+                runtime[0] = *reinterpret_cast<Type_Data *> (&result);
+            }           
+    };
+
+    template<typename T>
+    class OpSubInt : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                T result =
+                    *reinterpret_cast<T *> (&runtime[1])
+                    - 
+                    *reinterpret_cast<T *> (&runtime[0]);
+                
+                runtime.pop();
+                
+                runtime[0] = *reinterpret_cast<Type_Data *> (&result);
+            }           
+    };
+
+    template<typename T>
+    class OpMulInt : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                T result =
+                    *reinterpret_cast<T *> (&runtime[1])
+                    * 
+                    *reinterpret_cast<T *> (&runtime[0]);
+                
+                runtime.pop();
+                
+                runtime[0] = *reinterpret_cast<Type_Data *> (&result);
+            }           
+    };
+
+    template<typename T>
+    class OpDivInt : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                T left = *reinterpret_cast<T *> (&runtime[0]);
+            
+                if (left==0)
+                    throw std::runtime_error ("division by zero");
+            
+                T result =
+                    *reinterpret_cast<T *> (&runtime[1])
+                    / 
+                    left;
+                
+                runtime.pop();
+                
+                runtime[0] = *reinterpret_cast<Type_Data *> (&result);
+            }           
+    };
+}
+
+#endif
+

From c8c5ef5467283f26998e79507ac1479523e5dd69 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Tue, 29 Jun 2010 16:24:54 +0200
Subject: [PATCH 29/40] added bracket parsing

---
 components/compiler/exprparser.cpp | 25 +++++++++++++++++++++++++
 components/compiler/exprparser.hpp |  2 ++
 2 files changed, 27 insertions(+)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index 11347e3e4..12f63d3aa 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -14,6 +14,10 @@ namespace Compiler
     {
         switch (op)
         {
+            case '(':
+            
+                return 0;
+            
             case '+':
             case '-':
             
@@ -143,6 +147,14 @@ namespace Compiler
         mNextOperand = true;
     }
             
+    void ExprParser::close()
+    {
+        while (getOperator()!='(')
+            pop();
+            
+        popOperator();
+    }
+            
     ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
         Literals& literals)
     : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
@@ -209,6 +221,19 @@ namespace Compiler
             return true;
         }
         
+        if (code==Scanner::S_open && mNextOperand)
+        {
+            mOperators.push_back ('(');
+            mTokenLoc = loc;
+            return true;
+        }
+        
+        if (code==Scanner::S_close && !mNextOperand)
+        {
+            close();
+            return true;
+        }
+        
         mTokenLoc = loc;
    
         switch (code)
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index 73d6b82d7..a87dd995b 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -43,6 +43,8 @@ namespace Compiler
             
             void pushBinaryOperator (char c);
                         
+            void close();
+                        
         public:
     
             ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,

From 5fb4abae4f66a302e29f2994598e33a653953c0e Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Tue, 29 Jun 2010 17:51:02 +0200
Subject: [PATCH 30/40] added function parsing (only one function so far)

---
 components/compiler/exprparser.cpp        | 47 +++++++++++++++++++----
 components/compiler/exprparser.hpp        |  2 +
 components/compiler/generator.cpp         | 24 ++++++++++++
 components/compiler/generator.hpp         |  4 ++
 components/compiler/scanner.cpp           |  1 +
 components/compiler/scanner.hpp           |  3 +-
 components/interpreter/docs/vmformat.txt  |  3 +-
 components/interpreter/installopcodes.cpp |  1 +
 components/interpreter/mathopcodes.hpp    | 19 +++++++++
 9 files changed, 95 insertions(+), 9 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index 12f63d3aa..79b6f3447 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -155,6 +155,25 @@ namespace Compiler
         popOperator();
     }
             
+    void ExprParser::parseArguments (const std::string& arguments, Scanner& scanner)
+    {
+        ExprParser parser (getErrorHandler(), getContext(), mLocals, mLiterals);
+        
+        for (std::string::const_iterator iter (arguments.begin()); iter!=arguments.end();
+            ++iter)
+        {
+            parser.reset();    
+            scanner.scan (parser);
+
+            char type = parser.append (mCode);
+
+            if (type!=*iter)
+                Generator::convert (mCode, type, *iter);
+                
+            mOperands.push_back (*iter);
+        }
+    }
+            
     ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
         Literals& literals)
     : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
@@ -193,6 +212,17 @@ namespace Compiler
 
     bool ExprParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
     {
+        if (keyword==Scanner::K_getsquareroot && mNextOperand)
+        {
+            mTokenLoc = loc;        
+            parseArguments ("f", scanner);
+
+            Generator::squareRoot (mCode);
+            
+            mNextOperand = false;
+            return true;
+        }
+        
         return Parser::parseKeyword (keyword, loc, scanner);
     }
 
@@ -234,14 +264,17 @@ namespace Compiler
             return true;
         }
         
-        mTokenLoc = loc;
-   
-        switch (code)
+        if (!mNextOperand)
         {
-            case Scanner::S_plus: pushBinaryOperator ('+'); return true;
-            case Scanner::S_minus: pushBinaryOperator ('-'); return true;
-            case Scanner::S_mult: pushBinaryOperator ('*'); return true;
-            case Scanner::S_div: pushBinaryOperator ('/'); return true;
+            mTokenLoc = loc;
+   
+            switch (code)
+            {
+                case Scanner::S_plus: pushBinaryOperator ('+'); return true;
+                case Scanner::S_minus: pushBinaryOperator ('-'); return true;
+                case Scanner::S_mult: pushBinaryOperator ('*'); return true;
+                case Scanner::S_div: pushBinaryOperator ('/'); return true;
+            }
         }
         
         return Parser::parseSpecial (code, loc, scanner);
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index a87dd995b..6dba519ea 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -44,6 +44,8 @@ namespace Compiler
             void pushBinaryOperator (char c);
                         
             void close();
+            
+            void parseArguments (const std::string& arguments, Scanner& scanner);
                         
         public:
     
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index 971fd81b3..e704ac724 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -4,6 +4,7 @@
 #include <cassert>
 #include <algorithm>
 #include <iterator>
+#include <stdexcept>
 
 #include "literals.hpp"
 
@@ -144,6 +145,11 @@ namespace
     {
         code.push_back (segment5 (18));
     }    
+
+    void opSquareRoot (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (19));
+    }    
 }
 
 namespace Compiler
@@ -297,6 +303,24 @@ namespace Compiler
                 opDivFloat (code);
             }        
         }
+        
+        void convert (CodeContainer& code, char fromType, char toType)
+        {
+            if (fromType!=toType)
+            {
+                if (fromType=='f' && toType=='l')
+                    opFloatToInt (code);
+                else if (fromType=='l' && toType=='f')
+                    opIntToFloat (code);
+                else
+                    throw std::logic_error ("illegal type conversion");
+            }
+        }
+        
+        void squareRoot (CodeContainer& code)
+        {
+            opSquareRoot (code);
+        }
     }
 }
 
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index cea8a8636..44b0fc4f2 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -29,6 +29,10 @@ namespace Compiler
         void mul (CodeContainer& code, char valueType1, char valueType2);        
         
         void div (CodeContainer& code, char valueType1, char valueType2);        
+        
+        void convert (CodeContainer& code, char fromType, char toType);
+        
+        void squareRoot (CodeContainer& code);
     }
 }
 
diff --git a/components/compiler/scanner.cpp b/components/compiler/scanner.cpp
index 17b2dc305..e04e2114b 100644
--- a/components/compiler/scanner.cpp
+++ b/components/compiler/scanner.cpp
@@ -213,6 +213,7 @@ namespace Compiler
             "return",
             "messagebox",
             "set", "to",
+            "getsquareroot",
             0
         };
 
diff --git a/components/compiler/scanner.hpp b/components/compiler/scanner.hpp
index 63a0dbb4d..5a490d70e 100644
--- a/components/compiler/scanner.hpp
+++ b/components/compiler/scanner.hpp
@@ -35,7 +35,8 @@ namespace Compiler
                 K_while, K_endwhile,
                 K_return,
                 K_messageBox,
-                K_set, K_to
+                K_set, K_to,
+                K_getsquareroot
             };
 
             enum special
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
index db85e6af8..748e6e3ee 100644
--- a/components/interpreter/docs/vmformat.txt
+++ b/components/interpreter/docs/vmformat.txt
@@ -70,6 +70,7 @@ op  15: div (integer) stack[1] by stack[0], pop twice, push result
 op  16: div (float) stack[1] by stack[0], pop twice, push result
 op  17: convert stack[1] from integer to float
 op  18: convert stack[1] from float to integer
-opcodes 19-33554431 unused
+op  19: take square root of stack[0] (float)
+opcodes 20-33554431 unused
 opcodes 33554432-67108863 reserved for extensions
 
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
index a0f90b98e..b96a0a1a5 100644
--- a/components/interpreter/installopcodes.cpp
+++ b/components/interpreter/installopcodes.cpp
@@ -35,6 +35,7 @@ namespace Interpreter
         interpreter.installSegment5 (14, new OpMulInt<Type_Float>);
         interpreter.installSegment5 (15, new OpDivInt<Type_Integer>);
         interpreter.installSegment5 (16, new OpDivInt<Type_Float>);
+        interpreter.installSegment5 (19, new OpSquareRoot);        
     }
 }
 
diff --git a/components/interpreter/mathopcodes.hpp b/components/interpreter/mathopcodes.hpp
index 4cec3bfc9..bb12274d3 100644
--- a/components/interpreter/mathopcodes.hpp
+++ b/components/interpreter/mathopcodes.hpp
@@ -2,6 +2,7 @@
 #define INTERPRETER_MATHOPCODES_H_INCLUDED
 
 #include <stdexcept>
+#include <cmath>
 
 #include "opcodes.hpp"
 #include "runtime.hpp"
@@ -84,6 +85,24 @@ namespace Interpreter
                 runtime[0] = *reinterpret_cast<Type_Data *> (&result);
             }           
     };
+    
+    class OpSquareRoot : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Float value = *reinterpret_cast<Type_Float *> (&runtime[0]);
+                
+                if (value<0)
+                    throw std::runtime_error (
+                        "square root of negative number (we aren't that imaginary)");
+                
+                value = std::sqrt (value);
+                
+                runtime[0] = *reinterpret_cast<Type_Data *> (&value);
+            }           
+    };    
 }
 
 #endif

From 8bb2a6039dcaf557533eb58387daea932589063a Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Wed, 30 Jun 2010 11:03:08 +0200
Subject: [PATCH 31/40] modified comma handling to be morse consistent with
 original script language

---
 components/compiler/exprparser.cpp | 28 ++++++++++++++++++++++++----
 components/compiler/exprparser.hpp |  1 +
 components/compiler/scanner.cpp    | 23 +++++++++++++++--------
 components/compiler/scanner.hpp    | 14 ++++++++++----
 4 files changed, 50 insertions(+), 16 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index 79b6f3447..ffb6fd336 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -177,11 +177,13 @@ namespace Compiler
     ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
         Literals& literals)
     : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
-      mNextOperand (true)
+      mNextOperand (true), mFirst (true)
     {}
 
     bool ExprParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
     {
+        mFirst = false;
+        
         if (mNextOperand)
         {       
             pushIntegerLiteral (value);
@@ -194,6 +196,8 @@ namespace Compiler
 
     bool ExprParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
     {
+        mFirst = false;
+        
         if (mNextOperand)
         {    
             pushFloatLiteral (value);
@@ -207,11 +211,15 @@ namespace Compiler
     bool ExprParser::parseName (const std::string& name, const TokenLoc& loc,
         Scanner& scanner)
     {
+        mFirst = false;
+        
         return Parser::parseName (name, loc, scanner);
     }
 
     bool ExprParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
     {
+        mFirst = false;
+        
         if (keyword==Scanner::K_getsquareroot && mNextOperand)
         {
             mTokenLoc = loc;        
@@ -230,16 +238,27 @@ namespace Compiler
     {
         if (code==Scanner::S_comma)
         {
-            // end marker
             mTokenLoc = loc;
+
+            if (mFirst)
+            {
+                // leading comma
+                mFirst = false;
+                return true;
+            }
+            
+            // end marker
+            scanner.putbackSpecial (code, loc);
             return false;
         }
-        
+
+        mFirst = false;
+                
         if (code==Scanner::S_newline)
         {
             // end marker
             mTokenLoc = loc;
-            scanner.putbackNewline (loc);
+            scanner.putbackSpecial (code, loc);
             return false;
         }
         
@@ -286,6 +305,7 @@ namespace Compiler
         mOperators.clear();
         mNextOperand = true;
         mCode.clear();
+        mFirst = true;
     }
     
     char ExprParser::append (std::vector<Interpreter::Type_Code>& code)
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index 6dba519ea..14c530010 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -22,6 +22,7 @@ namespace Compiler
             bool mNextOperand;
             TokenLoc mTokenLoc;
             std::vector<Interpreter::Type_Code> mCode;
+            bool mFirst;
             
             int getPriority (char op) const;
             
diff --git a/components/compiler/scanner.cpp b/components/compiler/scanner.cpp
index e04e2114b..a8514f956 100644
--- a/components/compiler/scanner.cpp
+++ b/components/compiler/scanner.cpp
@@ -43,10 +43,17 @@ namespace Compiler
 
     bool Scanner::scanToken (Parser& parser)
     {
-        if (mNewline)
+        switch (mPutback)
         {
-            mNewline = false;
-            return parser.parseSpecial (S_newline, mPutbackLoc, *this);
+            case Putback_Special:
+            {            
+                mPutback = Putback_None;            
+                return parser.parseSpecial (mPutbackCode, mPutbackLoc, *this);
+            }
+            
+            case Putback_None:
+            
+                break;
         }
     
         char c;
@@ -419,20 +426,20 @@ namespace Compiler
     // constructor
 
     Scanner::Scanner (ErrorHandler& errorHandler, std::istream& inputStream)
-    : mErrorHandler (errorHandler), mStream (inputStream), mNewline (false)
+    : mErrorHandler (errorHandler), mStream (inputStream), mPutback (Putback_None)
     {
     }
 
     void Scanner::scan (Parser& parser)
     {
-        mNewline = false;
         while (scanToken (parser));
     }
     
-    void Scanner::putbackNewline (const TokenLoc& loc)
+    void Scanner::putbackSpecial (int code, const TokenLoc& loc)
     {
-        mNewline = true;
-        mPutbackLoc = loc;
+        mPutback = Putback_Special;
+        mPutbackCode = code;
+        mPutbackLoc = loc;    
     }
 }
 
diff --git a/components/compiler/scanner.hpp b/components/compiler/scanner.hpp
index 5a490d70e..271639c97 100644
--- a/components/compiler/scanner.hpp
+++ b/components/compiler/scanner.hpp
@@ -18,11 +18,17 @@ namespace Compiler
 
     class Scanner
     {
+            enum putback_type
+            {
+                Putback_None, Putback_Special,
+            };
+    
             ErrorHandler& mErrorHandler;
             TokenLoc mLoc;
             TokenLoc mPrevLoc;
             std::istream& mStream;
-            bool mNewline;
+            putback_type mPutback;
+            int mPutbackCode;
             TokenLoc mPutbackLoc;
 
         public:
@@ -81,9 +87,9 @@ namespace Compiler
 
             void scan (Parser& parser);
             ///< Scan a token and deliver it to the parser.
-            
-            void putbackNewline (const TokenLoc& loc);
-            ///< put back a newline token
+
+            void putbackSpecial (int code, const TokenLoc& loc); 
+            ///< put back a special token
     };
 }
 

From fac8fb8fcb2fe71c57d0d155f2df334aa7b9aac4 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Wed, 30 Jun 2010 12:04:26 +0200
Subject: [PATCH 32/40] added return and messagebox statements (messagebox does
 neither formating nor buttons yet)

---
 apps/mwinterpreter/context.cpp            |  8 ++++++
 apps/mwinterpreter/context.hpp            |  3 +++
 components/compiler/generator.cpp         | 26 +++++++++++++++++++
 components/compiler/generator.hpp         |  6 +++++
 components/compiler/lineparser.cpp        | 20 +++++++++++++++
 components/compiler/lineparser.hpp        |  1 +
 components/compiler/scanner.hpp           |  2 +-
 components/interpreter/context.hpp        |  5 +++-
 components/interpreter/controlopcodes.hpp | 20 +++++++++++++++
 components/interpreter/docs/vmformat.txt  | 10 ++++++--
 components/interpreter/installopcodes.cpp |  8 ++++++
 components/interpreter/miscopcodes.hpp    | 31 +++++++++++++++++++++++
 components/interpreter/runtime.cpp        | 16 ++++++++++++
 components/interpreter/runtime.hpp        |  5 +++-
 14 files changed, 156 insertions(+), 5 deletions(-)
 create mode 100644 components/interpreter/controlopcodes.hpp
 create mode 100644 components/interpreter/miscopcodes.hpp

diff --git a/apps/mwinterpreter/context.cpp b/apps/mwinterpreter/context.cpp
index 618abaf83..09d70ff3e 100644
--- a/apps/mwinterpreter/context.cpp
+++ b/apps/mwinterpreter/context.cpp
@@ -67,6 +67,14 @@ namespace SAInterpreter
         mFloats.at (index) = value;
     }    
     
+    void Context::messageBox (const std::string& message,
+        const std::vector<std::string>& buttons)
+    {
+        std::cout << "message box: " << message << std::endl;
+        for (std::size_t i=0; i<buttons.size(); ++i)
+            std::cout << "    button " << i << ": " << buttons[i] << std::endl;
+    }
+                    
     void Context::report()
     {
         std::size_t i = 0;
diff --git a/apps/mwinterpreter/context.hpp b/apps/mwinterpreter/context.hpp
index c3ab9bad7..0f7ce5cef 100644
--- a/apps/mwinterpreter/context.hpp
+++ b/apps/mwinterpreter/context.hpp
@@ -35,6 +35,9 @@ namespace SAInterpreter
 
             virtual void setLocalFloat (int index, float value);    
             
+            virtual void messageBox (const std::string& message,
+                const std::vector<std::string>& buttons); 
+                            
             void report();
             ///< Write state to std::cout   
     };
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index e704ac724..ddbae874a 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -150,6 +150,16 @@ namespace
     {
         code.push_back (segment5 (19));
     }    
+
+    void opReturn (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (20));
+    }       
+    
+    void opMessageBox (Compiler::Generator::CodeContainer& code, int buttons)
+    {
+        code.push_back (segment3 (0, buttons));
+    }
 }
 
 namespace Compiler
@@ -321,6 +331,22 @@ namespace Compiler
         {
             opSquareRoot (code);
         }
+        
+        void exit (CodeContainer& code)
+        {
+            opReturn (code);
+        }        
+        
+        void message (CodeContainer& code, Literals& literals, const std::string& message,
+            int buttons)
+        {
+            assert (buttons==0);
+
+            int index = literals.addString (message);
+            
+            opPushInt (code, index);
+            opMessageBox (code, buttons);
+        }
     }
 }
 
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index 44b0fc4f2..2dd81711e 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -2,6 +2,7 @@
 #define COMPILER_GENERATOR_H_INCLUDED
 
 #include <vector>
+#include <string>
 
 #include <components/interpreter/types.hpp>
 
@@ -33,6 +34,11 @@ namespace Compiler
         void convert (CodeContainer& code, char fromType, char toType);
         
         void squareRoot (CodeContainer& code);
+
+        void exit (CodeContainer& code);        
+        
+        void message (CodeContainer& code, Literals& literals, const std::string& message,
+            int buttons);
     }
 }
 
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 92c9aad57..09ecdb82a 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -76,6 +76,13 @@ namespace Compiler
             return false;            
         }
         
+        if (mState==MessageState || mState==MessageCommaState)
+        {
+            Generator::message (mCode, mLiterals, name, 0);
+            mState = EndState;
+            return false;
+        }
+        
         return Parser::parseName (name, loc, scanner);
     }
 
@@ -89,6 +96,13 @@ namespace Compiler
                 case Scanner::K_long: mState = LongState; return true;
                 case Scanner::K_float: mState = FloatState; return true;
                 case Scanner::K_set: mState = SetState; return true;
+                case Scanner::K_messagebox: mState = MessageState; return true;
+                
+                case Scanner::K_return:
+                
+                    Generator::exit (mCode);
+                    mState = EndState;
+                    return true;
             }
         }
         else if (mState==SetLocalVarState && keyword==Scanner::K_to)
@@ -114,6 +128,12 @@ namespace Compiler
         if (code==Scanner::S_newline && mState==EndState)
             return false;
             
+        if (code==Scanner::S_comma && mState==MessageState)
+        {
+            mState = MessageCommaState;
+            return true;
+        }
+            
         return Parser::parseSpecial (code, loc, scanner);
     }
     
diff --git a/components/compiler/lineparser.hpp b/components/compiler/lineparser.hpp
index e9fae92b7..0af222d86 100644
--- a/components/compiler/lineparser.hpp
+++ b/components/compiler/lineparser.hpp
@@ -22,6 +22,7 @@ namespace Compiler
                 BeginState,
                 ShortState, LongState, FloatState,
                 SetState, SetLocalVarState,
+                MessageState, MessageCommaState,
                 EndState
             };
 
diff --git a/components/compiler/scanner.hpp b/components/compiler/scanner.hpp
index 271639c97..044e02375 100644
--- a/components/compiler/scanner.hpp
+++ b/components/compiler/scanner.hpp
@@ -40,7 +40,7 @@ namespace Compiler
                 K_if, K_endif, K_else, K_elseif,
                 K_while, K_endwhile,
                 K_return,
-                K_messageBox,
+                K_messagebox,
                 K_set, K_to,
                 K_getsquareroot
             };
diff --git a/components/interpreter/context.hpp b/components/interpreter/context.hpp
index 582606c9c..32bde722e 100644
--- a/components/interpreter/context.hpp
+++ b/components/interpreter/context.hpp
@@ -19,7 +19,10 @@ namespace Interpreter
 
             virtual void setLocalLong (int index, int value) = 0;        
 
-            virtual void setLocalFloat (int index, float value) = 0;        
+            virtual void setLocalFloat (int index, float value) = 0;
+            
+            virtual void messageBox (const std::string& message,
+                const std::vector<std::string>& buttons) = 0; 
     };
 }
 
diff --git a/components/interpreter/controlopcodes.hpp b/components/interpreter/controlopcodes.hpp
new file mode 100644
index 000000000..90584decb
--- /dev/null
+++ b/components/interpreter/controlopcodes.hpp
@@ -0,0 +1,20 @@
+#ifndef INTERPRETER_CONTROLOPCODES_H_INCLUDED
+#define INTERPRETER_CONTROLOPCODES_H_INCLUDED
+
+#include "opcodes.hpp"
+#include "runtime.hpp"
+
+namespace Interpreter
+{
+    class OpReturn : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                runtime.setPC (-1);
+            }           
+    };
+}
+
+#endif
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
index 748e6e3ee..c5bc133f7 100644
--- a/components/interpreter/docs/vmformat.txt
+++ b/components/interpreter/docs/vmformat.txt
@@ -43,7 +43,12 @@ opcodes 0-511 unused
 opcodes 512-1023 reserved for extensions
 
 Segment 3:
-opcodes 0-511 unused
+op    0: show message box with message string literal index in stack[0];
+         buttons (if any) in stack[arg0]..stack[1];
+         additional arguments (if any) in stack[arg0+n]..stack[arg0+1];
+         n is determined according to the message string
+         all arguments are removed from stack
+opcodes 1-511 unused
 opcodes 512-1023 reserved for extensions
 
 Segment 4:
@@ -71,6 +76,7 @@ op  16: div (float) stack[1] by stack[0], pop twice, push result
 op  17: convert stack[1] from integer to float
 op  18: convert stack[1] from float to integer
 op  19: take square root of stack[0] (float)
-opcodes 20-33554431 unused
+op  20: return
+opcodes 21-33554431 unused
 opcodes 33554432-67108863 reserved for extensions
 
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
index b96a0a1a5..5836967ed 100644
--- a/components/interpreter/installopcodes.cpp
+++ b/components/interpreter/installopcodes.cpp
@@ -5,6 +5,8 @@
 #include "genericopcodes.hpp"
 #include "localopcodes.hpp"
 #include "mathopcodes.hpp"
+#include "controlopcodes.hpp"
+#include "miscopcodes.hpp"
 
 namespace Interpreter
 {
@@ -36,6 +38,12 @@ namespace Interpreter
         interpreter.installSegment5 (15, new OpDivInt<Type_Integer>);
         interpreter.installSegment5 (16, new OpDivInt<Type_Float>);
         interpreter.installSegment5 (19, new OpSquareRoot);        
+        
+        // control structures
+        interpreter.installSegment5 (20, new OpReturn);        
+        
+        // misc
+        interpreter.installSegment3 (0, new OpMessageBox);        
     }
 }
 
diff --git a/components/interpreter/miscopcodes.hpp b/components/interpreter/miscopcodes.hpp
new file mode 100644
index 000000000..f37620874
--- /dev/null
+++ b/components/interpreter/miscopcodes.hpp
@@ -0,0 +1,31 @@
+#ifndef INTERPRETER_MISCOPCODES_H_INCLUDED
+#define INTERPRETER_MISCOPCODES_H_INCLUDED
+
+#include <stdexcept>
+#include <vector>
+#include <string>
+
+#include "opcodes.hpp"
+#include "runtime.hpp"
+
+namespace Interpreter
+{
+    class OpMessageBox : public Opcode1
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime, unsigned int arg0)
+            {
+                if (arg0!=0)
+                    throw std::logic_error ("message box buttons not implemented yet");
+                    
+                int index = runtime[0];
+                runtime.pop();
+                std::vector<std::string> buttons;
+                runtime.getContext().messageBox (runtime.getStringLiteral (index), buttons);
+            }        
+    };
+}
+
+#endif
+
diff --git a/components/interpreter/runtime.cpp b/components/interpreter/runtime.cpp
index bde4d6b9f..746be60d2 100644
--- a/components/interpreter/runtime.cpp
+++ b/components/interpreter/runtime.cpp
@@ -3,6 +3,7 @@
 
 #include <stdexcept>
 #include <cassert>
+#include <cstring>
 
 namespace Interpreter
 {
@@ -30,6 +31,21 @@ namespace Interpreter
         
         return *reinterpret_cast<const float *> (&literalBlock[index]);
     }
+    
+    std::string Runtime::getStringLiteral (int index) const
+    {
+        assert (index>=0 && index<static_cast<int> (mCode[3]));
+    
+        const char *literalBlock =
+            reinterpret_cast<const char *> (mCode + 4 + mCode[0] + mCode[1] + mCode[2]);
+    
+        for (; index; --index)
+        {
+            literalBlock += std::strlen (literalBlock) + 1;
+        }
+    
+        return literalBlock;
+    }
                     
     void Runtime::configure (const Interpreter::Type_Code *code, int codeSize)
     {    
diff --git a/components/interpreter/runtime.hpp b/components/interpreter/runtime.hpp
index a683a0f0f..73e90f68a 100644
--- a/components/interpreter/runtime.hpp
+++ b/components/interpreter/runtime.hpp
@@ -2,6 +2,7 @@
 #define INTERPRETER_RUNTIME_H_INCLUDED
 
 #include <vector>
+#include <string>
 
 #include "types.hpp"
 
@@ -29,7 +30,9 @@ namespace Interpreter
             int getIntegerLiteral (int index) const;
         
             float getFloatLiteral (int index) const;
-                    
+              
+            std::string getStringLiteral (int index) const;
+                                
             void configure (const Type_Code *code, int codeSize);
             ///< \a context and \a code must exist as least until either configure, clear or
             /// the destructor is called. \a codeSize is given in 32-bit words.

From ed92ffcf89fc4679426044d13936c387cbbafeec Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Wed, 30 Jun 2010 12:46:10 +0200
Subject: [PATCH 33/40] added local variable usage in expressions

---
 components/compiler/exprparser.cpp        | 14 ++++++++
 components/compiler/generator.cpp         | 42 +++++++++++++++++++++++
 components/compiler/generator.hpp         |  2 ++
 components/interpreter/docs/vmformat.txt  |  5 ++-
 components/interpreter/installopcodes.cpp |  7 ++--
 components/interpreter/localopcodes.hpp   | 36 +++++++++++++++++++
 6 files changed, 103 insertions(+), 3 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index ffb6fd336..e780fdd31 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -7,6 +7,7 @@
 #include "generator.hpp"
 #include "scanner.hpp"
 #include "errorhandler.hpp"
+#include "locals.hpp"
 
 namespace Compiler
 {
@@ -212,6 +213,19 @@ namespace Compiler
         Scanner& scanner)
     {
         mFirst = false;
+
+        if (mNextOperand)
+        {    
+            char type = mLocals.getType (name);
+            
+            if (type!=' ')
+            {
+                Generator::fetchLocal (mCode, type, mLocals.getIndex (name));
+                mNextOperand = false;
+                mOperands.push_back (type=='f' ? 'f' : 'l');    
+                return true;    
+            }
+        }
         
         return Parser::parseName (name, loc, scanner);
     }
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index ddbae874a..9a07820db 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -160,6 +160,21 @@ namespace
     {
         code.push_back (segment3 (0, buttons));
     }
+    
+    void opFetchLocalShort (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (21));    
+    }
+    
+    void opFetchLocalLong (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (22));
+    }
+    
+    void opFetchLocalFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (23));
+    }    
 }
 
 namespace Compiler
@@ -347,6 +362,33 @@ namespace Compiler
             opPushInt (code, index);
             opMessageBox (code, buttons);
         }
+        
+        void fetchLocal (CodeContainer& code, char localType, int localIndex)
+        {
+            opPushInt (code, localIndex);
+
+            switch (localType)
+            {
+                case 'f':
+                
+                    opFetchLocalFloat (code);
+                    break;
+                
+                case 's':
+
+                    opFetchLocalShort (code);
+                    break;
+                
+                case 'l':
+
+                    opFetchLocalLong (code);
+                    break;
+            
+                default:
+                
+                    assert (0);
+            }        
+        }
     }
 }
 
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index 2dd81711e..9a5b568ca 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -39,6 +39,8 @@ namespace Compiler
         
         void message (CodeContainer& code, Literals& literals, const std::string& message,
             int buttons);
+            
+        void fetchLocal (CodeContainer& code, char localType, int localIndex);
     }
 }
 
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
index c5bc133f7..ffa906b90 100644
--- a/components/interpreter/docs/vmformat.txt
+++ b/components/interpreter/docs/vmformat.txt
@@ -77,6 +77,9 @@ op  17: convert stack[1] from integer to float
 op  18: convert stack[1] from float to integer
 op  19: take square root of stack[0] (float)
 op  20: return
-opcodes 21-33554431 unused
+op  21: replace stack[0] with local short stack[0]
+op  22: replace stack[0] with local long stack[0]
+op  23: replace stack[0] with local float stack[0]
+opcodes 24-33554431 unused
 opcodes 33554432-67108863 reserved for extensions
 
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
index 5836967ed..63d9e6c3f 100644
--- a/components/interpreter/installopcodes.cpp
+++ b/components/interpreter/installopcodes.cpp
@@ -21,13 +21,16 @@ namespace Interpreter
         interpreter.installSegment5 (17, new OpIntToFloat1);
         interpreter.installSegment5 (18, new OpFloatToInt1);
                     
-        // local variables
+        // local variables & literals
         interpreter.installSegment5 (0, new OpStoreLocalShort);
         interpreter.installSegment5 (1, new OpStoreLocalLong);
         interpreter.installSegment5 (2, new OpStoreLocalFloat);        
         interpreter.installSegment5 (4, new OpFetchIntLiteral);            
         interpreter.installSegment5 (5, new OpFetchFloatLiteral);  
-        
+        interpreter.installSegment5 (21, new OpFetchLocalShort);
+        interpreter.installSegment5 (22, new OpFetchLocalLong);
+        interpreter.installSegment5 (23, new OpFetchLocalFloat); 
+                
         // math
         interpreter.installSegment5 (9, new OpAddInt<Type_Integer>);
         interpreter.installSegment5 (10, new OpAddInt<Type_Float>);
diff --git a/components/interpreter/localopcodes.hpp b/components/interpreter/localopcodes.hpp
index d15635967..4be661d87 100644
--- a/components/interpreter/localopcodes.hpp
+++ b/components/interpreter/localopcodes.hpp
@@ -76,6 +76,42 @@ namespace Interpreter
                 runtime[0] = *reinterpret_cast<Type_Data *> (&floatValue);
             }           
     };     
+    
+    class OpFetchLocalShort : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                int index = runtime[0];           
+                int value = runtime.getContext().getLocalShort (index);
+                runtime[0] = *reinterpret_cast<Type_Data *> (&value);
+            }           
+    };    
+
+    class OpFetchLocalLong : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                int index = runtime[0];           
+                int value = runtime.getContext().getLocalLong (index);
+                runtime[0] = *reinterpret_cast<Type_Data *> (&value);
+            }           
+    };    
+
+    class OpFetchLocalFloat : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                int index = runtime[0];           
+                float value = runtime.getContext().getLocalFloat (index);
+                runtime[0] = *reinterpret_cast<Type_Data *> (&value);
+            }           
+    };    
 }
 
 #endif

From 73f9436ed963433665d2b14dd602f471478bbbcb Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Wed, 30 Jun 2010 14:08:59 +0200
Subject: [PATCH 34/40] fixed round brackets parsing bug

---
 components/compiler/exprparser.cpp | 17 +++++++++++++++--
 components/compiler/exprparser.hpp |  2 ++
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index e780fdd31..e2b68f70f 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -3,6 +3,7 @@
 
 #include <stdexcept>
 #include <cassert>
+#include <algorithm>
 
 #include "generator.hpp"
 #include "scanner.hpp"
@@ -51,6 +52,11 @@ namespace Compiler
         return mOperators[mOperators.size()-1];
     }
 
+    bool ExprParser::isOpen() const
+    {
+        return std::find (mOperators.begin(), mOperators.end(), '(')!=mOperators.end();
+    }
+            
     void ExprParser::popOperator()
     {
         assert (!mOperators.empty());
@@ -293,8 +299,15 @@ namespace Compiler
         
         if (code==Scanner::S_close && !mNextOperand)
         {
-            close();
-            return true;
+            if (isOpen())
+            {
+                close();
+                return true;
+            }
+            
+            mTokenLoc = loc;
+            scanner.putbackSpecial (code, loc);
+            return false;
         }
         
         if (!mNextOperand)
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index 14c530010..47b2151bb 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -30,6 +30,8 @@ namespace Compiler
 
             char getOperator() const;
                 
+            bool isOpen() const;
+                
             void popOperator();
             
             void popOperand();

From 69342f320d6e254ee2e7d05dd259c1cde6d87e45 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Wed, 30 Jun 2010 19:58:25 +0200
Subject: [PATCH 35/40] added if control structure

---
 components/compiler/controlparser.cpp     | 165 ++++++++++++++++++++++
 components/compiler/controlparser.hpp     |  64 +++++++++
 components/compiler/generator.cpp         |  50 +++++++
 components/compiler/generator.hpp         |   6 +
 components/compiler/scriptparser.cpp      |  12 ++
 components/compiler/scriptparser.hpp      |   2 +
 components/interpreter/controlopcodes.hpp |  56 ++++++++
 components/interpreter/docs/vmformat.txt  |  10 +-
 components/interpreter/installopcodes.cpp |   4 +
 9 files changed, 366 insertions(+), 3 deletions(-)
 create mode 100644 components/compiler/controlparser.cpp
 create mode 100644 components/compiler/controlparser.hpp

diff --git a/components/compiler/controlparser.cpp b/components/compiler/controlparser.cpp
new file mode 100644
index 000000000..f34896a62
--- /dev/null
+++ b/components/compiler/controlparser.cpp
@@ -0,0 +1,165 @@
+
+#include "controlparser.hpp"
+
+#include <algorithm>
+#include <iterator>
+
+#include "scanner.hpp"
+#include "generator.hpp"
+
+namespace Compiler
+{
+    ControlParser::ControlParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
+        Literals& literals)
+    : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
+      mLineParser (errorHandler, context, locals, literals, mCodeBlock),
+      mExprParser (errorHandler, context, locals, literals),
+      mState (StartState)
+    {
+    
+    }
+  
+    void ControlParser::appendCode (std::vector<Interpreter::Type_Code>& code) const
+    {
+        std::copy (mCode.begin(), mCode.end(), std::back_inserter (code));
+    }
+    
+    bool ControlParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (mState==StartState)
+        {
+            if (keyword==Scanner::K_if)
+            {
+                mExprParser.reset();
+                scanner.scan (mExprParser);
+
+                mState = IfEndState;
+                return true;
+            }
+        }
+        else if (mState==IfBodyState || mState==IfElseifBodyState || mState==IfElseBodyState)
+        {
+            if (keyword==Scanner::K_endif || keyword==Scanner::K_elseif ||
+                keyword==Scanner::K_else)
+            {
+                std::pair<Codes, Codes> entry;
+
+                if (mState!=IfElseBodyState)             
+                    mExprParser.append (entry.first);
+    
+                std::copy (mCodeBlock.begin(), mCodeBlock.end(),
+                    std::back_inserter (entry.second));
+                    
+                mIfCode.push_back (entry);
+
+                mCodeBlock.clear();
+                
+                if (keyword==Scanner::K_endif)
+                {
+                    // store code for if-cascade
+                    Codes codes;
+                    
+                    for (IfCodes::reverse_iterator iter (mIfCode.rbegin());
+                        iter!=mIfCode.rend(); ++iter)
+                    {
+                        Codes block;
+
+                        if (iter!=mIfCode.rbegin())
+                            Generator::jump (iter->second, codes.size()+1);
+
+                        if (!iter->first.empty())
+                        {
+                            // if or elseif
+                            std::copy (iter->first.begin(), iter->first.end(),
+                                std::back_inserter (block));
+                            Generator::jumpOnZero (block, iter->second.size()+1);
+                        }
+                        
+                        std::copy (iter->second.begin(), iter->second.end(),
+                            std::back_inserter (block));
+                       
+                       std::swap (codes, block);
+                       
+                       std::copy (block.begin(), block.end(), std::back_inserter (codes));
+                    }
+                    
+                    std::copy (codes.begin(), codes.end(), std::back_inserter (mCode));
+                    
+                    mIfCode.clear();
+                    mState = IfEndifState;
+                }
+                else if (keyword==Scanner::K_elseif)
+                {
+                    mExprParser.reset();
+                    scanner.scan (mExprParser);
+
+                    mState = IfElseifEndState;            
+                }
+                else if (keyword==Scanner::K_else)
+                {
+                    mState = IfElseEndState;            
+                }                
+                
+                return true;
+            }
+            else if (keyword==Scanner::K_if || keyword==Scanner::K_while)
+            {
+                // nested
+                ControlParser parser (getErrorHandler(), getContext(), mLocals, mLiterals);
+                
+                if (parser.parseKeyword (keyword, loc, scanner))
+                    scanner.scan (parser);  
+                    
+                parser.appendCode (mCodeBlock);                    
+                    
+                return true;
+            }
+            else
+            {
+                mLineParser.reset();
+                if (mLineParser.parseKeyword (keyword, loc, scanner))
+                    scanner.scan (mLineParser);      
+                    
+                return true;      
+            }
+        }
+        
+        return Parser::parseKeyword (keyword, loc, scanner);
+    }
+
+    bool ControlParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (code==Scanner::S_newline)
+        {
+            switch (mState)
+            {
+                case IfEndState: mState = IfBodyState; return true;
+                case IfElseifEndState: mState = IfElseifBodyState; return true;
+                case IfElseEndState: mState = IfElseBodyState; return true;
+                
+                case IfBodyState:
+                case IfElseifBodyState:
+                case IfElseBodyState:
+                    return true; // empty line
+            
+                case IfEndifState:
+                
+                    return false;
+                    
+                default: ;
+            }
+        
+        }
+    
+        return Parser::parseSpecial (code, loc, scanner);
+    }
+
+    void ControlParser::reset()
+    {
+        mCode.clear();
+        mCodeBlock.clear();
+        mIfCode.clear();
+        mState = StartState;
+    }
+}
+
diff --git a/components/compiler/controlparser.hpp b/components/compiler/controlparser.hpp
new file mode 100644
index 000000000..ef244ea50
--- /dev/null
+++ b/components/compiler/controlparser.hpp
@@ -0,0 +1,64 @@
+#ifndef COMPILER_CONTROLPARSER_H_INCLUDED
+#define COMPILER_CONTROLPARSER_H_INCLUDED
+
+#include <vector>
+
+#include <components/interpreter/types.hpp>
+
+#include "parser.hpp"
+#include "exprparser.hpp"
+#include "lineparser.hpp"
+
+namespace Compiler
+{
+    class Locals;
+    class Literals;
+    
+    // Control structure parser
+    
+    class ControlParser : public Parser
+    {
+            enum State
+            {
+                StartState,
+                IfState, IfEndState, IfBodyState,
+                IfElseifEndState, IfElseifBodyState,
+                IfElseEndState, IfElseBodyState,
+                IfEndifState
+            };
+            
+            typedef std::vector<Interpreter::Type_Code> Codes;
+            typedef std::vector<std::pair<Codes, Codes> > IfCodes;
+            
+            Locals& mLocals;  
+            Literals& mLiterals;    
+            Codes mCode;
+            Codes mCodeBlock;
+            IfCodes mIfCode; // condition, body
+            LineParser mLineParser;
+            ExprParser mExprParser;
+            State mState;
+                
+        public:
+        
+            ControlParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
+                Literals& literals);
+
+            void appendCode (std::vector<Interpreter::Type_Code>& code) const;
+            ///< store generated code in \æ code.
+
+            virtual bool parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a keyword token.
+            /// \return fetch another token?
+
+            virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+
+            void reset();
+            ///< Reset parser to clean state.
+    };
+}
+
+#endif
+
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index 9a07820db..d587c2982 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -175,6 +175,26 @@ namespace
     {
         code.push_back (segment5 (23));
     }    
+
+    void opJumpForward (Compiler::Generator::CodeContainer& code, int offset)
+    {
+        code.push_back (segment0 (1, offset));
+    }
+
+    void opJumpBackward (Compiler::Generator::CodeContainer& code, int offset)
+    {
+        code.push_back (segment0 (2, offset));
+    }
+    
+    void opSkipOnZero (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (24));
+    }      
+    
+    void opSkipOnNonZero (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (25));
+    }      
 }
 
 namespace Compiler
@@ -389,6 +409,36 @@ namespace Compiler
                     assert (0);
             }        
         }
+        
+        void jump (CodeContainer& code, int offset)
+        {
+            if (offset>0)
+                opJumpForward (code, offset);
+            else if (offset<0)
+                opJumpBackward (code, offset);
+            else
+                throw std::logic_error ("inifite loop");
+        }
+                
+        void jumpOnZero (CodeContainer& code, int offset)
+        {
+            opSkipOnNonZero (code);
+            
+            if (offset<0)
+                --offset; // compensate for skip instruction
+            
+            jump (code, offset);
+        }
+
+        void jumpOnNonZero (CodeContainer& code, int offset)
+        {
+            opSkipOnZero (code);
+            
+            if (offset<0)
+                --offset; // compensate for skip instruction
+            
+            jump (code, offset);            
+        }
     }
 }
 
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index 9a5b568ca..7d1f52df4 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -41,6 +41,12 @@ namespace Compiler
             int buttons);
             
         void fetchLocal (CodeContainer& code, char localType, int localIndex);
+
+        void jump (CodeContainer& code, int offset);
+         
+        void jumpOnZero (CodeContainer& code, int offset);
+        
+        void jumpOnNonZero (CodeContainer& code, int offset);
     }
 }
 
diff --git a/components/compiler/scriptparser.cpp b/components/compiler/scriptparser.cpp
index d3d32af89..ce142847f 100644
--- a/components/compiler/scriptparser.cpp
+++ b/components/compiler/scriptparser.cpp
@@ -9,6 +9,7 @@ namespace Compiler
         Locals& locals, bool end)
     : Parser (errorHandler, context), mOutput (locals),
       mLineParser (errorHandler, context, locals, mOutput.getLiterals(), mOutput.getCode()),
+      mControlParser (errorHandler, context, locals, mOutput.getLiterals()),
       mEnd (end)
     {}
 
@@ -29,6 +30,17 @@ namespace Compiler
 
     bool ScriptParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
     {
+        if (keyword==Scanner::K_while || keyword==Scanner::K_if)
+        {
+            mControlParser.reset();
+            if (mControlParser.parseKeyword (keyword, loc, scanner))
+                scanner.scan (mControlParser);   
+        
+            mControlParser.appendCode (mOutput.getCode());
+        
+            return true;
+        }
+    
         if (keyword==Scanner::K_end && mEnd)
         {
             return false;
diff --git a/components/compiler/scriptparser.hpp b/components/compiler/scriptparser.hpp
index dd4e38511..bb4809dab 100644
--- a/components/compiler/scriptparser.hpp
+++ b/components/compiler/scriptparser.hpp
@@ -4,6 +4,7 @@
 
 #include "parser.hpp"
 #include "lineparser.hpp"
+#include "controlparser.hpp"
 #include "output.hpp"
 
 namespace Compiler
@@ -16,6 +17,7 @@ namespace Compiler
     {
             Output mOutput;
             LineParser mLineParser;
+            ControlParser mControlParser;
             bool mEnd;
 
         public:
diff --git a/components/interpreter/controlopcodes.hpp b/components/interpreter/controlopcodes.hpp
index 90584decb..cf9185a69 100644
--- a/components/interpreter/controlopcodes.hpp
+++ b/components/interpreter/controlopcodes.hpp
@@ -1,6 +1,8 @@
 #ifndef INTERPRETER_CONTROLOPCODES_H_INCLUDED
 #define INTERPRETER_CONTROLOPCODES_H_INCLUDED
 
+#include <stdexcept>
+
 #include "opcodes.hpp"
 #include "runtime.hpp"
 
@@ -15,6 +17,60 @@ namespace Interpreter
                 runtime.setPC (-1);
             }           
     };
+    
+    class OpSkipZero : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Data data = runtime[0];
+                runtime.pop();
+                
+                if (data==0)
+                    runtime.setPC (runtime.getPC()+1);
+            }           
+    };    
+    
+    class OpSkipNonZero : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                Type_Data data = runtime[0];
+                runtime.pop();
+                
+                if (data!=0)
+                    runtime.setPC (runtime.getPC()+1);
+            }           
+    };      
+    
+    class OpJumpForward : public Opcode1
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime, unsigned int arg0)
+            {
+                if (arg0==0)
+                    throw std::logic_error ("inifite loop");
+                
+                runtime.setPC (runtime.getPC()+arg0-1);
+            }           
+    };        
+
+    class OpJumpBackward : public Opcode1
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime, unsigned int arg0)
+            {
+                if (arg0==0)
+                    throw std::logic_error ("inifite loop");
+                
+                runtime.setPC (runtime.getPC()-arg0-1);
+            }           
+    };        
 }
 
 #endif
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
index ffa906b90..4cd6b6608 100644
--- a/components/interpreter/docs/vmformat.txt
+++ b/components/interpreter/docs/vmformat.txt
@@ -30,8 +30,10 @@ A: argument 0
 B: argument 1
 
 Segment 0:
-op  0: push A
-opcodes 1-31 unused
+op  0: push arg0
+op  1: move pv ahead by arg0
+op  2: move pv back by arg0
+opcodes 3-31 unused
 opcodes 32-63 reserved for extensions
 
 Segment 1:
@@ -80,6 +82,8 @@ op  20: return
 op  21: replace stack[0] with local short stack[0]
 op  22: replace stack[0] with local long stack[0]
 op  23: replace stack[0] with local float stack[0]
-opcodes 24-33554431 unused
+op  24: skip next instruction if stack[0]==0; pop
+op  25: skip next instruction if stack[0]!=0; pop
+opcodes 26-33554431 unused
 opcodes 33554432-67108863 reserved for extensions
 
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
index 63d9e6c3f..5066fd5a0 100644
--- a/components/interpreter/installopcodes.cpp
+++ b/components/interpreter/installopcodes.cpp
@@ -44,6 +44,10 @@ namespace Interpreter
         
         // control structures
         interpreter.installSegment5 (20, new OpReturn);        
+        interpreter.installSegment5 (24, new OpSkipZero);
+        interpreter.installSegment5 (25, new OpSkipNonZero);
+        interpreter.installSegment0 (1, new OpJumpForward);
+        interpreter.installSegment0 (2, new OpJumpBackward);
         
         // misc
         interpreter.installSegment3 (0, new OpMessageBox);        

From 46fab68d4433e797db26d2aca50f330717f530a1 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Thu, 1 Jul 2010 10:42:49 +0200
Subject: [PATCH 36/40] implemented while loops

---
 components/compiler/controlparser.cpp | 69 +++++++++++++++++++++++++++
 components/compiler/controlparser.hpp |  6 ++-
 components/compiler/generator.cpp     |  2 +-
 3 files changed, 74 insertions(+), 3 deletions(-)

diff --git a/components/compiler/controlparser.cpp b/components/compiler/controlparser.cpp
index f34896a62..3425d2bbf 100644
--- a/components/compiler/controlparser.cpp
+++ b/components/compiler/controlparser.cpp
@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <iterator>
+#include <stdexcept>
 
 #include "scanner.hpp"
 #include "generator.hpp"
@@ -36,6 +37,14 @@ namespace Compiler
                 mState = IfEndState;
                 return true;
             }
+            else if (keyword==Scanner::K_while)
+            {
+                mExprParser.reset();
+                scanner.scan (mExprParser);
+
+                mState = WhileEndState;
+                return true;            
+            }
         }
         else if (mState==IfBodyState || mState==IfElseifBodyState || mState==IfElseBodyState)
         {
@@ -123,6 +132,61 @@ namespace Compiler
                 return true;      
             }
         }
+        else if (mState==WhileBodyState)
+        {
+            if (keyword==Scanner::K_endwhile)
+            {
+                Codes loop;
+                
+                Codes expr;
+                mExprParser.append (expr);
+                
+                Generator::jump (loop, -mCodeBlock.size()-expr.size());
+            
+                std::copy (expr.begin(), expr.end(), std::back_inserter (mCode));
+
+                Codes skip;
+                
+                Generator::jumpOnZero (skip, mCodeBlock.size()+loop.size()+1);
+                
+                std::copy (skip.begin(), skip.end(), std::back_inserter (mCode));
+                
+                std::copy (mCodeBlock.begin(), mCodeBlock.end(), std::back_inserter (mCode));
+                
+                Codes loop2;
+            
+                Generator::jump (loop2, -mCodeBlock.size()-expr.size()-skip.size());
+
+                if (loop.size()!=loop2.size())
+                    throw std::logic_error (
+                        "internal compiler error: failed to generate a while loop");
+
+                std::copy (loop2.begin(), loop2.end(), std::back_inserter (mCode));
+            
+                mState = WhileEndwhileState;
+                return true;    
+            }
+            else if (keyword==Scanner::K_if || keyword==Scanner::K_while)
+            {
+                // nested
+                ControlParser parser (getErrorHandler(), getContext(), mLocals, mLiterals);
+                
+                if (parser.parseKeyword (keyword, loc, scanner))
+                    scanner.scan (parser);  
+                    
+                parser.appendCode (mCodeBlock);                    
+                    
+                return true;
+            }
+            else
+            {
+                mLineParser.reset();
+                if (mLineParser.parseKeyword (keyword, loc, scanner))
+                    scanner.scan (mLineParser);      
+                    
+                return true;      
+            }        
+        }
         
         return Parser::parseKeyword (keyword, loc, scanner);
     }
@@ -136,13 +200,18 @@ namespace Compiler
                 case IfEndState: mState = IfBodyState; return true;
                 case IfElseifEndState: mState = IfElseifBodyState; return true;
                 case IfElseEndState: mState = IfElseBodyState; return true;
+
+                case WhileEndState: mState = WhileBodyState; return true;
                 
                 case IfBodyState:
                 case IfElseifBodyState:
                 case IfElseBodyState:
+                case WhileBodyState:
+                
                     return true; // empty line
             
                 case IfEndifState:
+                case WhileEndwhileState:
                 
                     return false;
                     
diff --git a/components/compiler/controlparser.hpp b/components/compiler/controlparser.hpp
index ef244ea50..1af9a2ca9 100644
--- a/components/compiler/controlparser.hpp
+++ b/components/compiler/controlparser.hpp
@@ -21,10 +21,12 @@ namespace Compiler
             enum State
             {
                 StartState,
-                IfState, IfEndState, IfBodyState,
+                IfEndState, IfBodyState,
                 IfElseifEndState, IfElseifBodyState,
                 IfElseEndState, IfElseBodyState,
-                IfEndifState
+                IfEndifState,
+                WhileEndState, WhileBodyState,
+                WhileEndwhileState
             };
             
             typedef std::vector<Interpreter::Type_Code> Codes;
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index d587c2982..f540f3314 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -415,7 +415,7 @@ namespace Compiler
             if (offset>0)
                 opJumpForward (code, offset);
             else if (offset<0)
-                opJumpBackward (code, offset);
+                opJumpBackward (code, -offset);
             else
                 throw std::logic_error ("inifite loop");
         }

From bf55880ce96f398a0a2a9f944f8108dcebce0071 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Thu, 1 Jul 2010 10:47:29 +0200
Subject: [PATCH 37/40] a bit of refactoring

---
 components/compiler/controlparser.cpp | 284 ++++++++++++++------------
 components/compiler/controlparser.hpp |   4 +
 2 files changed, 154 insertions(+), 134 deletions(-)

diff --git a/components/compiler/controlparser.cpp b/components/compiler/controlparser.cpp
index 3425d2bbf..4715d3214 100644
--- a/components/compiler/controlparser.cpp
+++ b/components/compiler/controlparser.cpp
@@ -10,6 +10,153 @@
 
 namespace Compiler
 {
+    bool ControlParser::parseIfBody (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (keyword==Scanner::K_endif || keyword==Scanner::K_elseif ||
+            keyword==Scanner::K_else)
+        {
+            std::pair<Codes, Codes> entry;
+
+            if (mState!=IfElseBodyState)             
+                mExprParser.append (entry.first);
+
+            std::copy (mCodeBlock.begin(), mCodeBlock.end(),
+                std::back_inserter (entry.second));
+                
+            mIfCode.push_back (entry);
+
+            mCodeBlock.clear();
+            
+            if (keyword==Scanner::K_endif)
+            {
+                // store code for if-cascade
+                Codes codes;
+                
+                for (IfCodes::reverse_iterator iter (mIfCode.rbegin());
+                    iter!=mIfCode.rend(); ++iter)
+                {
+                    Codes block;
+
+                    if (iter!=mIfCode.rbegin())
+                        Generator::jump (iter->second, codes.size()+1);
+
+                    if (!iter->first.empty())
+                    {
+                        // if or elseif
+                        std::copy (iter->first.begin(), iter->first.end(),
+                            std::back_inserter (block));
+                        Generator::jumpOnZero (block, iter->second.size()+1);
+                    }
+                    
+                    std::copy (iter->second.begin(), iter->second.end(),
+                        std::back_inserter (block));
+                   
+                   std::swap (codes, block);
+                   
+                   std::copy (block.begin(), block.end(), std::back_inserter (codes));
+                }
+                
+                std::copy (codes.begin(), codes.end(), std::back_inserter (mCode));
+                
+                mIfCode.clear();
+                mState = IfEndifState;
+            }
+            else if (keyword==Scanner::K_elseif)
+            {
+                mExprParser.reset();
+                scanner.scan (mExprParser);
+
+                mState = IfElseifEndState;            
+            }
+            else if (keyword==Scanner::K_else)
+            {
+                mState = IfElseEndState;            
+            }                
+            
+            return true;
+        }
+        else if (keyword==Scanner::K_if || keyword==Scanner::K_while)
+        {
+            // nested
+            ControlParser parser (getErrorHandler(), getContext(), mLocals, mLiterals);
+            
+            if (parser.parseKeyword (keyword, loc, scanner))
+                scanner.scan (parser);  
+                
+            parser.appendCode (mCodeBlock);                    
+                
+            return true;
+        }
+        else
+        {
+            mLineParser.reset();
+            if (mLineParser.parseKeyword (keyword, loc, scanner))
+                scanner.scan (mLineParser);      
+                
+            return true;      
+        }    
+        
+        return false;
+    }
+
+    bool ControlParser::parseWhileBody (int keyword, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (keyword==Scanner::K_endwhile)
+        {
+            Codes loop;
+            
+            Codes expr;
+            mExprParser.append (expr);
+            
+            Generator::jump (loop, -mCodeBlock.size()-expr.size());
+        
+            std::copy (expr.begin(), expr.end(), std::back_inserter (mCode));
+
+            Codes skip;
+            
+            Generator::jumpOnZero (skip, mCodeBlock.size()+loop.size()+1);
+            
+            std::copy (skip.begin(), skip.end(), std::back_inserter (mCode));
+            
+            std::copy (mCodeBlock.begin(), mCodeBlock.end(), std::back_inserter (mCode));
+            
+            Codes loop2;
+        
+            Generator::jump (loop2, -mCodeBlock.size()-expr.size()-skip.size());
+
+            if (loop.size()!=loop2.size())
+                throw std::logic_error (
+                    "internal compiler error: failed to generate a while loop");
+
+            std::copy (loop2.begin(), loop2.end(), std::back_inserter (mCode));
+        
+            mState = WhileEndwhileState;
+            return true;    
+        }
+        else if (keyword==Scanner::K_if || keyword==Scanner::K_while)
+        {
+            // nested
+            ControlParser parser (getErrorHandler(), getContext(), mLocals, mLiterals);
+            
+            if (parser.parseKeyword (keyword, loc, scanner))
+                scanner.scan (parser);  
+                
+            parser.appendCode (mCodeBlock);                    
+                
+            return true;
+        }
+        else
+        {
+            mLineParser.reset();
+            if (mLineParser.parseKeyword (keyword, loc, scanner))
+                scanner.scan (mLineParser);      
+                
+            return true;      
+        }            
+        
+        return false;
+    }
+
     ControlParser::ControlParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
         Literals& literals)
     : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
@@ -48,144 +195,13 @@ namespace Compiler
         }
         else if (mState==IfBodyState || mState==IfElseifBodyState || mState==IfElseBodyState)
         {
-            if (keyword==Scanner::K_endif || keyword==Scanner::K_elseif ||
-                keyword==Scanner::K_else)
-            {
-                std::pair<Codes, Codes> entry;
-
-                if (mState!=IfElseBodyState)             
-                    mExprParser.append (entry.first);
-    
-                std::copy (mCodeBlock.begin(), mCodeBlock.end(),
-                    std::back_inserter (entry.second));
-                    
-                mIfCode.push_back (entry);
-
-                mCodeBlock.clear();
-                
-                if (keyword==Scanner::K_endif)
-                {
-                    // store code for if-cascade
-                    Codes codes;
-                    
-                    for (IfCodes::reverse_iterator iter (mIfCode.rbegin());
-                        iter!=mIfCode.rend(); ++iter)
-                    {
-                        Codes block;
-
-                        if (iter!=mIfCode.rbegin())
-                            Generator::jump (iter->second, codes.size()+1);
-
-                        if (!iter->first.empty())
-                        {
-                            // if or elseif
-                            std::copy (iter->first.begin(), iter->first.end(),
-                                std::back_inserter (block));
-                            Generator::jumpOnZero (block, iter->second.size()+1);
-                        }
-                        
-                        std::copy (iter->second.begin(), iter->second.end(),
-                            std::back_inserter (block));
-                       
-                       std::swap (codes, block);
-                       
-                       std::copy (block.begin(), block.end(), std::back_inserter (codes));
-                    }
-                    
-                    std::copy (codes.begin(), codes.end(), std::back_inserter (mCode));
-                    
-                    mIfCode.clear();
-                    mState = IfEndifState;
-                }
-                else if (keyword==Scanner::K_elseif)
-                {
-                    mExprParser.reset();
-                    scanner.scan (mExprParser);
-
-                    mState = IfElseifEndState;            
-                }
-                else if (keyword==Scanner::K_else)
-                {
-                    mState = IfElseEndState;            
-                }                
-                
-                return true;
-            }
-            else if (keyword==Scanner::K_if || keyword==Scanner::K_while)
-            {
-                // nested
-                ControlParser parser (getErrorHandler(), getContext(), mLocals, mLiterals);
-                
-                if (parser.parseKeyword (keyword, loc, scanner))
-                    scanner.scan (parser);  
-                    
-                parser.appendCode (mCodeBlock);                    
-                    
-                return true;
-            }
-            else
-            {
-                mLineParser.reset();
-                if (mLineParser.parseKeyword (keyword, loc, scanner))
-                    scanner.scan (mLineParser);      
-                    
-                return true;      
-            }
+            if (parseIfBody (keyword, loc, scanner))
+                return true;            
         }
         else if (mState==WhileBodyState)
         {
-            if (keyword==Scanner::K_endwhile)
-            {
-                Codes loop;
-                
-                Codes expr;
-                mExprParser.append (expr);
-                
-                Generator::jump (loop, -mCodeBlock.size()-expr.size());
-            
-                std::copy (expr.begin(), expr.end(), std::back_inserter (mCode));
-
-                Codes skip;
-                
-                Generator::jumpOnZero (skip, mCodeBlock.size()+loop.size()+1);
-                
-                std::copy (skip.begin(), skip.end(), std::back_inserter (mCode));
-                
-                std::copy (mCodeBlock.begin(), mCodeBlock.end(), std::back_inserter (mCode));
-                
-                Codes loop2;
-            
-                Generator::jump (loop2, -mCodeBlock.size()-expr.size()-skip.size());
-
-                if (loop.size()!=loop2.size())
-                    throw std::logic_error (
-                        "internal compiler error: failed to generate a while loop");
-
-                std::copy (loop2.begin(), loop2.end(), std::back_inserter (mCode));
-            
-                mState = WhileEndwhileState;
-                return true;    
-            }
-            else if (keyword==Scanner::K_if || keyword==Scanner::K_while)
-            {
-                // nested
-                ControlParser parser (getErrorHandler(), getContext(), mLocals, mLiterals);
-                
-                if (parser.parseKeyword (keyword, loc, scanner))
-                    scanner.scan (parser);  
-                    
-                parser.appendCode (mCodeBlock);                    
-                    
+            if ( parseWhileBody (keyword, loc, scanner))
                 return true;
-            }
-            else
-            {
-                mLineParser.reset();
-                if (mLineParser.parseKeyword (keyword, loc, scanner))
-                    scanner.scan (mLineParser);      
-                    
-                return true;      
-            }        
         }
         
         return Parser::parseKeyword (keyword, loc, scanner);
diff --git a/components/compiler/controlparser.hpp b/components/compiler/controlparser.hpp
index 1af9a2ca9..17b3137c7 100644
--- a/components/compiler/controlparser.hpp
+++ b/components/compiler/controlparser.hpp
@@ -41,6 +41,10 @@ namespace Compiler
             ExprParser mExprParser;
             State mState;
                 
+            bool parseIfBody (int keyword, const TokenLoc& loc, Scanner& scanner);
+
+            bool parseWhileBody (int keyword, const TokenLoc& loc, Scanner& scanner);
+                
         public:
         
             ControlParser (ErrorHandler& errorHandler, Context& context, Locals& locals,

From 1674d406dcae70f91b4d960e0811e63e150f5f54 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Thu, 1 Jul 2010 11:07:21 +0200
Subject: [PATCH 38/40] made usage of comma as argument separator optional
 (largely untested, because we don't have anything that takes more than one
 argument)

---
 components/compiler/exprparser.cpp | 66 ++++++++++++++++++++++--------
 components/compiler/scanner.cpp    | 51 ++++++++++++++++++++++-
 components/compiler/scanner.hpp    | 19 ++++++++-
 3 files changed, 116 insertions(+), 20 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index e2b68f70f..4b572b6b1 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -197,8 +197,12 @@ namespace Compiler
             mTokenLoc = loc;
             return true;
         }
-        
-        return Parser::parseInt (value, loc, scanner);
+        else
+        {
+            // no comma was used between arguments
+            scanner.putbackInt (value, loc);
+            return false;
+        }
     }
 
     bool ExprParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
@@ -211,8 +215,12 @@ namespace Compiler
             mTokenLoc = loc;
             return true;
         }            
-            
-        return Parser::parseFloat (value, loc, scanner);
+        else
+        {
+            // no comma was used between arguments
+            scanner.putbackFloat (value, loc);
+            return false;
+        }
     }
 
     bool ExprParser::parseName (const std::string& name, const TokenLoc& loc,
@@ -232,6 +240,12 @@ namespace Compiler
                 return true;    
             }
         }
+        else
+        {
+            // no comma was used between arguments
+            scanner.putbackName (name, loc);
+            return false;
+        }
         
         return Parser::parseName (name, loc, scanner);
     }
@@ -239,16 +253,25 @@ namespace Compiler
     bool ExprParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
     {
         mFirst = false;
-        
-        if (keyword==Scanner::K_getsquareroot && mNextOperand)
-        {
-            mTokenLoc = loc;        
-            parseArguments ("f", scanner);
 
-            Generator::squareRoot (mCode);
-            
-            mNextOperand = false;
-            return true;
+        if (mNextOperand)
+        {        
+            if (keyword==Scanner::K_getsquareroot)
+            {
+                mTokenLoc = loc;        
+                parseArguments ("f", scanner);
+
+                Generator::squareRoot (mCode);
+                
+                mNextOperand = false;
+                return true;
+            }
+        }
+        else
+        {
+            // no comma was used between arguments
+            scanner.putbackKeyword (keyword, loc);
+            return false;
         }
         
         return Parser::parseKeyword (keyword, loc, scanner);
@@ -290,11 +313,20 @@ namespace Compiler
             return true;
         }
         
-        if (code==Scanner::S_open && mNextOperand)
+        if (code==Scanner::S_open)
         {
-            mOperators.push_back ('(');
-            mTokenLoc = loc;
-            return true;
+            if (mNextOperand)
+            {
+                mOperators.push_back ('(');
+                mTokenLoc = loc;
+                return true;
+            }
+            else
+            {
+                // no comma was used between arguments
+                scanner.putbackKeyword (code, loc);
+                return false;
+            }
         }
         
         if (code==Scanner::S_close && !mNextOperand)
diff --git a/components/compiler/scanner.cpp b/components/compiler/scanner.cpp
index a8514f956..e4869cba5 100644
--- a/components/compiler/scanner.cpp
+++ b/components/compiler/scanner.cpp
@@ -46,10 +46,29 @@ namespace Compiler
         switch (mPutback)
         {
             case Putback_Special:
-            {            
+           
                 mPutback = Putback_None;            
                 return parser.parseSpecial (mPutbackCode, mPutbackLoc, *this);
-            }
+            
+            case Putback_Integer:
+
+                mPutback = Putback_None;
+                return parser.parseInt (mPutbackInteger, mPutbackLoc, *this);
+            
+            case Putback_Float:
+
+                mPutback = Putback_None;
+                return parser.parseFloat (mPutbackFloat, mPutbackLoc, *this);
+                       
+            case Putback_Name:
+            
+                mPutback = Putback_None;
+                return parser.parseName (mPutbackName, mPutbackLoc, *this);
+            
+            case Putback_Keyword:
+
+                mPutback = Putback_None;
+                return parser.parseKeyword (mPutbackCode, mPutbackLoc, *this);
             
             case Putback_None:
             
@@ -441,5 +460,33 @@ namespace Compiler
         mPutbackCode = code;
         mPutbackLoc = loc;    
     }
+    
+    void Scanner::putbackInt (int value, const TokenLoc& loc)
+    {
+        mPutback = Putback_Integer;
+        mPutbackInteger = value;
+        mPutbackLoc = loc;    
+    }   
+
+    void Scanner::putbackFloat (float value, const TokenLoc& loc)
+    {
+        mPutback = Putback_Float;
+        mPutbackFloat = value;
+        mPutbackLoc = loc;    
+    }   
+
+    void Scanner::putbackName (const std::string& name, const TokenLoc& loc)
+    {
+        mPutback = Putback_Name;
+        mPutbackName = name;
+        mPutbackLoc = loc;    
+    }   
+
+    void Scanner::putbackKeyword (int keyword, const TokenLoc& loc)
+    {
+        mPutback = Putback_Keyword;
+        mPutbackCode = keyword;
+        mPutbackLoc = loc;    
+    }   
 }
 
diff --git a/components/compiler/scanner.hpp b/components/compiler/scanner.hpp
index 044e02375..2dd13d5df 100644
--- a/components/compiler/scanner.hpp
+++ b/components/compiler/scanner.hpp
@@ -20,7 +20,8 @@ namespace Compiler
     {
             enum putback_type
             {
-                Putback_None, Putback_Special,
+                Putback_None, Putback_Special, Putback_Integer, Putback_Float,
+                Putback_Name, Putback_Keyword
             };
     
             ErrorHandler& mErrorHandler;
@@ -29,6 +30,9 @@ namespace Compiler
             std::istream& mStream;
             putback_type mPutback;
             int mPutbackCode;
+            int mPutbackInteger;
+            float mPutbackFloat;
+            std::string mPutbackName;
             TokenLoc mPutbackLoc;
 
         public:
@@ -90,6 +94,19 @@ namespace Compiler
 
             void putbackSpecial (int code, const TokenLoc& loc); 
             ///< put back a special token
+
+            void putbackInt (int value, const TokenLoc& loc); 
+            ///< put back an integer token            
+
+            void putbackFloat (float value, const TokenLoc& loc); 
+            ///< put back a float token            
+
+            void putbackName (const std::string& name, const TokenLoc& loc); 
+            ///< put back a name toekn
+
+            void putbackKeyword (int keyword, const TokenLoc& loc); 
+            ///< put back a keyword token
+            
     };
 }
 

From aeb41105c4b787cbed84218f6aa93623d4c294e3 Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Thu, 1 Jul 2010 12:19:52 +0200
Subject: [PATCH 39/40] added comparison operators

---
 components/compiler/exprparser.cpp        |  56 ++++++++++--
 components/compiler/exprparser.hpp        |   5 +-
 components/compiler/generator.cpp         | 102 ++++++++++++++++++++++
 components/compiler/generator.hpp         |   2 +
 components/interpreter/docs/vmformat.txt  |  14 ++-
 components/interpreter/installopcodes.cpp |  31 ++++++-
 components/interpreter/mathopcodes.hpp    |  17 ++++
 7 files changed, 217 insertions(+), 10 deletions(-)

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index 4b572b6b1..b1522d99a 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -20,19 +20,28 @@ namespace Compiler
             
                 return 0;
             
+            case 'e': // ==
+            case 'n': // !=
+            case 'l': // <
+            case 'L': // <=
+            case 'g': // <
+            case 'G': // >=
+            
+                return 1;
+            
             case '+':
             case '-':
             
-                return 1;
+                return 2;
         
             case '*':
             case '/':
             
-                return 2;
+                return 3;
                 
             case 'm':
             
-                return 3;
+                return 4;
         }
     
         return 0;
@@ -125,6 +134,20 @@ namespace Compiler
                 replaceBinaryOperands();
                 break;
                             
+            case 'e':
+            case 'n':
+            case 'l':
+            case 'L':
+            case 'g':
+            case 'G':
+            
+                Generator::compare (mCode, op, getOperandType (1), getOperandType());
+                popOperator();
+                popOperand();
+                popOperand();
+                mOperands.push_back ('l');
+                break;
+                            
             default:
             
                 throw std::logic_error ("unknown operator");
@@ -164,7 +187,7 @@ namespace Compiler
             
     void ExprParser::parseArguments (const std::string& arguments, Scanner& scanner)
     {
-        ExprParser parser (getErrorHandler(), getContext(), mLocals, mLiterals);
+        ExprParser parser (getErrorHandler(), getContext(), mLocals, mLiterals, true);
         
         for (std::string::const_iterator iter (arguments.begin()); iter!=arguments.end();
             ++iter)
@@ -182,9 +205,9 @@ namespace Compiler
     }
             
     ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
-        Literals& literals)
+        Literals& literals, bool argument)
     : Parser (errorHandler, context), mLocals (locals), mLiterals (literals),
-      mNextOperand (true), mFirst (true)
+      mNextOperand (true), mFirst (true), mArgument (argument)
     {}
 
     bool ExprParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
@@ -345,6 +368,7 @@ namespace Compiler
         if (!mNextOperand)
         {
             mTokenLoc = loc;
+            char c = 0; // comparison
    
             switch (code)
             {
@@ -352,6 +376,26 @@ namespace Compiler
                 case Scanner::S_minus: pushBinaryOperator ('-'); return true;
                 case Scanner::S_mult: pushBinaryOperator ('*'); return true;
                 case Scanner::S_div: pushBinaryOperator ('/'); return true;
+                case Scanner::S_cmpEQ: c = 'e'; break;
+                case Scanner::S_cmpNE: c = 'n'; break;
+                case Scanner::S_cmpLT: c = 'l'; break;
+                case Scanner::S_cmpLE: c = 'L'; break;
+                case Scanner::S_cmpGT: c = 'g'; break;
+                case Scanner::S_cmpGE: c = 'G'; break;
+            }
+            
+            if (c)
+            {
+                if (mArgument && !isOpen())
+                {
+                    // expression ends here
+                    // Thank you Morrowind for this rotten syntax :(
+                    scanner.putbackSpecial (code, loc);
+                    return false;
+                }
+            
+                pushBinaryOperator (c);
+                return true;
             }
         }
         
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index 47b2151bb..db7074056 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -23,6 +23,7 @@ namespace Compiler
             TokenLoc mTokenLoc;
             std::vector<Interpreter::Type_Code> mCode;
             bool mFirst;
+            bool mArgument;
             
             int getPriority (char op) const;
             
@@ -53,8 +54,10 @@ namespace Compiler
         public:
     
             ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
-                Literals& literals);
+                Literals& literals, bool argument = false);
             ///< constructor
+            /// \param argument Parser is used to parse function- or instruction-
+            /// arguments (this influences the precedence rules).
 
             char getType() const;
             ///< Return type of parsed expression ('l' integer, 'f' float)
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index f540f3314..e6af41673 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -195,6 +195,66 @@ namespace
     {
         code.push_back (segment5 (25));
     }      
+    
+    void opEqualInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (26));
+    }
+    
+    void opNonEqualInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (27)); 
+    }
+    
+    void opLessThanInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (28));     
+    }
+    
+    void opLessOrEqualInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (29));     
+    }
+    
+    void opGreaterThanInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (30));     
+    }
+    
+    void opGreaterOrEqualInt (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (31));     
+    }
+    
+    void opEqualFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (32));
+    }
+    
+    void opNonEqualFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (33)); 
+    }
+    
+    void opLessThanFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (34));     
+    }
+    
+    void opLessOrEqualFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (35));     
+    }
+    
+    void opGreaterThanFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (36));     
+    }
+    
+    void opGreaterOrEqualFloat (Compiler::Generator::CodeContainer& code)
+    {
+        code.push_back (segment5 (37));     
+    }    
 }
 
 namespace Compiler
@@ -439,6 +499,48 @@ namespace Compiler
             
             jump (code, offset);            
         }
+        
+        void compare (CodeContainer& code, char op, char valueType1, char valueType2)
+        {
+            if (valueType1=='l' && valueType2=='l')
+            {
+                switch (op)
+                {
+                    case 'e': opEqualInt (code); break;
+                    case 'n': opNonEqualInt (code); break;
+                    case 'l': opLessThanInt (code); break;
+                    case 'L': opLessOrEqualInt (code); break;
+                    case 'g': opGreaterThanInt (code); break;
+                    case 'G': opGreaterOrEqualInt (code); break;
+                
+                    default:
+                    
+                        assert (0);
+                }
+            }
+            else
+            {
+                if (valueType1=='l')
+                    opIntToFloat1 (code);
+
+                if (valueType2=='l')
+                    opIntToFloat (code);
+            
+                switch (op)
+                {
+                    case 'e': opEqualFloat (code); break;
+                    case 'n': opNonEqualFloat (code); break;
+                    case 'l': opLessThanFloat (code); break;
+                    case 'L': opLessOrEqualFloat (code); break;
+                    case 'g': opGreaterThanFloat (code); break;
+                    case 'G': opGreaterOrEqualFloat (code); break;
+                
+                    default:
+                    
+                        assert (0);
+                }
+            }          
+        }
     }
 }
 
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index 7d1f52df4..8864d51ec 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -47,6 +47,8 @@ namespace Compiler
         void jumpOnZero (CodeContainer& code, int offset);
         
         void jumpOnNonZero (CodeContainer& code, int offset);
+
+        void compare (CodeContainer& code, char op, char valueType1, char valueType2);
     }
 }
 
diff --git a/components/interpreter/docs/vmformat.txt b/components/interpreter/docs/vmformat.txt
index 4cd6b6608..333747911 100644
--- a/components/interpreter/docs/vmformat.txt
+++ b/components/interpreter/docs/vmformat.txt
@@ -84,6 +84,18 @@ op  22: replace stack[0] with local long stack[0]
 op  23: replace stack[0] with local float stack[0]
 op  24: skip next instruction if stack[0]==0; pop
 op  25: skip next instruction if stack[0]!=0; pop
-opcodes 26-33554431 unused
+op  26: compare (intger) stack[1] with stack[0]; pop twice; push 1 if equal, 0 else
+op  27: compare (intger) stack[1] with stack[0]; pop twice; push 1 if no equal, 0 else
+op  28: compare (intger) stack[1] with stack[0]; pop twice; push 1 if lesser than, 0 else
+op  29: compare (intger) stack[1] with stack[0]; pop twice; push 1 if lesser or equal, 0 else
+op  30: compare (intger) stack[1] with stack[0]; pop twice; push 1 if greater than, 0 else
+op  31: compare (intger) stack[1] with stack[0]; pop twice; push 1 if greater or equal, 0 else
+op  32: compare (float) stack[1] with stack[0]; pop twice; push 1 if equal, 0 else
+op  33: compare (float) stack[1] with stack[0]; pop twice; push 1 if no equal, 0 else
+op  34: compare (float) stack[1] with stack[0]; pop twice; push 1 if lesser than, 0 else
+op  35: compare (float) stack[1] with stack[0]; pop twice; push 1 if lesser or equal, 0 else
+op  36: compare (float) stack[1] with stack[0]; pop twice; push 1 if greater than, 0 else
+op  37: compare (float) stack[1] with stack[0]; pop twice; push 1 if greater or equal, 0 else
+opcodes 38-33554431 unused
 opcodes 33554432-67108863 reserved for extensions
 
diff --git a/components/interpreter/installopcodes.cpp b/components/interpreter/installopcodes.cpp
index 5066fd5a0..3567d5943 100644
--- a/components/interpreter/installopcodes.cpp
+++ b/components/interpreter/installopcodes.cpp
@@ -1,6 +1,8 @@
 
 #include "installopcodes.hpp"
 
+#include <functional>
+
 #include "interpreter.hpp"
 #include "genericopcodes.hpp"
 #include "localopcodes.hpp"
@@ -40,8 +42,33 @@ namespace Interpreter
         interpreter.installSegment5 (14, new OpMulInt<Type_Float>);
         interpreter.installSegment5 (15, new OpDivInt<Type_Integer>);
         interpreter.installSegment5 (16, new OpDivInt<Type_Float>);
-        interpreter.installSegment5 (19, new OpSquareRoot);        
-        
+        interpreter.installSegment5 (19, new OpSquareRoot);   
+        interpreter.installSegment5 (26, 
+            new OpCompare<Type_Integer, std::equal_to<Type_Integer> >);     
+        interpreter.installSegment5 (27, 
+            new OpCompare<Type_Integer, std::not_equal_to<Type_Integer> >);     
+        interpreter.installSegment5 (28, 
+            new OpCompare<Type_Integer, std::less<Type_Integer> >);     
+        interpreter.installSegment5 (29, 
+            new OpCompare<Type_Integer, std::less_equal<Type_Integer> >);     
+        interpreter.installSegment5 (30, 
+            new OpCompare<Type_Integer, std::greater<Type_Integer> >);     
+        interpreter.installSegment5 (31, 
+            new OpCompare<Type_Integer, std::greater_equal<Type_Integer> >);     
+            
+        interpreter.installSegment5 (32, 
+            new OpCompare<Type_Float, std::equal_to<Type_Float> >);     
+        interpreter.installSegment5 (33, 
+            new OpCompare<Type_Float, std::not_equal_to<Type_Float> >);     
+        interpreter.installSegment5 (34, 
+            new OpCompare<Type_Float, std::less<Type_Float> >);     
+        interpreter.installSegment5 (35, 
+            new OpCompare<Type_Float, std::less_equal<Type_Float> >);     
+        interpreter.installSegment5 (36, 
+            new OpCompare<Type_Float, std::greater<Type_Float> >);     
+        interpreter.installSegment5 (37, 
+            new OpCompare<Type_Float, std::greater_equal<Type_Float> >); 
+                    
         // control structures
         interpreter.installSegment5 (20, new OpReturn);        
         interpreter.installSegment5 (24, new OpSkipZero);
diff --git a/components/interpreter/mathopcodes.hpp b/components/interpreter/mathopcodes.hpp
index bb12274d3..d569a5470 100644
--- a/components/interpreter/mathopcodes.hpp
+++ b/components/interpreter/mathopcodes.hpp
@@ -103,6 +103,23 @@ namespace Interpreter
                 runtime[0] = *reinterpret_cast<Type_Data *> (&value);
             }           
     };    
+    
+    template<typename T, typename C>
+    class OpCompare : public Opcode0
+    {
+        public:
+        
+            virtual void execute (Runtime& runtime)
+            {
+                int result = C() (
+                    *reinterpret_cast<T *> (&runtime[1]),
+                    *reinterpret_cast<T *> (&runtime[0]));
+                
+                runtime.pop();
+                
+                runtime[0] = *reinterpret_cast<Type_Data *> (&result);
+            }           
+    };    
 }
 
 #endif

From 804aed62985d9eabbd246339b9b7a4ee07cf10cf Mon Sep 17 00:00:00 2001
From: Marc Zinnschlag <marc@zpages.de>
Date: Thu, 1 Jul 2010 16:40:03 +0200
Subject: [PATCH 40/40] added basic message box formatting

---
 components/compiler/exprparser.cpp     | 76 ++++++++++++++++++++------
 components/compiler/exprparser.hpp     | 13 ++++-
 components/compiler/generator.cpp      |  6 ++
 components/compiler/generator.hpp      |  2 +
 components/compiler/lineparser.cpp     | 31 +++++++++++
 components/compiler/stringparser.cpp   | 52 ++++++++++++++++++
 components/compiler/stringparser.hpp   | 46 ++++++++++++++++
 components/interpreter/miscopcodes.hpp | 66 +++++++++++++++++++++-
 8 files changed, 271 insertions(+), 21 deletions(-)
 create mode 100644 components/compiler/stringparser.cpp
 create mode 100644 components/compiler/stringparser.hpp

diff --git a/components/compiler/exprparser.cpp b/components/compiler/exprparser.cpp
index b1522d99a..658e9334a 100644
--- a/components/compiler/exprparser.cpp
+++ b/components/compiler/exprparser.cpp
@@ -4,11 +4,13 @@
 #include <stdexcept>
 #include <cassert>
 #include <algorithm>
+#include <stack>
 
 #include "generator.hpp"
 #include "scanner.hpp"
 #include "errorhandler.hpp"
 #include "locals.hpp"
+#include "stringparser.hpp"
 
 namespace Compiler
 {
@@ -184,24 +186,10 @@ namespace Compiler
             
         popOperator();
     }
-            
+    
     void ExprParser::parseArguments (const std::string& arguments, Scanner& scanner)
     {
-        ExprParser parser (getErrorHandler(), getContext(), mLocals, mLiterals, true);
-        
-        for (std::string::const_iterator iter (arguments.begin()); iter!=arguments.end();
-            ++iter)
-        {
-            parser.reset();    
-            scanner.scan (parser);
-
-            char type = parser.append (mCode);
-
-            if (type!=*iter)
-                Generator::convert (mCode, type, *iter);
-                
-            mOperands.push_back (*iter);
-        }
+        parseArguments (arguments, scanner, mCode);
     }
             
     ExprParser::ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
@@ -285,6 +273,7 @@ namespace Compiler
                 parseArguments ("f", scanner);
 
                 Generator::squareRoot (mCode);
+                mOperands.push_back ('f');
                 
                 mNextOperand = false;
                 return true;
@@ -433,5 +422,60 @@ namespace Compiler
         assert (mOperands.size()==1);
         return mOperands[0];
     }    
+            
+    void ExprParser::parseArguments (const std::string& arguments, Scanner& scanner,
+        std::vector<Interpreter::Type_Code>& code, bool invert)
+    {
+        ExprParser parser (getErrorHandler(), getContext(), mLocals, mLiterals, true);
+        StringParser stringParser (getErrorHandler(), getContext(), mLiterals);
+        
+        std::stack<std::vector<Interpreter::Type_Code> > stack;
+        
+        for (std::string::const_iterator iter (arguments.begin()); iter!=arguments.end();
+            ++iter)
+        {
+            if (*iter=='S')
+            {
+                stringParser.reset();
+                scanner.scan (stringParser);            
+                
+                if (invert)
+                {
+                    std::vector<Interpreter::Type_Code> tmp;
+                    stringParser.append (tmp);
+                    
+                    stack.push (tmp);
+                }
+                else
+                    stringParser.append (code);
+            }
+            else
+            {
+                parser.reset();    
+                scanner.scan (parser);
+
+                std::vector<Interpreter::Type_Code> tmp;
+
+                char type = parser.append (tmp);
+
+                if (type!=*iter)
+                    Generator::convert (tmp, type, *iter);
+                    
+                if (invert)
+                    stack.push (tmp);
+                else
+                    std::copy (tmp.begin(), tmp.end(), std::back_inserter (code));
+            }
+        }
+        
+        while (!stack.empty())
+        {
+            std::vector<Interpreter::Type_Code>& tmp = stack.top();
+        
+            std::copy (tmp.begin(), tmp.end(), std::back_inserter (code));
+        
+            stack.pop();
+        }
+    }    
 }
 
diff --git a/components/compiler/exprparser.hpp b/components/compiler/exprparser.hpp
index db7074056..4ac74075c 100644
--- a/components/compiler/exprparser.hpp
+++ b/components/compiler/exprparser.hpp
@@ -48,9 +48,9 @@ namespace Compiler
             void pushBinaryOperator (char c);
                         
             void close();
-            
-            void parseArguments (const std::string& arguments, Scanner& scanner);
-                        
+ 
+            void parseArguments (const std::string& arguments, Scanner& scanner);                  
+                             
         public:
     
             ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
@@ -89,6 +89,13 @@ namespace Compiler
             char append (std::vector<Interpreter::Type_Code>& code);
             ///< Generate code for parsed expression.
             /// \return Type ('l': integer, 'f': float)
+ 
+            void parseArguments (const std::string& arguments, Scanner& scanner,
+                std::vector<Interpreter::Type_Code>& code, bool invert = false);
+            ///< Parse sequence of arguments specified by \a arguments.
+            /// \param arguments Each character represents one arguments ('l': integer,
+            /// 'f': float, 'S': string)                
+            /// \param invert Store arguments in reverted order.
     };
 }
 
diff --git a/components/compiler/generator.cpp b/components/compiler/generator.cpp
index e6af41673..0f5a9a478 100644
--- a/components/compiler/generator.cpp
+++ b/components/compiler/generator.cpp
@@ -275,6 +275,12 @@ namespace Compiler
             opFetchFloatLiteral (code);
         }
                 
+        void pushString (CodeContainer& code, Literals& literals, const std::string& value)
+        {
+            int index = literals.addString (value);               
+            opPushInt (code, index);
+        }
+        
         void assignToLocal (CodeContainer& code, char localType,
             int localIndex, const CodeContainer& value, char valueType)
         {               
diff --git a/components/compiler/generator.hpp b/components/compiler/generator.hpp
index 8864d51ec..708516cc7 100644
--- a/components/compiler/generator.hpp
+++ b/components/compiler/generator.hpp
@@ -17,6 +17,8 @@ namespace Compiler
         void pushInt (CodeContainer& code, Literals& literals, int value);
 
         void pushFloat (CodeContainer& code, Literals& literals, float value);
+        
+        void pushString (CodeContainer& code, Literals& literals, const std::string& value);
 
         void assignToLocal (CodeContainer& code, char localType,
             int localIndex, const CodeContainer& value, char valueType);
diff --git a/components/compiler/lineparser.cpp b/components/compiler/lineparser.cpp
index 09ecdb82a..50f89ab7f 100644
--- a/components/compiler/lineparser.cpp
+++ b/components/compiler/lineparser.cpp
@@ -78,6 +78,37 @@ namespace Compiler
         
         if (mState==MessageState || mState==MessageCommaState)
         {
+            std::string arguments;
+            
+            for (std::size_t i=0; i<name.size(); ++i)
+            {
+                if (name[i]=='%')
+                {
+                    ++i;
+                    if (i<name.size())
+                    {
+                        if (name[i]=='G' || name[i]=='g')
+                        {
+                            arguments += "l";
+                        }
+                        else if (name[i]=='S' || name[i]=='s')
+                        {
+                            arguments += 'S';
+                        }
+                        else if (name[i]=='.' || name[i]=='f')
+                        {
+                            arguments += 'f';
+                        }
+                    }
+                }
+            }
+
+            if (!arguments.empty())
+            {
+                mExprParser.reset();
+                mExprParser.parseArguments (arguments, scanner, mCode, true);
+            }
+
             Generator::message (mCode, mLiterals, name, 0);
             mState = EndState;
             return false;
diff --git a/components/compiler/stringparser.cpp b/components/compiler/stringparser.cpp
new file mode 100644
index 000000000..4d3e6935b
--- /dev/null
+++ b/components/compiler/stringparser.cpp
@@ -0,0 +1,52 @@
+
+#include "stringparser.hpp"
+
+#include <algorithm>
+#include <iterator>
+
+#include "scanner.hpp"
+#include "generator.hpp"
+
+namespace Compiler
+{
+    StringParser::StringParser (ErrorHandler& errorHandler, Context& context, Literals& literals)
+    : Parser (errorHandler, context), mLiterals (literals), mState (StartState)
+    {
+    
+    }
+
+    bool StringParser::parseName (const std::string& name, const TokenLoc& loc,
+        Scanner& scanner)
+    {
+        if (mState==StartState || mState==CommaState)
+        {
+            Generator::pushString (mCode, mLiterals, name);
+            return false;
+        }
+    
+        return Parser::parseName (name, loc, scanner);
+    }
+
+    bool StringParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (code==Scanner::S_comma && mState==StartState)
+        {
+            mState = CommaState;
+            return true;
+        }
+        
+        return Parser::parseSpecial (code, loc, scanner);
+    }
+    
+    void StringParser::append (std::vector<Interpreter::Type_Code>& code)
+    {
+        std::copy (mCode.begin(), mCode.end(), std::back_inserter (code));
+    }
+
+    void StringParser::reset()
+    {
+        mState = StartState;
+        mCode.clear();
+    }
+}
+
diff --git a/components/compiler/stringparser.hpp b/components/compiler/stringparser.hpp
new file mode 100644
index 000000000..9d128e2d3
--- /dev/null
+++ b/components/compiler/stringparser.hpp
@@ -0,0 +1,46 @@
+#ifndef COMPILER_STRINGPARSER_H_INCLUDED
+#define COMPILER_STRINGPARSER_H_INCLUDED
+
+#include <vector>
+
+#include <components/interpreter/types.hpp>
+
+#include "parser.hpp"
+
+namespace Compiler
+{
+    class Literals;
+    
+    class StringParser : public Parser
+    {
+            enum State
+            {
+                StartState, CommaState
+            };
+    
+            Literals& mLiterals;
+            State mState;
+            std::vector<Interpreter::Type_Code> mCode;
+                
+        public:
+        
+            StringParser (ErrorHandler& errorHandler, Context& context, Literals& literals);
+
+            virtual bool parseName (const std::string& name, const TokenLoc& loc,
+                Scanner& scanner);
+            ///< Handle a name token.
+            /// \return fetch another token?
+
+            virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+            
+            void append (std::vector<Interpreter::Type_Code>& code);
+            ///< Append code for parsed string.
+            
+            void reset();
+            ///< Reset parser to clean state.    
+    };
+}
+
+#endif
diff --git a/components/interpreter/miscopcodes.hpp b/components/interpreter/miscopcodes.hpp
index f37620874..89f6116d2 100644
--- a/components/interpreter/miscopcodes.hpp
+++ b/components/interpreter/miscopcodes.hpp
@@ -4,6 +4,7 @@
 #include <stdexcept>
 #include <vector>
 #include <string>
+#include <sstream>
 
 #include "opcodes.hpp"
 #include "runtime.hpp"
@@ -18,11 +19,72 @@ namespace Interpreter
             {
                 if (arg0!=0)
                     throw std::logic_error ("message box buttons not implemented yet");
-                    
+                
+                // message    
                 int index = runtime[0];
                 runtime.pop();
+                std::string message = runtime.getStringLiteral (index);
+                
+                // additional parameters
+                std::string formattedMessage;
+                
+                for (std::size_t i=0; i<message.size(); ++i)
+                {
+                    char c = message[i];
+                    
+                    if (c!='%')
+                        formattedMessage += c;
+                    else
+                    {
+                        ++i;
+                        if (i<message.size())
+                        {
+                            c = message[i];
+                            
+                            if (c=='S' || c=='s')
+                            {
+                                int index = runtime[0];
+                                runtime.pop();
+                                formattedMessage += runtime.getStringLiteral (index);
+                            }
+                            else if (c=='g' || c=='G')
+                            {
+                                int value = *reinterpret_cast<const int *> (&runtime[0]);
+                                runtime.pop();
+                                
+                                std::ostringstream out;
+                                out << value;
+                                formattedMessage += out.str();
+                            }
+                            else if (c=='f' || c=='F' || c=='.')
+                            {
+                                while (c!='f' && i<message.size())
+                                {
+                                    ++i;
+                                }
+                            
+                                float value = *reinterpret_cast<const float *> (&runtime[0]);
+                                runtime.pop();
+                                
+                                std::ostringstream out;
+                                out << value;
+                                formattedMessage += out.str();
+                            }
+                            else if (c=='%')
+                                formattedMessage += "%";
+                            else
+                            {
+                                formattedMessage += "%"; 
+                                formattedMessage += c;                    
+                            }
+                        }
+                    }
+                }
+                
+                // buttons (not implemented)
                 std::vector<std::string> buttons;
-                runtime.getContext().messageBox (runtime.getStringLiteral (index), buttons);
+                
+                runtime.getContext().messageBox (formattedMessage, buttons);
             }        
     };
 }