Merge branch 'morrowland_scripting' into 'master'

Morrowland scripting

Closes #6363

See merge request OpenMW/openmw!1318

CHANGELOG.md

@@ -59,6 +59,7 @@
     Bug #6323: Wyrmhaven: Alboin doesn't follower the player character out of his house
     Bug #6326: Detect Enchantment/Key should detect items in unresolved containers
     Bug #6347: PlaceItem/PlaceItemCell/PlaceAt should work with levelled creatures
+    Bug #6363: Some scripts in Morrowland fail to work
     Feature #890: OpenMW-CS: Column filtering
     Feature #2554: Modifying an object triggers the instances table to scroll to the corresponding record
     Feature #2780: A way to see current OpenMW version in the console

components/compiler/declarationparser.cpp

@@ -90,6 +90,16 @@ bool Compiler::DeclarationParser::parseSpecial (int code, const TokenLoc& loc, S
     return Parser::parseSpecial (code, loc, scanner);
 }
 
+bool Compiler::DeclarationParser::parseInt(int value, const TokenLoc& loc, Scanner& scanner)
+{
+    if(mState == State_Name)
+    {
+        // Allow integers to be used as variable names
+        return parseName(loc.mLiteral, loc, scanner);
+    }
+    return Parser::parseInt(value, loc, scanner);
+}
+
 void Compiler::DeclarationParser::reset()
 {
     mState = State_Begin;

components/compiler/declarationparser.hpp

@@ -35,6 +35,10 @@ namespace Compiler
             ///< Handle a special character token.
             /// \return fetch another token?
 
+            bool parseInt (int value, const TokenLoc& loc, Scanner& scanner) override;
+            ///< Handle an int token.
+            /// \return fetch another token?
+
             void reset() override;
 
     };

components/compiler/exprparser.cpp

@@ -632,7 +632,7 @@ namespace Compiler
     }
 
     int ExprParser::parseArguments (const std::string& arguments, Scanner& scanner,
-        std::vector<Interpreter::Type_Code>& code, int ignoreKeyword)
+        std::vector<Interpreter::Type_Code>& code, int ignoreKeyword, bool expectNames)
     {
         bool optional = false;
         int optionalCount = 0;
@@ -717,6 +717,8 @@ namespace Compiler
 
                 if (optional)
                     parser.setOptional (true);
+                if(expectNames)
+                    scanner.enableExpectName();
 
                 scanner.scan (parser);
 

components/compiler/exprparser.hpp

@@ -96,7 +96,7 @@ namespace Compiler
             /// \return Type ('l': integer, 'f': float)
 
             int parseArguments (const std::string& arguments, Scanner& scanner,
-                std::vector<Interpreter::Type_Code>& code, int ignoreKeyword = -1);
+                std::vector<Interpreter::Type_Code>& code, int ignoreKeyword = -1, bool expectNames = false);
             ///< Parse sequence of arguments specified by \a arguments.
             /// \param arguments Uses ScriptArgs typedef
             /// \see Compiler::ScriptArgs

components/compiler/extensions0.cpp

@@ -553,7 +553,7 @@ namespace Compiler
             extensions.registerFunction("getpos",'f',"c",opcodeGetPos,opcodeGetPosExplicit);
             extensions.registerFunction("getstartingpos",'f',"c",opcodeGetStartingPos,opcodeGetStartingPosExplicit);
             extensions.registerInstruction("position","ffffz",opcodePosition,opcodePositionExplicit);
-            extensions.registerInstruction("positioncell","ffffcX",opcodePositionCell,opcodePositionCellExplicit);
+            extensions.registerInstruction("positioncell","ffffczz",opcodePositionCell,opcodePositionCellExplicit);
             extensions.registerInstruction("placeitemcell","ccffffX",opcodePlaceItemCell);
             extensions.registerInstruction("placeitem","cffffX",opcodePlaceItem);
             extensions.registerInstruction("placeatpc","clflX",opcodePlaceAtPc);

components/compiler/lineparser.cpp

@@ -67,6 +67,11 @@ namespace Compiler
             parseExpression (scanner, loc);
             return true;
         }
+        else if (mState == SetState)
+        {
+            // Allow ints to be used as variable names
+            return parseName(loc.mLiteral, loc, scanner);
+        }
 
         return Parser::parseInt (value, loc, scanner);
     }
@@ -140,7 +145,7 @@ namespace Compiler
             if (!arguments.empty())
             {
                 mExprParser.reset();
-                mExprParser.parseArguments (arguments, scanner, mCode);
+                mExprParser.parseArguments (arguments, scanner, mCode, -1, true);
             }
 
             mName = name;

components/compiler/scanner.cpp

@@ -130,7 +130,8 @@ namespace Compiler
         {
             bool cont = false;
 
-            if (scanInt (c, parser, cont))
+            bool scanned = mExpectName ? scanName(c, parser, cont) : scanInt(c, parser, cont);
+            if (scanned)
             {
                 mLoc.mLiteral.clear();
                 return cont;
@@ -387,6 +388,8 @@ namespace Compiler
 
     bool Scanner::scanSpecial (MultiChar& c, Parser& parser, bool& cont)
     {
+        bool expectName = mExpectName;
+        mExpectName = false;
         int special = -1;
 
         if (c=='\n')
@@ -541,15 +544,16 @@ namespace Compiler
 
         if (special==S_newline)
             mLoc.mLiteral = "<newline>";
-        else if (mExpectName && (special == S_member || special == S_minus))
+        else if (expectName && (special == S_member || special == S_minus))
         {
-            mExpectName = false;
             bool tolerant = mTolerantNames;
             mTolerantNames = true;
             bool out = scanName(c, parser, cont);
             mTolerantNames = tolerant;
             return out;
         }
+        else if (expectName && special == S_comma)
+            mExpectName = true;
 
         TokenLoc loc (mLoc);
         mLoc.mLiteral.clear();

components/compiler/stringparser.cpp

@@ -86,6 +86,12 @@ namespace Compiler
         return Parser::parseSpecial (code, loc, scanner);
     }
 
+    bool StringParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
+    {
+        reportWarning("Treating integer argument as a string", loc);
+        return parseName(loc.mLiteral, loc, scanner);
+    }
+
     void StringParser::append (std::vector<Interpreter::Type_Code>& code)
     {
         std::copy (mCode.begin(), mCode.end(), std::back_inserter (code));

components/compiler/stringparser.hpp

@@ -43,6 +43,10 @@ namespace Compiler
             ///< Handle a special character token.
             /// \return fetch another token?
 
+            bool parseInt (int value, const TokenLoc& loc, Scanner& scanner) override;
+            ///< Handle an int token.
+            /// \return fetch another token?
+
             void append (std::vector<Interpreter::Type_Code>& code);
             ///< Append code for parsed string.