protected SessionAwareByteArrayRequiringValueSerializer(byte manifest,
Expression <Func <Action <Stream, TElementType, byte[]> > > writeStaticMethod,
Expression <Func <Func <Stream, byte[], TElementType> > > readStaticMethod)
{
_manifest = manifest;
_write = GetStatic(writeStaticMethod, typeof(void));
_read = GetStatic(readStaticMethod, typeof(TElementType));
#if NET45
var c = new IlCompiler <Action <Stream, object, byte[]> >();
#else
var c = new Compiler <Action <Stream, object, byte[]> >();
#endif
var stream = c.Parameter <Stream>("stream");
var value = c.Parameter <object>("value");
var buffer = c.Parameter <byte[]>("buffer");
var valueTyped = c.CastOrUnbox(value, typeof(TElementType));
c.EmitStaticCall(_write, stream, valueTyped, buffer);
_writeCompiled = c.Compile();
#if NET45
var c2 = new IlCompiler <Func <Stream, byte[], TElementType> >();
#else
var c2 = new Compiler <Func <Stream, byte[], TElementType> >();
#endif
var stream2 = c2.Parameter <Stream>("stream");
var buffer2 = c2.Parameter <byte[]>("buffer");
c2.EmitStaticCall(_read, stream2, buffer2);
_readCompiled = c2.Compile();
}
public bool CompileIngameScript(MyStringId id, StringBuilder errors)
{
#if XB1 // XB1_ALLINONEASSEMBLY
System.Diagnostics.Debug.Assert(false, "XB1 TODO?");
return(false);
#else // !XB1
// TODO: Not in use. Remove when Roslyn scripts are activated
if (!MyFakes.ENABLE_SCRIPTS)
{
return(false);
}
Assembly assembly;
bool success;
success = IlCompiler.Compile(new string[] { InGameScriptsCode[id].ToString() }, out assembly, false);
if (success)
{
var scriptType = typeof(MyIngameScript);
if (InGameScripts.ContainsKey(id))
{
InGameScripts.Remove(id);
}
foreach (var type in assembly.GetTypes())
{
if (scriptType.IsAssignableFrom(type))
{
InGameScripts.Add(id, type);
return(true);
}
}
}
return(false);
#endif // !XB1
}
private static ObjectReader GetDelegate(Type type, FieldInfo[] fields, Serializer serializer)
{
var c = new IlCompiler <ObjectReader>();
var stream = c.Parameter <Stream>("stream");
var session = c.Parameter <DeserializerSession>("session");
var newExpression = c.NewObject(type);
var target = c.Variable <object>("target");
var assignNewObjectToTarget = c.WriteVar(target, newExpression);
c.Emit(assignNewObjectToTarget);
var size = c.Constant(16);
var buffer = c.Variable <byte[]>(DefaultCodeGenerator.PreallocatedByteBuffer);
var bufferValue = c.Call(typeof(DeserializerSession).GetMethod("GetBuffer"), session, size);
var assignBuffer = c.WriteVar(buffer, bufferValue);
c.Emit(assignBuffer);
var typedTarget = c.CastOrUnbox(target, type);
foreach (var field in fields)
{
var s = serializer.GetSerializerByType(field.FieldType);
var read = s.EmitReadValue(c, stream, session, field);
var assignReadToField = c.WriteField(field, typedTarget, read);
c.Emit(assignReadToField);
}
c.Emit(target);
var readAllFields = c.Compile();
return(readAllFields);
}
protected SessionIgnorantValueSerializer(byte manifest,
Expression <Func <Action <Stream, TElementType> > > writeStaticMethod,
Expression <Func <Func <Stream, TElementType> > > readStaticMethod)
{
_manifest = manifest;
_write = GetStatic(writeStaticMethod, typeof(void));
_read = GetStatic(readStaticMethod, typeof(TElementType));
#if DESKTOPCLR
var c = new IlCompiler <Action <Stream, object> >();
#else
var c = new Compiler <Action <Stream, object> >();
#endif
var stream = c.Parameter <Stream>("stream");
var value = c.Parameter <object>("value");
var valueTyped = c.CastOrUnbox(value, typeof(TElementType));
c.EmitStaticCall(_write, stream, valueTyped);
_writeCompiled = c.Compile();
#if DESKTOPCLR
var c2 = new IlCompiler <Func <Stream, TElementType> >();
#else
var c2 = new Compiler <Func <Stream, TElementType> >();
#endif
var stream2 = c2.Parameter <Stream>("stream");
c2.EmitStaticCall(_read, stream2);
_readCompiled = c2.Compile();
}
public void CanCreateEmptyMethodWithArguments()
{
var c = new IlCompiler <Action <bool> >();
var a = c.Compile();
a(true);
}
public bool CompileIngameScript(MyStringId id, StringBuilder errors)
{
if (!MyFakes.ENABLE_SCRIPTS)
{
return(false);
}
Assembly assembly;
bool success;
success = IlCompiler.Compile(new string[] { InGameScriptsCode[id].ToString() }, out assembly, false);
if (success)
{
var scriptType = typeof(MyIngameScript);
if (InGameScripts.ContainsKey(id))
{
InGameScripts.Remove(id);
}
foreach (var type in assembly.GetTypes())
{
if (scriptType.IsAssignableFrom(type))
{
InGameScripts.Add(id, type);
return(true);
}
}
}
return(false);
}
public void CanCreateEmptyMethod()
{
var c = new IlCompiler <Action>();
var a = c.Compile();
a();
}
public static bool CompileProgram(string program, List <string> errors, ref Assembly assembly)
{
#if !XB1
if (!string.IsNullOrEmpty(program))
{
if (MyFakes.ENABLE_ROSLYN_SCRIPTS)
{
var messageList = new List <MyScriptCompiler.Message>();
assembly = MyScriptCompiler.Static.Compile(
MyApiTarget.Ingame,
Path.Combine(MyFileSystem.UserDataPath, "EditorCode.dll"),
MyScriptCompiler.Static.GetIngameScript(program, "Program", typeof(MyGridProgram).Name),
messageList).Result;
errors.Clear();
errors.AddRange(messageList.OrderByDescending(m => m.Severity).Select(m => m.Text));
return(assembly != null);
}
string finalCode = CODE_WRAPPER_BEFORE + program + CODE_WRAPPER_AFTER;
if (true == IlCompiler.CompileStringIngame(Path.Combine(MyFileSystem.UserDataPath, "IngameScript.dll"), new string[] { finalCode }, out assembly, errors))
{
return(true);
}
}
#else // XB1
System.Diagnostics.Debug.Assert(false, "No scripts on XB1");
#endif // XB1
return(false);
}
private void Compile(IEnumerable <string> scriptFiles, string assemblyName, bool zipped, MyModContext context)
{
#if XB1
System.Diagnostics.Debug.Assert(false, "Unsupported runtime script compilation on XB1.");
#else
Assembly assembly = null;
bool compiled = false;
if (zipped)
{
var tmp = Path.GetTempPath();
foreach (var file in scriptFiles)
{
try
{
var newPath = string.Format("{0}{1}", tmp, Path.GetFileName(file));
var stream = MyFileSystem.OpenRead(file);
using (var sr = new StreamReader(stream))
{
stream = MyFileSystem.OpenWrite(newPath);// (newPath);
using (var sw = new StreamWriter(stream))
{
sw.Write(sr.ReadToEnd()); //create file in tmp for debugging
}
}
m_cachedFiles.Add(newPath);
}
catch (Exception e)
{
MySandboxGame.Log.WriteLine(e);
MyDefinitionErrors.Add(context, string.Format("Cannot load {0}", Path.GetFileName(file)), TErrorSeverity.Error);
MyDefinitionErrors.Add(context, e.Message, TErrorSeverity.Error);
}
}
compiled = IlCompiler.CompileFileModAPI(assemblyName, m_cachedFiles.ToArray(), out assembly, m_errors);
}
else
{
compiled = IlCompiler.CompileFileModAPI(assemblyName, scriptFiles.ToArray(), out assembly, m_errors);
}
Debug.Assert(compiled == (assembly != null), "Compile results inconsistency!");
if (assembly != null && compiled)
{
AddAssembly(context, MyStringId.GetOrCompute(assemblyName), assembly);
}
else
{
MyDefinitionErrors.Add(context, string.Format("Compilation of {0} failed:", assemblyName), TErrorSeverity.Error);
MySandboxGame.Log.IncreaseIndent();
foreach (var error in m_errors)
{
MyDefinitionErrors.Add(context, error.ToString(), TErrorSeverity.Error);
Debug.Assert(false, error.ToString());
}
MySandboxGame.Log.DecreaseIndent();
m_errors.Clear();
}
m_cachedFiles.Clear();
#endif
}
private void Compile(IEnumerable <string> scriptFiles, string assemblyName, bool zipped)
{
Assembly assembly = null;
var c = new MyModContext();
c.Init(assemblyName, assemblyName);
if (zipped)
{
var tmp = Path.GetTempPath();
foreach (var file in scriptFiles)
{
try
{
var newPath = string.Format("{0}{1}", tmp, Path.GetFileName(file));
var stream = MyFileSystem.OpenRead(file);
using (var sr = new StreamReader(stream))
{
stream = MyFileSystem.OpenWrite(newPath);// (newPath);
using (var sw = new StreamWriter(stream))
{
sw.Write(sr.ReadToEnd()); //create file in tmp for debugging
}
}
m_cachedFiles.Add(newPath);
}
catch (Exception e)
{
MySandboxGame.Log.WriteLine(e);
MyDefinitionErrors.Add(c, string.Format("Cannot load {0}", Path.GetFileName(file)), ErrorSeverity.Error);
MyDefinitionErrors.Add(c, e.Message, ErrorSeverity.Error);
}
}
IlCompiler.CompileFileModAPI(assemblyName, m_cachedFiles.ToArray(), out assembly, m_errors);
}
else
{
IlCompiler.CompileFileModAPI(assemblyName, scriptFiles.ToArray(), out assembly, m_errors);
}
if (assembly != null)
{
AddAssembly(MyStringId.GetOrCompute(assemblyName), assembly);
}
else
{
MyDefinitionErrors.Add(c, string.Format("Compilation of {0} failed:", assemblyName), ErrorSeverity.Error);
MySandboxGame.Log.IncreaseIndent();
foreach (var error in m_errors)
{
MyDefinitionErrors.Add(c, error.ToString(), ErrorSeverity.Error);
Debug.Assert(false, error.ToString());
}
MySandboxGame.Log.DecreaseIndent();
m_errors.Clear();
}
m_cachedFiles.Clear();
}
public void CanCreateObject()
{
var c = new IlCompiler <Func <Dummy> >();
var obj = c.NewObject(typeof(Dummy));
c.Emit(obj);
var a = c.Compile();
a();
}
public void CanReturnConstantString()
{
var c = new IlCompiler <Func <string> >();
var b = c.Constant("hello");
c.Emit(b);
var a = c.Compile();
var res = a();
Assert.Equal("hello", res);
}
public void CanCreateEmptyMethodWithReturnType()
{
var c = new IlCompiler <Func <bool> >();
var b = c.Constant(true);
c.Emit(b);
var a = c.Compile();
var res = a();
Assert.Equal(true, res);
}
public void CanCreateObjectAndStoreInVar()
{
var c = new IlCompiler <Action>();
var variable = c.Variable <Dummy>("dummy");
var obj = c.NewObject(typeof(Dummy));
var assign = c.WriteVar(variable, obj);
c.Emit(assign);
var a = c.Compile();
a();
}
public void CanStoreBoolInField()
{
var c = new IlCompiler <Action>();
var True = c.Constant(true);
var obj = c.NewObject(typeof(Dummy));
var write = c.WriteField(BoolField, obj, True);
c.Emit(write);
var a = c.Compile();
a();
}
public void CanCallStaticMethodUsingParameter()
{
var c = new IlCompiler <Action <Dummy> >();
var param = c.Parameter <Dummy>("dummy");
c.EmitStaticCall(SetStatic, param);
var a = c.Compile();
var dummy = new Dummy();
a(dummy);
Assert.Equal(true, dummy.BoolField);
}
public void CanCallInstanceMethodOnParameter()
{
var c = new IlCompiler <Action <Dummy> >();
var param = c.Parameter <Dummy>("dummy");
c.EmitCall(SetBool, param);
var a = c.Compile();
var dummy = new Dummy();
a(dummy);
Assert.Equal(true, dummy.BoolField);
}
public static bool CompileProgram(string program, List <string> errors, ref Assembly assembly)
{
if (program != null && program.Length > 0)
{
string finalCode = CODE_WRAPPER_BEFORE + program + CODE_WRAPPER_AFTER;
if (true == IlCompiler.CompileString("IngameScript.dll", new string[] { finalCode }, out assembly, errors))
{
return(true);
}
}
return(false);
}
public void CanModifyParameter()
{
var c = new IlCompiler <Action <Dummy> >();
var param = c.Parameter <Dummy>("dummy");
var write = c.WriteField(BoolField, param, c.Constant(true));
c.Emit(write);
var a = c.Compile();
var dummy = new Dummy();
a(dummy);
Assert.Equal(true, dummy.BoolField);
}
public void CanCastToAndFromObject()
{
var c = new IlCompiler <Action>();
var True = c.Constant(true);
var boxedBool = c.Convert(True, typeof(object));
var unboxedBool = c.CastOrUnbox(boxedBool, typeof(bool));
var obj = c.NewObject(typeof(Dummy));
var write = c.WriteField(BoolField, obj, unboxedBool);
c.Emit(write);
var a = c.Compile();
a();
}
private bool CallScriptInternal(string message)
{
Assembly ass;
if (IlCompiler.Buffer.Length > 0)
{
if (IlCompiler.Compile(new string[] { IlCompiler.Buffer.ToString() }, out ass, true))
{
var retval = ass.GetType("wrapclass").GetMethod("run").Invoke(null, null);
if (!string.IsNullOrEmpty(message))
{
Sandbox.Game.Gui.MyHud.Chat.ShowMessage("returned", retval.ToString());
}
return(true);
IlCompiler.Buffer.Clear();
}
else
{
IlCompiler.Buffer.Clear();
return(false);
}
}
var parts = message.Split(Separators, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length < 3)
{
MyAPIGateway.Utilities.ShowNotification("Not enought parameters for script please provide following paramaters : Sriptname Classname MethodName", 5000);
return(false);
}
if (!Scripts.ContainsKey(MyStringId.TryGet(parts[1])))
{
string availableScripts = "";
foreach (var scriptName in Scripts)
{
availableScripts += scriptName.Key + "\n";
}
MyAPIGateway.Utilities.ShowMissionScreen("Script not found", "", "Available scripts:", availableScripts);
return(false);
}
ass = Scripts[MyStringId.Get(parts[1])];
var type = ass.GetType(parts[2]);
if (type == null)
{
string availableScripts = "";
var types = ass.GetTypes();
foreach (var scriptType in types)
{
availableScripts += scriptType.FullName + "\n";
}
MyAPIGateway.Utilities.ShowMissionScreen("Class not found", "", "Available classes:", availableScripts);
return(false);
}
var method = type.GetMethod(parts[3]);
if (method == null)
{
string availableScripts = "";
var types = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
foreach (var scriptType in types)
{
availableScripts += scriptType.Name + "\n";
}
MyAPIGateway.Utilities.ShowMissionScreen("Method not found", "", "Available methods:", availableScripts);
return(false);
}
var paramInfos = method.GetParameters();
List <object> parameters = new List <object>();
for (int i = 4; i < paramInfos.Length + 4 && i < parts.Length; i++)
{
var paramType = paramInfos[i - 4].ParameterType;
var parseMet = paramType.GetMethod("TryParse", new Type[] { typeof(System.String), paramType.MakeByRefType() });
if (parseMet != null)
{
var output = Activator.CreateInstance(paramType);
var args = new object[] { parts[i], output };
var par = parseMet.Invoke(null, args);
parameters.Add(args[1]);
}
else
{
parameters.Add(parts[i]);
}
}
if (paramInfos.Length == parameters.Count)
{
var retval = method.Invoke(null, parameters.ToArray());
if (retval != null)
{
Sandbox.Game.Gui.MyHud.Chat.ShowMessage("return value", retval.ToString());
}
Sandbox.Game.Gui.MyHud.Chat.ShowMessage("Call", "Success");
return(true);
}
return(false);
}
