even better error checking for extensions with explicit references

components/compiler/exprparser.cpp

@@ -331,7 +331,7 @@ namespace Compiler
                     char returnType;
                     std::string argumentType;
                     
-                    if (extensions->isFunction (keyword, returnType, argumentType))
+                    if (extensions->isFunction (keyword, returnType, argumentType, true))
                     {
                         mTokenLoc = loc;
                         parseArguments (argumentType, scanner);
@@ -434,7 +434,7 @@ namespace Compiler
                     char returnType;
                     std::string argumentType;
                     
-                    if (extensions->isFunction (keyword, returnType, argumentType))
+                    if (extensions->isFunction (keyword, returnType, argumentType, false))
                     {
                         mTokenLoc = loc;
                         parseArguments (argumentType, scanner);

components/compiler/extensions.cpp

@@ -21,24 +21,32 @@ namespace Compiler
         return iter->second;
     }
         
-    bool Extensions::isFunction (int keyword, char& returnType, std::string& argumentType) const
+    bool Extensions::isFunction (int keyword, char& returnType, std::string& argumentType,
+        bool explicitReference) const
     {
         std::map<int, Function>::const_iterator iter = mFunctions.find (keyword);
         
         if (iter==mFunctions.end())
             return false;
             
+        if (explicitReference && iter->second.mCodeExplicit==-1)
+            return false;
+            
         returnType = iter->second.mReturn;
         argumentType = iter->second.mArguments;
         return true;
     }
         
-    bool Extensions::isInstruction (int keyword, std::string& argumentType) const
+    bool Extensions::isInstruction (int keyword, std::string& argumentType,
+        bool explicitReference) const
     {
         std::map<int, Instruction>::const_iterator iter = mInstructions.find (keyword);
         
         if (iter==mInstructions.end())
             return false;
+
+        if (explicitReference && iter->second.mCodeExplicit==-1)
+            return false;
             
         argumentType = iter->second.mArguments;
         return true;

components/compiler/extensions.hpp

@@ -44,11 +44,13 @@ namespace Compiler
             /// - if no match is found 0 is returned.
             /// - keyword must be all lower case.
             
-            bool isFunction (int keyword, char& returnType, std::string& argumentType) const;
+            bool isFunction (int keyword, char& returnType, std::string& argumentType,
+                bool explicitReference) const;
             ///< Is this keyword registered with a function? If yes, return return and argument
             /// types.
 
-            bool isInstruction (int keyword, std::string& argumentType) const;
+            bool isInstruction (int keyword, std::string& argumentType,
+                bool explicitReference) const;
             ///< Is this keyword registered with a function? If yes, return argument types.
                         
             void registerFunction (const std::string& keyword, char returnType,

components/compiler/lineparser.cpp

@@ -163,7 +163,7 @@ namespace Compiler
             {
                 std::string argumentType;
                 
-                if (extensions->isInstruction (keyword, argumentType))
+                if (extensions->isInstruction (keyword, argumentType, mState==ExplicitState))
                 {
                     mExprParser.parseArguments (argumentType, scanner, mCode, true);