private static IScriptStructure CreateComplexType(TypeReference type, IReadOnlyDictionary <GenericParameter, TypeReference> arguments)
{
type = GetElementType(type, arguments);
if (IsEngineStruct(type))
{
return(ScriptStructure.EngineTypeToScriptStructure(type.Name));
}
PrimitiveType primType = ToPrimitiveType(type);
if (primType == PrimitiveType.Complex)
{
if (IsEnginePointer(type))
{
return(new ScriptPointer(type));
}
else
{
return(new MonoStructure(type.Resolve(), arguments));
}
}
else
{
return(null);
}
}
public ScriptAssemblies.IScript LoadScript(ScriptStructure script)
{
// Find next available AppDomain to put it in
AppDomainStructure FreeAppDomain;
// If we already have loaded file, then reuse that AppDomains
if (AppDomainFiles.ContainsKey(script.AssemblyFileName))
{
FreeAppDomain = AppDomainFiles[script.AssemblyFileName];
}
else
{
FreeAppDomain = GetFreeAppDomain();
}
// Set script object AppDomain
script.AppDomain = FreeAppDomain.CurrentAppDomain;
// Create instance of script
ScriptAssemblies.IScript mbrt = (ScriptAssemblies.IScript)
FreeAppDomain.CurrentAppDomain.CreateInstanceFromAndUnwrap(
script.AssemblyFileName, "ScriptAssemblies.Script");
//, true, BindingFlags.CreateInstance, null);
FreeAppDomain.ScriptsLoaded++;
return(mbrt);
}
public void ExecuteCommand(ref ScriptStructure scriptContainer, EventParams p)
{
m_log.DebugFormat("[{0}] ######################################################", Name);
m_log.DebugFormat("[{0}] Command execution ItemID {1}: \"{2}\".", Name, scriptContainer.ItemID, p.EventName);
scriptContainer.ExecuteEvent(p);
m_log.DebugFormat("[{0}] ######################################################", Name);
}
private static IScriptStructure CreateComplexType(TypeReference type)
{
TypeReference elementType = GetElementType(type);
if (IsEngineStruct(elementType))
{
return(ScriptStructure.EngineTypeToScriptStructure(elementType.Name));
}
TypeDefinition definition = elementType.Resolve();
if (definition.IsEnum)
{
return(null);
}
PrimitiveType primType = ToPrimitiveType(elementType);
if (primType == PrimitiveType.Complex)
{
if (IsEnginePointer(elementType))
{
return(new ScriptPointer(elementType));
}
else
{
return(new MonoStructure(definition));
}
}
else
{
return(null);
}
}
public void ExecuteCommand(EventParams p)
{
ScriptStructure ss = new ScriptStructure();
if (TryGetScript(p.LocalID, p.ItemID, ref ss))
{
ExecuteCommand(ref ss, p);
}
}
//private Dictionary<InstanceData, DetectParams[]> detparms = new Dictionary<InstanceData, DetectParams[]>();
// Load/Unload structure
public void AddScript(ScriptStructure script)
{
lock (LUQueue)
{
if ((LUQueue.Count >= LoadUnloadMaxQueueSize))
{
m_log.ErrorFormat("[{0}] ERROR: Load queue count is at {1} of max {2}. Ignoring load request for script LocalID: {3}, ItemID: {4}.",
Name, LUQueue.Count, LoadUnloadMaxQueueSize, script.LocalID, script.ItemID);
return;
}
LoadUnloadStructure ls = new LoadUnloadStructure();
ls.Script = script;
ls.Action = LoadUnloadStructure.LUType.Load;
LUQueue.Enqueue(ls);
}
}
public bool TryGetScript(uint localID, UUID itemID, ref ScriptStructure script)
{
lock (scriptLock)
{
if (Scripts.ContainsKey(localID) == false)
{
return(false);
}
Dictionary <UUID, ScriptStructure> Obj;
if (Scripts.TryGetValue(localID, out Obj))
{
if (Obj.ContainsKey(itemID) == false)
{
return(false);
}
}
// Get script
return(Obj.TryGetValue(itemID, out script));
}
}
//internal Dictionary<int, IScriptScheduler> ScriptMapping = new Dictionary<int, IScriptScheduler>();
//
// HANDLE EVENTS FROM SCRIPTS
// We will handle script add, change and remove events outside of command pipeline
//
#region Script Add/Change/Remove
void Events_RezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine)
{
// ###
// # New script created
// ###
m_log.DebugFormat(
"[{0}] NEW SCRIPT: localID: {1}, itemID: {2}, startParam: {3}, postOnRez: {4}, engine: {5}",
Name, localID, itemID, startParam, postOnRez, engine);
// Make a script object
ScriptStructure scriptObject = new ScriptStructure();
scriptObject.RegionInfo = RegionInfo;
scriptObject.LocalID = localID;
scriptObject.ItemID = itemID;
scriptObject.Source = script;
//
// Get MetaData from script header
//
ScriptMetaData scriptMetaData = ScriptMetaData.Extract(ref script);
scriptObject.ScriptMetaData = scriptMetaData;
foreach (string key in scriptObject.ScriptMetaData.Keys)
{
m_log.DebugFormat("[{0}] Script metadata: Key: \"{1}\", Value: \"{2}\".", Name, key, scriptObject.ScriptMetaData[key]);
}
//
// Load this assembly
//
// TODO: Use Executor to send a command instead?
m_log.DebugFormat("[{0}] Adding script to scheduler", Name);
RegionInfo.FindScheduler(scriptObject.ScriptMetaData).AddScript(scriptObject);
// Add to our internal mapping
//ScriptMapping.Add(itemID, Schedulers[scheduler]);
}
private void MemAddScript(ScriptStructure script)
{
lock (scriptLock)
{
// Create object if it doesn't exist
if (!Scripts.ContainsKey(script.LocalID))
{
Scripts.Add(script.LocalID, new Dictionary <UUID, ScriptStructure>());
}
// Delete script if it exists
Dictionary <UUID, ScriptStructure> Obj;
if (Scripts.TryGetValue(script.LocalID, out Obj))
{
if (Obj.ContainsKey(script.ItemID) == true)
{
Obj.Remove(script.ItemID);
}
}
// Add to object
Obj.Add(script.ItemID, script);
}
}
public void _StopScript(uint localID, UUID itemID)
{
ScriptStructure ss = new ScriptStructure();
if (!TryGetScript(localID, itemID, ref ss))
{
return;
}
m_log.DebugFormat("[{0}] Unloading script", Name);
// Stop long command on script
//AsyncCommandManager.RemoveScript(ss);
try
{
// Get AppDomain
// Tell script not to accept new requests
ss.Running = false;
ss.Disabled = true;
//AppDomain ad = ss.AppDomain;
// Remove from internal structure
MemRemoveScript(localID, itemID);
// TODO: Tell AppDomain that we have stopped script
}
catch (Exception e) // LEGIT: User Scripting
{
m_log.Error("[" +
Name +
"]: Exception stopping script localID: " +
localID + " LLUID: " + itemID.ToString() +
": " + e.ToString());
}
}
public void AddScript(ScriptStructure scriptStructure)
{
m_ScriptManager.AddScript(scriptStructure);
}
public static void MakeBaseClass(ScriptStructure script)
{
string asmName = "ScriptAssemblies";
string ModuleID = asmName;
string ClassID = "Script";
string moveToDir = "ScriptEngines";
string asmFileName = ModuleID + "_" + ClassID + ".dll";
if (!Directory.Exists(moveToDir))
{
Directory.CreateDirectory(moveToDir);
}
ILGenerator ilgen;
AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName(asmName), AssemblyBuilderAccess.RunAndSave);
// The module builder
ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule(ModuleID, asmFileName);
// The class builder
TypeBuilder classBuilder = modBuilder.DefineType(ClassID, TypeAttributes.Class | TypeAttributes.Public);
// The default constructor
//ConstructorBuilder ctorBuilder = classBuilder.DefineDefaultConstructor(MethodAttributes.Public);
Type[] paramsTypeArray = new Type[] { typeof(System.ParamArrayAttribute) };
Type[] executeFunctionTypeArray = new Type[] { typeof(string), typeof(System.ParamArrayAttribute) };
foreach (IScriptCommandProvider cp in script.RegionInfo.CommandProviders.Values)
{
Type t = cp.GetType();
foreach (MethodInfo mi in t.GetMethods())
{
MethodBuilder methodBuilder = classBuilder.DefineMethod(mi.Name, mi.Attributes, mi.GetType(), Type.EmptyTypes);
methodBuilder.SetParameters(paramsTypeArray);
//ParameterBuilder paramBuilder = methodBuilder.DefineParameter(1, ParameterAttributes.None, "args");
ilgen = methodBuilder.GetILGenerator();
//ilgen.Emit(OpCodes.Nop);
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Ldc_I4_0);
//ilgen.Emit(OpCodes.Ldelem_Ref);
//ilgen.MarkSequencePoint(doc, 6, 1, 6, 100);
//MethodInfo ExecuteFunction = typeof(ScriptAssemblies.IScript).GetMethod(
// "ExecuteFunction",
// executeFunctionTypeArray);
ilgen.DeclareLocal(typeof(string));
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Ldstr, mi.Name);
ilgen.Emit(OpCodes.Stloc_0);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldloc_0);
ilgen.Emit(OpCodes.Ldarg_1);
// FieldInfo testInfo = classBuilder.
//BindingFlags.NonPublic | BindingFlags.Instance);
//ilgen.Emit(OpCodes.Ldfld, testInfo);
//ilgen.EmitCall(OpCodes.Call, ExecuteFunction, executeFunctionTypeArray);
ilgen.EmitCall(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine"), executeFunctionTypeArray);
// // string.Format("Hello, {0} World!", toWhom)
// //
// ilgen.Emit(OpCodes.Ldstr, "Hello, {0} World!");
// ilgen.Emit(OpCodes.Ldarg_1);
// ilgen.Emit(OpCodes.Call, typeof(string).GetMethod
//("Format", new Type[] { typeof(string), typeof(object) }));
// // m_log.Debug("Hello, World!");
// //
// ilgen.Emit(OpCodes.Call, typeof(Console).GetMethod
// ("WriteLine", new Type[] { typeof(string) }));
ilgen.Emit(OpCodes.Ret);
//Label eom = ilgen.DefineLabel();
//ilgen.Emit(OpCodes.Br_S, eom);
//ilgen.MarkLabel(eom);
//ilgen.Emit(OpCodes.Ret);
//Type test = methodBuilder.SetParameters();
//methodBuilder.SetParameters(typeof (object[]));
}
}
//// Two fields: m_firstname, m_lastname
//FieldBuilder fBuilderFirstName = classBuilder.DefineField("m_firstname", typeof(string), FieldAttributes.Private);
//FieldBuilder fBuilderLastName = classBuilder.DefineField("m_lastname", typeof(string), FieldAttributes.Private);
//// Two properties for this object: FirstName, LastName
//PropertyBuilder pBuilderFirstName = classBuilder.DefineProperty("FirstName", System.Reflection.PropertyAttributes.HasDefault, typeof(string), null);
//PropertyBuilder pBuilderLastName = classBuilder.DefineProperty("LastName", System.Reflection.PropertyAttributes.HasDefault, typeof(string), null);
//// Custom attributes for get, set accessors
//MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName;
//// get,set accessors for FirstName
//MethodBuilder mGetFirstNameBuilder = classBuilder.DefineMethod("get_FirstName", getSetAttr, typeof(string), Type.EmptyTypes);
//// Code generation
//ilgen = mGetFirstNameBuilder.GetILGenerator();
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Ldfld, fBuilderFirstName); // returning the firstname field
//ilgen.Emit(OpCodes.Ret);
//MethodBuilder mSetFirstNameBuilder = classBuilder.DefineMethod("set_FirstName", getSetAttr, null, new Type[] { typeof(string) });
//// Code generation
//ilgen = mSetFirstNameBuilder.GetILGenerator();
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Ldarg_1);
//ilgen.Emit(OpCodes.Stfld, fBuilderFirstName); // setting the firstname field from the first argument (1)
//ilgen.Emit(OpCodes.Ret);
//// get,set accessors for LastName
//MethodBuilder mGetLastNameBuilder = classBuilder.DefineMethod("get_LastName", getSetAttr, typeof(string), Type.EmptyTypes);
//// Code generation
//ilgen = mGetLastNameBuilder.GetILGenerator();
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Ldfld, fBuilderLastName); // returning the firstname field
//ilgen.Emit(OpCodes.Ret);
//MethodBuilder mSetLastNameBuilder = classBuilder.DefineMethod("set_LastName", getSetAttr, null, new Type[] { typeof(string) });
//// Code generation
//ilgen = mSetLastNameBuilder.GetILGenerator();
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Ldarg_1);
//ilgen.Emit(OpCodes.Stfld, fBuilderLastName); // setting the firstname field from the first argument (1)
//ilgen.Emit(OpCodes.Ret);
//// Assigning get/set accessors
//pBuilderFirstName.SetGetMethod(mGetFirstNameBuilder);
//pBuilderFirstName.SetSetMethod(mSetFirstNameBuilder);
//pBuilderLastName.SetGetMethod(mGetLastNameBuilder);
//pBuilderLastName.SetSetMethod(mSetLastNameBuilder);
//// Now, a custom method named GetFullName that concatenates FirstName and LastName properties
//MethodBuilder mGetFullNameBuilder = classBuilder.DefineMethod("GetFullName", MethodAttributes.Public, typeof(string), Type.EmptyTypes);
//// Code generation
//ilgen = mGetFullNameBuilder.GetILGenerator();
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Call, mGetFirstNameBuilder); // getting the firstname
//ilgen.Emit(OpCodes.Ldstr, " "); // an space
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Call, mGetLastNameBuilder); // getting the lastname
//// We need the 'Concat' method from string type
//MethodInfo concatMethod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string), typeof(string) });
//ilgen.Emit(OpCodes.Call, concatMethod); // calling concat and returning the result
//ilgen.Emit(OpCodes.Ret);
//// Another constructor that initializes firstname and lastname
//ConstructorBuilder ctorBuilder2 = classBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(string), typeof(string) });
//ctorBuilder2.DefineParameter(1, ParameterAttributes.In, "firstname");
//ctorBuilder2.DefineParameter(2, ParameterAttributes.In, "lastname");
//// Code generation
//ilgen = ctorBuilder2.GetILGenerator();
//// First of all, we need to call the base constructor,
//// the Object's constructor in this sample
//Type objType = Type.GetType("System.Object");
//ConstructorInfo objCtor = objType.GetConstructor(Type.EmptyTypes);
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Call, objCtor); // calling the Object's constructor
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Ldarg_1);
//ilgen.Emit(OpCodes.Call, mSetFirstNameBuilder); // setting the firstname field from the first argument (1)
//ilgen.Emit(OpCodes.Ldarg_0);
//ilgen.Emit(OpCodes.Ldarg_2);
//ilgen.Emit(OpCodes.Call, mSetLastNameBuilder); // setting the lastname field from the second argument (2)
//ilgen.Emit(OpCodes.Ret);
// Finally, create the type and save the assembly
classBuilder.CreateType();
asmBuilder.Save(asmFileName);
string toFile = Path.Combine(moveToDir, asmFileName);
if (File.Exists(toFile))
{
File.Delete(toFile);
}
File.Move(asmFileName, toFile);
//string a = "";
}