public void PlateauSizeMissWidthOrLengthShouldThrowException() { var instructionSet = new InstructionSet(); instructionSet.Add("55"); instructionSet.GetPlateau(); }
public void InvalidPlateauSouthToNorthLengthShouldThrowException() { var instructionSet = new InstructionSet(); instructionSet.Add("55 A"); instructionSet.GetPlateau(); }
public void InvalidPlateauWestToEastLengthShouldThrowException() { var instructionSet = new InstructionSet(); instructionSet.Add("A 55"); instructionSet.GetPlateau(); }
public InstructionSet BuildPath(Point Start, ElementTypes Type, Direction CurrentDirection) { AlreadySearched = new List<Node>(); Shortest = null; distance = int.MaxValue; AlreadyTraveled = new List<Point>(); if (!GeneratedYet) GenerateMatrix(); Path N = FindClosestPath(Start, CurrentDirection); if (N != null) AlreadyTraveled.Add(N.Start.Location); InstructionSet Mine = new InstructionSet(); List<Path> Begin = new List<Path>(); Begin.Add(N); if (N != null) { BuildPath(new InstructionSet(Begin), Type, N.End); } //N.End.BuildPath(new InstructionSet(Begin), Type); return Shortest; }
public void PlateauWidthOrLengthIsNegativeShouldThrowException() { var instructionSet = new InstructionSet(); instructionSet.Add("5 -1"); instructionSet.GetPlateau(); }
public SlotIndex(InstructionSet instructionSet, int index) { Debug.Assert(index >= 0); this.instructionSet = instructionSet; this.index = index; }
public SlotIndex(Context context) { Debug.Assert(context.Index >= 0); this.instructionSet = context.InstructionSet; this.index = context.Index; }
public void Should_contain_expression_in_root_content( ) { string addressLkTest = "Address lk 'Test'"; var set = new InstructionSet<SampleData>( addressLkTest ); Assert.AreEqual( addressLkTest, set.Root.Content ); }
public void MoveNextWhenHaveInstructionAddedTest() { InstructionSet instructionSet = new InstructionSet(); instructionSet.Add("5 5"); instructionSet.Add("1 2 N"); instructionSet.Add("L"); Assert.AreEqual(true, instructionSet.MoveNext()); }
public void Set(InstructionSet instruction) { if (instruction != null) { TempInstructions = instruction; Rotor.SetValue("RotorLock", false); State = RotorState.single; } }
private void LoadData(TabPage tabPage) { tabPage.Controls.Clear(); InstructionSet instructionSet = tabPage.Tag as InstructionSet; instructionSet.Items = new List <ItemInfo>(); LoadMasterData(tabPage); LoadDomainData(tabPage); }
/// <summary> /// Initializes a new instance of the <see cref="TypeInitializerSchedulerStage"/> class. /// </summary> public TypeInitializerSchedulerStage() { basicBlocks = new BasicBlocks(); instructionSet = new InstructionSet(25); context = instructionSet.CreateNewBlock(basicBlocks); basicBlocks.AddHeaderBlock(context.BasicBlock); context.AppendInstruction(IRInstruction.Prologue); }
/// <summary> /// Converts an instruction set enumeration from MemorySharp to a mode from Keystone. /// </summary> /// <param name="instructionSet"></param> /// <returns></returns> private Mode MapToKeystoneMode(InstructionSet instructionSet) { if (ModeMappings.TryGetValue(instructionSet, out var mode)) { return(mode); } throw new ArgumentException("The instruction set is not supported", nameof(instructionSet)); }
/// <summary> /// Initializes a new instance of the <see cref="LinkerMethodCompiler"/> class. /// </summary> /// <param name="compiler">The assembly compiler executing this method compiler.</param> /// <param name="method">The metadata of the method to compile.</param> /// <param name="instructionSet">The instruction set.</param> /// <exception cref="System.ArgumentNullException"><paramref name="compiler"/>, <paramref name="method"/> or <paramref name="instructionSet"/> is null.</exception> public LinkerMethodCompiler(AssemblyCompiler compiler, RuntimeMethod method, InstructionSet instructionSet) : base(compiler.Pipeline.Find <IAssemblyLinker>(), compiler.Architecture, compiler.Assembly, method.DeclaringType, method) { InstructionSet = instructionSet; this.Pipeline.AddRange(new IMethodCompilerStage[] { new BasicBlockBuilderStage(), new CodeGenerationStage(), }); compiler.Architecture.ExtendMethodCompilerPipeline(this.Pipeline); }
public void TestBrkToCallIrq() { Mock <I6502> cpu = new Mock <I6502>(); cpu.Setup(m => m.irq(true)).Verifiable("IRQ not called."); Assert.Equal(0, InstructionSet.BRK(cpu.Object)); cpu.Verify(); }
private void WithdrawlMaterial(InstructionSet instructionSet) { var request = instructionSet.ObjectToProcess as RequestItem; if (request == null) { throw new InvalidCastException(this.Name + " failed to Cast ProductionAgent on Instruction.ObjectToProcess"); } Withdraw(request); }
public void TestClearCarryStatus() { Mock <I6502> cpu = new Mock <I6502>(); cpu.Setup(m => m.SetFlag(Flags.C, false)).Verifiable("Carry flag not cleared"); Assert.Equal(0, InstructionSet.CLC(cpu.Object)); cpu.Verify(); }
public void TestClearOverflowStatus() { Mock <I6502> cpu = new Mock <I6502>(); cpu.Setup(m => m.SetFlag(Flags.V, false)).Verifiable("Overflow flag not cleared"); Assert.AreEqual(0, InstructionSet.CLV(cpu.Object)); cpu.Verify(); }
/// <summary> /// Creates a new instance of the <see cref="Memory"/> class with the specified maximum side /// and the instructions to load into it. /// </summary> /// <param name="maximumSize">The maximum size of the memory; /// that is, the instructions region size plus the stack region size.</param> /// <param name="instructions">The instructions to load into the memory.</param> /// <returns></returns> public static Memory CreateMemory(int maximumSize, InstructionSet instructions) { Memory memory = new Memory(maximumSize); int stackMemory; memory.LoadInstructions(instructions.Instructions); stackMemory = maximumSize - instructions.Size; memory.StackRegion = new Stack(stackMemory < 0 ? 0 : stackMemory); return memory; }
public void CorrectPlateauSizeTest() { var instructionSet = new InstructionSet(); instructionSet.Add("5 3"); Plateau plateau = instructionSet.GetPlateau(); Assert.AreEqual(5, plateau.WestToEastLength); Assert.AreEqual(3, plateau.SouthToNorthLength); }
public void TestClearDecimalStatus() { Mock <I6502> cpu = new Mock <I6502>(); cpu.Setup(m => m.SetFlag(Flags.D, false)).Verifiable("Decimal flag not cleared"); Assert.AreEqual(0, InstructionSet.CLD(cpu.Object)); cpu.Verify(); }
public void TestClearInteruptStatus() { Mock <I6502> cpu = new Mock <I6502>(); cpu.Setup(m => m.SetFlag(Flags.I, false)).Verifiable("Interupt flag not cleared"); Assert.AreEqual(0, InstructionSet.CLI(cpu.Object)); cpu.Verify(); }
private Decoder[] EnsureDecoders() { if (this.primaryDecoders == null) { this.Options.TryGetValue("Model", out var model); var iset = InstructionSet.Create((string)model); this.primaryDecoders = iset.CreateDecoders(); } return(this.primaryDecoders); }
private static void Problem1() { var instructionSet = new InstructionSet(LoadSample(_classType).ToLines()); instructionSet.GetValueBeforeLoop().Should().Be(5); var result = new InstructionSet(LoadInput(_classType).ToLines()).GetValueBeforeLoop(); Console.WriteLine($"Accumulated Value is {result}"); }
//TODO: System Talk. private void CreateContractAgent(InstructionSet instructionSet) { // Check 0 ref var requestItem = instructionSet.ObjectToProcess as OrderPart; if (requestItem == null) { throw new InvalidCastException(this.Name + " Cast to OrderPart Failed"); } CreateAgents(requestItem); }
public void TestInstructionSet() { try { InstructionSet i = new InstructionSet(); } catch (Exception e) { Assert.Fail(e.ToString()); } }
public static bool IsValidInstruction(string instruction, InstructionSet iset) { try { return(!string.IsNullOrEmpty(iset.Instructions.Find(x => x.OpCode.Equals(instruction.ToUpper())).OpCode)); } catch (NullReferenceException) { return(false); } }
private void ProposalFromMachine(InstructionSet instructionSet) { var proposal = instructionSet.ObjectToProcess as Proposal; if (proposal == null) { throw new InvalidCastException("Could not Cast Proposal on InstructionSet.ObjectToProcess"); } // get releated workitem and add Proposal. var workItem = WorkItemQueue.Single(x => x.Id == proposal.WorkItemId); var proposalToRemove = workItem.Proposals.FirstOrDefault(x => x.AgentId == proposal.AgentId); if (proposalToRemove != null) { workItem.Proposals.Remove(proposalToRemove); } workItem.Proposals.Add(proposal); DebugMessage("Proposal for Schedule: " + proposal.PossibleSchedule + " from: " + proposal.AgentId + "!"); // if all Machines Answered if (workItem.Proposals.Count == MachineAgents.Count) { workItem.Status = workItem.WasSetReady ? Status.Ready : Status.InQueue; // item Postponed by All Machines ? -> reque after given amount of time. if (workItem.Proposals.All(x => x.Postponed)) { // Call Comunication Agent to Requeue CreateAndEnqueueInstuction(methodName: ComunicationAgent.InstuctionsMethods.EnqueueWorkItem.ToString(), objectToProcess: workItem, targetAgent: workItem.ComunicationAgent, waitFor: proposal.PostponedFor); return; } // aknowledge Machine -> therefore get Machine -> send aknowledgement var acknowledgement = workItem.Proposals.First(x => x.PossibleSchedule == workItem.Proposals.Where(y => y.Postponed == false) .Min(p => p.PossibleSchedule) && x.Postponed == false); workItem.MachineAgentId = acknowledgement.AgentId; workItem.EstimatedEnd = acknowledgement.PossibleSchedule + workItem.WorkSchedule.Duration; // set Proposal Start for Machine to Reque if time slot is closed. workItem.EstimatedStart = acknowledgement.PossibleSchedule; CreateAndEnqueueInstuction(methodName: MachineAgent.InstuctionsMethods.AcknowledgeProposal.ToString(), objectToProcess: workItem, targetAgent: GetMachineAgentById(acknowledgement.AgentId)); } }
public static IEnumerable <int> AllIndexesOf(this InstructionSet set, string[] commands) { int minIndex = set.Instructions.ToList().FindIndex(i => commands.Contains(i.cmd)); while (minIndex != -1) { yield return(minIndex); minIndex = set.Instructions.ToList().FindIndex(minIndex + 1, i => commands.Contains(i.cmd)); } }
public void Run() { while (InstructionPointer < Instructions.Length) { if (InstructionSet.TryGetValue(Instructions[InstructionPointer], out var action)) { action(this); } InstructionPointer++; } }
/// <summary> /// is Called if The Proposal is accepted by Comunication Agent /// </summary> /// <param name="instructionSet"></param> private void AcknowledgeProposal(InstructionSet instructionSet) { var workItem = instructionSet.ObjectToProcess as WorkItem; if (workItem == null) { throw new InvalidCastException("Could not Cast Workitem on InstructionSet.ObjectToProcess"); } if (Queue.Any(e => e.Priority(Context.TimePeriod) <= workItem.Priority(Context.TimePeriod))) { // Get item Latest End. var maxItem = Queue.Where(e => e.Priority(Context.TimePeriod) <= workItem.Priority(Context.TimePeriod)).Max(e => e.EstimatedEnd); // check if Queuable if (maxItem > workItem.EstimatedStart) { // reset Agent Status workItem.Status = Status.Created; workItem.EstimatedStart = 0; SendProposalTo(instructionSet.SourceAgent, workItem); return; } } DebugMessage("AcknowledgeProposal and Enqueued Item: " + workItem.WorkSchedule.Name); Queue.Add(workItem); // Enqued before another item? var position = Queue.OrderBy(x => x.Priority(Context.TimePeriod)).ToList().IndexOf(workItem); DebugMessage("Position: " + position + " Priority:" + workItem.Priority(Context.TimePeriod) + " Queue length " + Queue.Count()); // reorganize Queue if an Element has ben Queued which is More Important. if (position + 1 < Queue.Count) { var toRequeue = Queue.OrderBy(x => x.Priority(Context.TimePeriod)).ToList().GetRange(position + 1, Queue.Count() - position - 1); CallToReQueue(toRequeue); DebugMessage("New Queue length = " + Queue.Count); } if (workItem.Status == Status.Ready) { // update Processing queue UpdateProcessingQueue(workItem); // there is at least Something Ready so Start Work DoWork(new InstructionSet()); } }
/* * public InstructionSet RandomizeInstructionSet(InstructionSet iSet){ * return iSet; * } * * public InstructionSet createDeepCopy(){ * InstructionSet iSet = new InstructionSet(); * //for(int i = 0; i < ) * } */ //No new joint/segment creation, modify existing instructions public InstructionSet asexualRandomization(InstructionSet iSet) { InstructionSet result = new InstructionSet(); for (int i = 0; i < iSet.getCount(); i++) { Instruction newIns = iSet.getInstruction(i).copy(); newIns.setSpeed(newIns.getSpeed() + Random.Range(-1, 1)); result.addInstruction(newIns); } return(result); }
public void TestShiftLeftToAccumulator() { Cpu cpu = new Cpu(); cpu.ImpliedAddress = true; cpu.Fetched = 0x81; Assert.Equal(0, InstructionSet.ASL(cpu)); Assert.True(cpu.GetFlag(Flags.C)); Assert.Equal(0x02, cpu.A); }
/// <summary> /// Extend the base x86 architecture. /// </summary> private void Extend() { // Extend the base x86 register set. RegisterSet.UnionWith( new HashSet <string> { "rax", "rbx", "rcx", "rdx", "rsp", "rbp", "rsi", "rdi", "r8b", "r8w", "r8d", "r8", "r9b", "r9w", "r9d", "r9", "r10b", "r10w", "r10d", "r10", "r11b", "r11w", "r11d", "r11", "r12b", "r12w", "r12d", "r12", "r13b", "r13w", "r13d", "r13", "r14b", "r14w", "r14d", "r14", "r15b", "r15w", "r15d", "r15", "mm8", "mm9", "mm10", "mm11", "mm12", "mm13", "mm14", "mm15", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15", "xmm16", "xmm17", "xmm18", "xmm19", "xmm20", "xmm21", "xmm22", "xmm23", "xmm24", "xmm25", "xmm26", "xmm27", "xmm28", "xmm29", "xmm30", "xmm31", "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15", "ymm16", "ymm17", "ymm18", "ymm19", "ymm20", "ymm21", "ymm22", "ymm23", "ymm24", "ymm25", "ymm26", "ymm27", "ymm28", "ymm29", "ymm30", "ymm31", "zmm8", "zmm9", "zmm10", "zmm11", "zmm12", "zmm13", "zmm14", "zmm15", "zmm16", "zmm17", "zmm18", "zmm19", "zmm20", "zmm21", "zmm22", "zmm23", "zmm24", "zmm25", "zmm26", "zmm27", "zmm28", "zmm29", "zmm30", "zmm31", "st8", "st9", "st10", "st11", "st12", "st13", "st14", "st15", "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15", } ); // Extend the base x86 instruction set. InstructionSet.UnionWith(new HashSet <string> { "cdqe", "cqo", "cmpsq", "cmpxchg16b", "iretq", "jrcxz", "lodsq", "movsxd", "popfq", "pushfq", "rdtscp", "scasq", "stosq", "swapgs" }); }
public GreedyRegisterAllocator(BasicBlocks basicBlocks, VirtualRegisters compilerVirtualRegisters, InstructionSet instructionSet, StackLayout stackLayout, BaseArchitecture architecture, CompilerTrace trace) { this.trace = trace; this.basicBlocks = basicBlocks; this.instructionSet = instructionSet; this.stackLayout = stackLayout; this.architecture = architecture; this.virtualRegisterCount = compilerVirtualRegisters.Count; this.physicalRegisterCount = architecture.RegisterSet.Length; this.registerCount = virtualRegisterCount + physicalRegisterCount; this.liveIntervalTracks = new List<LiveIntervalTrack>(physicalRegisterCount); this.virtualRegisters = new List<VirtualRegister>(registerCount); this.extendedBlocks = new List<ExtendedBlock>(basicBlocks.Count); stackFrameRegister = architecture.StackFrameRegister; stackPointerRegister = architecture.StackPointerRegister; programCounter = architecture.ProgramCounter; // Setup extended physical registers foreach (var physicalRegister in architecture.RegisterSet) { Debug.Assert(physicalRegister.Index == virtualRegisters.Count); Debug.Assert(physicalRegister.Index == liveIntervalTracks.Count); bool reserved = (physicalRegister == stackFrameRegister || physicalRegister == stackPointerRegister || (programCounter != null && physicalRegister == programCounter)); this.virtualRegisters.Add(new VirtualRegister(physicalRegister, reserved)); this.liveIntervalTracks.Add(new LiveIntervalTrack(physicalRegister, reserved)); } // Setup extended virtual registers foreach (var virtualRegister in compilerVirtualRegisters) { Debug.Assert(virtualRegister.Index == virtualRegisters.Count - physicalRegisterCount + 1); this.virtualRegisters.Add(new VirtualRegister(virtualRegister)); } priorityQueue = new SimpleKeyPriorityQueue<LiveInterval>(); spilledIntervals = new List<LiveInterval>(); callSlots = new List<SlotIndex>(); moveHints = new Dictionary<SlotIndex, MoveHint>(); Start(); }
public SpecificInstructionGenerator(bool large, params Instruction[] ins) { InstructionCount = 50; this.Instructions = new ReadOnlyCollection <Instruction>(ins); _instructionSet = new InstructionSet(); _config = new RandomConfiguration(); _config.NoZeroRegister = true; var ilist = new List <(Instruction, double)>() { (new Addu(), 1), (new Ori(), 2), (new Subu(), 1), (new Nop(), 1), (new TwoOperandBranching("beq"), 1), }; foreach (var i in this.Instructions) { ilist.Add((i, 2)); } if (large) { ilist.Add((new Lui(), 2)); } if (ilist.Any(i => i.Item1.NeedMemory)) { _config.NumberOfData = 3; ilist.Add((new Lw(), 1)); ilist.Add((new Sw(), 1)); } else { _config.NumberOfData = 0; } _instructionSet.PopulateInstructionList(ilist); _large = large; if (large) { _config.MaximumImmediate = 2147483647; _config.MaximumRegister = 3; _config.NumberOfLabels = 2; } else { _config.MaximumImmediate = 5; _config.MaximumRegister = 3; _config.NumberOfLabels = 2; } }
public static string DefaultToEditorContent(this InstructionSet instructionSet, bool highlight = false) { if (instructionSet.instructions == null) { instructionSet.instructions = new List <InstructionSet.Instruction>(); } string result = ""; string defaultStringField = instructionSet.DefaultStringField(); foreach (var(field, value, indent) in instructionSet.FunctionIterateInstructions(force: true)) { string valueStr = value.ValueToString(); if (valueStr == null) { valueStr = ""; } if (result.Length > 0) { result += "\n\n"; } var indentTxt = ""; for (var i = 0; i < indent; i++) { indentTxt += '\t'; } valueStr = valueStr.Replace("\n", $"\n{indentTxt}"); result += indentTxt; if (field == defaultStringField) { result += valueStr; } else { if (highlight) { result += $"<b>{field} </b>: {valueStr}"; } else { result += $"{field}: {valueStr}"; } } } if (highlight) { result += "\n"; } return(result); }
private void AddMachineToComunicationAgent(InstructionSet instructionSet) { var machine = instructionSet.ObjectToProcess as MachineAgent; if (machine == null) { throw new InvalidCastException("Could not Cast MachineAgent on InstructionSet.ObjectToProcess"); } // Add Machine to Pool this.MachineAgents.Add(machine); // Added Machine Agent To Machine Pool DebugMessage("Added Machine Agent " + machine.Name + " to Machine Pool: " + ContractType); }
public bool IsHardwareInstrinsicWithRuntimeDeterminedSupport(MethodDesc method) { string intrinsicId = InstructionSetSupport.GetHardwareIntrinsicId(TypeSystemContext.Target.Architecture, method.OwningType); if (!string.IsNullOrEmpty(intrinsicId)) { InstructionSet instructionSet = _instructionSetMap[intrinsicId]; return(!InstructionSetSupport.IsInstructionSetSupported(instructionSet) && InstructionSetSupport.OptimisticFlags.HasInstructionSet(instructionSet)); } return(false); }
public void TestALtFetch() { Cpu cpu = new Cpu(); cpu.A = 0x30; cpu.Fetched = 0x45; Assert.Equal(1, InstructionSet.CMP(cpu)); Assert.False(cpu.GetFlag(Flags.C)); Assert.True(cpu.GetFlag(Flags.N)); Assert.False(cpu.GetFlag(Flags.Z)); }
public Instruction( InstructionSet Opcode, Operand FirstOperand, Operand SecondOperand, Operand ThirdOperand, String Annotation = null) { this.Opcode = Opcode; this.FirstOperand = FirstOperand; this.SecondOperand = SecondOperand; this.ThirdOperand = ThirdOperand; this.Annotation = Annotation; }
public void TestAEqualFetch() { Cpu cpu = new Cpu(); cpu.A = 0x45; cpu.Fetched = 0x45; Assert.AreEqual(1, InstructionSet.CMP(cpu)); Assert.IsTrue(cpu.GetFlag(Flags.C)); Assert.IsFalse(cpu.GetFlag(Flags.N)); Assert.IsTrue(cpu.GetFlag(Flags.Z)); }
public void TestXLtFetch() { Cpu cpu = new Cpu(); cpu.X = 0x30; cpu.Fetched = 0x45; Assert.AreEqual(0, InstructionSet.CPX(cpu)); Assert.IsFalse(cpu.GetFlag(Flags.C)); Assert.IsTrue(cpu.GetFlag(Flags.N)); Assert.IsFalse(cpu.GetFlag(Flags.Z)); }
public void TestYGtFetch() { Cpu cpu = new Cpu(); cpu.Y = 0x45; cpu.Fetched = 0x20; Assert.Equal(0, InstructionSet.CPY(cpu)); Assert.True(cpu.GetFlag(Flags.C)); Assert.False(cpu.GetFlag(Flags.N)); Assert.False(cpu.GetFlag(Flags.Z)); }
public InstructionSet ToInstructionSet(FlatRedBall.Scene scene) { InstructionSet instructionSet = new InstructionSet(); instructionSet.Name = this.Target; INameable nameable = null; foreach (KeyframeListSave keyframeList in Instructions) { KeyframeList keyframes = new KeyframeList(); keyframes.Name = keyframeList.Name; instructionSet.Add(keyframes); foreach (KeyframeSave keyframe in keyframeList.SceneKeyframes) { InstructionList list = new InstructionList(); list.Name = keyframe.Name; keyframes.Add(list); foreach (InstructionSave instructionSave in keyframe.InstructionSaves) { if (nameable == null || nameable.Name != instructionSave.TargetName) { // We don't have a nameable yet, or the current instruction is // not modifying the one referenced by nameable. nameable = scene.Sprites.FindByName(instructionSave.TargetName); if (nameable == null) { nameable = scene.SpriteFrames.FindByName(instructionSave.TargetName); } } if (nameable == null) { throw new NullReferenceException("Could not find an object of instance " + instructionSave.Type + " with the name " + instructionSave.TargetName); } list.Add(instructionSave.ToInstruction(nameable)); } } } return instructionSet; }
public void Context( ) { _expressionToTest = "Address lk 'Test' and ( Value gt '20' or AddDate gt '1/1/2011' )"; _set = new InstructionSet<SampleData>( _expressionToTest ); _repository = new SampleRepository { DataSource = new[ ] { new SampleData() {Address = "Test 1"}, new SampleData() {Address = "Test 2", Value = 21, AddDate = new DateTime(2012,1,1)}, new SampleData() {Address = "Could Not Pass", Value = 45}, new SampleData() {Address = "No Pass", Value = 33}, } }; }
public void Context( ) { _expressionToTest = "Address lk 'Test' and Value gt '20'"; _set = new InstructionSet<SampleData>( _expressionToTest ); _repository = new SampleRepository { DataSource = new[ ] { new SampleData() {Address = "Test 1"}, new SampleData() {Address = "Test 2", Value = 21}, new SampleData() {Address = "Could Not Pass", Value = 45}, new SampleData() {Address = "No Pass", Value = 33}, } }; }
public void ResetTest() { InstructionSet instructionSet = new InstructionSet(); instructionSet.Add("5 5"); instructionSet.Add("1 2 N"); instructionSet.Add("L"); instructionSet.Add("2 3 W"); instructionSet.Add("R"); instructionSet.MoveNext(); Assert.AreEqual(typeof(HeadingNorth), instructionSet.Current.GetLandingHeading().GetType()); instructionSet.MoveNext(); Assert.AreEqual(typeof(HeadingWest), instructionSet.Current.GetLandingHeading().GetType()); instructionSet.Reset(); instructionSet.MoveNext(); Assert.AreEqual(typeof(HeadingNorth), instructionSet.Current.GetLandingHeading().GetType()); }
public static RobotCollection LandingRobots(InstructionSet instructionSet) { var robotCollection = new RobotCollection(); Plateau plateau = instructionSet.GetPlateau(); foreach (IInstruction instruction in instructionSet) { var robot = new Robot(robotCollection.Count , instruction.GetLandingPosition() , instruction.GetLandingHeading() , instruction.GetMovingSequence() , plateau); robotCollection.Add(robot); } return robotCollection; }
private static InstructionSet ReceiveInstructions() { var instructionSet = new InstructionSet(); string instruction; while ((instruction = Console.ReadLine()) != string.Empty) { instructionSet.Add(instruction); } //instructionSet.Add("5 5"); //instructionSet.Add("1 2 N"); //instructionSet.Add("LMLMLMLMM"); //instructionSet.Add("3 3 E"); //instructionSet.Add("MMRMMRMRRM"); //instructionSet.Add("3 3 E"); //instructionSet.Add("MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM"); return instructionSet; }
public void InsertResolvingMoves(BaseArchitecture architecture, InstructionSet instructionSet) { if (moves.Count == 0) return; Context context = new Context(instructionSet, Source == Anchor ? Source.EndIndex : Destination.StartIndex); if (Source == Anchor) { context.GotoPrevious(); // Note: This won't work for expanded switch statements... but we can't insert into the end of those blocks anyway while (context.IsEmpty || context.Instruction.FlowControl == FlowControl.UnconditionalBranch || context.Instruction.FlowControl == FlowControl.ConditionalBranch || context.Instruction.FlowControl == FlowControl.Return) { context.GotoPrevious(); } } TrySimpleMoves(architecture, context); TryExchange(architecture, context); CreateMemoryMoves(architecture, context); Debug.Assert(moves.Count == 0); }
public SparseConditionalConstantPropagation(BasicBlocks basicBlocks, InstructionSet instructionSet, SectionTrace trace) { this.Trace = trace; this.BasicBlocks = basicBlocks; this.InstructionSet = instructionSet; MainTrace = CreateTrace("ConditionalConstantPropagation"); // Method is empty - must be a plugged method if (BasicBlocks.HeadBlocks.Count == 0) return; blockStates = new bool[BasicBlocks.Count]; for (int i = 0; i < BasicBlocks.Count; i++) { blockStates[i] = false; } // Initialize foreach (var block in BasicBlocks.HeadBlocks) { AddExecutionBlock(block); } while (blockWorklist.Count > 0 || instructionWorkList.Count > 0) { ProcessBlocks(); ProcessInstructions(); } DumpTrace(); // Release phiStatements = null; }
public BasicRegisterAllocator(BasicBlocks basicBlocks, VirtualRegisters compilerVirtualRegisters, InstructionSet instructionSet, StackLayout stackLayout, BaseArchitecture architecture, SectionTrace trace) : base(basicBlocks, compilerVirtualRegisters, instructionSet, stackLayout, architecture, trace) { }
public void NoPlateauInfoShouldThrowException() { var instructionSet = new InstructionSet(); instructionSet.GetPlateau(); }
public InstructionSet ToInstructionSet(IInstructable instructable) { InstructionSet instructionSet = new InstructionSet(); instructionSet.Name = this.Target; //INameable nameable = null; foreach (KeyframeListSave keyframeList in Instructions) { KeyframeList keyframes = new KeyframeList(); keyframes.Name = keyframeList.Name; instructionSet.Add(keyframes); foreach (KeyframeSave keyframe in keyframeList.SceneKeyframes) { InstructionList list = new InstructionList(); list.Name = keyframe.Name; keyframes.Add(list); foreach (InstructionSave instructionSave in keyframe.InstructionSaves) { list.Add(instructionSave.ToInstruction(instructable)); } } } return instructionSet; }
private static void AddSetToSave(InstructionSet instructionSet, InstructionSetSaveList instructionSetSaveList, string targetName) { // This following members be used as a buffer for holding the lists that will be saved. // In the following loop the code will only copy over instructions that set properties // which are included in EditorData.SavedMembers List<InstructionList> temporaryListList = new List<InstructionList>(); InstructionList temporaryList = new InstructionList(); InstructionSetSave instructionSetSave = new InstructionSetSave(); foreach (KeyframeList keyframeList in instructionSet) { temporaryListList = new List<InstructionList>(); foreach (InstructionList instructionList in keyframeList) { temporaryList = new InstructionList(); temporaryList.Name = instructionList.Name; foreach (Instruction instruction in instructionList) { // Assume that all instructions are GenericInstructions GenericInstruction asGenericInstruction = instruction as GenericInstruction; bool toAdd = false; if (asGenericInstruction.Target is PositionedModel) { toAdd = EditorData.CurrentPositionedModelMembersWatching.Contains(asGenericInstruction.Member); } else if (asGenericInstruction.Target is Sprite) { toAdd = EditorData.CurrentSpriteMembersWatching.Contains(asGenericInstruction.Member); } else if (asGenericInstruction.Target is SpriteFrame) { toAdd = EditorData.CurrentSpriteFrameMembersWatching.Contains(asGenericInstruction.Member); } else if (asGenericInstruction.Target is Text) { toAdd = EditorData.CurrentTextMembersWatching.Contains(asGenericInstruction.Member); } if (toAdd) { // this instruction is one we want to save temporaryList.Add(instruction); } } if (temporaryList.Count != 0) { temporaryListList.Add(temporaryList); } } if (temporaryListList.Count != 0) { instructionSetSave.AddInstructions(temporaryListList, keyframeList.Name); } } if (instructionSetSave.Instructions.Count != 0) { instructionSetSave.Target = targetName; instructionSetSaveList.InstructionSetSaves.Add(instructionSetSave); } }
public void MoveNextWhenNoInstructionAddedTest() { InstructionSet instructionSet = new InstructionSet(); Assert.AreEqual(false, instructionSet.MoveNext()); }
RegisterMap(InstructionSet instructionSet) { this.instructionSet = instructionSet; map = new RegisterBitmap[instructionSet.Size]; }
private void UpdateInstructions() { #if XBOX Thread.CurrentThread.SetProcessorAffinity(new int[]{ currentCore++ }); #endif updating = true; LetsGo = Node.Handle.BuildPath(new Point((int)Math.Round(Me.X), (int)Math.Round(Me.Y)), ElementTypes.PacDot, Previous); updating = false; }
public void Setup() { _instructionSet = new InstructionSet(); _instructionSet.Add("5 5"); _instructionSet.Add("1 2 N"); }