public void ConstTest1() { ConstExpression cos = new ConstExpression(); cos.SetValue(20); Assert.AreEqual(cos.Value.GetType(), typeof(int)); }
public void WhileTest1() { BinaryExpression eq = new BinaryExpression(); BinaryExpression sumadder = new BinaryExpression(); BinaryExpression oneadder = new BinaryExpression(); ConstExpression zero = new ConstExpression(); ConstExpression one = new ConstExpression(); ConstExpression six = new ConstExpression(); VariableExpression vari = new VariableExpression(); VariableExpression sum = new VariableExpression(); zero.SetValue(0); one.SetValue(1); six.SetValue(6); vari.Name = "VAR"; sum.Name = "SUM"; sumadder.Operator = BinaryExpression.OperatorEnum.Add; sumadder.LeftOperand = vari; sumadder.RightOperand = sum; oneadder.Operator = BinaryExpression.OperatorEnum.Add; oneadder.LeftOperand = vari; oneadder.RightOperand = one; eq.Operator = BinaryExpression.OperatorEnum.Sml; eq.LeftOperand = vari; eq.RightOperand = six; SetVarBlock initblk = new SetVarBlock(); SetVarBlock initblk2 = new SetVarBlock(); WhileBlock wblk = new WhileBlock(); SetVarBlock addblk = new SetVarBlock(); SetVarBlock sumaddblk = new SetVarBlock(); initblk.VarName = "SUM"; initblk.ValueExp = zero; initblk2.VarName = "VAR"; initblk2.ValueExp = zero; wblk.Condition = eq; addblk.VarName = "VAR"; addblk.ValueExp = oneadder; sumaddblk.VarName = "SUM"; sumaddblk.ValueExp = sumadder; initblk.NextBlock = initblk2; initblk2.NextBlock = wblk; wblk.InnerBlock = addblk; addblk.NextBlock = sumaddblk; initblk.Execute(); Assert.AreEqual(vari.Value, 6); }
public void VarTest1() { VariableExpression vari = new VariableExpression(); vari.Name = "ACC"; BinaryExpression exp = new BinaryExpression(); exp.Operator = BinaryExpression.OperatorEnum.Sub; ConstExpression cos = new ConstExpression(); cos.SetValue(15); ConstExpression cos2 = new ConstExpression(); cos2.SetValue(20); exp.LeftOperand = vari; exp.RightOperand = cos; SetVarBlock blk = new SetVarBlock(); blk.ValueExp = cos2; blk.VarName = "ACC"; blk.Execute(); Assert.AreEqual(5, exp.Value); }
private Expression readExpression() { Console.WriteLine(" 1: Const Expression\n 2: Var Expression\n 3: Arith Expression"); int c = Convert.ToInt32(Console.ReadLine()); if (c == 1) { Console.WriteLine("Input constant expression"); ConstExpression cx = new ConstExpression(Convert.ToInt32(Console.ReadLine())); return((Expression)cx); } else if (c == 2) { Console.WriteLine("Input variable expression"); VarExpression ve = new VarExpression(Console.ReadLine()); return((Expression)ve); } else if (c == 3) { ArithExpression ae = new ArithExpression(); Console.WriteLine("Input left expression"); ae.setL(readExpression()); Console.WriteLine("Input operator"); ae.setOp(Console.ReadLine()[0]); Console.WriteLine("Input right expression"); ae.setR(readExpression()); return((Expression)ae); } return(null); }
public void TestComplexExpression() { const string VAR_X = "x"; const string VAR_Y = "y"; const string VAR_Z = "z"; var ctx = new Context(); ctx.SetValue(VAR_X, true); ctx.SetValue(VAR_Y, true); ctx.SetValue(VAR_Z, false); var constExp = new ConstExpression(TRUE_TOKEN); var unaryExp = new UnaryExpression(constExp); Assert.AreEqual(false, unaryExp.Interpret(ctx)); var binaryExp = new BinaryExpression( new BinaryExpression(VAR_X, BinaryOp.And, unaryExp), BinaryOp.Or, new BinaryExpression(new UnaryExpression(VAR_Y), BinaryOp.And, VAR_Z)); Assert.AreEqual(false, binaryExp.Interpret(ctx)); }
void ButtonSubmitConstantClick(object sender, EventArgs e) { String constant = textBoxConstant.Text; ConstExpression cx = new ConstExpression(Convert.ToInt32(constant)); expression = cx; finished(); }
public void IfTest2() { VariableExpression vaexp = new VariableExpression(); vaexp.Name = "VAR1"; VariableExpression vaexp2 = new VariableExpression(); vaexp2.Name = "VAR2"; ConstExpression cst = new ConstExpression(); cst.SetValue(true); ConstExpression cst2 = new ConstExpression(); cst2.SetValue(10); ConstExpression cst3 = new ConstExpression(); cst3.SetValue(5); ConstExpression cst4 = new ConstExpression(); cst4.SetValue(7); IfBlock ifblk = new IfBlock(); ElseBlock elseblk = new ElseBlock(); SetVarBlock setvar1 = new SetVarBlock(); SetVarBlock setvar2 = new SetVarBlock(); SetVarBlock setvar3 = new SetVarBlock(); ifblk.Condition = cst; ifblk.InnerBlock = setvar1; ifblk.NextBlock = elseblk; elseblk.InnerBlock = setvar2; elseblk.NextBlock = setvar3; setvar1.VarName = "VAR1"; setvar1.ValueExp = cst2; setvar2.VarName = "VAR1"; setvar2.ValueExp = cst3; setvar3.VarName = "VAR2"; setvar3.ValueExp = cst4; ifblk.Execute(); Assert.AreEqual(vaexp.Value, 10); Assert.AreEqual(vaexp2.Value, 7); cst.SetValue(false); ifblk.Execute(); Assert.AreEqual(vaexp.Value, 5); Assert.AreEqual(vaexp2.Value, 7); }
public override void VisitConstExpression(ConstExpression expression) { nodeStack.Push(CurrentNode.Nodes.Add("ConstExpression " + expression.Value + " " + expression.ValueType)); CurrentNode.Tag = expression; base.VisitConstExpression(expression); nodeStack.Pop(); }
static void Main(string[] args) { var expressionContainerA = new ExpressionContainer("a", (ConstExpression)3); var expressionContainerB = new ExpressionContainer("b", (ConstExpression)4); var expressionContainerC = new ExpressionContainer("c", (ParametarExpression)"x"); var constExpression1 = new ConstExpression(3); var parametarExpressionX = new ParametarExpression("x"); var binaryExpressionMul = new BinaryExpression(constExpression1, parametarExpressionX, "*", false); var constExpression2 = new ConstExpression(15); var parametarExpressionY = new ParametarExpression("y"); var binaryExpressionDiv = new BinaryExpression(constExpression2, parametarExpressionY, "/", false); var constExpression3 = new ConstExpression(4); var binaryExpressionSub = new BinaryExpression(binaryExpressionDiv, constExpression3, "-", false); var binaryExpressionAdd = new BinaryExpression(binaryExpressionMul, binaryExpressionSub, "+", false); var expressionContainerIme = new ExpressionContainer("ime", binaryExpressionAdd); var binaryExpressionMul2 = new BinaryExpression(binaryExpressionMul, parametarExpressionY, "*", false); var expressionContainerIme2 = new ExpressionContainer("ime", binaryExpressionMul2); List <ExpressionContainer> lista = new List <ExpressionContainer>() { expressionContainerA, expressionContainerB, expressionContainerC }; Thread t1 = new Thread(() => ExpressionSingleton.Instance.ListId(lista).ForEach(t => Console.WriteLine("t1 " + t.ToString()))); Thread t2 = new Thread(() => { ExpressionSingleton.Instance.ChangeName(expressionContainerA, "Novi"); Console.WriteLine("t2 " + expressionContainerA.Name); }); Thread t3 = new Thread(() => { ExpressionSingleton.Instance.ChangeExpression(expressionContainerA, parametarExpressionY); expressionContainerA.Expression.Printf(); }); Thread t4 = new Thread(() => ExpressionSingleton.Instance.ListId(lista).ForEach(t => Console.WriteLine("t4 " + t.ToString()))); t1.Start(); t4.Start(); t2.Start(); t3.Start(); Serialize(expressionContainerIme); Deserialize(); //Console.ReadLine(); }
public void TestConst() { var ctx = new Context(); var constExp = new ConstExpression(TRUE_TOKEN); Assert.AreEqual(true, constExp.Interpret(ctx)); constExp = new ConstExpression(FALSE_TOKEN); Assert.AreEqual(false, constExp.Interpret(ctx)); }
private string GenerateExpr(Expression e) { return(e switch { BinOp binop => GenerateBinExpr(binop), UnOp unop => GenerateUnExpr(unop), ConstExpression constExpression => GenerateConstExpr(constExpression), VarExpression varExpression => GenerateVarExpr(varExpression), CallExpression callExpression => GenerateCallExpression(callExpression), ConditionalExpression conditionalExpression => GenerateConditionalExpression(conditionalExpression), _ => throw new CompilerException(e.GetType().ToString(), e.Row, e.Column) });
public void BinaryTest1() { BinaryExpression exp = new BinaryExpression(); exp.Operator = BinaryExpression.OperatorEnum.Add; ConstExpression cos = new ConstExpression(); cos.SetValue(20); ConstExpression cos2 = new ConstExpression(); cos2.SetValue(10); exp.LeftOperand = cos; exp.RightOperand = cos2; Assert.AreEqual(30, exp.Value); }
public void BinaryTest2() { BinaryExpression exp = new BinaryExpression(); exp.Operator = BinaryExpression.OperatorEnum.Eql; ConstExpression cos = new ConstExpression(); cos.SetValue(20); ConstExpression cos2 = new ConstExpression(); cos2.SetValue(20); exp.LeftOperand = cos; exp.RightOperand = cos2; Assert.IsTrue((bool)exp.Value); }
public void IfTest1() { VariableExpression vaexp = new VariableExpression(); vaexp.Name = "VAR1"; ConstExpression cst = new ConstExpression(); cst.SetValue(true); ConstExpression cst2 = new ConstExpression(); cst2.SetValue(10); ConstExpression cst3 = new ConstExpression(); cst3.SetValue(5); IfBlock ifblk = new IfBlock(); SetVarBlock setvar1 = new SetVarBlock(); SetVarBlock setvar2 = new SetVarBlock(); setvar1.VarName = "VAR1"; setvar1.ValueExp = cst2; setvar1.NextBlock = ifblk; ifblk.Condition = cst; ifblk.InnerBlock = setvar2; setvar2.VarName = "VAR1"; setvar2.ValueExp = cst3; setvar1.Execute(); Assert.AreEqual(vaexp.Value, 5); cst.SetValue(false); setvar1.Execute(); Assert.AreEqual(vaexp.Value, 10); }
/// <summary> /// Creates a method call returned via out parameter. /// </summary> /// <param name="state">Current program state.</param> /// <param name="isVirtual">True if method call is virtual, false otherwise.</param> /// <param name="calledMethod">The method being called.</param> /// <param name="returnType">The return type of the method being called.</param> /// <param name="returnVariable">Identifies the variable returned by the method.</param> /// <param name="callArgs">The method arguments.</param> /// <param name="methodCall">The Call SIL instruction.</param> /// <param name="isConstructorCall"><c>true</c> if the call is for a constructor, /// <c>false</c> otherwise.</param> protected static void CreateMethodCall(ProgramState state, bool isVirtual, MethodReference calledMethod, out TypeReference returnType, out Identifier returnVariable, out List <Call.CallArg> callArgs, out Call methodCall, bool isConstructorCall = false) { callArgs = new List <Call.CallArg>(); returnType = calledMethod.ReturnType; var paramCount = calledMethod.Parameters.Count; if (calledMethod.HasThis) { paramCount++; } if (isConstructorCall) { // In this case, the "this" argument of the constructor is located at the top of // the stack; we remove it and place it at the front of the argument list. (var thisExpr, var thisType) = state.Pop(); callArgs.Add(new Call.CallArg(thisExpr, thisType)); paramCount--; } var funcExp = new ConstExpression(new ProcedureName(calledMethod)); callArgs.AddRange(state.PopMany(paramCount) .Select(p => new Call.CallArg(p.Item1, p.Item2)) .ToList()); var callFlags = new Call.CallFlags(isVirtual, false, false); returnVariable = state.GetIdentifier(Identifier.IdentKind.Normal); methodCall = new Call(returnId: returnVariable, returnType: Typ.FromTypeReference(returnType), functionExpression: funcExp, args: callArgs, flags: callFlags, location: state.CurrentLocation); }
protected override bool ParseCilInstructionInternal(Instruction instruction, ProgramState state) { switch (instruction.OpCode.Code) { case Code.Isinst: (var objectExpression, var objectType) = state.Pop(); var typeToCheck = instruction.Operand as TypeReference; var returnIdentifier = state.GetIdentifier(Identifier.IdentKind.Normal); var returnType = new Tint(Tint.IntKind.IBool, true); var builtinFunctionExpression = new ConstExpression( ProcedureName.BuiltIn__instanceof); var sizeofExpression = new SizeofExpression( Typ.FromTypeReferenceNoPointer(typeToCheck), SizeofExpression.SizeofExpressionKind.instof); var args = new List <Call.CallArg> { new Call.CallArg(objectExpression, objectType), new Call.CallArg(sizeofExpression, new Tvoid()) }; var callInstruction = new Call( returnIdentifier, returnType, builtinFunctionExpression, args, new Call.CallFlags(), state.CurrentLocation); var newNode = AddMethodBodyInstructionsToCfg(state, callInstruction); state.PushExpr(new VarExpression(returnIdentifier), returnType); state.PushInstruction(instruction.Next, newNode); return(true); default: return(false); } }
private string GenerateConstExpr(ConstExpression e) { return($"\tpush {e.Data}\n"); }
protected override bool ParseCilInstructionInternal(Instruction instruction, ProgramState state) { ConstExpression constExp = null; Typ type = null; switch (instruction.OpCode.Code) { case Code.Ldc_I4_M1: (constExp, type) = MakeInt(-1); break; case Code.Ldc_I4: (constExp, type) = MakeInt((int)instruction.Operand); break; case Code.Ldc_I4_S: (constExp, type) = MakeInt((sbyte)instruction.Operand); break; case Code.Ldc_I4_0: (constExp, type) = MakeInt(0); break; case Code.Ldc_I4_1: (constExp, type) = MakeInt(1); break; case Code.Ldc_I4_2: (constExp, type) = MakeInt(2); break; case Code.Ldc_I4_3: (constExp, type) = MakeInt(3); break; case Code.Ldc_I4_4: (constExp, type) = MakeInt(4); break; case Code.Ldc_I4_5: (constExp, type) = MakeInt(5); break; case Code.Ldc_I4_6: (constExp, type) = MakeInt(6); break; case Code.Ldc_I4_7: (constExp, type) = MakeInt(7); break; case Code.Ldc_I4_8: (constExp, type) = MakeInt(8); break; case Code.Ldc_I8: (constExp, _) = MakeInt((long)instruction.Operand); type = new Tint(Tint.IntKind.ILongLong); break; case Code.Ldc_R4: constExp = new ConstExpression((float)instruction.Operand); type = new Tfloat(Tfloat.FloatKind.FFloat); break; case Code.Ldc_R8: constExp = new ConstExpression((double)instruction.Operand); type = new Tfloat(Tfloat.FloatKind.FDouble); break; case Code.Ldstr: constExp = new ConstExpression((string)instruction.Operand); type = new Tptr(Tptr.PtrKind.Pk_pointer, new Tstruct("System.String")); break; default: return(false); } state.PushExpr(constExp, type); state.PushInstruction(instruction.Next); return(true); }
public string VisitConstExpression(ConstExpression constExpression) => constExpression.Type is EmptyType ? "unit" : constExpression.Value.ToString();
public virtual T Visit(ConstExpression node) { return(Visit((Expression)node)); }
public override bool Visit(ConstExpression node) { Visit((Expression)node); return(true); }
public virtual void VisitConstExpression(ConstExpression expression) { VisitCommonExpNodes(expression); }