public Expression Parse(LoonyParser parser, LoonyToken token)
{
var expression = parser.ParseExpression();
parser.Take(LoonyTokenType.RightParen);
return(expression);
}
public BinaryOperatorExpression(LoonyToken token, Expression left, Expression right)
: base(token)
{
Operation = token.Type;
Left = left;
Right = right;
}
public Statement Parse(LoonyParser parser, LoonyToken token, out bool trailingSemicolon)
{
trailingSemicolon = true;
var value = parser.ParseExpression();
return new ReturnStatement(token, parser.Previous, value);
}
public Statement Parse(LoonyParser parser, LoonyToken token, out bool trailingSemicolon)
{
trailingSemicolon = true;
var name = parser.Take(LoonyTokenType.Identifier).Contents;
TypeBase type = null;
Expression initializer = null;
if (parser.MatchAndTake(LoonyTokenType.Colon))
{
type = parser.ParseType();
}
if (type == null)
{
parser.Take(LoonyTokenType.Assign);
initializer = parser.ParseExpression();
}
else if (parser.MatchAndTake(LoonyTokenType.Assign))
{
initializer = parser.ParseExpression();
}
return(new VariableStatement(token, parser.Previous, name, type, initializer));
}
public Declaration Parse(LoonyParser parser, LoonyToken token)
{
var start = token;
var name = parser.Take(LoonyTokenType.Identifier);
var parameters = new List <FuncDeclaration.Parameter>();
TypeBase returnType = null;
parser.Take(LoonyTokenType.LeftParen);
if (!parser.MatchAndTake(LoonyTokenType.RightParen))
{
do
{
var paramName = parser.Take(LoonyTokenType.Identifier);
parser.Take(LoonyTokenType.Colon);
var paramType = parser.ParseType();
parameters.Add(new FuncDeclaration.Parameter(paramName, paramType));
} while (parser.MatchAndTake(LoonyTokenType.Comma));
parser.Take(LoonyTokenType.RightParen);
}
if (parser.MatchAndTake(LoonyTokenType.Colon))
{
returnType = parser.ParseType();
}
var body = parser.ParseBlock(false);
var end = parser.Previous;
return(new FuncDeclaration(start, end, name, parameters, returnType, body));
}
public Declaration Parse(LoonyParser parser, LoonyToken token)
{
var start = token;
var name = parser.Take(LoonyTokenType.Identifier);
var parameters = new List<FuncDeclaration.Parameter>();
TypeBase returnType = null;
parser.Take(LoonyTokenType.LeftParen);
if (!parser.MatchAndTake(LoonyTokenType.RightParen))
{
do
{
var paramName = parser.Take(LoonyTokenType.Identifier);
parser.Take(LoonyTokenType.Colon);
var paramType = parser.ParseType();
parameters.Add(new FuncDeclaration.Parameter(paramName, paramType));
} while (parser.MatchAndTake(LoonyTokenType.Comma));
parser.Take(LoonyTokenType.RightParen);
}
if (parser.MatchAndTake(LoonyTokenType.Colon))
returnType = parser.ParseType();
var body = parser.ParseBlock(false);
var end = parser.Previous;
return new FuncDeclaration(start, end, name, parameters, returnType, body);
}
public Statement Parse(LoonyParser parser, LoonyToken token, out bool trailingSemicolon)
{
trailingSemicolon = true;
var value = parser.ParseExpression();
return(new ReturnStatement(token, parser.Previous, value));
}
public FuncDeclaration(LoonyToken start, LoonyToken end, LoonyToken name, IEnumerable <Parameter> parameters, TypeBase returnType, BlockStatement body)
: base(start, end)
{
Name = name;
Parameters = parameters.ToList().AsReadOnly();
ReturnType = returnType;
Body = body;
}
protected Declaration(LoonyToken start, LoonyToken end = null)
{
if (start == null)
{
throw new ArgumentNullException(nameof(start));
}
Start = start;
End = end ?? start;
}
public IdentifierExpression(LoonyToken token, string name)
: base(token)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
Name = name;
}
public BlockStatement(LoonyToken start, LoonyToken end, IEnumerable <Statement> statements)
: base(start, end)
{
if (statements == null)
{
throw new ArgumentNullException(nameof(statements));
}
Statements = statements.ToList().AsReadOnly();
}
public override Expression Visit(BinaryOperatorExpression expression)
{
var left = expression.Left.Accept(this);
var right = expression.Right.Accept(this);
var leftNum = left as NumberExpression;
var rightNum = right as NumberExpression;
if (leftNum == null && rightNum == null)
{
return(new BinaryOperatorExpression(expression.Start, left, right));
}
// n <op> n
Func <int, int, int> simplifyOp;
if (_simplifyMap.TryGetValue(expression.Operation, out simplifyOp) &&
leftNum != null &&
rightNum != null)
{
try
{
var result = simplifyOp(leftNum.Value, rightNum.Value);
var token = new LoonyToken(expression.Start, LoonyTokenType.Number, null);
return(new NumberExpression(token, result));
}
catch (DivideByZeroException)
{
throw new CompilerException(expression.Start, CompilerError.DivisionByZero);
}
}
// 0 + e || e + 0
if (expression.Operation == LoonyTokenType.Add)
{
if (leftNum != null && leftNum.Value == 0)
{
return(right);
}
if (rightNum != null && rightNum.Value == 0)
{
return(left);
}
}
return(new BinaryOperatorExpression(expression.Start, left, right));
}
public VariableStatement(LoonyToken start, LoonyToken end, string name, TypeBase type, Expression initializer)
: base(start, end)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
if (type == null && initializer == null)
{
throw new ArgumentNullException(nameof(initializer), "initializer can't be null when no type is specified");
}
Name = name;
Type = type;
Initializer = initializer;
}
public override Expression Visit(BinaryOperatorExpression expression)
{
var left = expression.Left.Accept(this);
var right = expression.Right.Accept(this);
var leftNum = left as NumberExpression;
var rightNum = right as NumberExpression;
if (leftNum == null && rightNum == null)
return new BinaryOperatorExpression(expression.Start, left, right);
// n <op> n
Func<int, int, int> simplifyOp;
if (_simplifyMap.TryGetValue(expression.Operation, out simplifyOp) &&
leftNum != null &&
rightNum != null)
{
try
{
var result = simplifyOp(leftNum.Value, rightNum.Value);
var token = new LoonyToken(expression.Start, LoonyTokenType.Number, null);
return new NumberExpression(token, result);
}
catch (DivideByZeroException)
{
throw new CompilerException(expression.Start, CompilerError.DivisionByZero);
}
}
// 0 + e || e + 0
if (expression.Operation == LoonyTokenType.Add)
{
if (leftNum != null && leftNum.Value == 0)
return right;
if (rightNum != null && rightNum.Value == 0)
return left;
}
return new BinaryOperatorExpression(expression.Start, left, right);
}
public Statement Parse(LoonyParser parser, LoonyToken token, out bool trailingSemicolon)
{
trailingSemicolon = true;
var name = parser.Take(LoonyTokenType.Identifier).Contents;
TypeBase type = null;
Expression initializer = null;
if (parser.MatchAndTake(LoonyTokenType.Colon))
type = parser.ParseType();
if (type == null)
{
parser.Take(LoonyTokenType.Assign);
initializer = parser.ParseExpression();
}
else if (parser.MatchAndTake(LoonyTokenType.Assign))
{
initializer = parser.ParseExpression();
}
return new VariableStatement(token, parser.Previous, name, type, initializer);
}
public Expression Parse(LoonyParser parser, LoonyToken token)
{
var value = int.Parse(token.Contents);
return new NumberExpression(token, value);
}
public ReturnStatement(LoonyToken start, LoonyToken end, Expression value)
: base(start, end)
{
Value = value;
}
public Expression Parse(LoonyParser parser, LoonyToken token)
{
var expression = parser.ParseExpression();
parser.Take(LoonyTokenType.RightParen);
return expression;
}
public Expression Parse(LoonyParser parser, LoonyToken token)
{
return new IdentifierExpression(token, token.Contents);
}
/// <summary>
/// Take a token from the stream.
/// </summary>
public LoonyToken Take()
{
Peek();
var result = _read[0];
_read.RemoveAt(0);
Previous = result;
return result;
}
public Expression Parse(LoonyParser parser, Expression left, LoonyToken token)
{
var right = parser.ParseExpression(Precedence - (_isRight ? 1 : 0));
return new BinaryOperatorExpression(token, left, right);
}
public StructDeclaration(LoonyToken start, LoonyToken end)
: base(start, end)
{
}
public Parameter(LoonyToken name, TypeBase type)
{
Name = name;
Type = type;
}
public Expression Parse(LoonyParser parser, LoonyToken token)
{
return(new IdentifierExpression(token, token.Contents));
}
public Expression Parse(LoonyParser parser, LoonyToken token)
{
var value = int.Parse(token.Contents);
return(new NumberExpression(token, value));
}
static LoonyLexer()
{
EofToken = new LoonyToken(null, default(SourcePosition), default(SourcePosition), LoonyTokenType.Eof, null);
_operators = new OperatorDictionary<LoonyTokenType>
{
{ ";", LoonyTokenType.Semicolon },
{ ",", LoonyTokenType.Comma },
{ ".", LoonyTokenType.Dot },
{ "=", LoonyTokenType.Assign },
{ "?", LoonyTokenType.QuestionMark },
{ ":", LoonyTokenType.Colon },
{ "->", LoonyTokenType.Pointy },
{ "(", LoonyTokenType.LeftParen },
{ ")", LoonyTokenType.RightParen },
{ "{", LoonyTokenType.LeftBrace },
{ "}", LoonyTokenType.RightBrace },
{ "[", LoonyTokenType.LeftSquare },
{ "]", LoonyTokenType.RightSquare },
{ "+", LoonyTokenType.Add },
{ "+=", LoonyTokenType.AddAssign },
{ "-", LoonyTokenType.Subtract },
{ "-=", LoonyTokenType.SubtractAssign },
{ "*", LoonyTokenType.Multiply },
{ "*=", LoonyTokenType.MultiplyAssign },
{ "/", LoonyTokenType.Divide },
{ "/=", LoonyTokenType.DivideAssign },
{ "%", LoonyTokenType.Remainder },
{ "%=", LoonyTokenType.RemainderAssign },
{ "++", LoonyTokenType.Increment },
{ "--", LoonyTokenType.Decrement },
{ "==", LoonyTokenType.EqualTo },
{ "!=", LoonyTokenType.NotEqualTo },
{ ">", LoonyTokenType.GreaterThan },
{ ">=", LoonyTokenType.GreaterThanOrEqual },
{ "<", LoonyTokenType.LessThan },
{ "<=", LoonyTokenType.LessThanOrEqual },
{ "&&", LoonyTokenType.LogicalAnd },
{ "||", LoonyTokenType.LogicalOr },
{ "!", LoonyTokenType.LogicalNot },
{ "~", LoonyTokenType.BitwiseNot },
{ "&", LoonyTokenType.BitwiseAnd },
{ "&=", LoonyTokenType.BitwiseAndAssign },
{ "|", LoonyTokenType.BitwiseOr },
{ "|=", LoonyTokenType.BitwiseOrAssign },
{ "^", LoonyTokenType.BitwiseXor },
{ "^=", LoonyTokenType.BitwiseXorAssign },
{ "<<", LoonyTokenType.BitwiseShiftLeft },
{ "<<=", LoonyTokenType.BitwiseShiftLeftAssign },
{ ">>", LoonyTokenType.BitwiseShiftRight },
{ ">>=", LoonyTokenType.BitwiseShiftRightAssign },
};
_keywords = new Dictionary<string, LoonyTokenType>
{
{ "null", LoonyTokenType.Null },
{ "true", LoonyTokenType.True },
{ "false", LoonyTokenType.False },
{ "any", LoonyTokenType.Any },
{ "bool", LoonyTokenType.Bool },
{ "char", LoonyTokenType.Char },
{ "short", LoonyTokenType.Short },
{ "int", LoonyTokenType.Int },
{ "var", LoonyTokenType.Var },
{ "return", LoonyTokenType.Return },
{ "if", LoonyTokenType.If },
{ "else", LoonyTokenType.Else },
{ "for", LoonyTokenType.For },
{ "while", LoonyTokenType.While },
{ "do", LoonyTokenType.Do },
{ "break", LoonyTokenType.Break },
{ "continue", LoonyTokenType.Continue },
{ "const", LoonyTokenType.Const },
{ "static", LoonyTokenType.Static },
{ "func", LoonyTokenType.Func },
{ "struct", LoonyTokenType.Struct },
{ "union", LoonyTokenType.Union },
{ "extern", LoonyTokenType.Extern },
};
}
public NumberExpression(LoonyToken token, int value)
: base(token)
{
Value = value;
}
public Expression Parse(LoonyParser parser, Expression left, LoonyToken token)
{
var right = parser.ParseExpression(Precedence - (_isRight ? 1 : 0));
return(new BinaryOperatorExpression(token, left, right));
}
internal CompilerException(LoonyToken token, string format, params object[] args)
: base($"{token.FileName ?? "null"}({token.RangeString}): {string.Format(format, args)}")
{
}
