public void TestPrintBoolExpression()
{
var buildResult = buildParser();
Assert.False(buildResult.IsError);
var parser = buildResult.Result;
ParseResult <WhileToken, WhileAST> result = parser.Parse("print true and false");
Assert.False(result.IsError);
Assert.NotNull(result.Result);
Assert.IsType <SequenceStatement>(result.Result);
SequenceStatement seq = result.Result as SequenceStatement;
Assert.IsType <PrintStatement>(seq.Get(0));
PrintStatement print = seq.Get(0) as PrintStatement;
Expression expr = print.Value;
Assert.IsType <BinaryOperation>(expr);
BinaryOperation bin = expr as BinaryOperation;
Assert.Equal(BinaryOperator.AND, bin.Operator);
Assert.True((bin.Left as BoolConstant)?.Value);
Assert.False((bin.Right as BoolConstant)?.Value);
}
public void TestInfiniteWhile()
{
var buildResult = buildParser();
Assert.False(buildResult.IsError);
var parser = buildResult.Result;
ParseResult <WhileToken, WhileAST> result = parser.Parse("while true do (skip)");
Assert.False(result.IsError);
Assert.NotNull(result.Result);
Assert.IsType <SequenceStatement>(result.Result);
SequenceStatement seq = result.Result as SequenceStatement;
Assert.IsType <WhileStatement>(seq.Get(0));
WhileStatement whil = seq.Get(0) as WhileStatement;
Expression cond = whil.Condition;
Assert.IsType <BoolConstant>(cond);
Assert.True((cond as BoolConstant).Value);
Statement s = whil.BlockStmt;
Assert.IsType <SequenceStatement>(whil.BlockStmt);
SequenceStatement seqBlock = whil.BlockStmt as SequenceStatement;
Assert.Equal(1, seqBlock.Count);
Assert.IsType <SkipStatement>(seqBlock.Get(0));
;
}
public void TestAssignAdd()
{
var buildResult = buildParser();
Assert.False(buildResult.IsError);
var parser = buildResult.Result;
ParseResult <WhileToken, WhileAST> result = parser.Parse("(a:=1+1)");
Assert.False(result.IsError);
Assert.NotNull(result.Result);
Assert.IsType <SequenceStatement>(result.Result);
SequenceStatement seq = result.Result as SequenceStatement;
Assert.IsType <AssignStatement>(seq.Get(0));
AssignStatement assign = seq.Get(0) as AssignStatement;
Assert.Equal("a", assign.VariableName);
Expression val = assign.Value;
Assert.IsType <BinaryOperation>(val);
BinaryOperation bin = val as BinaryOperation;
Assert.Equal(BinaryOperator.ADD, bin.Operator);
Assert.Equal(1, (bin.Left as IntegerConstant)?.Value);
Assert.Equal(1, (bin.Right as IntegerConstant)?.Value);
}
private void Interprete(SequenceStatement ast, InterpreterContext context)
{
for (var i = 0; i < ast.Count; i++)
{
var stmt = ast.Get(i);
Interprete(stmt, context);
}
}
public void TestIfThenElse()
{
var buildResult = buildParser();
Assert.False(buildResult.IsError);
var parser = buildResult.Result;
ParseResult <WhileToken, WhileAST> result = parser.Parse("if true then (a := \"hello\") else (b := \"world\")");
Assert.False(result.IsError);
Assert.NotNull(result.Result);
Assert.IsType <SequenceStatement>(result.Result);
SequenceStatement seq = result.Result as SequenceStatement;
Assert.IsType <IfStatement>(seq.Get(0));
IfStatement si = seq.Get(0) as IfStatement;
Expression cond = si.Condition;
Assert.IsType <BoolConstant>(cond);
Assert.True((cond as BoolConstant).Value);
Statement s = si.ThenStmt;
Assert.IsType <SequenceStatement>(si.ThenStmt);
SequenceStatement thenBlock = si.ThenStmt as SequenceStatement;
Assert.Equal(1, thenBlock.Count);
Assert.IsType <AssignStatement>(thenBlock.Get(0));
AssignStatement thenAssign = thenBlock.Get(0) as AssignStatement;
Assert.Equal("a", thenAssign.VariableName);
Assert.IsType <StringConstant>(thenAssign.Value);
Assert.Equal("hello", (thenAssign.Value as StringConstant).Value);
;
Assert.IsType <SequenceStatement>(si.ElseStmt);
SequenceStatement elseBlock = si.ElseStmt as SequenceStatement;
Assert.Equal(1, elseBlock.Count);
Assert.IsType <AssignStatement>(elseBlock.Get(0));
AssignStatement elseAssign = elseBlock.Get(0) as AssignStatement;
Assert.Equal("b", elseAssign.VariableName);
Assert.IsType <StringConstant>(elseAssign.Value);
Assert.Equal("world", (elseAssign.Value as StringConstant).Value);
}
public void TestSkipSkipSequence()
{
var buildResult = buildParser();
Assert.False(buildResult.IsError);
var parser = buildResult.Result;
ParseResult <WhileToken, WhileAST> result = parser.Parse("(skip; skip; skip)");
Assert.False(result.IsError);
Assert.NotNull(result.Result);
Assert.IsType <SequenceStatement>(result.Result);
SequenceStatement seq = result.Result as SequenceStatement;
Assert.Equal(3, seq.Count);
Assert.IsType <SkipStatement>(seq.Get(0));
Assert.IsType <SkipStatement>(seq.Get(1));
Assert.IsType <SkipStatement>(seq.Get(2));
}
private void SemanticCheck(SequenceStatement ast, CompilerContext context)
{
context.OpenNewScope();
ast.CompilerScope = context.CurrentScope;
for (int i = 0; i < ast.Count; i++)
{
Statement stmt = ast.Get(i);
SemanticCheck(stmt, context);
}
context.CloseScope();
}
public void TestSkipAssignSequence()
{
var buildResult = buildParser();
Assert.False(buildResult.IsError);
var parser = buildResult.Result;
ParseResult <WhileToken, WhileAST> result = parser.Parse("(a:=1; b:=2; c:=3)");
Assert.False(result.IsError);
Assert.NotNull(result.Result);
Assert.IsType <SequenceStatement>(result.Result);
SequenceStatement seq = result.Result as SequenceStatement;
Assert.Equal(3, seq.Count);
string[] names = new string[] { "a", "b", "c" };
for (int i = 0; i < names.Length; i++)
{
Assert.IsType <AssignStatement>(seq.Get(i));
AssignStatement assign = seq.Get(i) as AssignStatement;
Assert.Equal(names[i], assign.VariableName);
Assert.Equal(i + 1, (assign.Value as IntegerConstant).Value);
}
}
