mirror of
https://github.com/opensim/opensim.git
synced 2026-07-20 06:35:39 +08:00
385 lines
14 KiB
C#
385 lines
14 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Threading;
|
|
using System.Reflection;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Reflection.Emit;
|
|
using System.Runtime.Remoting.Lifetime;
|
|
using System.Security.Policy;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Text;
|
|
using OpenMetaverse;
|
|
using OpenSim.Framework;
|
|
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;
|
|
|
|
using LSL_Float = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLFloat;
|
|
using LSL_Integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
|
|
using LSL_Key = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
|
|
using LSL_List = OpenSim.Region.ScriptEngine.Shared.LSL_Types.list;
|
|
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;
|
|
|
|
// This class exists in the main app domain
|
|
//
|
|
namespace OpenSim.Region.ScriptEngine.XMREngine
|
|
{
|
|
public partial class XMRInstance
|
|
{
|
|
|
|
// In case Dispose() doesn't get called, we want to be sure to clean
|
|
// up. This makes sure we decrement m_CompiledScriptRefCount.
|
|
~XMRInstance()
|
|
{
|
|
Dispose();
|
|
}
|
|
|
|
/**
|
|
* @brief Clean up stuff.
|
|
* We specifically leave m_DescName intact for 'xmr ls' command.
|
|
*/
|
|
public void Dispose()
|
|
{
|
|
/*
|
|
* Tell script stop executing next time it calls CheckRun().
|
|
*/
|
|
suspendOnCheckRunHold = true;
|
|
|
|
/*
|
|
* Wait for it to stop executing and prevent it from starting again
|
|
* as it can't run without a microthread.
|
|
*/
|
|
lock (m_RunLock)
|
|
{
|
|
if (microthread != null)
|
|
{
|
|
m_RunOnePhase = "disposing";
|
|
CheckRunLockInvariants(true);
|
|
microthread.Dispose ();
|
|
microthread = null;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Don't send us any more events.
|
|
*/
|
|
if (m_Part != null)
|
|
{
|
|
xmrTrapRegionCrossing (0);
|
|
m_Part.RemoveScriptEvents(m_ItemID);
|
|
AsyncCommandManager.RemoveScript(m_Engine, m_LocalID, m_ItemID);
|
|
m_Part = null;
|
|
}
|
|
|
|
/*
|
|
* Let script methods get garbage collected if no one else is using
|
|
* them.
|
|
*/
|
|
DecObjCodeRefCount ();
|
|
}
|
|
|
|
private void DecObjCodeRefCount ()
|
|
{
|
|
if (m_ObjCode != null) {
|
|
lock (m_CompileLock) {
|
|
ScriptObjCode objCode;
|
|
|
|
if (m_CompiledScriptObjCode.TryGetValue (m_ScriptObjCodeKey, out objCode) &&
|
|
(objCode == m_ObjCode) &&
|
|
(-- objCode.refCount == 0)) {
|
|
m_CompiledScriptObjCode.Remove (m_ScriptObjCodeKey);
|
|
}
|
|
}
|
|
m_ObjCode = null;
|
|
}
|
|
}
|
|
|
|
public void Verbose (string format, params object[] args)
|
|
{
|
|
if (m_Engine.m_Verbose) m_log.DebugFormat (format, args);
|
|
}
|
|
|
|
// Called by 'xmr top' console command
|
|
// to dump this script's state to console
|
|
// Sacha
|
|
public void RunTestTop()
|
|
{
|
|
if (m_InstEHSlice > 0){
|
|
Console.WriteLine(m_DescName);
|
|
Console.WriteLine(" m_LocalID = " + m_LocalID);
|
|
Console.WriteLine(" m_ItemID = " + m_ItemID);
|
|
Console.WriteLine(" m_Item.AssetID = " + m_Item.AssetID);
|
|
Console.WriteLine(" m_StartParam = " + m_StartParam);
|
|
Console.WriteLine(" m_PostOnRez = " + m_PostOnRez);
|
|
Console.WriteLine(" m_StateSource = " + m_StateSource);
|
|
Console.WriteLine(" m_SuspendCount = " + m_SuspendCount);
|
|
Console.WriteLine(" m_SleepUntil = " + m_SleepUntil);
|
|
Console.WriteLine(" m_IState = " + m_IState.ToString());
|
|
Console.WriteLine(" m_StateCode = " + GetStateName(stateCode));
|
|
Console.WriteLine(" eventCode = " + eventCode.ToString());
|
|
Console.WriteLine(" m_LastRanAt = " + m_LastRanAt.ToString());
|
|
Console.WriteLine(" heapUsed/Limit = " + xmrHeapUsed () + "/" + heapLimit);
|
|
Console.WriteLine(" m_InstEHEvent = " + m_InstEHEvent.ToString());
|
|
Console.WriteLine(" m_InstEHSlice = " + m_InstEHSlice.ToString());
|
|
}
|
|
}
|
|
|
|
// Called by 'xmr ls' console command
|
|
// to dump this script's state to console
|
|
public string RunTestLs(bool flagFull)
|
|
{
|
|
if (flagFull) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendLine(m_DescName);
|
|
sb.AppendLine(" m_LocalID = " + m_LocalID);
|
|
sb.AppendLine(" m_ItemID = " + m_ItemID + " (.state file)");
|
|
sb.AppendLine(" m_Item.AssetID = " + m_Item.AssetID);
|
|
sb.AppendLine(" m_Part.WorldPosition = " + m_Part.GetWorldPosition ());
|
|
sb.AppendLine(" m_ScriptObjCodeKey = " + m_ScriptObjCodeKey + " (source text)");
|
|
sb.AppendLine(" m_StartParam = " + m_StartParam);
|
|
sb.AppendLine(" m_PostOnRez = " + m_PostOnRez);
|
|
sb.AppendLine(" m_StateSource = " + m_StateSource);
|
|
sb.AppendLine(" m_SuspendCount = " + m_SuspendCount);
|
|
sb.AppendLine(" m_SleepUntil = " + m_SleepUntil);
|
|
sb.AppendLine(" m_SleepEvMask1 = 0x" + m_SleepEventMask1.ToString("X"));
|
|
sb.AppendLine(" m_SleepEvMask2 = 0x" + m_SleepEventMask2.ToString("X"));
|
|
sb.AppendLine(" m_IState = " + m_IState.ToString());
|
|
sb.AppendLine(" m_StateCode = " + GetStateName(stateCode));
|
|
sb.AppendLine(" eventCode = " + eventCode.ToString());
|
|
sb.AppendLine(" m_LastRanAt = " + m_LastRanAt.ToString());
|
|
sb.AppendLine(" m_RunOnePhase = " + m_RunOnePhase);
|
|
sb.AppendLine(" suspOnCkRunHold = " + suspendOnCheckRunHold);
|
|
sb.AppendLine(" suspOnCkRunTemp = " + suspendOnCheckRunTemp);
|
|
sb.AppendLine(" m_CheckRunPhase = " + m_CheckRunPhase);
|
|
sb.AppendLine(" heapUsed/Limit = " + xmrHeapUsed () + "/" + heapLimit);
|
|
sb.AppendLine(" m_InstEHEvent = " + m_InstEHEvent.ToString());
|
|
sb.AppendLine(" m_InstEHSlice = " + m_InstEHSlice.ToString());
|
|
sb.AppendLine(" m_CPUTime = " + m_CPUTime);
|
|
sb.AppendLine(" callMode = " + callMode);
|
|
sb.AppendLine(" captureStackFrames = " + captureStackFrames);
|
|
sb.AppendLine(" stackFramesRestored = " + stackFramesRestored);
|
|
lock (m_QueueLock)
|
|
{
|
|
sb.AppendLine(" m_Running = " + m_Running);
|
|
foreach (EventParams evt in m_EventQueue)
|
|
{
|
|
sb.AppendLine(" evt.EventName = " + evt.EventName);
|
|
}
|
|
}
|
|
return sb.ToString();
|
|
} else {
|
|
return String.Format("{0} {1} {2} {3} {4} {5}",
|
|
m_ItemID,
|
|
m_CPUTime.ToString("F3").PadLeft(9),
|
|
m_InstEHEvent.ToString().PadLeft(9),
|
|
m_IState.ToString().PadRight(10),
|
|
m_Part.GetWorldPosition().ToString().PadRight(32),
|
|
m_DescName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief For a given stateCode, get a mask of the low 32 event codes
|
|
* that the state has handlers defined for.
|
|
*/
|
|
public int GetStateEventFlags(int stateCode)
|
|
{
|
|
if ((stateCode < 0) ||
|
|
(stateCode >= m_ObjCode.scriptEventHandlerTable.GetLength(0)))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int code = 0;
|
|
for (int i = 0 ; i < 32; i ++)
|
|
{
|
|
if (m_ObjCode.scriptEventHandlerTable[stateCode, i] != null)
|
|
{
|
|
code |= 1 << i;
|
|
}
|
|
}
|
|
|
|
return code;
|
|
}
|
|
|
|
/**
|
|
* @brief Get the .state file name.
|
|
*/
|
|
public static string GetStateFileName (string scriptBasePath, UUID itemID)
|
|
{
|
|
return GetScriptFileName (scriptBasePath, itemID.ToString() + ".state");
|
|
}
|
|
|
|
public string GetScriptFileName (string filename)
|
|
{
|
|
return GetScriptFileName (m_ScriptBasePath, filename);
|
|
}
|
|
|
|
public static string GetScriptFileName (string scriptBasePath, string filename)
|
|
{
|
|
/*
|
|
* Get old path, ie, all files lumped in a single huge directory.
|
|
*/
|
|
string oldPath = Path.Combine (scriptBasePath, filename);
|
|
|
|
/*
|
|
* Get new path, ie, files split up based on first 2 chars of name.
|
|
*/
|
|
string subdir = filename.Substring (0, 2);
|
|
filename = filename.Substring (2);
|
|
scriptBasePath = Path.Combine (scriptBasePath, subdir);
|
|
Directory.CreateDirectory (scriptBasePath);
|
|
string newPath = Path.Combine (scriptBasePath, filename);
|
|
|
|
/*
|
|
* If file exists only in old location, move to new location.
|
|
* If file exists in both locations, delete old location.
|
|
*/
|
|
if (File.Exists (oldPath)) {
|
|
if (File.Exists (newPath)) {
|
|
File.Delete (oldPath);
|
|
} else {
|
|
File.Move (oldPath, newPath);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Always return new location.
|
|
*/
|
|
return newPath;
|
|
}
|
|
|
|
/**
|
|
* @brief Decode state code (int) to state name (string).
|
|
*/
|
|
public string GetStateName (int stateCode)
|
|
{
|
|
try {
|
|
return m_ObjCode.stateNames[stateCode];
|
|
} catch {
|
|
return stateCode.ToString ();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief various gets & sets.
|
|
*/
|
|
public int StartParam
|
|
{
|
|
get { return m_StartParam; }
|
|
set { m_StartParam = value; }
|
|
}
|
|
|
|
public SceneObjectPart SceneObject
|
|
{
|
|
get { return m_Part; }
|
|
}
|
|
|
|
public DetectParams[] DetectParams
|
|
{
|
|
get { return m_DetectParams; }
|
|
set { m_DetectParams = value; }
|
|
}
|
|
|
|
public UUID ItemID
|
|
{
|
|
get { return m_ItemID; }
|
|
}
|
|
|
|
public UUID AssetID
|
|
{
|
|
get { return m_Item.AssetID; }
|
|
}
|
|
|
|
public bool Running
|
|
{
|
|
get { return m_Running; }
|
|
set
|
|
{
|
|
lock (m_QueueLock)
|
|
{
|
|
m_Running = value;
|
|
if (!value)
|
|
{
|
|
EmptyEventQueues ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Empty out the event queues.
|
|
* Assumes caller has the m_QueueLock locked.
|
|
*/
|
|
public void EmptyEventQueues ()
|
|
{
|
|
m_EventQueue.Clear();
|
|
for (int i = m_EventCounts.Length; -- i >= 0;) m_EventCounts[i] = 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Convert an LSL vector to an Openmetaverse vector.
|
|
*/
|
|
public static OpenMetaverse.Vector3 LSLVec2OMVec (LSL_Vector lslVec)
|
|
{
|
|
return new OpenMetaverse.Vector3 ((float)lslVec.x, (float)lslVec.y, (float)lslVec.z);
|
|
}
|
|
|
|
/**
|
|
* @brief Extract an integer from an element of an LSL_List.
|
|
*/
|
|
public static int ListInt (object element)
|
|
{
|
|
if (element is LSL_Integer) {
|
|
return (int)(LSL_Integer)element;
|
|
}
|
|
return (int)element;
|
|
}
|
|
|
|
/**
|
|
* @brief Extract a string from an element of an LSL_List.
|
|
*/
|
|
public static string ListStr (object element)
|
|
{
|
|
if (element is LSL_String) {
|
|
return (string)(LSL_String)element;
|
|
}
|
|
return (string)element;
|
|
}
|
|
}
|
|
}
|