added new argument type: z (optional, any)

components/CMakeLists.txt

@@ -58,7 +58,7 @@ add_component_dir (compiler
     context controlparser errorhandler exception exprparser extensions fileparser generator
     lineparser literals locals output parser scanner scriptparser skipparser streamerrorhandler
     stringparser tokenloc nullerrorhandler opcodes extensions0 declarationparser
-    quickfileparser
+    quickfileparser discardparser
     )
 
 add_component_dir (interpreter

components/compiler/discardparser.cpp

@@ -0,0 +1,70 @@
+
+#include "discardparser.hpp"
+
+#include "scanner.hpp"
+
+namespace Compiler
+{
+    DiscardParser::DiscardParser (ErrorHandler& errorHandler, const Context& context)
+    : Parser (errorHandler, context), mState (StartState)
+    {
+
+    }
+
+    bool DiscardParser::parseInt (int value, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (mState==StartState || mState==CommaState || mState==MinusState)
+        {
+            start();
+            return false;
+        }
+
+        return Parser::parseInt (value, loc, scanner);
+    }
+
+    bool DiscardParser::parseFloat (float value, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (mState==StartState || mState==CommaState || mState==MinusState)
+        {
+            start();
+            return false;
+        }
+
+        return Parser::parseFloat (value, loc, scanner);
+    }
+
+    bool DiscardParser::parseName (const std::string& name, const TokenLoc& loc,
+        Scanner& scanner)
+    {
+        if (mState==StartState || mState==CommaState)
+        {
+            start();
+            return false;
+        }
+
+        return Parser::parseName (name, loc, scanner);
+    }
+
+    bool DiscardParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
+    {
+        if (code==Scanner::S_comma && mState==StartState)
+        {
+            mState = CommaState;
+            return true;
+        }
+
+        if (code==Scanner::S_minus && (mState==StartState || mState==CommaState))
+        {
+            mState = MinusState;
+            return true;
+        }
+
+        return Parser::parseSpecial (code, loc, scanner);
+    }
+
+    void DiscardParser::reset()
+    {
+        mState = StartState;
+        Parser::reset();
+    }
+}

components/compiler/discardparser.hpp

@@ -0,0 +1,45 @@
+#ifndef COMPILER_DISCARDPARSER_H_INCLUDED
+#define COMPILER_DISCARDPARSER_H_INCLUDED
+
+#include "parser.hpp"
+
+namespace Compiler
+{
+    /// \brief Parse a single optional numeric value or string and discard it
+    class DiscardParser : public Parser
+    {
+            enum State
+            {
+                StartState, CommaState, MinusState
+            };
+
+            State mState;
+
+        public:
+
+            DiscardParser (ErrorHandler& errorHandler, const 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 parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
+            ///< Handle a special character token.
+            /// \return fetch another token?
+
+            virtual void reset();
+            ///< Reset parser to clean state.
+    };
+}
+
+#endif
+

components/compiler/exprparser.cpp

@@ -16,6 +16,7 @@
 #include "stringparser.hpp"
 #include "extensions.hpp"
 #include "context.hpp"
+#include "discardparser.hpp"
 
 namespace Compiler
 {
@@ -743,6 +744,7 @@ namespace Compiler
 
         ExprParser parser (getErrorHandler(), getContext(), mLocals, mLiterals, true);
         StringParser stringParser (getErrorHandler(), getContext(), mLiterals);
+        DiscardParser discardParser (getErrorHandler(), getContext());
 
         std::stack<std::vector<Interpreter::Type_Code> > stack;
 
@@ -785,7 +787,17 @@ namespace Compiler
 
                 scanner.scan (parser);
 
-                if (optional && parser.isEmpty())
+                if (parser.isEmpty())
+                    break;
+            }
+            else if (*iter=='z')
+            {
+                discardParser.reset();
+                discardParser.setOptional (true);
+
+                scanner.scan (discardParser);
+
+                if (discardParser.isEmpty())
                     break;
             }
             else

components/compiler/extensions.hpp

@@ -21,7 +21,8 @@ namespace Compiler
         s - Short <BR>
         S - String, case preserved <BR>
         x - Optional, ignored string argument
-        X - Optional, ignored float argument
+        X - Optional, ignored numeric expression
+        z - Optional, ignored string or numeric argument
     **/
     typedef std::string ScriptArgs;