1 files changed, 248 insertions, 256 deletions

diff --git a/OpenSim/Region/ScriptEngine/XMREngine/XMRInstRun.cs b/OpenSim/Region/ScriptEngine/YEngine/XMRInstRun.cs
index 9654b01..8603fbf 100644
--- a/OpenSim/Region/ScriptEngine/XMREngine/XMRInstRun.cs
+++ b/OpenSim/Region/ScriptEngine/YEngine/XMRInstRun.cs
@@ -32,11 +32,9 @@ using System.Text;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.ScriptEngine.Interfaces;
 using OpenSim.Region.ScriptEngine.Shared;
 using OpenSim.Region.ScriptEngine.Shared.Api;
 using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
-using OpenSim.Region.ScriptEngine.XMREngine;
 using OpenSim.Region.Framework.Scenes;
 using log4net;
 
@@ -48,7 +46,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
 {
     public partial class XMRInstance
     {
@@ -65,15 +63,15 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
          */
         public void PostEvent(EventParams evt)
         {
-            ScriptEventCode evc = (ScriptEventCode)Enum.Parse (typeof (ScriptEventCode), 
+            ScriptEventCode evc = (ScriptEventCode)Enum.Parse(typeof(ScriptEventCode),
                                                                  evt.EventName);
 
             /*
              * Put event on end of event queue.
              */
             bool startIt = false;
-            bool wakeIt  = false;
-            lock (m_QueueLock)
+            bool wakeIt = false;
+            lock(m_QueueLock)
             {
                 bool construct = (m_IState == XMRInstState.CONSTRUCT);
 
@@ -82,49 +80,50 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                  * We can't be state-specific here because state might be different
                  * by the time this event is dequeued and delivered to the script.
                  */
-                if (!construct &&                      // make sure m_HaveEventHandlers is filled in 
-                    ((uint)evc < (uint)m_HaveEventHandlers.Length) &&
-                    !m_HaveEventHandlers[(int)evc]) {  // don't bother if we don't have such a handler in any state
+                if(!construct &&                      // make sure m_HaveEventHandlers is filled in 
+                        ((uint)evc < (uint)m_HaveEventHandlers.Length) &&
+                        !m_HaveEventHandlers[(int)evc])  // don't bother if we don't have such a handler in any state
                     return;
-                }
+
 
                 /*
                  * Not running means we ignore any incoming events.
                  * But queue if still constructing because m_Running is not yet valid.
                  */
-                if (!m_Running && !construct) {
+                if(!m_Running && !construct)
                     return;
-                }
 
                 /*
                  * Only so many of each event type allowed to queue.
                  */
-                if ((uint)evc < (uint)m_EventCounts.Length) {
-                    int maxAllowed = MAXEVENTQUEUE;
-                    if (evc == ScriptEventCode.timer) maxAllowed = 1;
-                    if (m_EventCounts[(int)evc] >= maxAllowed)
+                if((uint)evc < (uint)m_EventCounts.Length)
+                {
+                    if(evc == ScriptEventCode.timer)
                     {
-                        return;
+                        if(m_EventCounts[(int)evc] >= 1)
+                            return;
                     }
-                    m_EventCounts[(int)evc] ++;
+                    else if(m_EventCounts[(int)evc] >= MAXEVENTQUEUE)
+                        return;
+
+                    m_EventCounts[(int)evc]++;
                 }
 
                 /*
                  * Put event on end of instance's event queue.
                  */
                 LinkedListNode<EventParams> lln = new LinkedListNode<EventParams>(evt);
-                switch (evc) {
-
+                switch(evc)
+                {
                     /*
                      * These need to go first.  The only time we manually
                      * queue them is for the default state_entry() and we
                      * need to make sure they go before any attach() events
                      * so the heapLimit value gets properly initialized.
                      */
-                    case ScriptEventCode.state_entry: {
+                    case ScriptEventCode.state_entry:
                         m_EventQueue.AddFirst(lln);
                         break;
-                    }
 
                     /*
                      * The attach event sneaks to the front of the queue.
@@ -134,22 +133,23 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                      * before attach(NULL_KEY) is executed.
                      */
                     case ScriptEventCode.attach:
-                    {
-                        if (evt.Params[0].ToString() == UUID.Zero.ToString())
+                        if(evt.Params[0].ToString() == UUID.Zero.ToString())
                         {
                             LinkedListNode<EventParams> lln2 = null;
-                            for (lln2 = m_EventQueue.First; lln2 != null; lln2 = lln2.Next)
+                            for(lln2 = m_EventQueue.First; lln2 != null; lln2 = lln2.Next)
                             {
                                 EventParams evt2 = lln2.Value;
-                                ScriptEventCode evc2 = (ScriptEventCode)Enum.Parse (typeof (ScriptEventCode), 
+                                ScriptEventCode evc2 = (ScriptEventCode)Enum.Parse(typeof(ScriptEventCode),
                                                                          evt2.EventName);
-                                if ((evc2 != ScriptEventCode.state_entry) &&
-                                    (evc2 != ScriptEventCode.attach)) break;
+                                if((evc2 != ScriptEventCode.state_entry) &&
+                                        (evc2 != ScriptEventCode.attach))
+                                    break;
                             }
-                            if (lln2 == null)
+                            if(lln2 == null)
                                 m_EventQueue.AddLast(lln);
                             else
                                 m_EventQueue.AddBefore(lln2, lln);
+
                             /* If we're detaching, limit the qantum. This will also
                              * cause the script to self-suspend after running this
                              * event
@@ -160,17 +160,15 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                         }
                         else
                             m_EventQueue.AddLast(lln);
+
                         break;
-                    }
 
                     /*
                      * All others just go on end in the order queued.
                      */
                     default:
-                    {
                         m_EventQueue.AddLast(lln);
                         break;
-                    }
                 }
 
                 /*
@@ -180,7 +178,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                  * to do the same thing right now.
                  * Dont' flag it if it's still suspended!
                  */
-                if ((m_IState == XMRInstState.IDLE) && !m_Suspended)
+                if((m_IState == XMRInstState.IDLE) && !m_Suspended)
                 {
                     m_IState = XMRInstState.ONSTARTQ;
                     startIt = true;
@@ -190,15 +188,13 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                  * If instance is sleeping (ie, possibly in xmrEventDequeue),
                  * wake it up if event is in the mask.
                  */
-                if ((m_SleepUntil > DateTime.UtcNow) && !m_Suspended)
+                if((m_SleepUntil > DateTime.UtcNow) && !m_Suspended)
                 {
                     int evc1 = (int)evc;
                     int evc2 = evc1 - 32;
-                    if ((((uint)evc1 < (uint)32) && (((m_SleepEventMask1 >> evc1) & 1) != 0)) ||
-                        (((uint)evc2 < (uint)32) && (((m_SleepEventMask2 >> evc2) & 1) != 0)))
-                    {
+                    if((((uint)evc1 < (uint)32) && (((m_SleepEventMask1 >> evc1) & 1) != 0)) ||
+                            (((uint)evc2 < (uint)32) && (((m_SleepEventMask2 >> evc2) & 1) != 0)))
                         wakeIt = true;
-                    }
                 }
             }
 
@@ -206,13 +202,13 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
              * If transitioned from IDLE->ONSTARTQ, actually go insert it
              * on m_StartQueue and give the RunScriptThread() a wake-up.
              */
-            if (startIt)
+            if(startIt)
                 m_Engine.QueueToStart(this);
 
             /*
              * Likewise, if the event mask triggered a wake, wake it up.
              */
-            if (wakeIt)
+            if(wakeIt)
             {
                 m_SleepUntil = DateTime.MinValue;
                 m_Engine.WakeFromSleep(this);
@@ -234,7 +230,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
              * up.
              */
             m_RunOnePhase = "check m_SleepUntil";
-            if (m_SleepUntil > now)
+            if(m_SleepUntil > now)
             {
                 m_RunOnePhase = "return is sleeping";
                 return XMRInstState.ONSLEEPQ;
@@ -244,7 +240,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
              * Also, someone may have called Suspend().
              */
             m_RunOnePhase = "check m_SuspendCount";
-            if (m_SuspendCount > 0)
+            if(m_SuspendCount > 0)
             {
                 m_RunOnePhase = "return is suspended";
                 return XMRInstState.SUSPENDED;
@@ -256,7 +252,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
              * back right away, delay a bit so we don't get in infinite loop.
              */
             m_RunOnePhase = "lock m_RunLock";
-            if (!Monitor.TryEnter (m_RunLock))
+            if(!Monitor.TryEnter(m_RunLock))
             {
                 m_SleepUntil = now.AddMilliseconds(3);
                 m_RunOnePhase = "return was locked";
@@ -269,23 +265,22 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                 Exception e = null;
 
                 /*
-                 * Maybe we have been disposed.
+                 * Maybe it has been Disposed()
                  */
-                m_RunOnePhase = "check disposed";
-                if (microthread == null)
+                if(m_Part == null)
                 {
-                    m_RunOnePhase = "return disposed";
+                    m_RunOnePhase = "runone saw it disposed";
                     return XMRInstState.DISPOSED;
                 }
 
                 /*
                  * Do some more of the last event if it didn't finish.
                  */
-                else if (eventCode != ScriptEventCode.None)
+                if(this.eventCode != ScriptEventCode.None)
                 {
-                    lock (m_QueueLock)
+                    lock(m_QueueLock)
                     {
-                        if (m_DetachQuantum > 0 && --m_DetachQuantum == 0)
+                        if(m_DetachQuantum > 0 && --m_DetachQuantum == 0)
                         {
                             m_Suspended = true;
                             m_DetachReady.Set();
@@ -296,10 +291,10 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                     }
 
                     m_RunOnePhase = "resume old event handler";
-                    m_LastRanAt   = now;
-                    m_InstEHSlice ++;
+                    m_LastRanAt = now;
+                    m_InstEHSlice++;
                     callMode = CallMode_NORMAL;
-                    e = microthread.ResumeEx ();
+                    e = ResumeEx();
                 }
 
                 /*
@@ -312,7 +307,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                     EventParams evt = null;
                     ScriptEventCode evc = ScriptEventCode.None;
 
-                    lock (m_QueueLock)
+                    lock(m_QueueLock)
                     {
 
                         /* We can't get here unless the script has been resumed
@@ -324,7 +319,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                          * out and may be improved in the future.
                          */
 
-                        if (m_Suspended)
+                        if(m_Suspended)
                         {
                             m_RunOnePhase = "m_Suspended is set";
                             CheckRunLockInvariants(true);
@@ -332,14 +327,14 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                         }
 
                         m_RunOnePhase = "dequeue event";
-                        if (m_EventQueue.First != null)
+                        if(m_EventQueue.First != null)
                         {
                             evt = m_EventQueue.First.Value;
-                            evc = (ScriptEventCode)Enum.Parse (typeof (ScriptEventCode), 
-                                                               evt.EventName);
-                            if (m_DetachQuantum > 0)
+                            if(m_DetachQuantum > 0)
                             {
-                                if (evc != ScriptEventCode.attach)
+                                evc = (ScriptEventCode)Enum.Parse(typeof(ScriptEventCode),
+                                                               evt.EventName);
+                                if(evc != ScriptEventCode.attach)
                                 {
                                     /*
                                      * This is the case where the attach event
@@ -355,17 +350,19 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                                 }
                             }
                             m_EventQueue.RemoveFirst();
-                            if (evc >= 0)
-                                m_EventCounts[(int)evc] --;
+                            evc = (ScriptEventCode)Enum.Parse(typeof(ScriptEventCode),
+                                                               evt.EventName);
+                            if((int)evc >= 0)
+                                m_EventCounts[(int)evc]--;
                         }
 
                         /*
                          * If there is no event to dequeue, don't run this script
                          * until another event gets queued.
                          */
-                        if (evt == null)
+                        if(evt == null)
                         {
-                            if (m_DetachQuantum > 0)
+                            if(m_DetachQuantum > 0)
                             {
                                 /*
                                  * This will happen if the attach event has run
@@ -385,19 +382,19 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                      * Dequeued an event, so start it going until it either 
                      * finishes or it calls CheckRun().
                      */
-                    m_RunOnePhase  = "start event handler";
+                    m_RunOnePhase = "start event handler";
                     m_DetectParams = evt.DetectParams;
-                    m_LastRanAt    = now;
-                    m_InstEHEvent ++;
-                    e = StartEventHandler (evc, evt.Params);
+                    m_LastRanAt = now;
+                    m_InstEHEvent++;
+                    e = StartEventHandler(evc, evt.Params);
                 }
                 m_RunOnePhase = "done running";
-                m_CPUTime    += DateTime.UtcNow.Subtract(now).TotalMilliseconds;
+                m_CPUTime += DateTime.UtcNow.Subtract(now).TotalMilliseconds;
 
                 /*
                  * Maybe it puqued.
                  */
-                if (e != null)
+                if(e != null)
                 {
                     m_RunOnePhase = "handling exception " + e.Message;
                     HandleScriptException(e);
@@ -409,10 +406,9 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                 /*
                  * If event handler completed, get rid of detect params.
                  */
-                if (this.eventCode == ScriptEventCode.None)
-                {
+                if(this.eventCode == ScriptEventCode.None)
                     m_DetectParams = null;
-                }
+
             }
             finally
             {
@@ -432,33 +428,30 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
          * @brief Immediately after taking m_RunLock or just before releasing it, check invariants.
          */
         private ScriptEventCode lastEventCode = ScriptEventCode.None;
-        private int             lastActive    = 0;
-        private string          lastRunPhase  = "";
+        private bool lastActive = false;
+        private string lastRunPhase = "";
 
         public void CheckRunLockInvariants(bool throwIt)
         {
             /*
-             * If not executing any event handler, active should be 0 indicating the microthread stack is not in use.
-             * If executing an event handler, active should be -1 indicating stack is in use but suspended.
+             * If not executing any event handler, there shouldn't be any saved stack frames.
+             * If executing an event handler, there should be some saved stack frames.
              */
-            IScriptUThread uth = microthread;
-            if (uth != null) {
-                int active = uth.Active ();
-                ScriptEventCode ec = this.eventCode;
-                if (((ec == ScriptEventCode.None) && (active != 0)) ||
-                    ((ec != ScriptEventCode.None) && (active >= 0))) {
-                    Console.WriteLine("CheckRunLockInvariants: script=" + m_DescName);
-                    Console.WriteLine("CheckRunLockInvariants: eventcode=" + ec.ToString() + ", active=" + active.ToString());
-                    Console.WriteLine("CheckRunLockInvariants: m_RunOnePhase=" + m_RunOnePhase);
-                    Console.WriteLine("CheckRunLockInvariants: lastec=" + lastEventCode + ", lastAct=" + lastActive + ", lastPhase=" + lastRunPhase);
-                    if (throwIt) {
-                        throw new Exception("CheckRunLockInvariants: eventcode=" + ec.ToString() + ", active=" + active.ToString());
-                    }
-                }
-                lastEventCode = ec;
-                lastActive    = active;
-                lastRunPhase  = m_RunOnePhase;
+            bool active = (stackFrames != null);
+            ScriptEventCode ec = this.eventCode;
+            if(((ec == ScriptEventCode.None) && active) ||
+                ((ec != ScriptEventCode.None) && !active))
+            {
+                Console.WriteLine("CheckRunLockInvariants: script=" + m_DescName);
+                Console.WriteLine("CheckRunLockInvariants: eventcode=" + ec.ToString() + ", active=" + active.ToString());
+                Console.WriteLine("CheckRunLockInvariants: m_RunOnePhase=" + m_RunOnePhase);
+                Console.WriteLine("CheckRunLockInvariants: lastec=" + lastEventCode + ", lastAct=" + lastActive + ", lastPhase=" + lastRunPhase);
+                if(throwIt)
+                    throw new Exception("CheckRunLockInvariants: eventcode=" + ec.ToString() + ", active=" + active.ToString());
             }
+            lastEventCode = ec;
+            lastActive = active;
+            lastRunPhase = m_RunOnePhase;
         }
 
         /*
@@ -475,38 +468,34 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
          *  from ehArgs[] and will throw an array bounds or cast exception 
          *  if it can't.
          */
-        private Exception StartEventHandler (ScriptEventCode eventCode, object[] ehArgs)
+        private Exception StartEventHandler(ScriptEventCode eventCode, object[] ehArgs)
         {
             /*
              * We use this.eventCode == ScriptEventCode.None to indicate we are idle.
              * So trying to execute ScriptEventCode.None might make a mess.
              */
-            if (eventCode == ScriptEventCode.None)
-                return new Exception ("Can't process ScriptEventCode.None");
+            if(eventCode == ScriptEventCode.None)
+                return new Exception("Can't process ScriptEventCode.None");
 
             /*
              * Silly to even try if there is no handler defined for this event.
              */
-            if ((eventCode >= 0) && (m_ObjCode.scriptEventHandlerTable[this.stateCode,(int)eventCode] == null))
+            if(((int)eventCode >= 0) && (m_ObjCode.scriptEventHandlerTable[this.stateCode, (int)eventCode] == null))
                 return null;
 
             /*
              * The microthread shouldn't be processing any event code.
              * These are assert checks so we throw them directly as exceptions.
              */
-            if (this.eventCode != ScriptEventCode.None)
-                throw new Exception ("still processing event " + this.eventCode.ToString ());
-
-            int active = microthread.Active ();
-            if (active != 0)
-                throw new Exception ("microthread is active " + active.ToString ());
+            if(this.eventCode != ScriptEventCode.None)
+                throw new Exception("still processing event " + this.eventCode.ToString());
 
             /*
              * Save eventCode so we know what event handler to run in the microthread.
              * And it also marks us busy so we can't be started again and this event lost.
              */
             this.eventCode = eventCode;
-            this.ehArgs    = ehArgs;
+            this.ehArgs = ehArgs;
 
             /*
              * This calls ScriptUThread.Main() directly, and returns when Main() [indirectly]
@@ -515,9 +504,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
              * without doing any stack frame restores first.
              */
             this.stackFrames = null;
-            Exception e;
-            e = microthread.StartEx ();
-            return e;
+            return StartEx();
         }
 
 
@@ -533,17 +520,17 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
              */
             eventCode = ScriptEventCode.None;
 
-            if (e is ScriptDeleteException)
+            if(e is ScriptDeleteException)
             {
                 /*
                  * Script did something like llRemoveInventory(llGetScriptName());
                  * ... to delete itself from the object.
                  */
                 m_SleepUntil = DateTime.MaxValue;
-                Verbose ("[XMREngine]: script self-delete {0}", m_ItemID);
+                Verbose("[YEngine]: script self-delete {0}", m_ItemID);
                 m_Part.Inventory.RemoveInventoryItem(m_ItemID);
             }
-            else if (e is ScriptDieException)
+            else if(e is ScriptDieException)
             {
                 /*
                  * Script did an llDie()
@@ -552,7 +539,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                 m_SleepUntil = DateTime.MaxValue;
                 m_Engine.World.DeleteSceneObject(m_Part.ParentGroup, false);
             }
-            else if (e is ScriptResetException)
+            else if(e is ScriptResetException)
             {
                 /*
                  * Script did an llResetScript().
@@ -579,63 +566,68 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
         {
             StringBuilder msg = new StringBuilder();
 
-            msg.Append ("[XMREngine]: Exception while running ");
-            msg.Append (m_ItemID);
-            msg.Append ('\n');
+            msg.Append("[YEngine]: Exception while running ");
+            msg.Append(m_ItemID);
+            msg.Append('\n');
 
             /*
              * Add exception message.
              */
             string des = e.Message;
             des = (des == null) ? "" : (": " + des);
-            msg.Append (e.GetType ().Name + des + "\n");
+            msg.Append(e.GetType().Name + des + "\n");
 
             /*
              * Tell script owner what to do.
              */
-            msg.Append ("Prim: <");
-            msg.Append (m_Part.Name);
-            msg.Append (">, Script: <");
-            msg.Append (m_Item.Name);
-            msg.Append (">, Location: ");
-            msg.Append (m_Engine.World.RegionInfo.RegionName);
-            msg.Append (" <");
+            msg.Append("Prim: <");
+            msg.Append(m_Part.Name);
+            msg.Append(">, Script: <");
+            msg.Append(m_Item.Name);
+            msg.Append(">, Location: ");
+            msg.Append(m_Engine.World.RegionInfo.RegionName);
+            msg.Append(" <");
             Vector3 pos = m_Part.AbsolutePosition;
-            msg.Append ((int) Math.Floor (pos.X));
-            msg.Append (',');
-            msg.Append ((int) Math.Floor (pos.Y));
-            msg.Append (',');
-            msg.Append ((int) Math.Floor (pos.Z));
-            msg.Append (">\nScript must be Reset to re-enable.\n");
+            msg.Append((int)Math.Floor(pos.X));
+            msg.Append(',');
+            msg.Append((int)Math.Floor(pos.Y));
+            msg.Append(',');
+            msg.Append((int)Math.Floor(pos.Z));
+            msg.Append(">\nScript must be Reset to re-enable.\n");
 
             /*
              * Display full exception message in log.
              */
-            m_log.Info (msg.ToString() + XMRExceptionStackString (e), e);
+            m_log.Info(msg.ToString() + XMRExceptionStackString(e), e);
 
             /*
              * Give script owner the stack dump.
              */
-            msg.Append (XMRExceptionStackString (e));
+            msg.Append(XMRExceptionStackString(e));
 
             /*
              * Send error message to owner.
              * Suppress internal code stack trace lines.
              */
             string msgst = msg.ToString();
-            if (!msgst.EndsWith ("\n")) msgst += '\n';
+            if(!msgst.EndsWith("\n"))
+                msgst += '\n';
             int j = 0;
-            StringBuilder imstr = new StringBuilder ();
-            for (int i = 0; (i = msgst.IndexOf ('\n', i)) >= 0; j = ++ i) {
-                string line = msgst.Substring (j, i - j);
-                if (line.StartsWith ("at ")) {
-                    if (line.StartsWith ("at (wrapper")) continue;  // at (wrapper ...
-                    int k = line.LastIndexOf (".cs:");  // ... .cs:linenumber
-                    if (Int32.TryParse (line.Substring (k + 4), out k)) continue;
+            StringBuilder imstr = new StringBuilder();
+            for(int i = 0; (i = msgst.IndexOf('\n', i)) >= 0; j = ++i)
+            {
+                string line = msgst.Substring(j, i - j);
+                if(line.StartsWith("at "))
+                {
+                    if(line.StartsWith("at (wrapper"))
+                        continue;  // at (wrapper ...
+                    int k = line.LastIndexOf(".cs:");  // ... .cs:linenumber
+                    if(Int32.TryParse(line.Substring(k + 4), out k))
+                        continue;
                 }
-                this.llOwnerSay (line);
-                imstr.Append (line);
-                imstr.Append ('\n');
+                this.llOwnerSay(line);
+                imstr.Append(line);
+                imstr.Append('\n');
             }
 
             /*
@@ -643,14 +635,15 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
              * Code modelled from llInstantMessage().
              */
             IMessageTransferModule transferModule = m_Engine.World.RequestModuleInterface<IMessageTransferModule>();
-            if (transferModule != null) {
+            if(transferModule != null)
+            {
                 UUID friendTransactionID = UUID.Random();
                 GridInstantMessage gim = new GridInstantMessage();
-                gim.fromAgentID = new Guid (m_Part.UUID.ToString());
-                gim.toAgentID = new Guid (m_Part.OwnerID.ToString ());
+                gim.fromAgentID = new Guid(m_Part.UUID.ToString());
+                gim.toAgentID = new Guid(m_Part.OwnerID.ToString());
                 gim.imSessionID = new Guid(friendTransactionID.ToString());
                 gim.timestamp = (uint)Util.UnixTimeSinceEpoch();
-                gim.message = imstr.ToString ();
+                gim.message = imstr.ToString();
                 gim.dialog = (byte)19; // messgage from script
                 gim.fromGroup = false;
                 gim.offline = (byte)0;
@@ -663,7 +656,9 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                     (int)Math.Floor(pos.X),
                     (int)Math.Floor(pos.Y),
                     (int)Math.Floor(pos.Z));
-                transferModule.SendInstantMessage(gim, delegate(bool success) {});
+                transferModule.SendInstantMessage(gim, delegate (bool success)
+                {
+                });
             }
 
             /*
@@ -679,16 +674,15 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
          */
         public void Reset()
         {
-        checkstate:
+            checkstate:
             XMRInstState iState = m_IState;
-            switch (iState) {
-
+            switch(iState)
+            {
                 /*
                  * If it's really being constructed now, that's about as reset as we get.
                  */
-                case XMRInstState.CONSTRUCT: {
+                case XMRInstState.CONSTRUCT:
                     return;
-                }
 
                 /*
                  * If it's idle, that means it is ready to receive a new event.
@@ -696,15 +690,16 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                  * it out of idle, verify that it is still in idle then transition
                  * it to resetting so no other thread will touch it.
                  */
-                case XMRInstState.IDLE: {
-                    lock (m_QueueLock) {
-                        if (m_IState == XMRInstState.IDLE) {
+                case XMRInstState.IDLE:
+                    lock(m_QueueLock)
+                    {
+                        if(m_IState == XMRInstState.IDLE)
+                        {
                             m_IState = XMRInstState.RESETTING;
                             break;
                         }
                     }
                     goto checkstate;
-                }
 
                 /*
                  * If it's on the start queue, that means it is about to dequeue an
@@ -712,112 +707,108 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
                  * can't be started and transition it to resetting so no other thread
                  * will touch it.
                  */
-                case XMRInstState.ONSTARTQ: {
-                    lock (m_Engine.m_StartQueue) {
-                        if (m_IState == XMRInstState.ONSTARTQ) {
+                case XMRInstState.ONSTARTQ:
+                    lock(m_Engine.m_StartQueue)
+                    {
+                        if(m_IState == XMRInstState.ONSTARTQ)
+                        {
                             m_Engine.m_StartQueue.Remove(this);
                             m_IState = XMRInstState.RESETTING;
                             break;
                         }
                     }
                     goto checkstate;
-                }
 
                 /*
                  * If it's running, tell CheckRun() to suspend the thread then go back
                  * to see what it got transitioned to.
                  */
-                case XMRInstState.RUNNING: {
+                case XMRInstState.RUNNING:
                     suspendOnCheckRunHold = true;
-                    lock (m_QueueLock) { }
+                    lock(m_QueueLock)
+                    {
+                    }
                     goto checkstate;
-                }
+
 
                 /*
                  * If it's sleeping, remove it from sleep queue and transition it to
                  * resetting so no other thread will touch it.
                  */
-                case XMRInstState.ONSLEEPQ: {
-                    lock (m_Engine.m_SleepQueue) {
-                        if (m_IState == XMRInstState.ONSLEEPQ) {
+                case XMRInstState.ONSLEEPQ:
+                    lock(m_Engine.m_SleepQueue)
+                    {
+                        if(m_IState == XMRInstState.ONSLEEPQ)
+                        {
                             m_Engine.m_SleepQueue.Remove(this);
                             m_IState = XMRInstState.RESETTING;
                             break;
                         }
                     }
                     goto checkstate;
-                }
 
                 /*
                  * It was just removed from the sleep queue and is about to be put
                  * on the yield queue (ie, is being woken up).
                  * Let that thread complete transition and try again.
                  */
-                case XMRInstState.REMDFROMSLPQ: {
-                    Sleep (10);
+                case XMRInstState.REMDFROMSLPQ:
+                    Sleep(10);
                     goto checkstate;
-                }
 
                 /*
                  * If it's yielding, remove it from yield queue and transition it to
                  * resetting so no other thread will touch it.
                  */
-                case XMRInstState.ONYIELDQ: {
-                    lock (m_Engine.m_YieldQueue) {
-                        if (m_IState == XMRInstState.ONYIELDQ) {
+                case XMRInstState.ONYIELDQ:
+                    lock(m_Engine.m_YieldQueue)
+                    {
+                        if(m_IState == XMRInstState.ONYIELDQ)
+                        {
                             m_Engine.m_YieldQueue.Remove(this);
                             m_IState = XMRInstState.RESETTING;
                             break;
                         }
                     }
                     goto checkstate;
-                }
 
                 /*
                  * If it just finished running something, let that thread transition it
                  * to its next state then check again.
                  */
-                case XMRInstState.FINISHED: {
-                    Sleep (10);
+                case XMRInstState.FINISHED:
+                    Sleep(10);
                     goto checkstate;
-                }
 
                 /*
                  * If it's disposed, that's about as reset as it gets.
                  */
-                case XMRInstState.DISPOSED: {
+                case XMRInstState.DISPOSED:
                     return;
-                }
 
                 /*
                  * Some other thread is already resetting it, let it finish.
                  */
-                case XMRInstState.RESETTING: {
+                case XMRInstState.RESETTING:
                     return;
-                }
 
-                default: throw new Exception("bad state");
+
+                default:
+                    throw new Exception("bad state");
             }
 
             /*
              * This thread transitioned the instance to RESETTING so reset it.
              */
-            lock (m_RunLock) {
+            lock(m_RunLock)
+            {
                 CheckRunLockInvariants(true);
 
                 /*
                  * No other thread should have transitioned it from RESETTING.
                  */
-                if (m_IState != XMRInstState.RESETTING) throw new Exception("bad state");
-
-                /*
-                 * If the microthread is active, that means it has call frame
-                 * context that we don't want.  Throw it out and get a fresh one.
-                 */
-                if (microthread.Active () < 0) {
-                    microthread.Dispose ();
-                    microthread = (IScriptUThread)m_Engine.uThreadCtor.Invoke (new object[] { this });
-                }
+                if(m_IState != XMRInstState.RESETTING)
+                    throw new Exception("bad state");
 
                 /*
                  * Mark it idle now so it can get queued to process new stuff.
@@ -836,21 +827,22 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
 
         private void ClearQueueExceptLinkMessages()
         {
-            lock (m_QueueLock) {
+            lock(m_QueueLock)
+            {
                 EventParams[] linkMessages = new EventParams[m_EventQueue.Count];
                 int n = 0;
-                foreach (EventParams evt2 in m_EventQueue) {
-                    if (evt2.EventName == "link_message") {
+                foreach(EventParams evt2 in m_EventQueue)
+                {
+                    if(evt2.EventName == "link_message")
                         linkMessages[n++] = evt2;
-                    }
                 }
 
                 m_EventQueue.Clear();
-                for (int i = m_EventCounts.Length; -- i >= 0;) m_EventCounts[i] = 0;
+                for(int i = m_EventCounts.Length; --i >= 0;)
+                    m_EventCounts[i] = 0;
 
-                for (int i = 0; i < n; i ++) {
+                for(int i = 0; i < n; i++)
                     m_EventQueue.AddLast(linkMessages[i]);
-                }
 
                 m_EventCounts[(int)ScriptEventCode.link_message] = n;
             }
@@ -858,10 +850,11 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
 
         private void ClearQueue()
         {
-            lock (m_QueueLock)
+            lock(m_QueueLock)
             {
                 m_EventQueue.Clear();               // no events queued
-                for (int i = m_EventCounts.Length; -- i >= 0;) m_EventCounts[i] = 0;
+                for(int i = m_EventCounts.Length; --i >= 0;)
+                    m_EventCounts[i] = 0;
             }
         }
 
@@ -882,7 +875,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
             m_Part.Inventory.GetInventoryItem(m_ItemID).PermsMask = 0;
             m_Part.Inventory.GetInventoryItem(m_ItemID).PermsGranter = UUID.Zero;
             IUrlModule urlModule = m_Engine.World.RequestModuleInterface<IUrlModule>();
-            if (urlModule != null)
+            if(urlModule != null)
                 urlModule.ScriptRemoved(m_ItemID);
 
             AsyncCommandManager.RemoveScript(m_Engine, m_LocalID, m_ItemID);
@@ -890,8 +883,8 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
             m_RunOnePhase = "ResetLocked: clearing current event";
             this.eventCode = ScriptEventCode.None;  // not processing an event
             m_DetectParams = null;                  // not processing an event
-            m_SleepUntil   = DateTime.MinValue;     // not doing llSleep()
-            m_ResetCount ++;                        // has been reset once more
+            m_SleepUntil = DateTime.MinValue;     // not doing llSleep()
+            m_ResetCount++;                        // has been reset once more
 
             /*
              * Tell next call to 'default state_entry()' to reset all global
@@ -906,8 +899,8 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
             m_RunOnePhase = "ResetLocked: posting default:state_entry() event";
             stateCode = 0;
             m_Part.SetScriptEvents(m_ItemID, GetStateEventFlags(0));
-            PostEvent(new EventParams("state_entry", 
-                                      zeroObjectArray, 
+            PostEvent(new EventParams("state_entry",
+                                      zeroObjectArray,
                                       zeroDetectParams));
 
             /*
@@ -920,27 +913,30 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
 
         private void ReleaseControls()
         {
-            if (m_Part != null)
+            if(m_Part != null)
             {
                 bool found;
                 int permsMask;
                 UUID permsGranter;
 
-                try {
+                try
+                {
                     permsGranter = m_Part.TaskInventory[m_ItemID].PermsGranter;
                     permsMask = m_Part.TaskInventory[m_ItemID].PermsMask;
                     found = true;
-                } catch {
+                }
+                catch
+                {
                     permsGranter = UUID.Zero;
                     permsMask = 0;
                     found = false;
                 }
 
-                if (found && ((permsMask & ScriptBaseClass.PERMISSION_TAKE_CONTROLS) != 0)) {
+                if(found && ((permsMask & ScriptBaseClass.PERMISSION_TAKE_CONTROLS) != 0))
+                {
                     ScenePresence presence = m_Engine.World.GetScenePresence(permsGranter);
-                    if (presence != null) {
+                    if(presence != null)
                         presence.UnRegisterControlEventsToScript(m_LocalID, m_ItemID);
-                    }
                 }
             }
         }
@@ -949,61 +945,53 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
          * @brief The script code should call this routine whenever it is
          *        convenient to perform a migation or switch microthreads.
          */
-        public override void CheckRunWork ()
+        public override void CheckRunWork()
         {
-            if(!suspendOnCheckRunHold && ! suspendOnCheckRunTemp)
+            if(!suspendOnCheckRunHold && !suspendOnCheckRunTemp)
             {
                 if(Util.GetTimeStampMS() - m_SliceStart < 60.0)
                     return;
                 suspendOnCheckRunTemp = true;
             }
-
             m_CheckRunPhase = "entered";
 
             /*
              * Stay stuck in this loop as long as something wants us suspended.
              */
-            while (suspendOnCheckRunHold || suspendOnCheckRunTemp)
+            while(suspendOnCheckRunHold || suspendOnCheckRunTemp)
             {
                 m_CheckRunPhase = "top of while";
+                suspendOnCheckRunTemp = false;
 
-                /*
-                 * See if MigrateOutEventHandler() has been called.
-                 * If so, dump our stack to stackFrames and unwind.
-                 */
-                if (this.captureStackFrames)
+                switch(this.callMode)
                 {
+                    // Now we are ready to suspend the microthread.
+                    // This is like a longjmp() to the most recent StartEx() or ResumeEx()
+                    // with a simultaneous setjmp() so ResumeEx() can longjmp() back here.
+
+                    // the script event handler wants to hibernate
+                    // capture stack frames and unwind to Start() or Resume()
+                    case CallMode_NORMAL:
+                        m_CheckRunPhase = "suspending";
+                        callMode = XMRInstance.CallMode_SAVE;
+                        stackFrames = null;
+                        throw new StackHibernateException();
+
+                    // We get here when the script state has been read in by MigrateInEventHandler().
+                    // Since the stack is completely restored at this point, any subsequent calls
+                    // within the functions should do their normal processing instead of trying to 
+                    // restore their state.
+
+                    // the stack has been restored as a result of calling ResumeEx()
+                    // tell script code to process calls normally
+                    case CallMode_RESTORE:
+                        this.callMode = CallMode_NORMAL;
+                        break;
 
-                    /*
-                     * Puque our stack to the output stream.
-                     * But otherwise, our state remains intact.
-                     */
-                    m_CheckRunPhase = "saving";
-                    this.callMode = CallMode_SAVE;
-                    this.stackFrames = null;
-                    throw new StackCaptureException ();
-                }
-
-                /*
-                 * We get here when the script state has been read in by MigrateInEventHandler().
-                 * Since the stack is completely restored at this point, any subsequent calls
-                 * within the functions should do their normal processing instead of trying to 
-                 * restore their state.
-                 */
-                if (this.callMode == CallMode_RESTORE)
-                {
-                    stackFramesRestored = true;
-                    this.callMode = CallMode_NORMAL;
+                    default:
+                        throw new Exception("callMode=" + callMode);
                 }
 
-                /*
-                 * Now we are ready to suspend the microthread.
-                 * This is like a longjmp() to the most recent StartEx() or ResumeEx()
-                 * with a simultaneous setjmp() so ResumeEx() can longjmp() back here.
-                 */
-                m_CheckRunPhase = "suspending";
-                suspendOnCheckRunTemp = false;
-                microthread.Hiber ();
                 m_CheckRunPhase = "resumed";
             }
 
@@ -1013,7 +1001,8 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
              * Upon return from CheckRun() it should always be the case that the script is
              * going to process calls normally, neither saving nor restoring stack frame state.
              */
-            if (callMode != CallMode_NORMAL) throw new Exception ("bad callMode " + callMode);
+            if(callMode != CallMode_NORMAL)
+                throw new Exception("bad callMode " + callMode);
         }
 
         /**
@@ -1021,12 +1010,13 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
          */
         public void ResumeIt()
         {
-            lock (m_QueueLock)
+            lock(m_QueueLock)
             {
                 m_Suspended = false;
-                if ((m_EventQueue != null) &&
+                if((m_EventQueue != null) &&
                     (m_EventQueue.First != null) &&
-                    (m_IState == XMRInstState.IDLE)) {
+                    (m_IState == XMRInstState.IDLE))
+                {
                     m_IState = XMRInstState.ONSTARTQ;
                     m_Engine.QueueToStart(this);
                 }
@@ -1039,7 +1029,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
          */
         public void SuspendIt()
         {
-            lock (m_QueueLock)
+            lock(m_QueueLock)
             {
                 m_Suspended = true;
             }
@@ -1052,5 +1042,7 @@ namespace OpenSim.Region.ScriptEngine.XMREngine
      *        to intercept this exception as it would block the stack capture
      *        functionality.
      */
-    public class StackCaptureException : Exception, IXMRUncatchable { }
+    public class StackCaptureException: Exception, IXMRUncatchable
+    {
+    }
 }