public void Replace(IMethodContext context, ModuleDefinition targetModule)
{
var currentMethod = context.CurrentMethod;
var currentArguments = context.CurrentArguments;
var currentArgument = context.CurrentArgument;
var pushMethod = targetModule.ImportMethod <Stack <object> >("Push");
var worker = context.CilWorker;
var methodMap = _context.MethodMap;
var targetDependency = _context.TargetDependency;
var interfaceType = _context.InterfaceType;
var adapterConstructor = _adapterBuilder.CreateAdapterConstructor(methodMap);
foreach (ParameterReference param in currentMethod.Parameters)
{
var arguments = new ParameterContext(worker,
interfaceType,
pushMethod,
currentArguments,
currentArgument,
targetDependency, adapterConstructor, param);
// Save the current argument
_pushParameter.Adapt(arguments);
}
}
public void Replace(IMethodContext context, ModuleDefinition targetModule)
{
var currentMethod = context.CurrentMethod;
var currentArguments = context.CurrentArguments;
var currentArgument = context.CurrentArgument;
var pushMethod = targetModule.ImportMethod<Stack<object>>("Push");
var worker = context.CilWorker;
var methodMap = _context.MethodMap;
var targetDependency = _context.TargetDependency;
var interfaceType = _context.InterfaceType;
var adapterConstructor = _adapterBuilder.CreateAdapterConstructor(methodMap);
foreach (ParameterReference param in currentMethod.Parameters)
{
var arguments = new ParameterContext(worker,
interfaceType,
pushMethod,
currentArguments,
currentArgument,
targetDependency, adapterConstructor, param);
// Save the current argument
_pushParameter.Adapt(arguments);
}
}
public static void Data(IList args, IMethodContext context)
{
ImplLogger.LogImpl("customdata", args);
var type = (MatchingType)args[0];
var filter = (string)args[1];
var append = (bool)args[2];
var permision = (DataPermision)args[3];
var value = (string)args[4];
List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>();
BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks);
ImplLogger.LogBlocks(blocks);
foreach (var block in blocks)
{
if (block is IMyProgrammableBlock && permision < DataPermision.AllowPB)
{
Log.Write(ImplLogger.LOG_CAT, LogLevel.Error, "permition AllowPB required to overwrite programmable block's data");
Log.Write(ImplLogger.LOG_CAT, LogLevel.Error, $"skipping \"{block.CustomName}\"");
continue;
}
if (block == Program.Current.Me && permision < DataPermision.AllowSelf)
{
Log.Write(ImplLogger.LOG_CAT, LogLevel.Error, "permition AllowSelf required to overwrite user script");
Log.Write(ImplLogger.LOG_CAT, LogLevel.Error, $"skipping \"{block.CustomName}\" (this is me)");
continue;
}
block.CustomData = append ? (block.CustomData + value) : value;
}
}
internal static void ListActions(IList args, IMethodContext context)
{
ImplLogger.LogImpl("listactions", args);
MatchingType type = (MatchingType)args[0];
string filter = (string)args[1];
List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>();
BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks);
ImplLogger.LogBlocks(blocks);
List <ITerminalAction> actions = new List <ITerminalAction>();
foreach (var block in blocks)
{
Log.WriteFormat("block \"{0}\" of type \"{1}\" have actions:", new object[] { block.CustomName, block.GetType().Name });
actions.Clear();
block.GetActions(actions);
foreach (var action in actions)
{
Log.WriteFormat("\"{0}\": {1}", new object[] { action.Id, action.Name });
}
Log.WriteLine();
}
}
private static void ListBlocks(IList args, IMethodContext context)
{
ImplLogger.LogImpl("listblocks", args);
MatchingType type = (MatchingType)args[0];
string filter = (string)args[1];
List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>();
BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks);
ImplLogger.LogBlocks(blocks);
Log.Write("TypeName/SubtypeName \"Name\" [IntityId]");
Log.WriteLine();
foreach (var block in blocks)
{
Log.WriteFormat("{0}/{1} \"{2}\" [{3}]", new object[] {
block.GetType().Name,
block.BlockDefinition.SubtypeName,
block.CustomName,
block.EntityId
});
}
}
internal static void Test3(IList args, IMethodContext context)
{
ImplLogger.LogImpl("test3", args);
MatchingType type = (MatchingType)args[0];
string filter = (string)args[1];
// string prop = (string)args[2];
var blocks = new List <IMyTerminalBlock>();
BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks);
ImplLogger.LogBlocks(blocks);
Log.Write("TypeName/SubtypeName \"Name\" [IntityId]");
Log.WriteLine();
foreach (var block in blocks)
{
var propDef = block.GetProperty("FontColor");
Log.WriteFormat("name as sb {0}", propDef.As <Color>());
Log.WriteFormat("name as int {0}", propDef.As <int>());
Log.WriteFormat("existing prop {0}", block.GetProperty("FontColor"));
Log.WriteFormat("unexisting prop {0}", block.GetProperty("someunexistingproperty"));
}
}
public static void Action(IList args, IMethodContext context)
{
ImplLogger.LogImpl("action", args);
MatchingType type = (MatchingType)args[0];
string filter = (string)args[1];
string action = (string)args[2];
List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>();
BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks);
ImplLogger.LogBlocks(blocks);
foreach (var block in blocks)
{
if (block.HasAction(action))
{
block.ApplyAction(action);
}
else
{
Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, "block \"{0}\" does not support action \"{1}\", ignoring", block.CustomName, action);
}
}
}
public void Replace(IMethodContext methodContext, ModuleDefinition module)
{
// Put all the method arguments into the argument stack
_pushMethodArguments.Replace(methodContext, module);
// Push the arguments back onto the stack
_popMethodArguments.Replace(methodContext, module);
}
public void Replace(IMethodContext methodContext, ModuleDefinition module)
{
// Put all the method arguments into the argument stack
_pushMethodArguments.Replace(methodContext, module);
// Push the arguments back onto the stack
_popMethodArguments.Replace(methodContext, module);
}
public static void AddInput(IList args, IMethodContext context)
{
var action = (string)args[0];
var _event = (InputEvent)args[1];
var method = (string)args[2];
CMMapper.Shared.Add(action, _event, method);
}
public static void RemoveInput(IList args, IMethodContext context)
{
ImplLogger.LogImpl("cm_removeInput", args);
var action = (string)args[0];
var _event = (InputEvent?)args[1];
var method = (string)args[2];
CMMapper.Shared.Remove(action, _event, method);
}
internal static void Test2(IList args, IMethodContext context)
{
var surface = Program.Current.Me.GetSurface(0);
var sprites = new List <string>();
surface.GetSprites(sprites);
//sprites.ForEach(x => Log.Write(x));
var frame = surface.DrawFrame();
frame.Add(new MySprite(SpriteType.TEXTURE, "Construction", new Vector2(0, 0), new Vector2(100, 100)));
//frame.Dispose();
}
public void Replace(IMethodContext context, ModuleDefinition targetModule)
{
var currentMethod = context.CurrentMethod;
var currentArguments = context.CurrentArguments;
var popMethod = targetModule.ImportMethod<Stack<object>>("Pop");
var IL = context.CilWorker;
foreach (ParameterReference param in currentMethod.Parameters)
{
IL.Emit(OpCodes.Ldloc, currentArguments);
IL.Emit(OpCodes.Callvirt, popMethod);
IL.Emit(OpCodes.Unbox_Any, param.ParameterType);
}
}
public void Replace(IMethodContext context, ModuleDefinition targetModule)
{
var currentMethod = context.CurrentMethod;
var currentArguments = context.CurrentArguments;
var popMethod = targetModule.ImportMethod <Stack <object> >("Pop");
var IL = context.CilWorker;
foreach (ParameterReference param in currentMethod.Parameters)
{
IL.Emit(OpCodes.Ldloc, currentArguments);
IL.Emit(OpCodes.Callvirt, popMethod);
IL.Emit(OpCodes.Unbox_Any, param.ParameterType);
}
}
public static void Switch(IList args, IMethodContext context)
{
ImplLogger.LogImpl("switch", args);
int var = (int)(context.Get((string)args[0]));
IList cases = (IList)args[1];
if (var < 0 || var >= cases.Count)
{
Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, "Value {0} is out of bounds (0..{1})", var, cases.Count);
}
else
{
context.Runtime.StartProgram((string)cases[var]);
}
}
internal static void Load(IList args, IMethodContext context)
{
ImplLogger.LogImpl("load", args);
Parser parser = new Parser((string)args[0]);
parser.Parse(() => false);
if (parser.Finalize())
{
context.Runtime.RegisterPrograms(parser.Programs);
}
else
{
Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, "exception during parsing: {0}", parser.ErrorMessage);
}
}
public static void Run(IList args, IMethodContext context)
{
ImplLogger.LogImpl("run", args);
MatchingType type = (MatchingType)args[0];
string filter = (string)args[1];
string argument = (string)args[2];
List <IMyProgrammableBlock> blocks = new List <IMyProgrammableBlock>();
BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks);
ImplLogger.LogBlocks(blocks);
foreach (var block in blocks)
{
block.TryRun(argument);
}
}
private IReadOnlyList <TryCatchBlock> TranslateSehBlocks(IMethod method, IMethodContext context, IList <SEHBlock> blocks, ILStream code)
{
var list = new List <TryCatchBlock>();
var handlers = new BlockList();
TryCatchBlock tryBlock = null;
int n = blocks.Count;
for (int i = 0; i < n; ++i)
{
var block = blocks[i];
tryBlock = EnshureTryBlock(blocks, i, tryBlock, code, block, list);
var handler = CreateHandlerBlock(method, context, code, block);
int entryIndex = code.GetOffsetIndex(block.HandlerOffset);
int exitIndex = GetIndex(code, block.HandlerOffset, block.HandlerLength);
handler.EntryPoint = code[entryIndex];
handler.ExitPoint = code[exitIndex];
tryBlock.Handlers.Add(handler);
handlers.Add(handler);
}
//set parents
for (int i = 0; i < list.Count; ++i)
{
var block = list[i];
var parent = FindParent(list, block);
if (parent != null)
{
parent.Add(block);
list.RemoveAt(i);
--i;
}
}
foreach (var block in list)
{
SetupInstructions(code, block);
}
return(list.AsReadOnlyList());
}
private HandlerBlock CreateHandlerBlock(IMethod method, IMethodContext context, IInstructionList code, SEHBlock block)
{
switch (block.Type)
{
case SEHFlags.Catch:
{
int token = block.Value;
var type = context.ResolveType(method, token);
if (!HasGenericExceptions && type.IsGenericContext())
{
_genericFlags |= GenericFlags.HasGenericExceptions;
}
var h = new HandlerBlock(BlockType.Catch)
{
ExceptionType = type
};
return(h);
}
case SEHFlags.Filter:
{
var h = new HandlerBlock(BlockType.Filter)
{
FilterIndex = code.GetOffsetIndex(block.Value)
};
return(h);
}
case SEHFlags.Finally:
return(new HandlerBlock(BlockType.Finally));
case SEHFlags.Fault:
return(new HandlerBlock(BlockType.Fault));
default:
throw new IndexOutOfRangeException();
}
}
// static blocks
internal static void Test1(IList args, IMethodContext context)
{
ImplLogger.LogImpl("test1", args);
MatchingType type = (MatchingType)args[0];
string filter = (string)args[1];
List <IMyTextSurfaceProvider> blocks = new List <IMyTextSurfaceProvider>();
BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks);
ImplLogger.LogBlocks(blocks);
Log.Write("TypeName/SubtypeName \"Name\" [IntityId]");
Log.WriteLine();
foreach (var lcd in blocks)
{
var block = lcd as IMyTerminalBlock;
Log.Write($"{block.GetType().Name}/{block.BlockDefinition.SubtypeName} \"{block.CustomName}\" [{block.EntityId}]");
Log.WriteFormat("surfaces count: {0}", lcd.SurfaceCount);
}
}
private ILStream ReadCode(IMethod method, IMethodContext context, BufferedBinaryReader reader, int codeSize)
{
var list = new ILStream();
var startPos = reader.Position;
int offset = 0;
while (offset < codeSize)
{
var pos = reader.Position;
var instr = ReadInstruction(method, context, reader, startPos);
var size = reader.Position - pos;
offset += (int)size;
instr.Index = list.Count;
list.Add(instr);
if (!HasGenericInstructions && instr.IsGenericContext)
{
_genericFlags |= GenericFlags.HasGenericInstructions;
}
}
return(list);
}
public static void Text(IList args, IMethodContext context)
{
ImplLogger.LogImpl("text", args);
MatchingType type = (MatchingType)args[0];
string filter = (string)args[1];
int index = (int)(double)args[2];
bool append = (bool)args[3];
string text = (string)args[4];
var blocks = new List <IMyTextSurfaceProvider>();
BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks);
ImplLogger.LogBlocks(blocks);
foreach (var block in blocks)
{
IMyTextSurface surface;
if (block is IMyTextPanel && index == 0)
{
surface = block as IMyTextSurface;
}
else
{
surface = block.GetSurface(index);
}
if (surface != null)
{
surface?.WriteText(text, append);
}
else
{
Log.Write(ImplLogger.LOG_CAT, LogLevel.Verbose, "surface index out of range");
}
}
}
internal static void LogLevel_(IList args, IMethodContext context)
{
ImplLogger.LogImpl("loglevel", args);
string cat = (string)args[0];
double level = (double)args[1];
if (string.IsNullOrEmpty(cat))
{
Log.Write("LogLevels:");
foreach (var kvp in Log.LogLevels)
{
Log.WriteFormat("{0} : {1}", kvp.Key, kvp.Value);
}
}
else
{
if (level < 0)
{
Log.WriteFormat("LogLevel for \"{0}\": {1}", cat, Log.LogLevels.ContainsKey(cat) ? Log.LogLevels[cat] : LogLevel.None);
}
else
{
if (cat.Equals("all", StringComparison.InvariantCultureIgnoreCase))
{
foreach (var key in new List <string>(Log.LogLevels.Keys))
{
Log.LogLevels[key] = (LogLevel)level;
}
}
else
{
Log.LogLevels[cat] = (LogLevel)level;
}
}
}
}
// Tries to find a method by name from the list of contexts
internal bool TryGetMethod(string MethodName, out MethodInfo Method, out IMethodContext Context,
out bool RequiresValidation)
{
lock (ContextList)
{
foreach (var MethodContext in ContextList)
{
if (MethodContext.GetType().GetMethods().Any(x => x.GetCustomAttributes(true)
.Any(i => i is ApiMethod && ((ApiMethod)i).MethodName == MethodName)))
{
Method = MethodContext.GetType().GetMethods().First(x => x.GetCustomAttributes(true)
.Any(i => i is ApiMethod && ((ApiMethod)i).MethodName == MethodName));
Context = MethodContext;
RequiresValidation = Method.GetCustomAttributes(true).Any(i => i is ApiMethod &&
((ApiMethod)i).RequiresValidation);
return(true);
}
}
Method = null;
Context = null;
RequiresValidation = false;
return(false);
}
}
internal static void Unload(IList args, IMethodContext context)
{
ImplLogger.LogImpl("unload", args);
context.Runtime.UnloadProgram((string)args[0]);
}
public override void Compile(IMethodContext context)
{
var ic = InstructionChain.FromInstructions(context.Instruction);
while (!ic.EndOfInstructions)
{
if (Compile(context, ic))
ic.Increment();
}
ic.Reset();
for (; !ic.EndOfInstructions; ic++)
{
var ins = ic.Instruction;
if (ins.Code != InstructionCode.ZilStore)
continue;
var next = ins.Next;
if (next == null || next.Code != InstructionCode.ZilLoad || ins.Operand0 != next.Operand0)
continue;
//store and immediate load can be replaced with NOOP
ic.Remove(); // store
ic.Remove(); // load
}
}
public override void Execute(IMethodContext context)
{
"login filter ->{0} execting".Log4Debug(context.Handler);
base.Execute(context);
"login filter ->{0} exected".Log4Debug(context.Handler);
}
public virtual void Execute(IMethodContext context)
{
context.Execute();
}
public void Add(string key, IMethodContext methodContext)
{
_compilationContexts[key] = methodContext;
}
public virtual bool Compile(IMethodContext context, InstructionChain chain)
{
var ins = chain.Instruction;
Simplifier simplifier;
if (Simplifiers.TryGetValue(ins.Code, out simplifier))
simplifier(context, ins);
else
{
// default operation
}
//remove jumping branches that go to the next instruction
if (ins.Code == InstructionCode.CilBr && ins.Operand0 == ins.Next)
{
chain.Remove();
return false;
}
return true;
}
public static void Stop(IList args, IMethodContext context)
{
ImplLogger.LogImpl("stop", args);
context.Runtime.StopProgram((string)args[0]);
}
public override void Execute(IMethodContext context)
{
"admin filter ->{0}".Log4Debug(context.Handler);
base.Execute(context);
}
public abstract void Compile(IMethodContext context);
public static void Transmit(IList args, IMethodContext context)
{
ImplLogger.LogImpl("transmit", args);
MatchingType matchingType = (MatchingType)args[0];
string filter = (string)args[1];
string targetString = (string)args[2];
string message = (string)args[3];
List <IMyTerminalBlock> antennas = new List <IMyTerminalBlock>();
List <IMyRadioAntenna> radioAntennas = new List <IMyRadioAntenna>();
BlockSelector.GetBlocksOfTypeWithQuery(matchingType, filter, radioAntennas);
ImplLogger.LogBlocks(antennas);
//get most powerful radio antenna
IMyRadioAntenna mostPowerfulAntenna = null;
//get radio antenna with longest radius that's enabled and broadcasting
foreach (IMyRadioAntenna antenna in radioAntennas)
{
if (antenna.Enabled && antenna.GetValueBool("EnableBroadCast") &&
(mostPowerfulAntenna == null || antenna.Radius > mostPowerfulAntenna.Radius))
{
mostPowerfulAntenna = antenna;
}
}
if (mostPowerfulAntenna != null)
{
antennas.Add(mostPowerfulAntenna);
}
//--------get all laser antennas
List <IMyLaserAntenna> laserAntennas = new List <IMyLaserAntenna>();
BlockSelector.GetBlocksOfTypeWithQuery(matchingType, filter, laserAntennas);
Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Verbose, "{0} block(s) found", laserAntennas.Count);
foreach (IMyLaserAntenna antenna in laserAntennas)
{
if (antenna.Status == MyLaserAntennaStatus.Connected)
{
antennas.Add(antenna);
}
}
//-----check whether at least one valid antenna was found
if (antennas.Count != 0)
{
var transmitter = new Transmitter(antennas);
transmitter.Transmit(message, targetString);
}
else
{
string warning;
switch (matchingType)
{
default:
case MatchingType.Match:
warning = string.Format("No antennas called \"{0}\" are currently able to transmit.", filter);
break;
case MatchingType.Contains:
warning = string.Format("No antennas containing \"{0}\" are currently able to transmit.", filter);
break;
case MatchingType.Head:
warning = string.Format("No antennas starting with \"{0}\" are currently able to transmit.", filter);
break;
case MatchingType.Group:
warning = string.Format("No antennas in group \"{0}\" are currently able to transmit.", filter);
break;
case MatchingType.Type:
warning = string.Format("No antennas of type \"{0}\" are currently able to transmit.", filter);
break;
}
Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, warning);
}
}
public static void WaitTicks(IList args, IMethodContext context)
{
ImplLogger.LogImpl("waitticks", args);
context.Wait(((double)args[0]) / 60);
}
public override void Execute(IMethodContext context)
{
"login filter ->{0} execting".Log4Debug(context.Handler);
base.Execute(context);
"login filter ->{0} exected".Log4Debug(context.Handler);
}
public static void Repeat(IList args, IMethodContext context)
{
ImplLogger.LogImpl("repeat", args);
context.Goto(0);
}
public override void Execute(IMethodContext context)
{
"admin filter ->{0}".Log4Debug(context.Handler);
base.Execute(context);
}
public static void SetVar(IList args, IMethodContext context)
{
ImplLogger.LogImpl("setvar", args);
context.Set((string)args[0], (double)args[1]);
}
// Assigns our method context in which we will invoke methods
internal void AssignMethodContext(IMethodContext Context)
{
MethodContext = Context;
}
public override void Compile(IMethodContext context)
{
}
public object Execute(IMethodContext context, object[] parameters)
{
return mHandler.Execute(Controller, parameters);
}
