private AssemblyOperationFormat ParseAssemblyOperationFormat()
{
var kw = NextToken();
if (!kw.IsKeyword(Keyword.Format))
{
_stream.Previous();
return(null);
}
var allowedVals = new HashSet <string>()
{
"8", "16", "32"
};
var t = NextToken();
AssertLiteral(t);
if (!allowedVals.Contains(t.Value))
{
throw SyntaxError.Make(SyntaxErrorMessages.INVALID_TOKEN, t);
}
var node = new AssemblyOperationFormat(t);
node.PropagatePosition(kw.Position);
return(node);
}
private VarType ParseType(bool assert = true)
{
var t = NextToken();
var allowedTypes = new HashSet <string>()
{
Keyword.Int, Keyword.Short, Keyword.Byte
};
if (t.Type != TokenType.Keyword || !allowedTypes.Contains(t.Value))
{
_stream.Previous();
if (assert)
{
throw SyntaxError.Make(SyntaxErrorMessages.TYPE_EXPECTED, t);
}
return(null);
}
var node = new VarType(t);
return(node);
}
private Statement ParseStatement()
{
var label = ParseLabel();
var inner = TryExtractVariants(new Func <AstNode>[] {
ParseAssemblyBlock,
ParseExtensionStatement,
});
if (label == null && inner == null)
{
return(null);
}
if (label != null && inner == null)
{
var t = NextToken();
throw SyntaxError.Make(SyntaxErrorMessages.STATEMENT_EXPECTED, t);
}
var node = new Statement();
if (label != null)
{
node.AddChild(node);
}
node.AddChild(inner);
return(node);
}
protected void AssertRegister(Token received)
{
if (received.Type != TokenType.Register)
{
throw SyntaxError.Make(SyntaxErrorMessages.REGISTER_EXPECTED, received);
}
}
public ProgramRaw ParseProgram()
{
var node = new ProgramRaw();
while (_stream.HasTokens())
{
var nextNode = TryExtractVariants(new Func <AstNode>[] {
ParseAnnotation,
ParseData,
ParseModule,
ParseRoutine,
ParseCode,
});
if (nextNode != null)
{
node.AddChild(nextNode);
}
else
{
throw SyntaxError.Make(SyntaxErrorMessages.INVALID_TOKEN, NextToken());
}
}
return(node);
}
protected void AssertLiteral(Token received)
{
if (received.Type != TokenType.Number)
{
throw SyntaxError.Make(SyntaxErrorMessages.LITERAL_EXPECTED, received);
}
}
protected void AssertIdentifier(Token received)
{
if (received.Type != TokenType.Identifier)
{
throw SyntaxError.Make(SyntaxErrorMessages.IDENTIFIER_EXPECTED, received);
}
}
protected void AssertOperator(string expected, Token received)
{
if (!received.IsOperator(expected))
{
throw SyntaxError.Make(SyntaxErrorMessages.UNEXPECTED_TOKEN, expected, received);
}
}
protected void AssertTokenExist(Token token)
{
if (token == null)
{
var last = _stream.Last();
// Next char position
var start = last.Position.Start.ToTuple();
var end = last.Position.End.ToTuple();
start.Item2 += 1;
end.Item2 += 1;
var prettyPos = new Position(start, end);
throw SyntaxError.Make(SyntaxErrorMessages.UNEXPECTED_EOS(), prettyPos);
}
}
private Operand ParseOperand()
{
var operand = TryExtractVariants(new Func <AstNode>[] {
ParseReceiver,
ParseReference,
() => ParseLiteral(false),
});
if (operand == null)
{
var t = NextToken();
throw SyntaxError.Make(SyntaxErrorMessages.OPERAND_EXPECTED, t);
}
var node = new Operand();
node.AddChild(operand);
return(node);
}
private Swap ParseSwap()
{
var tx = _stream.Fixate();
var arg0 = ParsePrimary();
if (arg0 == null)
{
return(null);
}
var t = NextToken();
if (!t.IsOperator(Operator.AssignSwap))
{
_stream.Rollback(tx); // Undo operator and 'primary' read
return(null);
}
var node = new Swap();
node.AddChild(arg0);
var arg1 = ParsePrimary();
if (arg1 == null)
{
throw SyntaxError.Make(SyntaxErrorMessages.PRIMARY_EXPECTED, t);
}
node.AddChild(arg1);
t = NextToken();
AssertDelimiter(Delimiter.Semicolon, t);
return(node);
}
private AssemblyOperation ParseAssemblyOperation()
{
var asterisk = NextToken(false);
if (asterisk.IsOperator(Operator.Asterisk))
{
_stream.Next();
}
else
{
asterisk = null;
}
var reg = ParseRegister();
var allowedOps = new HashSet <string>()
{
Operator.Assign,
Operator.AssignPlus,
Operator.AssignMinus,
Operator.AssignShiftRight,
Operator.AssignShiftLeft,
Operator.AssignOr,
Operator.AssignAnd,
Operator.AssignXor,
Operator.AssignLess,
Operator.AssignGreater,
Operator.AssignCond
};
var op = NextToken();
if (op.Type != TokenType.Operator || !allowedOps.Contains(op.Value))
{
throw SyntaxError.Make(SyntaxErrorMessages.INVALID_TOKEN, op);
}
var node = new AssemblyOperation(op);
if (asterisk != null)
{
var deref = new Dereference(asterisk);
deref.AddChild(reg);
node.AddChild(deref);
}
else
{
node.AddChild(reg);
asterisk = NextToken(false);
if (asterisk.IsOperator(Operator.Asterisk))
{
_stream.Next();
}
else
{
asterisk = null;
}
}
// If we have two dereferences in the statement ParseRegister will fail
reg = ParseRegister();
if (asterisk != null)
{
var deref = new Dereference(asterisk);
deref.AddChild(reg);
node.AddChild(deref);
}
else
{
node.AddChild(reg);
}
if (!op.IsOperator(Operator.Assign) && asterisk != null)
{
throw SyntaxError.Make(SyntaxErrorMessages.INVALID_ASM_DEREFERENCE_USE(), node.Position);
}
return(node);
}