Revert "Merge master into teravuswork", it should have been avination, not master.

This reverts commit dfac269032300872c4d0dc507f4f9062d102b0f4, reversing
changes made to 619c39e5144f15aca129d6d999bcc5c34133ee64.

1 files changed, 11 insertions, 70 deletions

diff --git a/OpenSim/Region/CoreModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs b/OpenSim/Region/OptionalModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs
index dc54c3f..c5c96a9 100644
--- a/OpenSim/Region/CoreModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs
@@ -130,25 +130,13 @@ namespace OpenSim.Region.OptionalModules.Scripting.ScriptModuleComms
             m_scriptModule.PostScriptEvent(script, "link_message", args);
         }
 
-        private static MethodInfo GetMethodInfoFromType(Type target, string meth, bool searchInstanceMethods)
-        {
-            BindingFlags getMethodFlags =
-                    BindingFlags.NonPublic | BindingFlags.Public;
-
-            if (searchInstanceMethods)
-                getMethodFlags |= BindingFlags.Instance;
-            else
-                getMethodFlags |= BindingFlags.Static;
-
-            return target.GetMethod(meth, getMethodFlags);
-        }
-
         public void RegisterScriptInvocation(object target, string meth)
         {
-            MethodInfo mi = GetMethodInfoFromType(target.GetType(), meth, true);
+            MethodInfo mi = target.GetType().GetMethod(meth,
+                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
             if (mi == null)
             {
-                m_log.WarnFormat("[MODULE COMMANDS] Failed to register method {0}", meth);
+                m_log.WarnFormat("[MODULE COMMANDS] Failed to register method {0}",meth);
                 return;
             }
 
@@ -163,71 +151,38 @@ namespace OpenSim.Region.OptionalModules.Scripting.ScriptModuleComms
 
         public void RegisterScriptInvocation(object target, MethodInfo mi)
         {
-            m_log.DebugFormat("[MODULE COMMANDS] Register method {0} from type {1}", mi.Name, (target is Type) ? ((Type)target).Name : target.GetType().Name);
+            m_log.DebugFormat("[MODULE COMMANDS] Register method {0} from type {1}", mi.Name, target.GetType().Name);
 
             Type delegateType;
-            List<Type> typeArgs = mi.GetParameters()
+            var typeArgs = mi.GetParameters()
                     .Select(p => p.ParameterType)
                     .ToList();
 
             if (mi.ReturnType == typeof(void))
             {
-                delegateType = Expression.GetActionType(typeArgs.ToArray());
+                    delegateType = Expression.GetActionType(typeArgs.ToArray());
             }
             else
             {
-                typeArgs.Add(mi.ReturnType);
-                delegateType = Expression.GetFuncType(typeArgs.ToArray());
+                    typeArgs.Add(mi.ReturnType);
+                    delegateType = Expression.GetFuncType(typeArgs.ToArray());
             }
 
-            Delegate fcall;
-            if (!(target is Type))
-                fcall = Delegate.CreateDelegate(delegateType, target, mi);
-            else
-                fcall = Delegate.CreateDelegate(delegateType, (Type)target, mi.Name);
+            Delegate fcall = Delegate.CreateDelegate(delegateType, target, mi);
 
             lock (m_scriptInvocation)
             {
-                ParameterInfo[] parameters = fcall.Method.GetParameters();
+                ParameterInfo[] parameters = fcall.Method.GetParameters ();
                 if (parameters.Length < 2) // Must have two UUID params
                     return;
 
                 // Hide the first two parameters
                 Type[] parmTypes = new Type[parameters.Length - 2];
-                for (int i = 2; i < parameters.Length; i++)
+                for (int i = 2 ; i < parameters.Length ; i++)
                     parmTypes[i - 2] = parameters[i].ParameterType;
                 m_scriptInvocation[fcall.Method.Name] = new ScriptInvocationData(fcall.Method.Name, fcall, parmTypes, fcall.Method.ReturnType);
             }
         }
-
-        public void RegisterScriptInvocation(Type target, string[] methods)
-        {
-            foreach (string method in methods)
-            {
-                MethodInfo mi = GetMethodInfoFromType(target, method, false);
-                if (mi == null)
-                    m_log.WarnFormat("[MODULE COMMANDS] Failed to register method {0}", method);
-                else
-                    RegisterScriptInvocation(target, mi);
-            }
-        }
-
-        public void RegisterScriptInvocations(IRegionModuleBase target)
-        {
-            foreach(MethodInfo method in target.GetType().GetMethods(
-                    BindingFlags.Public | BindingFlags.Instance |
-                    BindingFlags.Static))
-            {
-                if(method.GetCustomAttributes(
-                        typeof(ScriptInvocationAttribute), true).Any())
-                {
-                    if(method.IsStatic)
-                        RegisterScriptInvocation(target.GetType(), method);
-                    else
-                        RegisterScriptInvocation(target, method);
-                }
-            }
-        }
         
         public Delegate[] GetScriptInvocationList()
         {
@@ -330,20 +285,6 @@ namespace OpenSim.Region.OptionalModules.Scripting.ScriptModuleComms
             }
         }
 
-        public void RegisterConstants(IRegionModuleBase target)
-        {
-            foreach (FieldInfo field in target.GetType().GetFields(
-                    BindingFlags.Public | BindingFlags.Static |
-                    BindingFlags.Instance))
-            {
-                if (field.GetCustomAttributes(
-                        typeof(ScriptConstantAttribute), true).Any())
-                {
-                    RegisterConstant(field.Name, field.GetValue(target));
-                }
-            }
-        }
-
         /// <summary>
         /// Operation to check for a registered constant
         /// </summary>