Adds a new script command 'modInvoke' to invoke registered functions

from region modules. The LSL translator is extended to generate the
modInvoke format of commands for directly inlined function calls.

A region module can register a function Test() with the name "Test".
LSL code can call that function as "Test()". The compiler will translate
that invocation into modInvoke("Test", ...)

5 files changed, 163 insertions, 3 deletions

diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/MOD_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/MOD_Api.cs
index d4facdd..2942104 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/MOD_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/MOD_Api.cs
@@ -116,6 +116,115 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             wComm.DeliverMessage(ChatTypeEnum.Shout, ScriptBaseClass.DEBUG_CHANNEL, m_host.Name, m_host.UUID, message);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="fname">The name of the function to invoke</param>
+        /// <param name="fname">List of parameters</param>
+        /// <returns>string result of the invocation</returns>
+        public string modInvokeS(string fname, params object[] parms)
+        {
+            Type returntype = m_comms.LookupReturnType(fname);
+            if (returntype != typeof(string))
+                MODError(String.Format("return type mismatch for {0}",fname));
+
+            return (string)modInvoke(fname,parms);
+        }
+
+        public int modInvokeI(string fname, params object[] parms)
+        {
+            Type returntype = m_comms.LookupReturnType(fname);
+            if (returntype != typeof(int))
+                MODError(String.Format("return type mismatch for {0}",fname));
+
+            return (int)modInvoke(fname,parms);
+        }
+        
+        public float modInvokeF(string fname, params object[] parms)
+        {
+            Type returntype = m_comms.LookupReturnType(fname);
+            if (returntype != typeof(float))
+                MODError(String.Format("return type mismatch for {0}",fname));
+
+            return (float)modInvoke(fname,parms);
+        }
+
+        /// <summary>
+        /// Invokes a preregistered function through the ScriptModuleComms class
+        /// </summary>
+        /// <param name="fname">The name of the function to invoke</param>
+        /// <param name="fname">List of parameters</param>
+        /// <returns>string result of the invocation</returns>
+        protected object modInvoke(string fname, params object[] parms)
+        {
+            if (!m_MODFunctionsEnabled)
+            {
+                MODShoutError("Module command functions not enabled");
+                return "";
+            }
+
+            Type[] signature = m_comms.LookupTypeSignature(fname);
+            if (signature.Length != parms.Length)
+                MODError(String.Format("wrong number of parameters to function {0}",fname));
+            
+            object[] convertedParms = new object[parms.Length];
+
+            for (int i = 0; i < parms.Length; i++)
+            {
+                if (parms[i] is LSL_String)
+                {
+                    if (signature[i] != typeof(string))
+                        MODError(String.Format("parameter type mismatch in {0}; expecting {1}",fname,signature[i].Name));
+
+                    convertedParms[i] = (string)(LSL_String)parms[i];
+                }
+                else if (parms[i] is LSL_Integer)
+                {
+                    if (signature[i] != typeof(int))
+                        MODError(String.Format("parameter type mismatch in {0}; expecting {1}",fname,signature[i].Name));
+
+                    convertedParms[i] = (int)(LSL_Integer)parms[i];
+                }
+                else if (parms[i] is LSL_Float)
+                {
+                    if (signature[i] != typeof(float))
+                        MODError(String.Format("parameter type mismatch in {0}; expecting {1}",fname,signature[i].Name));
+
+                    convertedParms[i] = (float)(LSL_Float)parms[i];
+                }
+                else if (parms[i] is LSL_Key)
+                {
+                    if (signature[i] != typeof(string))
+                        MODError(String.Format("parameter type mismatch in {0}; expecting {1}",fname,signature[i].Name));
+
+                    convertedParms[i] =  (string)(LSL_Key)parms[i];
+                }
+                else if (parms[i] is LSL_Rotation)
+                {
+                    if (signature[i] != typeof(string))
+                        MODError(String.Format("parameter type mismatch in {0}; expecting {1}",fname,signature[i].Name));
+
+                    convertedParms[i] =  (string)(LSL_Rotation)parms[i];
+                }
+                else if (parms[i] is LSL_Vector)
+                {
+                    if (signature[i] != typeof(string))
+                        MODError(String.Format("parameter type mismatch in {0}; expecting {1}",fname,signature[i].Name));
+
+                    convertedParms[i] =  (string)(LSL_Vector)parms[i];
+                }
+                else
+                {
+                    if (signature[i] != parms[i].GetType())
+                        MODError(String.Format("parameter type mismatch in {0}; expecting {1}",fname,signature[i].Name));
+
+                    convertedParms[i] = parms[i];
+                }
+            }
+
+            return m_comms.InvokeOperation(m_itemID,fname,convertedParms);
+        }
+        
         public string modSendCommand(string module, string command, string k)
         {
             if (!m_MODFunctionsEnabled)
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IMOD_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IMOD_Api.cs
index e08eca5..756a59f 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IMOD_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IMOD_Api.cs
@@ -40,6 +40,15 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
 {
     public interface IMOD_Api
     {
+        // Invocation functions
+        string modInvokeS(string fname, params object[] parms);
+        int modInvokeI(string fname, params object[] parms);
+        float modInvokeF(string fname, params object[] parms);
+        // vector modInvokeV(string fname, params object[] parms);
+        // rotation modInvokeV(string fname, params object[] parms);
+        // key modInvokeK(string fname, params object[] parms);
+        // list modInvokeL(string fname, params object[] parms);
+        
         //Module functions
         string modSendCommand(string modules, string command, string k);
     }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/MOD_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/MOD_Stub.cs
index 6525c76..04b7f14 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/MOD_Stub.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/MOD_Stub.cs
@@ -58,6 +58,21 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
             m_MOD_Functions = (IMOD_Api)api;
         }
 
+        public string modInvokeS(string fname, params object[] parms)
+        {
+            return m_MOD_Functions.modInvokeS(fname, parms);
+        }
+
+        public int modInvokeI(string fname, params object[] parms)
+        {
+            return m_MOD_Functions.modInvokeI(fname, parms);
+        }
+
+        public float modInvokeF(string fname, params object[] parms)
+        {
+            return m_MOD_Functions.modInvokeF(fname, parms);
+        }
+
         public string modSendCommand(string module, string command, string k)
         {
             return m_MOD_Functions.modSendCommand(module, command, k);
diff --git a/OpenSim/Region/ScriptEngine/Shared/CodeTools/CSCodeGenerator.cs b/OpenSim/Region/ScriptEngine/Shared/CodeTools/CSCodeGenerator.cs
index 65d3b9b..28c031f 100644
--- a/OpenSim/Region/ScriptEngine/Shared/CodeTools/CSCodeGenerator.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/CodeTools/CSCodeGenerator.cs
@@ -32,6 +32,8 @@ using System.Reflection;
 using log4net;
 using Tools;
 
+using OpenSim.Region.Framework.Interfaces;
+
 namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
 {
     public class CSCodeGenerator : ICodeConverter
@@ -45,12 +47,20 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
         private int m_CSharpLine;       // the current line of generated C# code
         private int m_CSharpCol;        // the current column of generated C# code
         private List<string> m_warnings = new List<string>();
+        private IScriptModuleComms m_comms = null;
 
         /// <summary>
         /// Creates an 'empty' CSCodeGenerator instance.
         /// </summary>
         public CSCodeGenerator()
         {
+            m_comms = null;
+            ResetCounters();
+        }
+
+        public CSCodeGenerator(IScriptModuleComms comms)
+        {
+            m_comms = comms;
             ResetCounters();
         }
 
@@ -866,8 +876,22 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
         {
             string retstr = String.Empty;
 
-            retstr += Generate(String.Format("{0}(", CheckName(fc.Id)), fc);
-
+            string modinvoke = m_comms.LookupModInvocation(fc.Id);
+            if (modinvoke != null)
+            {
+                if (fc.kids[0] is ArgumentList)
+                {
+                    if ((fc.kids[0] as ArgumentList).kids.Count == 0)
+                        retstr += Generate(String.Format("{0}(\"{1}\"",modinvoke,fc.Id), fc);
+                    else
+                        retstr += Generate(String.Format("{0}(\"{1}\",",modinvoke,fc.Id), fc);
+                }
+            }
+            else
+            {
+                retstr += Generate(String.Format("{0}(", CheckName(fc.Id)), fc);
+            }
+            
             foreach (SYMBOL kid in fc.kids)
                 retstr += GenerateNode(kid);
 
diff --git a/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs b/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs
index c10143b..8f2ec49 100644
--- a/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs
@@ -35,6 +35,7 @@ using Microsoft.CSharp;
 //using Microsoft.JScript;
 using Microsoft.VisualBasic;
 using log4net;
+
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.ScriptEngine.Interfaces;
 using OpenMetaverse;
@@ -293,6 +294,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
         {
 //            m_log.DebugFormat("[Compiler]: Compiling script\n{0}", Script);
 
+            IScriptModuleComms comms = m_scriptEngine.World.RequestModuleInterface<IScriptModuleComms>();
+
             linemap = null;
             m_warnings.Clear();
 
@@ -382,7 +385,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
             if (language == enumCompileType.lsl)
             {
                 // Its LSL, convert it to C#
-                LSL_Converter = (ICodeConverter)new CSCodeGenerator();
+                LSL_Converter = (ICodeConverter)new CSCodeGenerator(comms);
                 compileScript = LSL_Converter.Convert(Script);
 
                 // copy converter warnings into our warnings.