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);
}
