/// <summary>
/// Parses a looping expression that is dependent on an expression
/// evaluating to true.
/// Syntax:
/// "While" "{" Expression "}" Statement
/// </summary>
private void ParseWhile()
{
// Check we are in a valid scope.
if (_currentScope.Type != SymbolType.Function || _currentScope == _globalScope)
Error(ErrorCode.InvalidScope, "While statments are only valid inside a function's or event's scope.", false, 0);
// Create some jump target symbols.
JumpTargetSymbol startJumpTarget = null, endJumpTarget = null;
Instruction instruction;
// Bind the starting jump target to here.
if (_currentPass == 1)
{
startJumpTarget = new JumpTargetSymbol(_currentScope);
endJumpTarget = new JumpTargetSymbol(_currentScope);
}
// Read in the expression to evaluate
ExpectToken(TokenID.CharOpenParenthesis);
DataTypeValue expressionDataType = ParseExpression();
ExpectToken(TokenID.CharCloseParenthesis);
// Make sure we can cast between the expression type and boolean.
if (!CanImplicitlyCast(new DataTypeValue(DataType.Bool, false, false), expressionDataType))
Error(ErrorCode.InvalidCast, "Can't implicitly cast between \"Bool\" and \"" + expressionDataType.ToString() + "\"", false, 0);
// Emit evaluation byte code.
if (_currentPass == 1)
{
// Pop the result of the expression into arith register 1.
instruction = CreateInstruction(OpCodeByType(expressionDataType, OpCodeType.POP), _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
// Cast it to boolean if its not already boolean
if (expressionDataType != new DataTypeValue(DataType.Bool, false, false))
{
instruction = CreateInstruction(OpCode.CAST_BOOL, _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
}
// Compare the expression result to 0.
instruction = CreateInstruction(OpCode.CMP_BOOL, _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
new Operand(instruction, false);
// Jump to finish jump target if comparison is equal to false.
instruction = CreateInstruction(OpCode.JMP_EQ, _currentScope, _currentToken);
new Operand(instruction, endJumpTarget);
// Push a new loop tracker onto the loop stack.
_loopTrackerStack.Push(new LoopTracker(startJumpTarget, endJumpTarget));
}
// Parse the statements contained in this while block.
ParseStatement();
// Emit finishing byte code.
if (_currentPass == 1)
{
// Pop the loop tracker of the loop stack.
_loopTrackerStack.Pop();
// Jump to the start of the loop.
instruction = CreateInstruction(OpCode.JMP, _currentScope, _currentToken);
new Operand(instruction, startJumpTarget);
// Bind exit jump target.
endJumpTarget.Bind();
}
}
/// <summary>
/// Parses a label, which is used in conjunction with the goto statement to jump
/// to specific areas in the code.
/// Syntax:
/// Identifier ":"
/// </summary>
private void ParseLabel()
{
// Check we are in a valid scope.
if (_currentScope.Type != SymbolType.Function || _currentScope == _globalScope)
Error(ErrorCode.InvalidScope, "Label statments are only valid inside a function's or event's scope.", false, 0);
// Create a jump target for this label.
JumpTargetSymbol jumpTarget = null;
if (_currentPass == 0)
{
jumpTarget = new JumpTargetSymbol(_currentScope);
jumpTarget.Identifier = _currentToken.Ident;
}
else if (_currentPass == 1)
{
jumpTarget = _currentScope.FindSymbol(_currentToken.Ident, SymbolType.JumpTarget) as JumpTargetSymbol;
jumpTarget.Bind();
}
// Read in the colon that ends this label.
ExpectToken(TokenID.CharColon);
}
/// <summary>
/// Parses a switch statement, a switch statement is essentially a
/// nicer way of write a list of if/elseif blocks.
/// Syntax:
/// "Switch" "(" Expression ")" "{" { [ "case" Expresion ":" Statement ] [ "default" ":" Statement ] } "}"
///
/// Output byte code example:
/// [expression]
/// pop a1
///
/// [expression]
/// pop a2
/// cmp a2, a1
/// jmp_ne case1exit
/// [block]
/// jmp exit
/// case1exit:
///
/// [expression]
/// pop a2
/// cmp a2, a1
/// jmp_ne case2exit
/// [block]
/// jmp exit
/// case2exit:
///
/// default:
/// jmp exit
///
/// exit:
///
/// </summary>
private void ParseSwitch()
{
// Check we are in a valid scope.
if (_currentScope.Type != SymbolType.Function || _currentScope == _globalScope)
Error(ErrorCode.InvalidScope, "Switch statements are only valid inside a function's or event's scope.", false, 0);
// Declare variables used within this function.
JumpTargetSymbol defaultJumpTarget = null, exitJumpTarget = null;
JumpTargetSymbol exitCaseJumpTarget = null;
Instruction instruction = null;
// If we are in pass 2 then create the jump targets.
if (_currentPass == 1)
{
defaultJumpTarget = new JumpTargetSymbol(_currentScope);
exitJumpTarget = new JumpTargetSymbol(_currentScope);
}
// Read in the main expression.
ExpectToken(TokenID.CharOpenParenthesis);
DataTypeValue expressionDataType = ParseExpression();
ExpectToken(TokenID.CharCloseParenthesis);
// Pop the expression into reserved register 3.
if (_currentPass == 1)
{
instruction = CreateInstruction(OpCodeByType(expressionDataType, OpCodeType.POP), _currentScope, _currentToken);
new Operand(instruction, Register.Reserved3);
}
// Read in opening brace.
ExpectToken(TokenID.CharOpenBrace);
// Create and push a new loop tracker into the tracker stack.
if (_currentPass == 1)
_loopTrackerStack.Push(new LoopTracker(null, exitJumpTarget));
// Keep looping until we find the end of this switch statement.
bool foundDefault = false;
while (true)
{
// If the next token is a closing brace then exit loop.
if (LookAheadToken().ID == TokenID.CharCloseBrace)
break;
// Read in a case block.
if (LookAheadToken().ID == TokenID.KeywordCase)
{
NextToken(); // Read in the case keyword.
// Create a exit-case jump target.
if (_currentPass == 1) exitCaseJumpTarget = new JumpTargetSymbol(_currentScope);
// Read in the case expression.
DataTypeValue caseResultDataType = ParseExpression();
// Cast the value into the correct type.
if (CanImplicitlyCast(expressionDataType, caseResultDataType) == false)
Error(ErrorCode.InvalidCast, "Can't implicitly cast between \"" + expressionDataType.ToString() + "\" and \"" + caseResultDataType.ToString() + "\"");
if (_currentPass == 1)
{
// Pop the value into arith register 1.
instruction = CreateInstruction(OpCodeByType(caseResultDataType, OpCodeType.POP), _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
// Cast to the correct type if its not already it.
if (expressionDataType != caseResultDataType)
{
instruction = CreateInstruction(OpCodeByType(expressionDataType, OpCodeType.CAST), _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
}
// Compare the expression and this case's expression.
instruction = CreateInstruction(OpCodeByType(expressionDataType, OpCodeType.CMP), _currentScope, _currentToken);
new Operand(instruction, Register.Reserved3);
new Operand(instruction, Register.Arithmetic1);
// If its not equal to the expression then jump to the case
// exit jump target.
instruction = CreateInstruction(OpCode.JMP_NE, _currentScope, _currentToken);
new Operand(instruction, exitCaseJumpTarget);
}
ExpectToken(TokenID.CharColon); // Read in the colon.
// Parse the case statement.
ParseStatement();
if (_currentPass == 1)
{
// Jump to the default block.
instruction = CreateInstruction(OpCode.JMP, _currentScope, _currentToken);
new Operand(instruction, exitJumpTarget);
// Bind the case exit jump target.
exitCaseJumpTarget.Bind();
}
}
// Its not a case so check if its a default block.
if (LookAheadToken().ID == TokenID.KeywordDefault)
{
NextToken(); // Read in the deault keyword.
ExpectToken(TokenID.CharColon); // Read in the colon.
// Check we haven't already found a default block.
if (foundDefault == true) Error(ErrorCode.DuplicateDefault, "Switch statements can't contain duplicate default blocks.");
foundDefault = true;
if (_currentPass == 1)
{
// Create a exit-case jump target.
exitCaseJumpTarget = new JumpTargetSymbol(_currentScope);
// Jump past the default block.
instruction = CreateInstruction(OpCode.JMP, _currentScope, _currentToken);
new Operand(instruction, exitCaseJumpTarget);
// Bind the default jump target.
defaultJumpTarget.Bind();
}
// Parses the default block's statement.
ParseStatement();
if (_currentPass == 1)
{
// Jump to the exit jump target.
instruction = CreateInstruction(OpCode.JMP, _currentScope, _currentToken);
new Operand(instruction, exitJumpTarget);
// Bind the case exit jump target.
exitCaseJumpTarget.Bind();
}
}
}
// Read in closing brace.
ExpectToken(TokenID.CharCloseBrace);
// Pop the loop tracker off the tracker stack.
if (_currentPass == 1)
_loopTrackerStack.Pop();
if (_currentPass == 1)
{
// Jump to the default block if its defined.
if (foundDefault == true)
{
instruction = CreateInstruction(OpCode.JMP, _currentScope, _currentToken);
new Operand(instruction, defaultJumpTarget);
}
// Bind the exit jump target.
exitJumpTarget.Bind();
}
}
/// <summary>
/// Parses a flow-of-control if statement, which will preform the given action
/// if the expression evaluates to true. Optional Else and ElseIf block's will be
/// preformed if expression evaluates to false.
/// Syntax:
/// "if" "(" Expression ")" Statement { [ "elseif" Block ] } [ "else" Block ]
/// </summary>
private void ParseIf()
{
// Check we are in a valid scope.
if (_currentScope.Type != SymbolType.Function || _currentScope == _globalScope)
Error(ErrorCode.InvalidScope, "If statments are only valid inside a function's or event's scope.", false, 0);
// Generate a false jump target.
Instruction instruction = null;
JumpTargetSymbol falseJumpTarget = null;
JumpTargetSymbol skipFalseJumpTarget = null;
// Parse the expression.
ExpectToken(TokenID.CharOpenParenthesis);
DataTypeValue expressionDataType = ParseExpression();
ExpectToken(TokenID.CharCloseParenthesis);
// Make sure we can cast between the expression type and boolean.
if (!CanImplicitlyCast(new DataTypeValue(DataType.Bool, false, false), expressionDataType))
Error(ErrorCode.InvalidCast, "Can't implicitly cast between \"Bool\" and \"" + expressionDataType.ToString() + "\"", false, 0);
// Generate comparison byte code.
if (_currentPass == 1)
{
// Generate false jump target
falseJumpTarget = new JumpTargetSymbol(_currentScope);
// Pop the result into arith register 1
instruction = CreateInstruction(OpCodeByType(expressionDataType, OpCodeType.POP), _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
// Cast it to boolean if its not already boolean
if (expressionDataType != new DataTypeValue(DataType.Bool, false, false))
{
instruction = CreateInstruction(OpCode.CAST_BOOL,_currentScope,_currentToken);
new Operand(instruction, Register.Arithmetic1);
}
// Compare result with 0
instruction = CreateInstruction(OpCode.CMP_BOOL, _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
new Operand(instruction, false);
// Jump to false jump target if comparison is equal.
instruction = CreateInstruction(OpCode.JMP_EQ, _currentScope, _currentToken);
new Operand(instruction, falseJumpTarget);
}
// Parse the true statement.
ParseStatement();
// Check for the else keyword.
if (LookAheadToken().ID == TokenID.KeywordElse)
{
// Read in the else keyword.
NextToken();
if (_currentPass == 1)
{
// Append an unconditional jump past the false
// block to the true block.
skipFalseJumpTarget = new JumpTargetSymbol(_currentScope);
instruction = CreateInstruction(OpCode.JMP, _currentScope, _currentToken);
new Operand(instruction, skipFalseJumpTarget);
// Bind the false jump target.
falseJumpTarget.Bind();
}
// Parse the else statement.
ParseStatement();
if (_currentPass == 1) skipFalseJumpTarget.Bind();
}
else
if (_currentPass == 1) falseJumpTarget.Bind();
}
/// <summary>
/// Parses a for loop, which is similar to the while statement but keeps the initialization,
/// incrementation and comparison in a more intuative format.
/// Syntax:
/// "For" "(" Initialization ";" Expression ";" Expression ")" Statement
///
/// Output byte code example:
/// [initialization]
/// start:
/// [expression]
/// pop a1
/// cmp a1, 0
/// jmp_eq exit
/// [statement block]
/// [increment]
/// jmp start
///
/// </summary>
private void ParseFor()
{
// Check we are in a valid scope.
if (_currentScope.Type != SymbolType.Function || _currentScope == _globalScope)
Error(ErrorCode.InvalidScope, "For statements are only valid inside a function's or event's scope.", false, 0);
// Declare some important variables.
JumpTargetSymbol startJumpTarget = null;
JumpTargetSymbol finishJumpTarget = null;
JumpTargetSymbol incrementJumpTarget = null;
Instruction instruction = null;
// Create jump targets if we are in pass 2.
if (_currentPass == 1)
{
startJumpTarget = new JumpTargetSymbol(_currentScope);
incrementJumpTarget = new JumpTargetSymbol(_currentScope);
finishJumpTarget = new JumpTargetSymbol(_currentScope);
}
// Read in the variable declaration.
ExpectToken(TokenID.CharOpenParenthesis);
NextToken();
if (_currentToken.ID == TokenID.KeywordBool || _currentToken.ID == TokenID.KeywordByte ||
_currentToken.ID == TokenID.KeywordDouble || _currentToken.ID == TokenID.KeywordObject ||
_currentToken.ID == TokenID.KeywordFloat || _currentToken.ID == TokenID.KeywordInt ||
_currentToken.ID == TokenID.KeywordLong || _currentToken.ID == TokenID.KeywordShort ||
_currentToken.ID == TokenID.KeywordString || _currentToken.ID == TokenID.KeywordVoid ||
_currentToken.ID == TokenID.KeywordConst || _currentToken.ID == TokenID.KeywordStatic)
ParseVariable();
// Its not a variable declaration so read it in as a assignment.
else
ParseAssignment();
// Bind the starting target.
if (_currentPass == 1)
startJumpTarget.Bind();
// Parse the expression block.
DataTypeValue expressionType = ParseExpression();
ExpectToken(TokenID.CharSemiColon);
// Create the expression evaluation instruction's.
if (_currentPass == 1)
{
// Pop the result of the expression into arith register 1.
instruction = CreateInstruction(OpCodeByType(expressionType, OpCodeType.POP), _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
// Cast it to boolean if its not already boolean.
if (expressionType != new DataTypeValue(DataType.Bool, false, false))
{
instruction = CreateInstruction(OpCode.CAST_BOOL, _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
}
// Compare the result of the expression to false.
instruction = CreateInstruction(OpCode.CMP_BOOL, _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
new Operand(instruction, false);
// If its equal jump out of this loop.
instruction = CreateInstruction(OpCode.JMP_EQ, _currentScope, _currentToken);
new Operand(instruction, finishJumpTarget);
}
// Skip the increment and parse the block.
int incrementTokenIndex = _tokenIndex;
Token incrementToken = _currentToken;
while (EndOfTokenStream() == false && LookAheadToken().ID != TokenID.CharCloseParenthesis)
NextToken();
NextToken(); // Read in closing brace.
// Push a loop tracker into the tracker stack.
if (_currentPass == 1)
_loopTrackerStack.Push(new LoopTracker(incrementJumpTarget, finishJumpTarget));
// Parse the loop's body.
ParseStatement();
// Pop the loop tracker of the tracker state.
if (_currentPass == 1)
_loopTrackerStack.Pop();
// Note down the current token index / token.
int finishTokenIndex = _tokenIndex;
Token finishToken = _currentToken;
// Go back to the increment block and parse it.
_tokenIndex = incrementTokenIndex;
_currentToken = incrementToken;
NextToken();
// Bind the increment jump target.
if (_currentPass == 1)
incrementJumpTarget.Bind();
// Parse the increment.
ParseAssignment();
// Go back to the end.
_tokenIndex = finishTokenIndex;
_currentToken = finishToken;
// Jump to the start block.
if (_currentPass == 1)
{
instruction = CreateInstruction(OpCode.JMP, _currentScope, _currentToken);
new Operand(instruction, startJumpTarget);
}
// Bind the finishing target.
if (_currentPass == 1)
finishJumpTarget.Bind();
}
/// <summary>
/// Parses a do looping statment. The do loop comes in 2 flavours do and do/while; The do
/// loop will loop through the statements body for x amount of times, where x is the result
/// of the expression. The Do/While loop works just like the While loop but gets evaluated
/// at the end rather than the start.
/// Syntax:
/// "Do" ["(" Expression ")"] Statement [ "While" "(" Expression ")" ]
/// </summary>
private void ParseDo()
{
// Check we are in a valid scope.
if (_currentScope.Type != SymbolType.Function || _currentScope == _globalScope)
Error(ErrorCode.InvalidScope, "Do statments are only valid inside a function's or event's scope.", false, 0);
bool whileLoop = true;
VariableSymbol doTrackerVariable = null;
Instruction instruction = null;
// Bind the starting jump target.
JumpTargetSymbol startJumpTarget = null, endJumpTarget = null;
if (_currentPass == 1)
{
startJumpTarget = new JumpTargetSymbol(_currentScope);
endJumpTarget = new JumpTargetSymbol(_currentScope);
}
// Check if there is an expression next, if there is its a do loop.
if (LookAheadToken().ID == TokenID.CharOpenParenthesis)
{
// Create an internal variable to count number of loops.
if (_currentPass == 0)
{
doTrackerVariable = new VariableSymbol(_currentScope);
doTrackerVariable.Identifier = "$" + _internalVariableIndex++;
doTrackerVariable.IsUsed = true;
doTrackerVariable.DataType = new DataTypeValue(DataType.Int, false, false);
doTrackerVariable.VariableType = VariableType.Local;
if (_currentScope.Type == SymbolType.Function)
{
doTrackerVariable.StackIndex = -(((FunctionSymbol)_currentScope).LocalDataSize + 2);
((FunctionSymbol)_currentScope).LocalDataSize++;
}
}
else
{
doTrackerVariable = _currentScope.FindSymbol("$" + _internalVariableIndex++, SymbolType.Variable) as VariableSymbol;
// Reset the tracker variable to 0.
instruction = CreateInstruction(OpCode.MOV_INT, _currentScope, _currentToken);
Operand.DirectStackOperand(instruction, doTrackerVariable.StackIndex);
new Operand(instruction, (long)0);
}
// Bind the jump target to here.
if (_currentPass == 1) startJumpTarget.Bind();
// Read in do expression.
whileLoop = false;
NextToken();
DataTypeValue expressionDataType = ParseExpression();
ExpectToken(TokenID.CharCloseParenthesis);
// Make sure we can cast between the expression type and boolean.
if (!CanImplicitlyCast(new DataTypeValue(DataType.Int, false, false), expressionDataType))
Error(ErrorCode.InvalidCast, "Can't implicitly cast between \"Int\" and \"" + expressionDataType.ToString() + "\"", false, 0);
// If we are in pass 2 emit byte code to check value.
if (_currentPass == 1)
{
// Pop the amount of times to loop into the reserved register 1.
instruction = CreateInstruction(OpCodeByType(expressionDataType, OpCodeType.POP), _currentScope, _currentToken);
new Operand(instruction, Register.Reserved1);
// If the value is not a long then cast it into one.
if (expressionDataType != new DataTypeValue(DataType.Int, false, false))
{
instruction = CreateInstruction(OpCode.CAST_INT, _currentScope, _currentToken);
new Operand(instruction, Register.Reserved1);
}
// Compare the loop tracker to the number of times to loop.
instruction = CreateInstruction(OpCode.CMP_INT, _currentScope, _currentToken);
Operand.DirectStackOperand(instruction, doTrackerVariable.StackIndex);
new Operand(instruction, Register.Reserved1);
// If its above or equal to the number of times we want to loop for, then exit.
instruction = CreateInstruction(OpCode.JMP_GE, _currentScope, _currentToken);
new Operand(instruction, endJumpTarget);
// Increment the loop tracker variable.
instruction = CreateInstruction(OpCode.INC_INT, _currentScope, _currentToken);
Operand.DirectStackOperand(instruction, doTrackerVariable.StackIndex);
}
}
else
{
// Bind the jump target to here.
if (_currentPass == 1) startJumpTarget.Bind();
}
// Push a loop tracker onto the loop stack.
if (_currentPass == 1)
_loopTrackerStack.Push(new LoopTracker(startJumpTarget, endJumpTarget));
// Parse the body of this statement.
bool indexerLoop = _insideIndexerLoop;
int indexerIndex = _indexerLoopIndex;
if (whileLoop == false)
{
_insideIndexerLoop = true;
_indexerLoopIndex = _internalVariableIndex - 1;
}
ParseStatement();
_insideIndexerLoop = indexerLoop;
_indexerLoopIndex = indexerIndex;
// Pop the loop tracker of the loop stack
if (_currentPass == 1)
_loopTrackerStack.Pop();
// If its a while loop then read in the while expression and output evaluation code.
if (whileLoop == true)
{
// Parse the expression.
ExpectToken(TokenID.KeywordWhile);
ExpectToken(TokenID.CharOpenParenthesis);
DataTypeValue expressionDataType = ParseExpression();
ExpectToken(TokenID.CharCloseParenthesis);
if (_currentPass == 1)
{
// Pop the result of the expression into arith register 1.
instruction = CreateInstruction(OpCodeByType(expressionDataType, OpCodeType.POP), _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
// Cast it to boolean if its not already boolean
if (expressionDataType != new DataTypeValue(DataType.Bool, false, false))
{
instruction = CreateInstruction(OpCode.CAST_BOOL, _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
}
// Compare the expression result to 0.
instruction = CreateInstruction(OpCode.CMP_BOOL, _currentScope, _currentToken);
new Operand(instruction, Register.Arithmetic1);
new Operand(instruction, false);
// Jump to finish jump target if comparison is equal to false.
instruction = CreateInstruction(OpCode.JMP_EQ, _currentScope, _currentToken);
new Operand(instruction, endJumpTarget);
}
}
// Create an instruction to jump back to the start of the loop.
if (_currentPass == 1)
{
instruction = CreateInstruction(OpCode.JMP, _currentScope, _currentToken);
new Operand(instruction, startJumpTarget);
// Bind the end jump target to here.
endJumpTarget.Bind();
}
}
public Operand(Instruction instruction, JumpTargetSymbol value)
{
_opType = OperandType.JumpTarget;
_jumpTarget = value;
instruction[instruction.OperandCount] = this;
}
/// <summary>
/// Initializes a new instance of this class and sets it start
/// and end jump targets as those given.
/// </summary>
/// <param name="start">Jump target pointing to the start of the loop.</param>
/// <param name="end">Jump target pointing to the end of the loop.</param>
public LoopTracker(JumpTargetSymbol start, JumpTargetSymbol end)
{
_startJumpTarget = start;
_endJumpTarget = end;
}