rename XMREngine as Yengine (still not all done), big mess source formating changes, move state files to proper folder, fix a source file locking on errors, more changes for cross platform including from Mike,... yes yes i know a messy commit

1 files changed, 101 insertions, 73 deletions

diff --git a/OpenSim/Region/ScriptEngine/XMREngine/XMRHeapTracker.cs b/OpenSim/Region/ScriptEngine/YEngine/XMRHeapTracker.cs
index 0e7d303..33eb8bf 100644
--- a/OpenSim/Region/ScriptEngine/XMREngine/XMRHeapTracker.cs
+++ b/OpenSim/Region/ScriptEngine/YEngine/XMRHeapTracker.cs
@@ -37,7 +37,7 @@ using LSL_Rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
 using LSL_String = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
 using LSL_Vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
 
-namespace OpenSim.Region.ScriptEngine.XMREngine
+namespace OpenSim.Region.ScriptEngine.Yengine
 {
     /**
      * One instance of this class for lsl base objects that take a variable
@@ -48,32 +48,35 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
      * Note that the xmr arrays and script-defined objects have their own
      * heap tracking built in so do not need any of this stuff.
      */
-    public class HeapTrackerBase {
+    public class HeapTrackerBase
+    {
         protected int usage;                    // num bytes used by object
         protected XMRInstAbstract instance;     // what script it is in
 
-        public HeapTrackerBase (XMRInstAbstract inst)
+        public HeapTrackerBase(XMRInstAbstract inst)
         {
-            if (inst == null) throw new ArgumentNullException ("inst");
+            if(inst == null)
+                throw new ArgumentNullException("inst");
             instance = inst;
         }
 
-        ~HeapTrackerBase ()
+        ~HeapTrackerBase()
         {
-            usage = instance.UpdateHeapUse (usage, 0);
+            usage = instance.UpdateHeapUse(usage, 0);
         }
     }
 
     /**
      * Wrapper around lists to keep track of how much memory they use.
      */
-    public class HeapTrackerList : HeapTrackerBase {
-        private static FieldInfo listValueField = typeof (HeapTrackerList).GetField ("value");
-        private static MethodInfo listSaveMethod = typeof (HeapTrackerList).GetMethod ("Save");
+    public class HeapTrackerList: HeapTrackerBase
+    {
+        private static FieldInfo listValueField = typeof(HeapTrackerList).GetField("value");
+        private static MethodInfo listSaveMethod = typeof(HeapTrackerList).GetMethod("Save");
 
         public LSL_List value;
 
-        public HeapTrackerList (XMRInstAbstract inst) : base (inst) { }
+        public HeapTrackerList(XMRInstAbstract inst) : base(inst) { }
 
         // generate CIL code to pop the value from the CIL stack
         //  input:
@@ -83,7 +86,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
         //   'this' pointer popped from stack
         //   new value popped from CIL stack
         //   heap usage updated
-        public static void GenPop (Token errorAt, ScriptMyILGen ilGen)
+        public static void GenPop(Token errorAt, ScriptMyILGen ilGen)
         {
             ilGen.Emit(errorAt, OpCodes.Call, listSaveMethod);
         }
@@ -95,21 +98,21 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
         //   'this' pointer popped from stack
         //   value pushed on CIL stack replacing 'this' pointer
         //   returns typeof value pushed on stack
-        public static Type GenPush (Token errorAt, ScriptMyILGen ilGen)
+        public static Type GenPush(Token errorAt, ScriptMyILGen ilGen)
         {
-            ilGen.Emit (errorAt, OpCodes.Ldfld, listValueField);
-            return typeof (LSL_List);
+            ilGen.Emit(errorAt, OpCodes.Ldfld, listValueField);
+            return typeof(LSL_List);
         }
 
-        public void Save (LSL_List lis)
+        public void Save(LSL_List lis)
         {
-            int newuse = Size (lis);
-            usage = instance.UpdateHeapUse (usage, newuse);
+            int newuse = Size(lis);
+            usage = instance.UpdateHeapUse(usage, newuse);
             value = lis;
         }
 
         //private static int counter = 5;
-        public static int Size (LSL_List lis)
+        public static int Size(LSL_List lis)
         {
             // VS2017 in debug mode seems to have a problem running this statement quickly:
             //SLOW: return (!typeof(LSL_List).IsValueType && (lis == null)) ? 0 : lis.Size;
@@ -120,9 +123,12 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
 
             // VS2017 in debug mode seems content to run this quickly though:
 
-            try {
+            try
+            {
                 return lis.Size;
-            } catch {
+            }
+            catch
+            {
                 return 0;
             }
         }
@@ -131,22 +137,23 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
     /**
      * Wrapper around objects to keep track of how much memory they use.
      */
-    public class HeapTrackerObject : HeapTrackerBase {
-        private static FieldInfo objectValueField = typeof (HeapTrackerObject).GetField ("value");
-        private static MethodInfo objectSaveMethod = typeof (HeapTrackerObject).GetMethod ("Save");
+    public class HeapTrackerObject: HeapTrackerBase
+    {
+        private static FieldInfo objectValueField = typeof(HeapTrackerObject).GetField("value");
+        private static MethodInfo objectSaveMethod = typeof(HeapTrackerObject).GetMethod("Save");
 
         public const int HT_CHAR = 2;
         public const int HT_DELE = 8;
         public const int HT_DOUB = 8;
         public const int HT_SING = 4;
         public const int HT_SFLT = 4;
-        public const int HT_INT  = 4;
-        public const int HT_VEC  = HT_DOUB * 3;
-        public const int HT_ROT  = HT_DOUB * 4;
+        public const int HT_INT = 4;
+        public const int HT_VEC = HT_DOUB * 3;
+        public const int HT_ROT = HT_DOUB * 4;
 
         public object value;
 
-        public HeapTrackerObject (XMRInstAbstract inst) : base (inst) { }
+        public HeapTrackerObject(XMRInstAbstract inst) : base(inst) { }
 
         // generate CIL code to pop the value from the CIL stack
         //  input:
@@ -156,7 +163,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
         //   'this' pointer popped from stack
         //   new value popped from CIL stack
         //   heap usage updated
-        public static void GenPop (Token errorAt, ScriptMyILGen ilGen)
+        public static void GenPop(Token errorAt, ScriptMyILGen ilGen)
         {
             ilGen.Emit(errorAt, OpCodes.Call, objectSaveMethod);
         }
@@ -168,67 +175,88 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
         //   'this' pointer popped from stack
         //   value pushed on CIL stack replacing 'this' pointer
         //   returns typeof value pushed on stack
-        public static Type GenPush (Token errorAt, ScriptMyILGen ilGen)
+        public static Type GenPush(Token errorAt, ScriptMyILGen ilGen)
         {
-            ilGen.Emit (errorAt, OpCodes.Ldfld, objectValueField);
-            return typeof (object);
+            ilGen.Emit(errorAt, OpCodes.Ldfld, objectValueField);
+            return typeof(object);
         }
 
-        public void Save (object obj)
+        public void Save(object obj)
         {
-            int newuse = Size (obj);
-            usage = instance.UpdateHeapUse (usage, newuse);
+            int newuse = Size(obj);
+            usage = instance.UpdateHeapUse(usage, newuse);
             value = obj;
         }
 
         // public so it can be used by XMRArray
-        public static int Size (object obj)
+        public static int Size(object obj)
         {
-            if (obj == null) return 0;
-
-            if (obj is char)            return HT_CHAR;
-            if (obj is Delegate)        return HT_DELE;
-            if (obj is double)          return HT_DOUB;
-            if (obj is float)           return HT_SING;
-            if (obj is int)             return HT_INT;
-            if (obj is LSL_Float)       return HT_SFLT;
-            if (obj is LSL_Integer)     return HT_INT;
-            if (obj is LSL_List)        return ((LSL_List)obj).Size;
-            if (obj is LSL_Rotation)    return HT_ROT;
-            if (obj is LSL_String)      return ((LSL_String)obj).m_string.Length * HT_CHAR;
-            if (obj is LSL_Vector)      return HT_VEC;
-            if (obj is string)          return ((string)obj).Length * HT_CHAR;
-            if (obj is XMR_Array)       return 0;
-            if (obj is XMRArrayListKey) return ((XMRArrayListKey)obj).Size;
-            if (obj is XMRSDTypeClObj)  return 0;
-
-            if (obj is Array) {
+            if(obj == null)
+                return 0;
+
+            if(obj is char)
+                return HT_CHAR;
+            if(obj is Delegate)
+                return HT_DELE;
+            if(obj is double)
+                return HT_DOUB;
+            if(obj is float)
+                return HT_SING;
+            if(obj is int)
+                return HT_INT;
+            if(obj is LSL_Float)
+                return HT_SFLT;
+            if(obj is LSL_Integer)
+                return HT_INT;
+            if(obj is LSL_List)
+                return ((LSL_List)obj).Size;
+            if(obj is LSL_Rotation)
+                return HT_ROT;
+            if(obj is LSL_String)
+                return ((LSL_String)obj).m_string.Length * HT_CHAR;
+            if(obj is LSL_Vector)
+                return HT_VEC;
+            if(obj is string)
+                return ((string)obj).Length * HT_CHAR;
+            if(obj is XMR_Array)
+                return 0;
+            if(obj is XMRArrayListKey)
+                return ((XMRArrayListKey)obj).Size;
+            if(obj is XMRSDTypeClObj)
+                return 0;
+
+            if(obj is Array)
+            {
                 Array ar = (Array)obj;
                 int len = ar.Length;
-                if (len == 0) return 0;
-                Type et = ar.GetType ().GetElementType ();
-                if (et.IsValueType) return Size (ar.GetValue (0)) * len;
+                if(len == 0)
+                    return 0;
+                Type et = ar.GetType().GetElementType();
+                if(et.IsValueType)
+                    return Size(ar.GetValue(0)) * len;
                 int size = 0;
-                for (int i = 0; i < len; i ++) {
-                    size += Size (ar.GetValue (i));
+                for(int i = 0; i < len; i++)
+                {
+                    size += Size(ar.GetValue(i));
                 }
                 return size;
             }
 
-            throw new Exception ("unknown size of type " + obj.GetType ().Name);
+            throw new Exception("unknown size of type " + obj.GetType().Name);
         }
     }
 
     /**
      * Wrapper around strings to keep track of how much memory they use.
      */
-    public class HeapTrackerString : HeapTrackerBase {
-        private static FieldInfo stringValueField = typeof (HeapTrackerString).GetField ("value");
-        private static MethodInfo stringSaveMethod = typeof (HeapTrackerString).GetMethod ("Save");
+    public class HeapTrackerString: HeapTrackerBase
+    {
+        private static FieldInfo stringValueField = typeof(HeapTrackerString).GetField("value");
+        private static MethodInfo stringSaveMethod = typeof(HeapTrackerString).GetMethod("Save");
 
         public string value;
 
-        public HeapTrackerString (XMRInstAbstract inst) : base (inst) { }
+        public HeapTrackerString(XMRInstAbstract inst) : base(inst) { }
 
         // generate CIL code to pop the value from the CIL stack
         //  input:
@@ -238,9 +266,9 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
         //   'this' pointer popped from stack
         //   new value popped from CIL stack
         //   heap usage updated
-        public static void GenPop (Token errorAt, ScriptMyILGen ilGen)
+        public static void GenPop(Token errorAt, ScriptMyILGen ilGen)
         {
-            ilGen.Emit (errorAt, OpCodes.Call, stringSaveMethod);
+            ilGen.Emit(errorAt, OpCodes.Call, stringSaveMethod);
         }
 
         // generate CIL code to push the value on the CIL stack
@@ -250,20 +278,20 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
         //   'this' pointer popped from stack
         //   value pushed on CIL stack replacing 'this' pointer
         //   returns typeof value pushed on stack
-        public static Type GenPush (Token errorAt, ScriptMyILGen ilGen)
+        public static Type GenPush(Token errorAt, ScriptMyILGen ilGen)
         {
-            ilGen.Emit (errorAt, OpCodes.Ldfld, stringValueField);
-            return typeof (string);
+            ilGen.Emit(errorAt, OpCodes.Ldfld, stringValueField);
+            return typeof(string);
         }
 
-        public void Save (string str)
+        public void Save(string str)
         {
-            int newuse = Size (str);
-            usage = instance.UpdateHeapUse (usage, newuse);
+            int newuse = Size(str);
+            usage = instance.UpdateHeapUse(usage, newuse);
             value = str;
         }
 
-        public static int Size (string str)
+        public static int Size(string str)
         {
             return (str == null) ? 0 : str.Length * HeapTrackerObject.HT_CHAR;
         }