public void SetUp() { Instruction instr1 = new AddInstruction(2, 3, 4); Instruction instr2 = new LuiInstruction(5, 0xFFFF); Instruction[] instructions = { instr1, instr2 }; target = new InstructionMemory(instructions); }
public void Execute_PlusThreeToZero_ReturnsThree() { AddInstruction instruction = new AddInstruction(3); var expectedOutput = 3; Assert.AreEqual(expectedOutput, instruction.Execute(0)); }
public void SetInstruction_ValidIndex() { target = new InstructionMemory(8); Instruction instr = new AddInstruction(1, 1, 2); target[4] = 0x00220820; //Assert.AreEqual(instr, target.GetInstruction(4)); }
public static Machine getSampleMachine() { Machine machine = new Machine(6); Instruction i0 = new AddInstruction(); List <int> p = new List <int>(); p.Add(2); p.Add(3); p.Add(0); // M2 = 0 + M0 i0.setParameters(p); machine.addInstruction(i0); Instruction i1 = new AssignValueInstruction(); p.Clear(); p.Add(4); p.Add(1); //M4 = 1 i1.setParameters(p); machine.addInstruction(i1); Instruction i2 = new GotoIfInstruction(); p.Clear(); p.Add(5); p.Add(2); // goto 5 if M2 > 0 i2.setParameters(p); machine.addInstruction(i2); Instruction i3 = new AddInstruction(); p.Clear(); p.Add(0); p.Add(3); p.Add(5); // M0 = M3 + 0 i3.setParameters(p); machine.addInstruction(i3); Instruction i4 = new HaltInstruction(); machine.addInstruction(i4); //halt Instruction i5 = new AddInstruction(); p.Clear(); p.Add(3); p.Add(3); p.Add(1); // M3 = M3 + M1 i5.setParameters(p); machine.addInstruction(i5); Instruction i6 = new SubstractInstruction(); p.Clear(); p.Add(2); p.Add(2); p.Add(4); // M2 = M2 - 1 i6.setParameters(p); machine.addInstruction(i6); Instruction i7 = new GotoIfInstruction(); p.Clear(); p.Add(2); p.Add(4); // goto 2 i7.setParameters(p); machine.addInstruction(i7); int[] input = { 5, 6 }; machine.insertInput(input); // when machine halts result will be in M0 return(machine); }
public void Execute_Overflow() { reg[9] = 0xFFFFFFFF; reg[10] = 0x1; target = new AddInstruction(8, 9, 10); target.Execute(ref pc, mem, reg); Assert.AreEqual(0x0, reg[8]); Assert.AreEqual(0x4, pc); }
public void Execute_NegativeNumber() { reg[9] = 0x3; reg[10] = 0xFFFFFFFF; target = new AddInstruction(8, 9, 10); target.Execute(ref pc, mem, reg); Assert.AreEqual(0x2, reg[8]); Assert.AreEqual(0x4, pc); }
public void Execute_PositiveNumbers() { reg[9] = 0x1; reg[10] = 0x3; target = new AddInstruction(8, 9, 10); target.Execute(ref pc, mem, reg); Assert.AreEqual(0x4, reg[8]); Assert.AreEqual(0x4, pc); }
public void EmitAdd(Type type, bool @checked) { if (@checked) { Emit(AddOvfInstruction.Create(type)); } else { Emit(AddInstruction.Create(type)); } }
protected override void VisitAddInstruction(AddInstruction instruction) { ControlState.EvaluationStack.Pop(out var stackVal1, out var stackVal2); var resultStackVal = ComputeBinaryNumericOperation( stackVal1, stackVal2, (a, b) => new CilStackValueInt32(a.Value + b.Value), (a, b) => new CilStackValueInt64(a.Value + b.Value), (a, b) => new CilStackValueFloat(a.Value + b.Value) ); ControlState.EvaluationStack.Push(resultStackVal); ControlState.MoveToNextInstruction(); }
private Operand MakeVariableAssignment(VariableAssignmentNode node, ILGenerator generator) { SymbolOperand leftHandSide = node.Accessor.Visit(generator) as SymbolOperand; Operand rightHandSide = node.Right.Visit(generator); // If right-hand side exists and has a type, do some type checking /*if (rightHandSide.Type != leftHandSide.Type) * throw new AstWalkerException($"Cannot convert {rightHandSide.Type} to {leftHandSide.Type} ('{leftHandSide.Name}')");*/ if (node.Operator.Type == TokenType.Assignment) { generator.Emmit(new StoreInstruction(leftHandSide, rightHandSide)); return(leftHandSide); } Instruction instr = null; switch (node.Operator.Type) { case TokenType.IncrementAndAssign: instr = new AddInstruction(leftHandSide, leftHandSide, rightHandSide); break; case TokenType.DecrementAndAssign: instr = new SubInstruction(leftHandSide, leftHandSide, rightHandSide); break; case TokenType.MultAndAssign: instr = new MultInstruction(leftHandSide, leftHandSide, rightHandSide); break; case TokenType.DivideAndAssign: instr = new DivInstruction(leftHandSide, leftHandSide, rightHandSide); break; default: throw new InvalidInstructionException($"Unsupported operation: {node.Operator.Value} ({node.Operator.Type})"); } generator.Emmit(instr); return(leftHandSide); }
public static void Add(Compiler cmp, Argument[] args) { Function fct = cmp.Functions.Last(); Variable v1 = fct.GetVariable(args[1]); Variable v2 = fct.GetVariable(args[2]) ?? TryConst(args[2]); AddInstruction i = new AddInstruction { From = new Variable[] { v1, v2 }, To = fct.GetVariable(args[3]) }; fct.Instructions.Add(i); }
static AssemblerController() { Assemblers["ADD"] = new AddInstruction(); Assemblers["AND"] = new AndInstruction(); Assemblers["BR"] = new BranchInstruction("BR", true, true, true); // Alias of BRNZP Assemblers["BRN"] = new BranchInstruction("BRN", true, false, false); Assemblers["BRZ"] = new BranchInstruction("BRZ", false, true, false); Assemblers["BRP"] = new BranchInstruction("BRP", false, false, true); Assemblers["BRZP"] = new BranchInstruction("BRZP", false, true, true); Assemblers["BRNP"] = new BranchInstruction("BRNP", true, false, true); Assemblers["BRNZ"] = new BranchInstruction("BRNZ", true, true, false); Assemblers["BRNZP"] = new BranchInstruction("BRNZP", true, true, true); Assemblers["JMP"] = new RegisterBasedPCAccessInstruction("JMP", 0b1100); Assemblers["JSR"] = new JSRInstruction(); Assemblers["JSRR"] = new RegisterBasedPCAccessInstruction("JSRR", 0b0100); Assemblers["LD"] = new LabelBasedMemoryAccessInstruction("LD", 0b0010); Assemblers["LDI"] = new LabelBasedMemoryAccessInstruction("LDI", 0b1010); Assemblers["LDR"] = new OffsetBasedMemoryAccessInstruction("LDR", 0b0110); Assemblers["LEA"] = new LabelBasedMemoryAccessInstruction("LEA", 0b1110); Assemblers["NOT"] = new NotInstruction(); Assemblers["RET"] = new ZeroArgumentsInstruction("RET", 0xC1C0); // 1100 000 111 000000, i.e. JMP R7 Assemblers["RTI"] = new ZeroArgumentsInstruction("RTI", 0x8000); // 1000 000000000000 Assemblers["ST"] = new LabelBasedMemoryAccessInstruction("ST", 0b0011); Assemblers["STI"] = new LabelBasedMemoryAccessInstruction("STI", 0b1011); Assemblers["STR"] = new OffsetBasedMemoryAccessInstruction("STR", 0b0111); Assemblers["TRAP"] = new TrapInstruction(); Assemblers["GETC"] = new ZeroArgumentsInstruction("GETC", 0xF020); // TRAP x20 Assemblers["OUT"] = new ZeroArgumentsInstruction("OUT", 0xF021); // TRAP x21 Assemblers["PUTS"] = new ZeroArgumentsInstruction("PUTS", 0xF022); // TRAP x22 Assemblers["IN"] = new ZeroArgumentsInstruction("IN", 0xF023); // TRAP x23 Assemblers["PUTSP"] = new ZeroArgumentsInstruction("PUTSP", 0xF024); // TRAP x24 Assemblers["HALT"] = new ZeroArgumentsInstruction("HALT", 0xF025); // TRAP x25 }
private bool ExecuteInstruction(AddInstruction instruction) { registers[instruction.RegisterAddress] += instruction.Value; return(true); }
public void VisitAdd(AddInstruction instruction) => IncrementCallCount(nameof(VisitAdd));
public static Machine GetSampleMachine() { var machine = new Machine(6); Instruction ix = new AssignValueInstruction(); ix.SetParameters(new List <int> { 0, 5 }); machine.AddInstruction(ix); Instruction iy = new AssignValueInstruction(); iy.SetParameters(new List <int> { 1, 6 }); machine.AddInstruction(iy); Instruction i0 = new AddInstruction(); i0.SetParameters(new List <int> { 2, 3, 0 }); // M2 = 0 + M0 machine.AddInstruction(i0); Instruction i1 = new AssignValueInstruction(); i1.SetParameters(new List <int> { 4, 1 }); //M4 = 1 machine.AddInstruction(i1); Instruction i2 = new GotoIfInstruction(); i2.SetParameters(new List <int> { 7, 2 }); // goto 7 if M2 > 0 machine.AddInstruction(i2); Instruction i3 = new AddInstruction(); i3.SetParameters(new List <int> { 0, 3, 5 }); // M0 = M3 + 5 machine.AddInstruction(i3); Instruction i4 = new HaltInstruction(); machine.AddInstruction(i4); //halt Instruction i5 = new AddInstruction(); i5.SetParameters(new List <int> { 3, 3, 1 }); // M3 = M3 + M1 machine.AddInstruction(i5); Instruction i6 = new SubstractInstruction(); i6.SetParameters(new List <int> { 2, 2, 4 }); // M2 = M2 - 1 machine.AddInstruction(i6); Instruction i7 = new GotoIfInstruction(); i7.SetParameters(new List <int> { 4, 4 }); // goto 4 if M4 > 0 machine.AddInstruction(i7); // when machine halts result will be in M0 return(machine); }
public void EmitAdd(Type type, bool @checked) { Emit(@checked ? AddOvfInstruction.Create(type) : AddInstruction.Create(type)); }
public override CILInstructionNone BuildNode(ParseTreeNode node) { var instrNoneParseTreeNode = node.GetFirstChildWithGrammarName(GrammarNames.INSTR_NONE); var addParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_add); if (addParseTreeNode != null) { var addInstruction = new AddInstruction(); return(addInstruction); } var andParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_and); if (andParseTreeNode != null) { var andInstruction = new AndInstruction(); return(andInstruction); } var ceqParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ceq); if (ceqParseTreeNode != null) { var checkIfEqualInstruction = new CheckIfEqualInstruction(); return(checkIfEqualInstruction); } var cgtParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_cgt); if (cgtParseTreeNode != null) { var checkIfGreaterInstruction = new CheckIfGreaterInstruction(); return(checkIfGreaterInstruction); } var cltParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_clt); if (cltParseTreeNode != null) { var checkIfLessInstruction = new CheckIfLessInstruction(); return(checkIfLessInstruction); } var convi1ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_convi1); if (convi1ParseTreeNode != null) { var convertToSByteInstruction = new ConvertToSByteInstruction(); return(convertToSByteInstruction); } var convi2ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_convi2); if (convi2ParseTreeNode != null) { var convertToShortInstruction = new ConvertToShortInstruction(); return(convertToShortInstruction); } var convi4ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_convi4); if (convi4ParseTreeNode != null) { var convertToIntInstruction = new ConvertToIntInstruction(); return(convertToIntInstruction); } var convi8ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_convi8); if (convi8ParseTreeNode != null) { var convertToLongInstruction = new ConvertToLongInstruction(); return(convertToLongInstruction); } var convr4ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_convr4); if (convr4ParseTreeNode != null) { var convertToFloatInstruction = new ConvertToFloatInstruction(); return(convertToFloatInstruction); } var convr8ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_convr8); if (convr8ParseTreeNode != null) { var convertToDoubleInstruction = new ConvertToDoubleInstruction(); return(convertToDoubleInstruction); } var convu8ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_convu8); if (convu8ParseTreeNode != null) { var convertToUnsignedLongInstruction = new ConvertToUnsignedLongInstruction(); return(convertToUnsignedLongInstruction); } var divParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_div); if (divParseTreeNode != null) { var divideInstruction = new DivideInstruction(); return(divideInstruction); } var dupParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_dup); if (dupParseTreeNode != null) { var duplicateInstruction = new DuplicateInstruction(); return(duplicateInstruction); } var ldarg0ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldarg0); if (ldarg0ParseTreeNode != null) { var loadArgument0Instruction = new LoadArgument0Instruction(); return(loadArgument0Instruction); } var ldarg1ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldarg1); if (ldarg1ParseTreeNode != null) { var loadArgument1Instruction = new LoadArgument1Instruction(); return(loadArgument1Instruction); } var ldarg2ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldarg2); if (ldarg2ParseTreeNode != null) { var loadArgument2Instruction = new LoadArgument2Instruction(); return(loadArgument2Instruction); } var ldarg3ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldarg3); if (ldarg3ParseTreeNode != null) { var loadArgument3Instruction = new LoadArgument3Instruction(); return(loadArgument3Instruction); } var ldci40ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci40); if (ldci40ParseTreeNode != null) { var loadConstantInt0Instruction = new LoadConstantInt0Instruction(); return(loadConstantInt0Instruction); } var ldci41ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci41); if (ldci41ParseTreeNode != null) { var loadConstantInt1Instruction = new LoadConstantInt1Instruction(); return(loadConstantInt1Instruction); } var ldci42ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci42); if (ldci42ParseTreeNode != null) { var loadConstantInt2Instruction = new LoadConstantInt2Instruction(); return(loadConstantInt2Instruction); } var ldci43ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci43); if (ldci43ParseTreeNode != null) { var loadConstantInt3Instruction = new LoadConstantInt3Instruction(); return(loadConstantInt3Instruction); } var ldci44ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci44); if (ldci44ParseTreeNode != null) { var loadConstantInt4Instruction = new LoadConstantInt4Instruction(); return(loadConstantInt4Instruction); } var ldci45ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci45); if (ldci45ParseTreeNode != null) { var loadConstantInt5Instruction = new LoadConstantInt5Instruction(); return(loadConstantInt5Instruction); } var ldci46ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci46); if (ldci46ParseTreeNode != null) { var loadConstantInt6Instruction = new LoadConstantInt6Instruction(); return(loadConstantInt6Instruction); } var ldci47ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci47); if (ldci47ParseTreeNode != null) { var loadConstantInt7Instruction = new LoadConstantInt7Instruction(); return(loadConstantInt7Instruction); } var ldci48ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci48); if (ldci48ParseTreeNode != null) { var loadConstantInt8Instruction = new LoadConstantInt8Instruction(); return(loadConstantInt8Instruction); } var ldci4m1ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldci4m1); if (ldci4m1ParseTreeNode != null) { var loadConstantIntMinus1Instruction = new LoadConstantIntMinus1Instruction(); return(loadConstantIntMinus1Instruction); } var ldelemi4ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldelemi4); if (ldelemi4ParseTreeNode != null) { var loadElementIntInstruction = new LoadElementIntInstruction(); return(loadElementIntInstruction); } var ldelemrefParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldelemref); if (ldelemrefParseTreeNode != null) { var loadElementRefInstruction = new LoadElementRefInstruction(); return(loadElementRefInstruction); } var ldlenParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldlen); if (ldlenParseTreeNode != null) { var loadLengthInstruction = new LoadLengthInstruction(); return(loadLengthInstruction); } var ldloc0ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldloc0); if (ldloc0ParseTreeNode != null) { var loadLocalVariable0Instruction = new LoadLocalVariable0Instruction(); return(loadLocalVariable0Instruction); } var ldloc1ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldloc1); if (ldloc1ParseTreeNode != null) { var loadLocalVariable1Instruction = new LoadLocalVariable1Instruction(); return(loadLocalVariable1Instruction); } var ldloc2ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldloc2); if (ldloc2ParseTreeNode != null) { var loadLocalVariable2Instruction = new LoadLocalVariable2Instruction(); return(loadLocalVariable2Instruction); } var ldloc3ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ldloc3); if (ldloc3ParseTreeNode != null) { var loadLocalVariable3Instruction = new LoadLocalVariable3Instruction(); return(loadLocalVariable3Instruction); } var mulParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_mul); if (mulParseTreeNode != null) { var multiplyInstruction = new MultiplyInstruction(); return(multiplyInstruction); } var notParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_not); if (notParseTreeNode != null) { var notInstruction = new NotInstruction(); return(notInstruction); } var orParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_or); if (orParseTreeNode != null) { var orInstruction = new OrInstruction(); return(orInstruction); } var popParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_pop); if (popParseTreeNode != null) { var popInstruction = new PopInstruction(); return(popInstruction); } var remParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_rem); if (remParseTreeNode != null) { var remainderInstruction = new RemainderInstruction(); return(remainderInstruction); } var retParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_ret); if (retParseTreeNode != null) { var returnInstruction = new ReturnInstruction(); return(returnInstruction); } var shlParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_shl); if (shlParseTreeNode != null) { var shiftLeftInstruction = new ShiftLeftInstruction(); return(shiftLeftInstruction); } var shrParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_shr); if (shrParseTreeNode != null) { var shiftRightInstruction = new ShiftRightInstruction(); return(shiftRightInstruction); } var stelemi4ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_stelemi4); if (stelemi4ParseTreeNode != null) { var setElementIntInstruction = new SetElementIntInstruction(); return(setElementIntInstruction); } var stelemrefParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_stelemref); if (stelemrefParseTreeNode != null) { var setElementRefInstruction = new SetElementRefInstruction(); return(setElementRefInstruction); } var stloc0ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_stloc0); if (stloc0ParseTreeNode != null) { var setLocalVariable0Instruction = new SetLocalVariable0Instruction(); return(setLocalVariable0Instruction); } var stloc1ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_stloc1); if (stloc1ParseTreeNode != null) { var setLocalVariable1Instruction = new SetLocalVariable1Instruction(); return(setLocalVariable1Instruction); } var stloc2ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_stloc2); if (stloc2ParseTreeNode != null) { var setLocalVariable2Instruction = new SetLocalVariable2Instruction(); return(setLocalVariable2Instruction); } var stloc3ParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_stloc3); if (stloc3ParseTreeNode != null) { var setLocalVariable3Instruction = new SetLocalVariable3Instruction(); return(setLocalVariable3Instruction); } var subParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_sub); if (subParseTreeNode != null) { var subtractInstruction = new SubtractInstruction(); return(subtractInstruction); } var xorParseTreeNode = instrNoneParseTreeNode?.GetFirstChildWithGrammarName(GrammarNames.keyword_xor); if (xorParseTreeNode != null) { var xorInstruction = new XorInstruction(); return(xorInstruction); } throw new ArgumentException("Cannot recognize CIL instruction none."); }
public void ToString_Formatted() { target = new AddInstruction(8, 9, 10); Assert.AreEqual("ADD $t0, $t1, $t2", target.ToString()); }
public Instruction Translate() { Instruction instruction; switch (Type) { case CommandType.AssignValue: instruction = new AssignValueInstruction(); instruction.SetParameters(new List <int> { Arg1.Value, Arg2.Value }); break; case CommandType.Add: instruction = new AddInstruction(); instruction.SetParameters(new List <int> { Arg1.Value, Arg2.Value, Arg3.Value }); break; case CommandType.Substract: instruction = new SubstractInstruction(); instruction.SetParameters(new List <int> { Arg1.Value, Arg2.Value, Arg3.Value }); break; case CommandType.Divide: instruction = new DivideByTwoInstruction(); instruction.SetParameters(new List <int> { Arg1.Value }); break; case CommandType.CopyValue: instruction = new CopyValueInstruction(); instruction.SetParameters(new List <int> { Arg1.Value, Arg2.Value }); break; case CommandType.CopyValue2: instruction = new CopyValue2Instruction(); instruction.SetParameters(new List <int> { Arg1.Value, Arg2.Value }); break; case CommandType.GotoIf: instruction = new GotoIfInstruction(); instruction.SetParameters(new List <int> { Arg1.Value, Arg2.Value }); break; case CommandType.Halt: instruction = new HaltInstruction(); instruction.SetParameters(new List <int>()); break; default: throw new InvalidEnumArgumentException(); } return(instruction); }
private bool GenerateNode(out OneOperandNode node) { node = null; InstructionToken instructionToken; if (this.ExpectInstructionToken(out instructionToken)) { Instructions instruction = instructionToken.Instruction; switch (instruction) { case Instructions.Mov: { Token operand1; Token operand2; if (this.ExpectTwoOperands(out operand1, out operand2)) { node = new MovInstruction(this.rawInput, instructionToken, operand1, operand2); } else { this.LogExpectedTwoOperandsError(instructionToken); return(false); } } break; case Instructions.Add: { Token operand1; Token operand2; if (this.ExpectTwoOperands(out operand1, out operand2)) { node = new AddInstruction(this.rawInput, instructionToken, operand1, operand2); } else { this.LogExpectedTwoOperandsError(instructionToken); return(false); } } break; case Instructions.Sub: { Token operand1; Token operand2; if (this.ExpectTwoOperands(out operand1, out operand2)) { node = new SubInstruction(this.rawInput, instructionToken, operand1, operand2); } else { this.LogExpectedTwoOperandsError(instructionToken); return(false); } } break; case Instructions.Mul: { Token operand1; Token operand2; if (this.ExpectTwoOperands(out operand1, out operand2)) { node = new MulInstruction(this.rawInput, instructionToken, operand1, operand2); } else { this.LogExpectedTwoOperandsError(instructionToken); return(false); } } break; case Instructions.Div: { Token operand1; Token operand2; if (this.ExpectTwoOperands(out operand1, out operand2)) { node = new DivInstruction(this.rawInput, instructionToken, operand1, operand2); } else { this.LogExpectedTwoOperandsError(instructionToken); return(false); } } break; case Instructions.Cmp: { Token operand1; Token operand2; if (this.ExpectTwoOperands(out operand1, out operand2)) { node = new CmpInstruction(this.rawInput, instructionToken, operand1, operand2); } else { this.LogExpectedTwoOperandsError(instructionToken); return(false); } } break; case Instructions.Inc: { Token operand; if (this.ExpectOneOperand(out operand)) { node = new IncInstruction(this.rawInput, instructionToken, operand); } else { this.LogExpectedOneOperandError(instructionToken); return(false); } } break; case Instructions.Dec: { Token operand; if (this.ExpectOneOperand(out operand)) { node = new DecInstruction(this.rawInput, instructionToken, operand); } else { this.LogExpectedOneOperandError(instructionToken); return(false); } } break; case Instructions.Jmp: { Token operand; if (this.ExpectOneOperand(out operand)) { node = new JmpInstruction(this.rawInput, instructionToken, operand); } else { this.LogExpectedOneOperandError(instructionToken); return(false); } } break; case Instructions.Jeq: { Token operand; if (this.ExpectOneOperand(out operand)) { node = new JeqInstruction(this.rawInput, instructionToken, operand); } else { this.LogExpectedOneOperandError(instructionToken); return(false); } } break; case Instructions.Jne: { Token operand; if (this.ExpectOneOperand(out operand)) { node = new JneInstruction(this.rawInput, instructionToken, operand); } else { this.LogExpectedOneOperandError(instructionToken); return(false); } } break; case Instructions.Jsm: { Token operand; if (this.ExpectOneOperand(out operand)) { node = new JsmInstruction(this.rawInput, instructionToken, operand); } else { this.LogExpectedOneOperandError(instructionToken); return(false); } } break; case Instructions.Jns: { Token operand; if (this.ExpectOneOperand(out operand)) { node = new JnsInstruction(this.rawInput, instructionToken, operand); } else { this.LogExpectedOneOperandError(instructionToken); return(false); } } break; } } return(true); }
protected abstract void VisitAddInstruction(AddInstruction instruction);
public Operand Visit(ILGenerator generator, BinaryNode binary) { Operand left = binary.Left.Visit(generator); Operand right = binary.Right.Visit(generator); SymbolOperand tmpname = generator.SymbolTable.NewTempSymbol(OperandType.Auto); Instruction instr = null; switch (binary.Operator.Type) { case TokenType.Addition: instr = new AddInstruction(tmpname, left, right); break; case TokenType.Minus: instr = new SubInstruction(tmpname, left, right); break; case TokenType.Multiplication: instr = new MultInstruction(tmpname, left, right); break; case TokenType.Division: instr = new DivInstruction(tmpname, left, right); break; case TokenType.Or: instr = new OrInstruction(tmpname, left, right); break; case TokenType.And: instr = new AndInstruction(tmpname, left, right); break; case TokenType.GreatThan: instr = new CgtInstruction(tmpname, left, right); break; case TokenType.GreatThanEqual: instr = new CgteInstruction(tmpname, left, right); break; case TokenType.LessThan: instr = new CltInstruction(tmpname, left, right); break; case TokenType.LessThanEqual: instr = new ClteInstruction(tmpname, left, right); break; case TokenType.Equal: case TokenType.NotEqual: // Use NOT instruction instr = new CeqInstruction(tmpname, left, right); break; } generator.Emmit(new VarInstruction(tmpname, null)); generator.Emmit(instr); if (binary.Operator.Type == TokenType.NotEqual) { SymbolOperand notname = generator.SymbolTable.NewTempSymbol(OperandType.Auto); generator.Emmit(new VarInstruction(notname, null)); generator.Emmit(new NotInstruction(notname, tmpname)); return(notname); } return(tmpname); }
public void Read(ref BlobReader reader) { this.ReadStart(); while (reader.RemainingBytes > 0) { int offset = reader.Offset; ILOpCode opCode = reader.DecodeILOpCode(); switch (opCode) { case ILOpCode.Nop: this.Read(NopInstruction.Nop(), offset); break; case ILOpCode.Ldarg_0: this.Read(LoadArgumentInstruction.FromIndex(0), offset); break; case ILOpCode.Ldarg_1: this.Read(LoadArgumentInstruction.FromIndex(1), offset); break; case ILOpCode.Ldloc_0: this.Read(LoadLocalInstruction.FromIndex(0), offset); break; case ILOpCode.Ldloc_1: this.Read(LoadLocalInstruction.FromIndex(1), offset); break; case ILOpCode.Ldloca_s: this.Read(LoadLocalAddressInstruction.FromIndex(reader.ReadSByte()), offset); break; case ILOpCode.Stloc_0: this.Read(StoreLocalInstruction.ToIndex(0), offset); break; case ILOpCode.Stloc_1: this.Read(StoreLocalInstruction.ToIndex(1), offset); break; case ILOpCode.Ldc_i4_0: this.Read(PushInt32Instruction.Constant(0), offset); break; case ILOpCode.Ldc_i4_1: this.Read(PushInt32Instruction.Constant(1), offset); break; case ILOpCode.Ldc_i4_2: this.Read(PushInt32Instruction.Constant(2), offset); break; case ILOpCode.Ldc_i4_3: this.Read(PushInt32Instruction.Constant(3), offset); break; case ILOpCode.Ldc_i4_s: this.Read(PushInt32Instruction.Constant(reader.ReadSByte()), offset); break; case ILOpCode.Ldc_i4: this.Read(PushInt32Instruction.Constant(reader.ReadInt32()), offset); break; case ILOpCode.Ldc_i8: this.Read(PushInt64Instruction.Constant(reader.ReadInt64()), offset); break; case ILOpCode.Br_s: this.Read(BranchInstruction.ILIndex(reader.ReadSByte() + reader.Offset), offset); break; case ILOpCode.Bgt_s: this.Read(BranchGreaterInstruction.ILIndex(reader.ReadSByte() + reader.Offset), offset); break; case ILOpCode.Brfalse_s: this.Read(BranchFalseInstruction.ILIndex(reader.ReadSByte() + reader.Offset), offset); break; case ILOpCode.Call: this.Read(CallInstruction.Handle(reader.ReadInt32()), offset); break; case ILOpCode.Pop: this.Read(PopInstruction.Pop(), offset); break; case ILOpCode.Ret: this.Read(ReturnInstruction.Return(), offset); break; case ILOpCode.Add: this.Read(AddInstruction.Add(), offset); break; case ILOpCode.Sub: this.Read(SubtractInstruction.Subtract(), offset); break; case ILOpCode.Initobj: this.Read(InitObjectInstruction.Handle(reader.ReadInt32()), offset); break; case ILOpCode.Ldfld: this.Read(LoadFieldValueInstruction.Handle(reader.ReadInt32()), offset); break; case ILOpCode.Stfld: this.Read(SaveFieldValueInstruction.Handle(reader.ReadInt32()), offset); break; default: throw new NotSupportedException("Opcode: " + opCode); } } this.ReadEnd(); }
protected override void PrepareNonCommonPar() { ParVar fv = GetUniquePar <ParVar>(DefPar.AddHHMembers.FlagVar); if (fv != null) { flagVar = new VarSpec() { name = fv.name } } ; foreach (var g in GetParGroups(DefPar.AddHHMembers.GROUP_MAIN)) { var group = g.Value; int groupNo = g.Key; AddInstruction addInstruction = new AddInstruction(); // first find out whether we are adding children or partners or other persons ... ParCateg parWho = GetUniqueGroupPar <ParCateg>(DefPar.AddHHMembers.Add_Who, group); if (parWho == null) { continue; // compulsory parameter, error already issued } addInstruction.addWho = parWho.GetCateg(); // ... depending on that, check the add-condition ParCond parParent = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.ParentCond, group); ParCond parPartner = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.PartnerCond, group); ParCond parOther = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.HHCond, group); string missing = string.Empty; string tooMuch = string.Empty; switch (addInstruction.addWho) { case DefPar.Value.ADDHHMEMBERS_CHILD: if (parParent != null) { addInstruction.cond = parParent; } else { missing = DefPar.AddHHMembers.ParentCond; } if (parPartner != null) { tooMuch = DefPar.AddHHMembers.PartnerCond + " "; } if (parOther != null) { tooMuch = DefPar.AddHHMembers.HHCond; } ParBool parIsPP = GetUniqueGroupPar <ParBool>(DefPar.AddHHMembers.IsPartnerParent, group); if (parIsPP != null) { addInstruction.isPartnerParent = parIsPP.GetBoolValue(); } break; case DefPar.Value.ADDHHMEMBERS_PARTNER: if (parParent != null) { tooMuch = DefPar.AddHHMembers.ParentCond + " "; } if (parPartner != null) { addInstruction.cond = parPartner; } else { missing = DefPar.AddHHMembers.PartnerCond; } if (parOther != null) { tooMuch = DefPar.AddHHMembers.HHCond; } break; case DefPar.Value.ADDHHMEMBERS_OTHER: if (parParent != null) { tooMuch = DefPar.AddHHMembers.ParentCond + " "; } if (parPartner != null) { tooMuch = DefPar.AddHHMembers.PartnerCond; } if (parOther != null) { addInstruction.cond = parOther; } else { missing = DefPar.AddHHMembers.HHCond; } break; default: continue; // error is caught by general error handling } if (missing != string.Empty) { infoStore.communicator.ReportError(new Communicator.ErrorInfo() { isWarning = false, message = $"{description.Get()} (group {groupNo}): {DefPar.AddHHMembers.Add_Who}={addInstruction.addWho} requires parameter {missing}" }); } if (tooMuch != string.Empty) { infoStore.communicator.ReportError(new Communicator.ErrorInfo() { isWarning = true, message = $"{description.Get()} (group {groupNo}): {DefPar.AddHHMembers.Add_Who}={addInstruction.addWho} does not require {tooMuch}" }); } // here we are only gathering the variables that are to be set, but do not evaluate whether they exist // note: this function does not "register" variables, i.e. if a variable is not used anywhere else, it cannot be set foreach (ParFormula parVarDefinition in GetPlaceholderGroupPar <ParFormula>(group)) { string varName = parVarDefinition.description.GetParName(); if (addInstruction.prepVarDefinitions.ContainsKey(varName)) { infoStore.communicator.ReportError(new Communicator.ErrorInfo() { isWarning = false, message = $"{parVarDefinition.description.Get()}: double definition of variable {varName}" }); continue; } if (varName == DefVarName.IDHH || varName == DefVarName.IDPERSON || varName == DefVarName.DWT || varName == DefVarName.DCT) { infoStore.communicator.ReportError(new Communicator.ErrorInfo() { isWarning = false, message = $"{parVarDefinition.description.Get()}: variable {varName} is system-set and cannot be changed" }); continue; } addInstruction.prepVarDefinitions.Add(varName, parVarDefinition); } addInstructions.Add(addInstruction); } }