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 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 static void Repeat(IList args, IMethodContext context) { ImplLogger.LogImpl("repeat", args); context.Goto(0); }
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); }