377 lines
10 KiB
C#
377 lines
10 KiB
C#
using System.Diagnostics.CodeAnalysis;
|
|
|
|
namespace Compiler;
|
|
|
|
public sealed class Parser(List<Token> tokens)
|
|
{
|
|
public static List<NodeDefinition> Parse(List<Token> tokens)
|
|
{
|
|
return new Parser(tokens).Parse();
|
|
}
|
|
|
|
private int index;
|
|
|
|
private List<NodeDefinition> Parse()
|
|
{
|
|
var nodes = new List<NodeDefinition>();
|
|
|
|
while (Peek() != null)
|
|
nodes.Add(ParseDefinition());
|
|
|
|
return nodes;
|
|
}
|
|
|
|
private NodeDefinition ParseDefinition()
|
|
{
|
|
var startIndex = index;
|
|
|
|
if (TryExpectKeyword(Keyword.Func))
|
|
{
|
|
var name = ExpectIdent();
|
|
var parameters = new List<NodeDefinitionFunc.Param>();
|
|
|
|
ExpectSymbol(Symbol.OpenParen);
|
|
while (!TryExpectSymbol(Symbol.CloseParen))
|
|
{
|
|
var paramStartIndex = index;
|
|
var parameterName = ExpectIdent();
|
|
ExpectSymbol(Symbol.Colon);
|
|
var parameterType = ParseType();
|
|
parameters.Add(new NodeDefinitionFunc.Param(TokensFrom(paramStartIndex), parameterName, parameterType));
|
|
}
|
|
|
|
ExpectSymbol(Symbol.Colon);
|
|
var returnType = ParseType();
|
|
|
|
var body = ParseStatement();
|
|
|
|
return new NodeDefinitionFunc(TokensFrom(startIndex), name, parameters, body, returnType);
|
|
}
|
|
|
|
throw new Exception("Not a valid definition");
|
|
}
|
|
|
|
private NodeStatement ParseStatement()
|
|
{
|
|
var startIndex = index;
|
|
|
|
if (TryExpectSymbol(Symbol.OpenCurly))
|
|
{
|
|
var statements = new List<NodeStatement>();
|
|
while (!TryExpectSymbol(Symbol.CloseCurly))
|
|
statements.Add(ParseStatement());
|
|
|
|
return new NodeStatementBlock(TokensFrom(startIndex), statements);
|
|
}
|
|
|
|
var expression = ParseExpression();
|
|
var parameters = new List<NodeExpression>();
|
|
|
|
ExpectSymbol(Symbol.OpenParen);
|
|
while (!TryExpectSymbol(Symbol.CloseParen))
|
|
parameters.Add(ParseExpression());
|
|
|
|
return new NodeStatementFuncCall(TokensFrom(startIndex), expression, parameters);
|
|
}
|
|
|
|
private NodeExpression ParseExpression()
|
|
{
|
|
var startIndex = index;
|
|
|
|
if (TryExpectIntLiteral(out var intLiteral))
|
|
{
|
|
return new NodeExpressionIntLiteral(TokensFrom(startIndex), intLiteral);
|
|
}
|
|
|
|
if (TryExpectFloatLiteral(out var floatLiteral))
|
|
{
|
|
return new NodeExpressionFloatLiteral(TokensFrom(startIndex), floatLiteral);
|
|
}
|
|
|
|
if (TryExpectStringLiteral(out var stringLiteral))
|
|
{
|
|
return new NodeExpressionStringLiteral(TokensFrom(startIndex), stringLiteral);
|
|
}
|
|
|
|
if (TryExpectBoolLiteral(out var boolLiteral))
|
|
{
|
|
return new NodeExpressionBoolLiteral(TokensFrom(startIndex), boolLiteral);
|
|
}
|
|
|
|
if (TryExpectIdent(out var ident))
|
|
{
|
|
return new NodeExpressionIdent(TokensFrom(startIndex), ident);
|
|
}
|
|
|
|
throw new Exception("Not a valid expression");
|
|
}
|
|
|
|
private NodeType ParseType()
|
|
{
|
|
var startIndex = index;
|
|
|
|
if (TryExpectSymbol(Symbol.Caret))
|
|
{
|
|
var to = ParseType();
|
|
return new NodeTypePointer(TokensFrom(startIndex), to);
|
|
}
|
|
|
|
if (TryExpectIdent(out var ident))
|
|
{
|
|
switch (ident.Ident)
|
|
{
|
|
case "void":
|
|
return new NubTypeVoid(TokensFrom(startIndex));
|
|
case "string":
|
|
return new NodeTypeString(TokensFrom(startIndex));
|
|
case "i8":
|
|
return new NodeTypeSInt(TokensFrom(startIndex), 8);
|
|
case "i16":
|
|
return new NodeTypeSInt(TokensFrom(startIndex), 16);
|
|
case "i32":
|
|
return new NodeTypeSInt(TokensFrom(startIndex), 32);
|
|
case "i64":
|
|
return new NodeTypeSInt(TokensFrom(startIndex), 64);
|
|
case "u8":
|
|
return new NodeTypeUInt(TokensFrom(startIndex), 8);
|
|
case "u16":
|
|
return new NodeTypeUInt(TokensFrom(startIndex), 16);
|
|
case "u32":
|
|
return new NodeTypeUInt(TokensFrom(startIndex), 32);
|
|
case "u64":
|
|
return new NodeTypeUInt(TokensFrom(startIndex), 64);
|
|
case "f32":
|
|
return new NodeTypeFloat(TokensFrom(startIndex), 32);
|
|
case "f64":
|
|
return new NodeTypeFloat(TokensFrom(startIndex), 64);
|
|
default:
|
|
return new NodeTypeCustom(TokensFrom(startIndex), ident);
|
|
}
|
|
}
|
|
|
|
throw new Exception("Not a valid type");
|
|
}
|
|
|
|
private List<Token> TokensFrom(int startIndex)
|
|
{
|
|
return tokens.GetRange(startIndex, index - startIndex);
|
|
}
|
|
|
|
private bool TryExpectKeyword(Keyword keyword)
|
|
{
|
|
if (Peek() is TokenKeyword token && token.Keyword == keyword)
|
|
{
|
|
Consume();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void ExpectSymbol(Symbol symbol)
|
|
{
|
|
if (Peek() is TokenSymbol token && token.Symbol == symbol)
|
|
{
|
|
Consume();
|
|
return;
|
|
}
|
|
|
|
throw new Exception($"Expected symbol '{symbol}'");
|
|
}
|
|
|
|
private bool TryExpectSymbol(Symbol symbol)
|
|
{
|
|
if (Peek() is TokenSymbol token && token.Symbol == symbol)
|
|
{
|
|
Consume();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private TokenIdent ExpectIdent()
|
|
{
|
|
if (Peek() is TokenIdent token)
|
|
{
|
|
Consume();
|
|
return token;
|
|
}
|
|
|
|
throw new Exception("Expected ident");
|
|
}
|
|
|
|
private bool TryExpectIdent([NotNullWhen(true)] out TokenIdent? ident)
|
|
{
|
|
if (Peek() is TokenIdent token)
|
|
{
|
|
Consume();
|
|
ident = token;
|
|
return true;
|
|
}
|
|
|
|
ident = null;
|
|
return false;
|
|
}
|
|
|
|
private bool TryExpectIntLiteral([NotNullWhen(true)] out TokenIntLiteral? intLiteral)
|
|
{
|
|
if (Peek() is TokenIntLiteral token)
|
|
{
|
|
Consume();
|
|
intLiteral = token;
|
|
return true;
|
|
}
|
|
|
|
intLiteral = null;
|
|
return false;
|
|
}
|
|
|
|
private bool TryExpectFloatLiteral([NotNullWhen(true)] out TokenFloatLiteral? floatLiteral)
|
|
{
|
|
if (Peek() is TokenFloatLiteral token)
|
|
{
|
|
Consume();
|
|
floatLiteral = token;
|
|
return true;
|
|
}
|
|
|
|
floatLiteral = null;
|
|
return false;
|
|
}
|
|
|
|
private bool TryExpectStringLiteral([NotNullWhen(true)] out TokenStringLiteral? stringLiteral)
|
|
{
|
|
if (Peek() is TokenStringLiteral token)
|
|
{
|
|
Consume();
|
|
stringLiteral = token;
|
|
return true;
|
|
}
|
|
|
|
stringLiteral = null;
|
|
return false;
|
|
}
|
|
|
|
private bool TryExpectBoolLiteral([NotNullWhen(true)] out TokenBoolLiteral? boolLiteral)
|
|
{
|
|
if (Peek() is TokenBoolLiteral token)
|
|
{
|
|
Consume();
|
|
boolLiteral = token;
|
|
return true;
|
|
}
|
|
|
|
boolLiteral = null;
|
|
return false;
|
|
}
|
|
|
|
private Token Consume()
|
|
{
|
|
if (index >= tokens.Count)
|
|
throw new Exception("End of tokens");
|
|
|
|
return tokens[index++];
|
|
}
|
|
|
|
private Token? Peek(int offset = 0)
|
|
{
|
|
if (index + offset >= tokens.Count)
|
|
return null;
|
|
|
|
return tokens[index + offset];
|
|
}
|
|
}
|
|
|
|
public abstract class Node(List<Token> tokens)
|
|
{
|
|
public List<Token> Tokens = tokens;
|
|
}
|
|
|
|
public abstract class NodeDefinition(List<Token> tokens) : Node(tokens);
|
|
|
|
public sealed class NodeDefinitionFunc(List<Token> tokens, TokenIdent name, List<NodeDefinitionFunc.Param> parameters, NodeStatement body, NodeType returnType)
|
|
: NodeDefinition(tokens)
|
|
{
|
|
public TokenIdent Name = name;
|
|
public List<Param> Parameters = parameters;
|
|
public NodeStatement Body = body;
|
|
public NodeType ReturnType = returnType;
|
|
|
|
public sealed class Param(List<Token> tokens, TokenIdent name, NodeType type) : Node(tokens)
|
|
{
|
|
public TokenIdent Name = name;
|
|
public NodeType Type = type;
|
|
}
|
|
}
|
|
|
|
public abstract class NodeStatement(List<Token> tokens) : Node(tokens);
|
|
|
|
public sealed class NodeStatementBlock(List<Token> tokens, List<NodeStatement> statements) : NodeStatement(tokens)
|
|
{
|
|
public List<NodeStatement> Statements = statements;
|
|
}
|
|
|
|
public sealed class NodeStatementFuncCall(List<Token> tokens, NodeExpression func, List<NodeExpression> parameters) : NodeStatement(tokens)
|
|
{
|
|
public NodeExpression Func = func;
|
|
public List<NodeExpression> Parameters = parameters;
|
|
}
|
|
|
|
public abstract class NodeExpression(List<Token> tokens) : Node(tokens);
|
|
|
|
public sealed class NodeExpressionIntLiteral(List<Token> tokens, TokenIntLiteral value) : NodeExpression(tokens)
|
|
{
|
|
public TokenIntLiteral Value = value;
|
|
}
|
|
|
|
public sealed class NodeExpressionFloatLiteral(List<Token> tokens, TokenFloatLiteral value) : NodeExpression(tokens)
|
|
{
|
|
public TokenFloatLiteral Value = value;
|
|
}
|
|
|
|
public sealed class NodeExpressionStringLiteral(List<Token> tokens, TokenStringLiteral value) : NodeExpression(tokens)
|
|
{
|
|
public TokenStringLiteral Value = value;
|
|
}
|
|
|
|
public sealed class NodeExpressionBoolLiteral(List<Token> tokens, TokenBoolLiteral value) : NodeExpression(tokens)
|
|
{
|
|
public TokenBoolLiteral Value = value;
|
|
}
|
|
|
|
public sealed class NodeExpressionIdent(List<Token> tokens, TokenIdent value) : NodeExpression(tokens)
|
|
{
|
|
public TokenIdent Value = value;
|
|
}
|
|
|
|
public abstract class NodeType(List<Token> tokens) : Node(tokens);
|
|
|
|
public sealed class NubTypeVoid(List<Token> tokens) : NodeType(tokens);
|
|
|
|
public sealed class NodeTypeUInt(List<Token> tokens, int width) : NodeType(tokens)
|
|
{
|
|
public int Width = width;
|
|
}
|
|
|
|
public sealed class NodeTypeSInt(List<Token> tokens, int width) : NodeType(tokens)
|
|
{
|
|
public int Width = width;
|
|
}
|
|
|
|
public sealed class NodeTypeFloat(List<Token> tokens, int width) : NodeType(tokens)
|
|
{
|
|
public int Width = width;
|
|
}
|
|
|
|
public sealed class NodeTypeString(List<Token> tokens) : NodeType(tokens);
|
|
|
|
public sealed class NodeTypeCustom(List<Token> tokens, TokenIdent name) : NodeType(tokens)
|
|
{
|
|
public TokenIdent Name = name;
|
|
}
|
|
|
|
public sealed class NodeTypePointer(List<Token> tokens, NodeType to) : NodeType(tokens)
|
|
{
|
|
public NodeType To = to;
|
|
} |