feat(parser): add recursive descent parser
This commit is contained in:
dualfroz committed
1 parent
7660141d69
commit
0cf76fb6a2
1 file changed
+410
@@ -0,0 +1,410 @@
|
|||||||
|
package lumen.parser
|
||||||
|
|
||||||
|
import lumen.ParseError
|
||||||
|
import lumen.ast.*
|
||||||
|
import lumen.lexer.Token
|
||||||
|
import lumen.lexer.TokenType
|
||||||
|
|
||||||
|
class Parser(private val tokens: List<Token>) {
|
||||||
|
private var current = 0
|
||||||
|
|
||||||
|
fun parseProgram(): List<Stmt> {
|
||||||
|
val statements = mutableListOf<Stmt>()
|
||||||
|
skipSeparators()
|
||||||
|
while (!check(TokenType.Eof)) {
|
||||||
|
statements.add(statement())
|
||||||
|
skipSeparators()
|
||||||
|
}
|
||||||
|
return statements
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun statement(): Stmt = when (peek().type) {
|
||||||
|
TokenType.Let -> declaration(mutable = false)
|
||||||
|
TokenType.Var -> declaration(mutable = true)
|
||||||
|
TokenType.Import -> importStatement()
|
||||||
|
TokenType.Fn -> if (peekNext().type == TokenType.Identifier) functionStatement() else expressionStatement()
|
||||||
|
TokenType.Return -> returnStatement()
|
||||||
|
TokenType.If -> ifStatement()
|
||||||
|
TokenType.While -> whileStatement()
|
||||||
|
TokenType.For -> forStatement()
|
||||||
|
else -> expressionStatement()
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun declaration(mutable: Boolean): Stmt {
|
||||||
|
val keyword = advance()
|
||||||
|
val name = consume(TokenType.Identifier, "expected variable name").lexeme
|
||||||
|
consume(TokenType.Assign, "expected '=' in declaration")
|
||||||
|
val initializer = expression()
|
||||||
|
return LetStmt(name, initializer, mutable, keyword.line, keyword.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun importStatement(): Stmt {
|
||||||
|
val keyword = advance()
|
||||||
|
val path = consume(TokenType.StringLiteral, "expected module path string after 'import'")
|
||||||
|
return ImportStmt(path.stringValue, keyword.line, keyword.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun functionStatement(): Stmt {
|
||||||
|
val keyword = advance()
|
||||||
|
val name = consume(TokenType.Identifier, "expected function name").lexeme
|
||||||
|
val params = parameters()
|
||||||
|
val body = block()
|
||||||
|
return FunctionStmt(name, FunctionExpr(name, params, body, keyword.line, keyword.column), keyword.line, keyword.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun returnStatement(): Stmt {
|
||||||
|
val keyword = advance()
|
||||||
|
val value = if (isStatementEnd()) null else expression()
|
||||||
|
return ReturnStmt(value, keyword.line, keyword.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun ifStatement(): Stmt {
|
||||||
|
val keyword = advance()
|
||||||
|
consume(TokenType.LeftParen, "expected '(' after 'if'")
|
||||||
|
val condition = expression()
|
||||||
|
consume(TokenType.RightParen, "expected ')' after condition")
|
||||||
|
val thenBranch = block()
|
||||||
|
var elseBranch: List<Stmt>? = null
|
||||||
|
if (matchElse()) {
|
||||||
|
elseBranch = if (check(TokenType.If)) listOf(ifStatement()) else block()
|
||||||
|
}
|
||||||
|
return IfStmt(condition, thenBranch, elseBranch, keyword.line, keyword.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun whileStatement(): Stmt {
|
||||||
|
val keyword = advance()
|
||||||
|
consume(TokenType.LeftParen, "expected '(' after 'while'")
|
||||||
|
val condition = expression()
|
||||||
|
consume(TokenType.RightParen, "expected ')' after condition")
|
||||||
|
val body = block()
|
||||||
|
return WhileStmt(condition, body, keyword.line, keyword.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun forStatement(): Stmt {
|
||||||
|
val keyword = advance()
|
||||||
|
consume(TokenType.LeftParen, "expected '(' after 'for'")
|
||||||
|
val name = consume(TokenType.Identifier, "expected loop variable name").lexeme
|
||||||
|
consume(TokenType.In, "expected 'in' in for loop")
|
||||||
|
val iterable = expression()
|
||||||
|
consume(TokenType.RightParen, "expected ')' after for header")
|
||||||
|
val body = block()
|
||||||
|
return ForStmt(name, iterable, body, keyword.line, keyword.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun expressionStatement(): Stmt {
|
||||||
|
val expr = expression()
|
||||||
|
return ExprStmt(expr, expr.line, expr.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun block(): List<Stmt> {
|
||||||
|
consume(TokenType.LeftBrace, "expected '{'")
|
||||||
|
val statements = mutableListOf<Stmt>()
|
||||||
|
skipSeparators()
|
||||||
|
while (!check(TokenType.RightBrace) && !check(TokenType.Eof)) {
|
||||||
|
statements.add(statement())
|
||||||
|
skipSeparators()
|
||||||
|
}
|
||||||
|
consume(TokenType.RightBrace, "expected '}' to close block")
|
||||||
|
return statements
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun parameters(): List<String> {
|
||||||
|
consume(TokenType.LeftParen, "expected '(' after function name")
|
||||||
|
val params = mutableListOf<String>()
|
||||||
|
if (!check(TokenType.RightParen)) {
|
||||||
|
do {
|
||||||
|
params.add(consume(TokenType.Identifier, "expected parameter name").lexeme)
|
||||||
|
} while (match(TokenType.Comma))
|
||||||
|
}
|
||||||
|
consume(TokenType.RightParen, "expected ')' after parameters")
|
||||||
|
return params
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun expression(): Expr = assignment()
|
||||||
|
|
||||||
|
private fun assignment(): Expr {
|
||||||
|
val target = or()
|
||||||
|
if (check(TokenType.Assign)) {
|
||||||
|
val op = advance()
|
||||||
|
val value = assignment()
|
||||||
|
return when (target) {
|
||||||
|
is Variable -> Assign(target.name, value, target.line, target.column)
|
||||||
|
is Index -> IndexAssign(target.target, target.index, value, target.line, target.column)
|
||||||
|
else -> throw ParseError("invalid assignment target", op.line, op.column)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return target
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun or(): Expr {
|
||||||
|
var left = and()
|
||||||
|
while (check(TokenType.Or)) {
|
||||||
|
val op = advance()
|
||||||
|
val right = and()
|
||||||
|
left = Logical(LogicalOp.Or, left, right, op.line, op.column)
|
||||||
|
}
|
||||||
|
return left
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun and(): Expr {
|
||||||
|
var left = equality()
|
||||||
|
while (check(TokenType.And)) {
|
||||||
|
val op = advance()
|
||||||
|
val right = equality()
|
||||||
|
left = Logical(LogicalOp.And, left, right, op.line, op.column)
|
||||||
|
}
|
||||||
|
return left
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun equality(): Expr {
|
||||||
|
var left = comparison()
|
||||||
|
while (check(TokenType.EqualEqual) || check(TokenType.BangEqual)) {
|
||||||
|
val token = advance()
|
||||||
|
val op = if (token.type == TokenType.EqualEqual) BinaryOp.Equal else BinaryOp.NotEqual
|
||||||
|
val right = comparison()
|
||||||
|
left = Binary(op, left, right, token.line, token.column)
|
||||||
|
}
|
||||||
|
return left
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun comparison(): Expr {
|
||||||
|
var left = term()
|
||||||
|
while (true) {
|
||||||
|
val op = when (peek().type) {
|
||||||
|
TokenType.Less -> BinaryOp.Less
|
||||||
|
TokenType.LessEqual -> BinaryOp.LessEqual
|
||||||
|
TokenType.Greater -> BinaryOp.Greater
|
||||||
|
TokenType.GreaterEqual -> BinaryOp.GreaterEqual
|
||||||
|
else -> break
|
||||||
|
}
|
||||||
|
val token = advance()
|
||||||
|
val right = term()
|
||||||
|
left = Binary(op, left, right, token.line, token.column)
|
||||||
|
}
|
||||||
|
return left
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun term(): Expr {
|
||||||
|
var left = factor()
|
||||||
|
while (true) {
|
||||||
|
val op = when (peek().type) {
|
||||||
|
TokenType.Plus -> BinaryOp.Add
|
||||||
|
TokenType.Minus -> BinaryOp.Sub
|
||||||
|
else -> break
|
||||||
|
}
|
||||||
|
val token = advance()
|
||||||
|
val right = factor()
|
||||||
|
left = Binary(op, left, right, token.line, token.column)
|
||||||
|
}
|
||||||
|
return left
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun factor(): Expr {
|
||||||
|
var left = unary()
|
||||||
|
while (true) {
|
||||||
|
val op = when (peek().type) {
|
||||||
|
TokenType.Star -> BinaryOp.Mul
|
||||||
|
TokenType.Slash -> BinaryOp.Div
|
||||||
|
TokenType.Percent -> BinaryOp.Mod
|
||||||
|
else -> break
|
||||||
|
}
|
||||||
|
val token = advance()
|
||||||
|
val right = unary()
|
||||||
|
left = Binary(op, left, right, token.line, token.column)
|
||||||
|
}
|
||||||
|
return left
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun unary(): Expr {
|
||||||
|
if (check(TokenType.Minus)) {
|
||||||
|
val op = advance()
|
||||||
|
return Unary(UnaryOp.Negate, unary(), op.line, op.column)
|
||||||
|
}
|
||||||
|
if (check(TokenType.Not)) {
|
||||||
|
val op = advance()
|
||||||
|
return Unary(UnaryOp.Not, unary(), op.line, op.column)
|
||||||
|
}
|
||||||
|
return callChain()
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun callChain(): Expr {
|
||||||
|
var expr = primary()
|
||||||
|
while (true) {
|
||||||
|
when (peek().type) {
|
||||||
|
TokenType.LeftParen -> {
|
||||||
|
advance()
|
||||||
|
expr = Call(expr, argumentList(), expr.line, expr.column)
|
||||||
|
}
|
||||||
|
TokenType.LeftBracket -> {
|
||||||
|
advance()
|
||||||
|
val index = expression()
|
||||||
|
consume(TokenType.RightBracket, "expected ']' after index")
|
||||||
|
expr = Index(expr, index, expr.line, expr.column)
|
||||||
|
}
|
||||||
|
TokenType.Dot -> {
|
||||||
|
advance()
|
||||||
|
val name = consume(TokenType.Identifier, "expected method name after '.'")
|
||||||
|
consume(TokenType.LeftParen, "expected '(' after method name")
|
||||||
|
expr = MethodCall(expr, name.lexeme, argumentList(), name.line, name.column)
|
||||||
|
}
|
||||||
|
else -> break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return expr
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun argumentList(): List<Expr> {
|
||||||
|
val args = mutableListOf<Expr>()
|
||||||
|
skipNewlines()
|
||||||
|
if (!check(TokenType.RightParen)) {
|
||||||
|
do {
|
||||||
|
skipNewlines()
|
||||||
|
args.add(expression())
|
||||||
|
skipNewlines()
|
||||||
|
} while (match(TokenType.Comma))
|
||||||
|
}
|
||||||
|
skipNewlines()
|
||||||
|
consume(TokenType.RightParen, "expected ')' after arguments")
|
||||||
|
return args
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun primary(): Expr {
|
||||||
|
val token = peek()
|
||||||
|
return when (token.type) {
|
||||||
|
TokenType.IntLiteral -> {
|
||||||
|
advance()
|
||||||
|
IntLiteral(token.intValue, token.line, token.column)
|
||||||
|
}
|
||||||
|
TokenType.DoubleLiteral -> {
|
||||||
|
advance()
|
||||||
|
DoubleLiteral(token.doubleValue, token.line, token.column)
|
||||||
|
}
|
||||||
|
TokenType.StringLiteral -> {
|
||||||
|
advance()
|
||||||
|
StringLiteral(token.stringValue, token.line, token.column)
|
||||||
|
}
|
||||||
|
TokenType.True -> {
|
||||||
|
advance()
|
||||||
|
BoolLiteral(true, token.line, token.column)
|
||||||
|
}
|
||||||
|
TokenType.False -> {
|
||||||
|
advance()
|
||||||
|
BoolLiteral(false, token.line, token.column)
|
||||||
|
}
|
||||||
|
TokenType.Nil -> {
|
||||||
|
advance()
|
||||||
|
NilLiteral(token.line, token.column)
|
||||||
|
}
|
||||||
|
TokenType.Identifier -> {
|
||||||
|
advance()
|
||||||
|
Variable(token.lexeme, token.line, token.column)
|
||||||
|
}
|
||||||
|
TokenType.LeftParen -> {
|
||||||
|
advance()
|
||||||
|
val inner = expression()
|
||||||
|
consume(TokenType.RightParen, "expected ')' after expression")
|
||||||
|
inner
|
||||||
|
}
|
||||||
|
TokenType.LeftBracket -> listLiteral()
|
||||||
|
TokenType.LeftBrace -> mapLiteral()
|
||||||
|
TokenType.Fn -> functionExpression()
|
||||||
|
else -> throw ParseError("unexpected ${describe(token)}", token.line, token.column)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun listLiteral(): Expr {
|
||||||
|
val open = advance()
|
||||||
|
val elements = mutableListOf<Expr>()
|
||||||
|
skipNewlines()
|
||||||
|
if (!check(TokenType.RightBracket)) {
|
||||||
|
do {
|
||||||
|
skipNewlines()
|
||||||
|
if (check(TokenType.RightBracket)) break
|
||||||
|
elements.add(expression())
|
||||||
|
skipNewlines()
|
||||||
|
} while (match(TokenType.Comma))
|
||||||
|
}
|
||||||
|
skipNewlines()
|
||||||
|
consume(TokenType.RightBracket, "expected ']' after list")
|
||||||
|
return ListLiteral(elements, open.line, open.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun mapLiteral(): Expr {
|
||||||
|
val open = advance()
|
||||||
|
val entries = mutableListOf<Pair<Expr, Expr>>()
|
||||||
|
skipNewlines()
|
||||||
|
if (!check(TokenType.RightBrace)) {
|
||||||
|
do {
|
||||||
|
skipNewlines()
|
||||||
|
if (check(TokenType.RightBrace)) break
|
||||||
|
val key = expression()
|
||||||
|
consume(TokenType.Colon, "expected ':' in map entry")
|
||||||
|
val value = expression()
|
||||||
|
entries.add(key to value)
|
||||||
|
skipNewlines()
|
||||||
|
} while (match(TokenType.Comma))
|
||||||
|
}
|
||||||
|
skipNewlines()
|
||||||
|
consume(TokenType.RightBrace, "expected '}' after map")
|
||||||
|
return MapLiteral(entries, open.line, open.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun functionExpression(): Expr {
|
||||||
|
val keyword = advance()
|
||||||
|
val name = if (check(TokenType.Identifier)) advance().lexeme else null
|
||||||
|
val params = parameters()
|
||||||
|
val body = block()
|
||||||
|
return FunctionExpr(name, params, body, keyword.line, keyword.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun isStatementEnd(): Boolean =
|
||||||
|
check(TokenType.Newline) || check(TokenType.Semicolon) ||
|
||||||
|
check(TokenType.RightBrace) || check(TokenType.Eof)
|
||||||
|
|
||||||
|
private fun matchElse(): Boolean {
|
||||||
|
val saved = current
|
||||||
|
skipNewlines()
|
||||||
|
if (check(TokenType.Else)) {
|
||||||
|
advance()
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
current = saved
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun skipSeparators() {
|
||||||
|
while (check(TokenType.Newline) || check(TokenType.Semicolon)) advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun skipNewlines() {
|
||||||
|
while (check(TokenType.Newline)) advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun match(type: TokenType): Boolean {
|
||||||
|
if (check(type)) {
|
||||||
|
advance()
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun consume(type: TokenType, message: String): Token {
|
||||||
|
if (check(type)) return advance()
|
||||||
|
val found = peek()
|
||||||
|
throw ParseError("$message, got ${describe(found)}", found.line, found.column)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun describe(token: Token): String = when (token.type) {
|
||||||
|
TokenType.Newline -> "end of line"
|
||||||
|
TokenType.Eof -> "end of input"
|
||||||
|
else -> "'${token.lexeme.ifEmpty { token.type.name }}'"
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun check(type: TokenType): Boolean = peek().type == type
|
||||||
|
|
||||||
|
private fun advance(): Token = tokens[current++]
|
||||||
|
|
||||||
|
private fun peek(): Token = tokens[current]
|
||||||
|
|
||||||
|
private fun peekNext(): Token = if (current + 1 < tokens.size) tokens[current + 1] else tokens.last()
|
||||||
|
}
|
||||||
Reference in new issue
Block a user