private static void AnalyseWhileStatement()
{
Tokenizer.ExpectToken(TokenType.While);
var brStart = SymbolManager.AddInstruction(new Instruction(InstructionType.Br, 0));
SymbolManager.EnterWhile(brStart);
var condition = ExpressionAnalyser.AnalyseExpression();
if (condition.ValueType != ValueType.Int)
{
throw new Exception("invalid condition expression");
}
SymbolManager.AddInstruction(new Instruction(InstructionType.BrTrue, 1));
var brForward = SymbolManager.AddInstruction(new Instruction(InstructionType.Br, 0));
AnalyseBlockStatement(true);
var brBack = SymbolManager.AddInstruction(new Instruction(InstructionType.Br, 0));
brBack.SetParam(SymbolManager.GetInstructionOffset(brBack, brStart));
brForward.SetParam(SymbolManager.GetInstructionOffset(brForward, brBack) + 1);
SymbolManager.LeaveWhile();
}
private static void AnalyseLetStatement()
{
Tokenizer.ExpectToken(TokenType.Let);
var ident = Tokenizer.ExpectToken(TokenType.Identifier);
Tokenizer.ExpectToken(TokenType.Colon);
var type = Tokenizer.ExpectToken(TokenType.Identifier);
var variable = SymbolManager.NewVariable((string)ident.Value, type.ToValueType(), false);
if (Tokenizer.PeekToken().Is(TokenType.Assign))
{
Tokenizer.ExpectToken(TokenType.Assign);
// load symbol address
SymbolManager.AddLoadAddressInstruction(variable);
var e = ExpressionAnalyser.AnalyseExpression();
if (variable.ValueType != e.ValueType)
{
throw new Exception("value type not match");
}
SymbolManager.CurFunction.AddInstruction(new Instruction(InstructionType.Store64));
variable.Initial();
}
Tokenizer.ExpectToken(TokenType.Semicolon);
}
private static void AnalyseReturnStatement()
{
Tokenizer.ExpectToken(TokenType.Return);
if (SymbolManager.CurFunction.ReturnType != ValueType.Void)
{
var symbol = SymbolManager.FindSymbol("return()");
SymbolManager.AddLoadAddressInstruction(symbol);
}
var e = ExpressionAnalyser.AnalyseExpression();
if (e.ValueType != SymbolManager.CurFunction.ReturnType)
{
throw new Exception("unexpected return value");
}
if (e.ValueType != ValueType.Void)
{
SymbolManager.AddInstruction(new Instruction(InstructionType.Store64));
}
Tokenizer.ExpectToken(TokenType.Semicolon);
SymbolManager.AddInstruction(new Instruction(InstructionType.Ret));
}
private static void AnalyseIfStatement()
{
Tokenizer.ExpectToken(TokenType.If);
var condition = ExpressionAnalyser.AnalyseExpression();
if (condition.ValueType != ValueType.Int)
{
throw new Exception("invalid condition expression");
}
SymbolManager.AddInstruction(new Instruction(InstructionType.BrTrue, 1));
var iThrough = SymbolManager.AddInstruction(new Instruction(InstructionType.Br, 0));
AnalyseBlockStatement(true);
// iThrough should jump to here
iThrough.SetParam(SymbolManager.GetInstructionOffset(iThrough) + 1);
if (Tokenizer.PeekToken().Is(TokenType.Else))
{
var iInnerThrough = SymbolManager.AddInstruction(new Instruction(InstructionType.Br, 0));
Tokenizer.ExpectToken(TokenType.Else);
if (Tokenizer.PeekToken().Is(TokenType.LBrace))
{
AnalyseBlockStatement(true);
}
else
{
AnalyseIfStatement();
}
// iThrough should jump to here
iInnerThrough.SetParam(SymbolManager.GetInstructionOffset(iInnerThrough) + 1);
}
SymbolManager.AddInstruction(new Instruction(InstructionType.Br, 0));
}
private static void AnalyseExpressionStatement()
{
ExpressionAnalyser.AnalyseExpression();
Tokenizer.ExpectToken(TokenType.Semicolon);
}
public void HasBeenSaved <TU>(Expression <Func <TU, bool> > assertions) where TU : TableEntity, new()
{
var exactResults = GetList <TU>();
ExpressionAnalyser.CheckMessagesMatch(exactResults, assertions);
}
public void HasBeenDeleted <TU>(Expression <Func <TU, bool> > assertions) where TU : TableEntity, new()
{
var results = GetList <TU>();
ExpressionAnalyser.CheckMessagesDoNotMatch(results, assertions);
}
